[#llvm]
= llvm
:mrdocs:

Top&hyphen;level LLVM library namespace&period;

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:llvm/AA.adoc[`AA`] 
| Abstract Attribute helper functions&period;
| xref:llvm/AArch64.adoc[`AArch64`] 
| AArch64 CPU, architecture, and extension name parsing helpers&period;
| xref:llvm/AArch64BuildAttributes.adoc[`AArch64BuildAttributes`] 
| Enumerations and helpers for AArch64 ELF build attributes&period;
| xref:llvm/AMDGPU.adoc[`AMDGPU`] 
| AMDGPU&hyphen;specific address&hyphen;space helpers and DWARF mappings&period;
| xref:llvm/AMDGPUAS.adoc[`AMDGPUAS`] 
| AMDGPU address space identifiers for OpenCL and the backend&period;
| xref:llvm/APIntOps.adoc[`APIntOps`] 
| Additional APInt utility operations&period;
| xref:llvm/ARM.adoc[`ARM`] 
| ARM architecture support utilities and constants&period;
| xref:llvm/ARMBuildAttrs.adoc[`ARMBuildAttrs`] 
| Enumerations and helpers for ARM ELF build attributes&period;
| xref:llvm/AVR.adoc[`AVR`] 
| AVR architecture feature parsing helpers&period;
| xref:llvm/ArchYAML.adoc[`ArchYAML`] 
| YAML representations of Unix archive (ar) files&period;
| xref:llvm/AttributeFuncs.adoc[`AttributeFuncs`] 
| Helpers for attribute&sol;type compatibility and intersection&period;
| xref:llvm/BBAddrMapYAML.adoc[`BBAddrMapYAML`] 
| YAML representations of BB address map sections&period;
| xref:llvm/BTF.adoc[`BTF`] 
| BPF Type Format (&period;BTF &sol; &period;BTF&period;ext) binary layout definitions&period;
| xref:llvm/BitmaskEnumDetail.adoc[`BitmaskEnumDetail`] 
| Implementation details and operator overloads for bitmask enumerations&period;
| xref:llvm/COFF.adoc[`COFF`] 
| Constants, structures, and helpers for the Windows COFF and PE formats&period;
| xref:llvm/COFFYAML.adoc[`COFFYAML`] 
| YAML representations of COFF and PE object files&period;
| xref:llvm/CSKY.adoc[`CSKY`] 
| CSKY CPU, architecture, FPU, and extension name parsing helpers&period;
| xref:llvm/CSKYAttrs.adoc[`CSKYAttrs`] 
| Enumerations and helpers for CSKY ELF build attributes&period;
| xref:llvm/CallingConv.adoc[`CallingConv`] 
| CallingConv Namespace &hyphen; This namespace contains an enum with a value for the well&hyphen;known calling conventions&period;
| xref:llvm/Check.adoc[`Check`] 
| Utilities describing FileCheck directive kinds and modifiers&period;
| xref:llvm/CodeGenOpt.adoc[`CodeGenOpt`] 
| Helpers for parsing and converting code&hyphen;generation optimization levels&period;
| xref:llvm/CodeModel.adoc[`CodeModel`] 
| Code model types&period;
| xref:llvm/CodeViewYAML.adoc[`CodeViewYAML`] 
| YAML representations of CodeView debug subsections&period;
| xref:llvm/ConverterEBCDIC.adoc[`ConverterEBCDIC`] 
| Utilities for converting between EBCDIC&hyphen;1047 and UTF&hyphen;8&period;
| xref:llvm/DOT.adoc[`DOT`] 
| Helpers for writing Graphviz DOT text&period;
| xref:llvm/DWARFYAML.adoc[`DWARFYAML`] 
| Emitters that serialize DWARFYAML data into binary DWARF debug sections&period;
| xref:llvm/DXContainerYAML.adoc[`DXContainerYAML`] 
| YAML representations of DXContainer binaries&period;
| xref:llvm/DomTreeBuilder.adoc[`DomTreeBuilder`] 
| Helpers for building and updating MachineBasicBlock dominator trees&period;
| xref:llvm/ELF.adoc[`ELF`] 
| Constants, structures, and helpers for the ELF object&hyphen;file format&period;
| xref:llvm/ELFAttrs.adoc[`ELFAttrs`] 
| Shared helpers and constants for ELF build&hyphen;attribute sections&period;
| xref:llvm/ELFYAML.adoc[`ELFYAML`] 
| YAML representations of ELF object files&period;
| xref:llvm/EngineKind.adoc[`EngineKind`] 
| Identifiers for which kind of execution engine to build&period;
| xref:llvm/FPOpFusion.adoc[`FPOpFusion`] 
| Controls when floating&hyphen;point operations may be fused during code generation&period;
| xref:llvm/FloatABI.adoc[`FloatABI`] 
| Floating&hyphen;point ABI selection&period;
| xref:llvm/GCOV.adoc[`GCOV`] 
| Types and options shared by gcov note&sol;data readers and reporters&period;
| xref:llvm/GISelAddressing.adoc[`GISelAddressing`] 
| Helpers for decomposing and alias&hyphen;checking GlobalISel memory addresses&period;
| xref:llvm/GOFF.adoc[`GOFF`] 
| Constants, structures, and helpers for the GOFF object&hyphen;file format&period;
| xref:llvm/GOFFYAML.adoc[`GOFFYAML`] 
| YAML representations of GOFF object files&period;
| xref:llvm/GVNExpression.adoc[`GVNExpression`] 
| Classes representing value&hyphen;numbered expressions for the GVN pass&period;
| xref:llvm/GraphProgram.adoc[`GraphProgram`] 
| Identifiers for Graphviz layout programs used to render graphs&period;
| xref:llvm/HWASanAccessInfo.adoc[`HWASanAccessInfo`] 
| Bit&hyphen;field layout for the accessinfo parameter to llvm&period;hwasan&period;check&period;memaccess&period;
| xref:llvm/HexStyle.adoc[`HexStyle`] 
| Styles for printing hexadecimal immediate values&period;
| xref:llvm/HexagonAttrs.adoc[`HexagonAttrs`] 
| Enumerations and helpers for Qualcomm Hexagon ELF build attributes&period;
| xref:llvm/IDFCalculatorDetail.adoc[`IDFCalculatorDetail`] 
| Detail helpers for iterated dominance frontier calculation on BasicBlock&period;
| xref:llvm/ISD.adoc[`ISD`] 
| ISD namespace &hyphen; This namespace contains an enum which represents all of the SelectionDAG node types and value types&period;
| xref:llvm/ImutAVLDetail.adoc[`ImutAVLDetail`] 
| Internal helpers for optional tree canonicalization (digest cache and collision chains)&period; Not part of the public interface&period;
| xref:llvm/IndexedCGData.adoc[`IndexedCGData`] 
| Binary indexed codegen data format constants and header layout&period;
| xref:llvm/IndexedInstrProf.adoc[`IndexedInstrProf`] 
| Indexed (on&hyphen;disk) instrumented profile format helpers and structures&period;
| xref:llvm/InlineConstants.adoc[`InlineConstants`] 
| Thresholds and magic constants used by inline cost analysis&period;
| xref:llvm/IntegerInclusiveIntervalUtils.adoc[`IntegerInclusiveIntervalUtils`] 
| Utilities for parsing, querying, and printing lists of inclusive integer intervals&period;
| xref:llvm/IntervalMapImpl.adoc[`IntervalMapImpl`] 
| IntervalMapImpl &hyphen; Namespace used for IntervalMap implementation details&period; It should be considered private to the implementation&period;
| xref:llvm/Intrinsic.adoc[`Intrinsic`] 
| Namespace for SSA&sol;intrinsic helpers used by GenericSSAContext&period;
| xref:llvm/JumpTable.adoc[`JumpTable`] 
| Options for partitioning indirect call jump tables&period;
| xref:llvm/LCOMM.adoc[`LCOMM`] 
| Local common (`&period;lcomm`) directive alignment helpers&period;
| xref:llvm/LegalityPredicates.adoc[`LegalityPredicates`] 
| Helpers that build LegalityPredicate callables for legalizer rules&period;
| xref:llvm/LegalizeActions.adoc[`LegalizeActions`] 
| Legalization actions that describe how an illegal operation should be fixed&period;
| xref:llvm/LegalizeMutations.adoc[`LegalizeMutations`] 
| Helpers that build LegalizeMutation callables for legalizer rules&period;
| xref:llvm/LoongArch.adoc[`LoongArch`] 
| LoongArch CPU, architecture, and extension name parsing helpers&period;
| xref:llvm/MCD.adoc[`MCD`] 
| Helpers and opcodes for MC disassembler instruction decoding&period;
| xref:llvm/MCID.adoc[`MCID`] 
| Machine instruction descriptor flags encoded in `MCInstrDesc&colon;&colon;Flags&period;`
| xref:llvm/MCOI.adoc[`MCOI`] 
| Machine operand information shared by TableGen instruction descriptions&period;
| xref:llvm/MCParserUtils.adoc[`MCParserUtils`] 
| Helpers for parsing symbol assignment expressions in MC assembly&period;
| xref:llvm/MIPatternMatch.adoc[`MIPatternMatch`] 
| Matchers for GlobalISel SSA MachineInstr patterns&period;
| xref:llvm/MISched.adoc[`MISched`] 
| Options controlling machine&hyphen;instruction scheduling direction&period;
| xref:llvm/MSP430Attrs.adoc[`MSP430Attrs`] 
| Enumerations and helpers for MSP430 ELF build attributes&period;
| xref:llvm/MSSAHelpers.adoc[`MSSAHelpers`] 
| Helper tags used to distinguish MemoryAccess intrusive lists&period;
| xref:llvm/MachO.adoc[`MachO`] 
| Constants, structures, and helpers for the Mach&hyphen;O object&hyphen;file format&period;
| xref:llvm/MachOYAML.adoc[`MachOYAML`] 
| YAML representations of Mach&hyphen;O object files and fat binaries&period;
| xref:llvm/MinidumpYAML.adoc[`MinidumpYAML`] 
| YAML representations of minidump object files&period;
| xref:llvm/Mips.adoc[`Mips`] 
| Constants for the MIPS ABI flags structure and related GNU object tags&period;
| xref:llvm/NVPTX.adoc[`NVPTX`] 
| NVPTX architecture and GPU name parsing helpers&period;
| xref:llvm/NVPTXAS.adoc[`NVPTXAS`] 
| NVPTX address space identifiers for LLVM IR and DWARF&period;
| xref:llvm/NVVMAttr.adoc[`NVVMAttr`] 
| Canonical string constants for NVVM function and parameter attributes&period;
| xref:llvm/OMF.adoc[`OMF`] 
| Structures for CodeView OMF debug&hyphen;directory signatures&period;
| xref:llvm/OffloadYAML.adoc[`OffloadYAML`] 
| YAML representations of offloading binaries&period;
| xref:llvm/PBQP.adoc[`PBQP`] 
| Partitioned Boolean Quadratic Programming (PBQP) types and utilities&period;
| xref:llvm/PICLevel.adoc[`PICLevel`] 
| PIC level used to map &hyphen;fpic&sol;&hyphen;fPIC&period;
| xref:llvm/PIELevel.adoc[`PIELevel`] 
| Position&hyphen;independent executable level&period;
| xref:llvm/PPC.adoc[`PPC`] 
| PowerPC CPU name and target&hyphen;feature parsing helpers&period;
| xref:llvm/PatternMatch.adoc[`PatternMatch`] 
| Pattern&hyphen;matching helpers for LLVM IR values and instructions&period;
| xref:llvm/PatternMatchHelpers.adoc[`PatternMatchHelpers`] 
| Pattern&hyphen;match helpers specialized for SCEV use wrappers&period;
| xref:llvm/RISCV.adoc[`RISCV`] 
| RISC&hyphen;V CPU name, feature, and tune&hyphen;feature parsing helpers&period;
| xref:llvm/RISCVAttrs.adoc[`RISCVAttrs`] 
| Enumerations and helpers for RISC&hyphen;V ELF build attributes&period;
| xref:llvm/RISCVCFI.adoc[`RISCVCFI`] 
| RISC&hyphen;V control&hyphen;flow integrity (Zicfilp) label&hyphen;scheme helpers&period;
| xref:llvm/RISCVISAUtils.adoc[`RISCVISAUtils`] 
| Utilities for RISC&hyphen;V ISA extension names, versions, and canonical ordering&period;
| xref:llvm/RISCVVType.adoc[`RISCVVType`] 
| RISC&hyphen;V vector VTYPE encoding, decoding, and printing helpers&period;
| xref:llvm/RTLIB.adoc[`RTLIB`] 
| Helpers that map operations and types to `RTLIB&colon;&colon;Libcall` values&period;
| xref:llvm/RawInstrProf.adoc[`RawInstrProf`] 
| Raw (in&hyphen;memory &sol; continuous) instrumented profile format helpers&period;
| xref:llvm/Reloc.adoc[`Reloc`] 
| Relocation model types&period;
| xref:llvm/SCEVPatternMatch.adoc[`SCEVPatternMatch`] 
| Pattern matchers for Scalar Evolution (SCEV) expressions&period;
| xref:llvm/SDPatternMatch.adoc[`SDPatternMatch`] 
| Matchers for SelectionDAG SDValue and SDNode patterns&period;
| xref:llvm/ScaledNumbers.adoc[`ScaledNumbers`] 
| Helpers for arithmetic on pairs of digits and a binary scale&period;
| xref:llvm/Sched.adoc[`Sched`] 
| Groups target instruction&hyphen;scheduling preference definitions&period;
| xref:llvm/SignBitsOps.adoc[`SignBitsOps`] 
| Helpers for analyzing sign&hyphen;bit count through rotate operations&period;
| xref:llvm/SwitchCG.adoc[`SwitchCG`] 
| Utilities and data structures for lowering multi&hyphen;case switch statements&period;
| xref:llvm/SymbolRewriter.adoc[`SymbolRewriter`] 
| Utilities and descriptors for rewriting IR symbol names&period;
| xref:llvm/SyncScope.adoc[`SyncScope`] 
| Synchronization scope names and IDs for atomic memory operations&period;
| xref:llvm/TLSModel.adoc[`TLSModel`] 
| Thread&hyphen;local storage models&period;
| xref:llvm/TableGen.adoc[`TableGen`] 
| TableGen backend registration and invocation helpers&period;
| xref:llvm/TargetOpcode.adoc[`TargetOpcode`] 
| Namespace holding the target&hyphen;independent instruction opcode enumerators&period;
| xref:llvm/TargetStackID.adoc[`TargetStackID`] 
| Identifiers for distinct target stack allocation spaces&period;
| xref:llvm/ThinLTOCodeGeneratorImpl.adoc[`ThinLTOCodeGeneratorImpl`] 
| ThinLTOCodeGeneratorImpl &hyphen; Namespace used for ThinLTOCodeGenerator implementation details&period; It should be considered private to the implementation&period;
| xref:llvm/ThreadModel.adoc[`ThreadModel`] 
| Threading model assumed for atomics and related code generation&period;
| xref:llvm/VFABI.adoc[`VFABI`] 
| Utilities for Vector Function ABI mangling and variant mapping&period;
| xref:llvm/VNCoercion.adoc[`VNCoercion`] 
| Utilities for coercing values across mismatched memory types in VN&period;
| xref:llvm/WasmYAML.adoc[`WasmYAML`] 
| YAML representations of Wasm object files&period;
| xref:llvm/WebAssembly.adoc[`WebAssembly`] 
| Constants for WebAssembly exception handling&period;
| xref:llvm/Win64EH.adoc[`Win64EH`] 
| Helpers for encoding Windows x64, ARM, and ARM64 unwind information&period;
| xref:llvm/WinEH.adoc[`WinEH`] 
| Windows exception&hyphen;handling encoding helpers&period;
| xref:llvm/X86.adoc[`X86`] 
| X86 CPU name, feature, and tune&hyphen;feature parsing helpers&period;
| xref:llvm/X86Disassembler.adoc[`X86Disassembler`] 
| X86 instruction disassembler decoder tables, contexts, and shared helpers&period;
| xref:llvm/XCOFF.adoc[`XCOFF`] 
| Constants, structures, and helpers for the XCOFF object&hyphen;file format&period;
| xref:llvm/XCOFFYAML.adoc[`XCOFFYAML`] 
| YAML representations of XCOFF object files&period;
| xref:llvm/Xtensa.adoc[`Xtensa`] 
| Xtensa CPU and hardware&hyphen;feature name parsing helpers&period;
| xref:llvm/ZeroCallUsedRegs.adoc[`ZeroCallUsedRegs`] 
| Specify what type of zeroing for callee&hyphen;used registers&period;
| xref:llvm/abi.adoc[`abi`] 
| Types and helpers for classifying function arguments and returns under an ABI&period;
| xref:llvm/adl_detail.adoc[`adl&lowbar;detail`] 
| Helpers that invoke range algorithms via argument&hyphen;dependent lookup&period;
| xref:llvm/afdo_detail.adoc[`afdo&lowbar;detail`] 
| Detail helpers mapping IR entities used by the AFDO sample profile loader&period;
| xref:llvm/amdhsa.adoc[`amdhsa`] 
| AMDHSA kernel descriptor layout, bitfield packs, and related constants&period;
| xref:llvm/at.adoc[`at`] 
| Assignment Tracking (at)&period;
| xref:llvm/bfi_detail.adoc[`bfi&lowbar;detail`] 
| Implementation details for BlockFrequencyInfoImpl&period;
| xref:llvm/binaryformat.adoc[`binaryformat`] 
| Swift binary&hyphen;format constants and section kinds&period;
| xref:llvm/bitc.adoc[`bitc`] 
| Bitcode record and block code enumerations for LLVM IR bitcode files&period;
| xref:llvm/bitfields_details.adoc[`bitfields&lowbar;details`] 
| Implementation helpers that pack and unpack typed bitfield elements into unsigned storage words&period;
| xref:llvm/callable_detail.adoc[`callable&lowbar;detail`] 
| Internal helpers for owning and invoking callables&period;
| xref:llvm/callgraph-08.adoc[`callgraph`] 
| Types and flags for ELF call&hyphen;graph profile section entries&period;
| xref:llvm/cas.adoc[`cas`] 
| Content&hyphen;addressable storage (CAS) APIs&period;
| xref:llvm/cfg.adoc[`cfg`] 
| Helpers for encoding and legalizing CFG edge insert&sol;delete updates&period;
| xref:llvm/cgdata.adoc[`cgdata`] 
| Convenience wrappers around the CodeGenData singleton&period;
| xref:llvm/cl.adoc[`cl`] 
| This namespace contains all of the command line option processing machinery&period; It is intentionally a short name to make qualified usage concise&period;
| xref:llvm/codegen.adoc[`codegen`] 
| Shared codegen command&hyphen;line flag accessors used by tools such as llc and opt&period;
| xref:llvm/codegenoptions.adoc[`codegenoptions`] 
| Options controlling debug&hyphen;info emission for frontend code generation&period;
| xref:llvm/codelayout.adoc[`codelayout`] 
| Algorithms for laying out code to improve locality and I&hyphen;cache utilization&period;
| xref:llvm/codeview.adoc[`codeview`] 
| CodeView debug&hyphen;info types, records, and type&sol;symbol stream builders&period;
| xref:llvm/compression.adoc[`compression`] 
| Compression and decompression helpers for zlib, zstd, and related formats&period;
| xref:llvm/consthoist.adoc[`consthoist`] 
| A private &quot;module&quot; namespace for types and utilities used by ConstantHoisting&period; These are implementation details and should not be used by clients&period;
| xref:llvm/coro.adoc[`coro`] 
| Coroutine ABI lowering utilities and class hierarchy&period;
| xref:llvm/coverage.adoc[`coverage`] 
| Code coverage mapping data and APIs for reading instrumented coverage&period;
| xref:llvm/ctx_profile.adoc[`ctx&lowbar;profile`] 
| Types and helpers for contextual instrumentation profiles&period;
| xref:llvm/densemap-07.adoc[`densemap`] 
| DenseMap&hyphen;specific hashing helpers&period;
| xref:llvm/details.adoc[`details`] 
| Internal helpers for fixed&hyphen; versus vscale&hyphen;sized quantities&period;
| xref:llvm/directive-07.adoc[`directive`] 
| Namespace for versioned spellings of frontend directives and clauses&period;
| xref:llvm/driver.adoc[`driver`] 
| Shared frontend driver code&hyphen;generation options used by Clang and Flang&period;
| xref:llvm/dwarf.adoc[`dwarf`] 
| DWARF constants, encodings, and helpers for debug&hyphen;info consumers and producers&period;
| xref:llvm/dwarf_linker.adoc[`dwarf&lowbar;linker`] 
| DWARF linker facilities&period;
| xref:llvm/dxbc.adoc[`dxbc`] 
| Constants, structures, and helpers for the DirectX DXContainer (DXBC) object&hyphen;file format&period;
| xref:llvm/dxil.adoc[`dxil`] 
| DXIL module metadata types shared by analysis passes&period;
| xref:llvm/fp.adoc[`fp`] 
| Floating&hyphen;point environment utilities for constrained floating&hyphen;point operations&period;
| xref:llvm/fuzzerop.adoc[`fuzzerop`] 
| Tools for describing IR&hyphen;fuzzer operations that can be built and mutated&period;
| xref:llvm/gsym.adoc[`gsym`] 
| Namespace for the GSYM debug info format&period;
| xref:llvm/hashbuilder_detail.adoc[`hashbuilder&lowbar;detail`] 
| Implementation details for `HashBuilder&period;`
| xref:llvm/hashing.adoc[`hashing`] 
| Implementation details for hash computation&period;
| xref:llvm/hlsl.adoc[`hlsl`] 
| HLSL frontend utilities for resources, bindings, and related IR helpers&period;
| xref:llvm/ifs.adoc[`ifs`] 
| Interface stub (IFS) helpers for reading and writing ELF binaries&period;
| xref:llvm/ilist_detail.adoc[`ilist&lowbar;detail`] 
| Implementation details for intrusive list node prev&sol;next storage&period;
| xref:llvm/impl.adoc[`impl`] 
| Implementation details for the LDBG() and LDBG&lowbar;OS() macros&period;
| xref:llvm/impl_detail.adoc[`impl&lowbar;detail`] 
| Implementation details for the new&hyphen;pass&hyphen;manager machine scheduler wrappers&period;
| xref:llvm/instrumentor.adoc[`instrumentor`] 
| Types and helpers for the configurable Instrumentor instrumentation pass&period;
| xref:llvm/ir2vec.adoc[`ir2vec`] 
| Helpers and data types for generating IR2Vec embeddings&period;
| xref:llvm/irsymtab.adoc[`irsymtab`] 
| Symbol table format, reader, and builder for LLVM IR bitcode&period;
| xref:llvm/itanium_demangle.adoc[`itanium&lowbar;demangle`] 
| Itanium C&plus;&plus; ABI demangler AST nodes, utilities, and parser&period;
| xref:llvm/jitlink.adoc[`jitlink`] 
| Just&hyphen;in&hyphen;time linking APIs for relocatable object formats&period;
| xref:llvm/json.adoc[`json`] 
| Forward declarations of LLVM JSON types used by TensorSpec serialization&period;
| xref:llvm/jumpthreading.adoc[`jumpthreading`] 
| A private &quot;module&quot; namespace for types and utilities used by JumpThreading&period; These are implementation details and should not be used by clients&period;
| xref:llvm/legacy.adoc[`legacy`] 
| Contains the legacy (old) pass manager infrastructure&period;
| xref:llvm/lltok.adoc[`lltok`] 
| Token codes for the LLVM IR assembly (&period;ll) lexer&period;
| xref:llvm/logicalview.adoc[`logicalview`] 
| Logical view types and utilities for comparing debug information&period;
| xref:llvm/lowertypetests.adoc[`lowertypetests`] 
| Helpers and data structures for the type&hyphen;test lowering pass&period;
| xref:llvm/lsp.adoc[`lsp`] 
| Language Server Protocol types, transport, and logging utilities&period;
| xref:llvm/lto.adoc[`lto`] 
| Link&hyphen;time optimization APIs, including Distributed ThinLTO (DTLTO)&period;
| xref:llvm/mc.adoc[`mc`] 
| Fixup classification helpers used during assembly and relocation&period;
| xref:llvm/mca.adoc[`mca`] 
| Machine code analyzer (llvm&hyphen;mca) customization hooks&period;
| xref:llvm/mcdwarf.adoc[`mcdwarf`] 
| Internal helpers for emitting DWARF list table headers&period;
| xref:llvm/mcdxbc.adoc[`mcdxbc`] 
| MC&hyphen;layer helpers for reading and writing DXContainer (DXBC) parts&period;
| xref:llvm/mdconst.adoc[`mdconst`] 
| Transitional API for extracting constants from Metadata&period;
| xref:llvm/memprof.adoc[`memprof`] 
| Utilities for analyzing and applying memory profile information&period;
| xref:llvm/memtag.adoc[`memtag`] 
| Helpers shared by HWAddressSanitizer and AArch64 stack tagging&period;
| xref:llvm/minidump.adoc[`minidump`] 
| Constants and structures for the Windows minidump core&hyphen;file format&period;
| xref:llvm/mir2vec.adoc[`mir2vec`] 
| MIR2Vec embedding helpers, vocabulary, and embedder types&period;
| xref:llvm/misexpect.adoc[`misexpect`] 
| Utilities for diagnosing incorrect llvm&period;expect usage against PGO data&period;
| xref:llvm/ms_demangle.adoc[`ms&lowbar;demangle`] 
| Microsoft Visual C&plus;&plus; name&hyphen;mangling demangler&period;
| xref:llvm/msf.adoc[`msf`] 
| Namespace for Microsoft Symbol File (MSF) support&period;
| xref:llvm/msgpack.adoc[`msgpack`] 
| In&hyphen;memory MessagePack document node types&period;
| xref:llvm/mustache.adoc[`mustache`] 
| Mustache template rendering against `llvm&colon;&colon;json&colon;&colon;Value` data&period;
| xref:llvm/numbers.adoc[`numbers`] 
| Mathematical constants backported from C&plus;&plus;20 &lt;numbers&gt;&period;
| xref:llvm/nvvm.adoc[`nvvm`] 
| Helpers for NVVM &sol; NVPTX intrinsic enums, printers, and FP semantics&period;
| xref:llvm/objcarc.adoc[`objcarc`] 
| Objective&hyphen;C Automatic Reference Counting analyses and utilities&period;
| xref:llvm/objcopy.adoc[`objcopy`] 
| Tools and configuration for copying and transforming object files&period;
| xref:llvm/object.adoc[`object`] 
| Object&hyphen;file formats and utilities for reading, writing, and inspecting binaries&period;
| xref:llvm/offloading.adoc[`offloading`] 
| Helpers for embedding and registering device images with offload runtimes&period;
| xref:llvm/omp.adoc[`omp`] 
| OpenMP front&hyphen;end utilities for representing directives and descriptor metadata&period;
| xref:llvm/opt.adoc[`opt`] 
| Command&hyphen;line option and argument parsing utilities&period;
| xref:llvm/orc.adoc[`orc`] 
| On&hyphen;Request Compilation (ORC) JIT APIs&period;
| xref:llvm/ore.adoc[`ore`] 
| Add a small namespace to avoid name clashes with the classes used in the streaming interface&period; We want these to be short for better write&sol;readability&period;
| xref:llvm/outliner.adoc[`outliner`] 
| Shared data structures for the MachineOutliner and target outlining hooks&period;
| xref:llvm/parallel.adoc[`parallel`] 
| Helpers for running work across a pool of worker threads&period;
| xref:llvm/pdb.adoc[`pdb`] 
| PDB types referenced by the CodeView logical&hyphen;view reader&period;
| xref:llvm/pgo.adoc[`pgo`] 
| Helpers shared by PGO&hyphen;driven and sample&hyphen;profile indirect&hyphen;call promotion&period;
| xref:llvm/po_detail.adoc[`po&lowbar;detail`] 
| Implementation details for post&hyphen;order graph iterators&period;
| xref:llvm/pointer_union_detail.adoc[`pointer&lowbar;union&lowbar;detail`] 
| Implementation details for PointerUnion tag packing&period;
| xref:llvm/rdf.adoc[`rdf`] 
| Register data&hyphen;flow (RDF) graph types and builders for non&hyphen;SSA machine code&period;
| xref:llvm/reassociate.adoc[`reassociate`] 
| A private &quot;module&quot; namespace for types and utilities used by Reassociate&period; These are implementation details and should not be used by clients&period;
| xref:llvm/remarks.adoc[`remarks`] 
| Interfaces for emitting and serializing optimization remarks&period;
| xref:llvm/sampleprof.adoc[`sampleprof`] 
| Sample profile data structures and helpers&period;
| xref:llvm/sampleprofutil.adoc[`sampleprofutil`] 
| Utilities shared by sample profile loader implementations&period;
| xref:llvm/sandboxir.adoc[`sandboxir`] 
| Transactional IR layer over LLVM IR with save&sol;restore and an LLVM&hyphen;like API&period;
| xref:llvm/sframe.adoc[`sframe`] 
| Constants and structures for the SFrame (&period;sframe) unwind format&period;
| xref:llvm/slpvectorizer.adoc[`slpvectorizer`] 
| A private &quot;module&quot; namespace for types and utilities used by this pass&period; These are implementation details and should not be used by clients&period;
| xref:llvm/support.adoc[`support`] 
| Implementation details for formatv support helpers&period;
| xref:llvm/symbolize.adoc[`symbolize`] 
| Namespace for LLVM symbolization APIs and result printers&period;
| xref:llvm/sys.adoc[`sys`] 
| Host system utilities&period;
| xref:llvm/telemetry.adoc[`telemetry`] 
| Framework for collecting and transmitting LLVM tool telemetry&period;
| xref:llvm/this_thread.adoc[`this&lowbar;thread`] 
| Utilities for querying the calling thread, analogous to std&colon;&colon;this&lowbar;thread&period;
| xref:llvm/trailing_objects_internal.adoc[`trailing&lowbar;objects&lowbar;internal`] 
| Implementation details supporting TrailingObjects&period;
| xref:llvm/vfs.adoc[`vfs`] 
| Namespace for the virtual file system interface&period;
| xref:llvm/wasm.adoc[`wasm`] 
| Constants and structures for the WebAssembly binary object&hyphen;file format&period;
| xref:llvm/wholeprogramdevirt.adoc[`wholeprogramdevirt`] 
| Helpers and data structures for the whole&hyphen;program devirtualization pass&period;
| xref:llvm/windows_manifest.adoc[`windows&lowbar;manifest`] 
| Utilities for merging Microsoft Windows application &period;manifest XML files&period;
| xref:llvm/xray.adoc[`xray`] 
| APIs for loading, writing, and analyzing XRay function&hyphen;call traces&period;
| xref:llvm/yaml.adoc[`yaml`] 
| YAML serialization support for Machine IR (MIR)&period;
|===


== Types

[cols="1,4"]
|===
| Name| Description
| xref:llvm/AAAddressSpace.adoc[`AAAddressSpace`] 
| An abstract interface for address space information&period;
| xref:llvm/AAAlign.adoc[`AAAlign`] 
| An abstract interface for all align attributes&period;
| xref:llvm/AAAllocationInfo.adoc[`AAAllocationInfo`] 
| Abstract attribute describing allocation size information&period;
| xref:llvm/AAAssumptionInfo.adoc[`AAAssumptionInfo`] 
| An abstract attribute for getting assumption information&period;
| xref:llvm/AACacheLoc.adoc[`AACacheLoc`] 
| Cache key for BasicAA results&period;
| xref:llvm/AACallEdgeIterator.adoc[`AACallEdgeIterator`] 
| An Iterator for call edges, creates AACallEdges attributes in a lazy way&period;
| xref:llvm/AACallEdges.adoc[`AACallEdges`] 
| An abstract state for querying live call edges&period; This interface uses the Attributor&apos;s optimistic liveness information to compute the edges that are alive&period;
| xref:llvm/AACallGraphNode.adoc[`AACallGraphNode`] 
| Node in the Attributor call graph&period;
| xref:llvm/AADenormalFPMath.adoc[`AADenormalFPMath`] 
| An abstract Attribute for specializing &quot;dynamic&quot; components of denormal&lowbar;fpenv to a known denormal mode&period;
| xref:llvm/AADepGraph.adoc[`AADepGraph`] 
| The data structure for the dependency graph
| xref:llvm/AADepGraphNode.adoc[`AADepGraphNode`] 
| Node in the Attributor dependence graph&period;
| xref:llvm/AADereferenceable.adoc[`AADereferenceable`] 
| An abstract interface for all dereferenceable attribute&period;
| xref:llvm/AAEvaluator.adoc[`AAEvaluator`] 
| A pass that evaluates alias analysis accuracy via N&circ;2 pointer queries&period;
| xref:llvm/AAExecutionDomain.adoc[`AAExecutionDomain`] 
| Abstract attribute describing thread execution domains&period;
| xref:llvm/AAGlobalValueInfo.adoc[`AAGlobalValueInfo`] 
| An abstract interface for llvm&colon;&colon;GlobalValue information interference&period;
| xref:llvm/AAHeapToStack.adoc[`AAHeapToStack`] 
| Abstract attribute for heap&hyphen;to&hyphen;stack conversion opportunities&period;
| xref:llvm/AAIndirectCallInfo.adoc[`AAIndirectCallInfo`] 
| An abstract interface for indirect call information interference&period;
| xref:llvm/AAInstanceInfo.adoc[`AAInstanceInfo`] 
| Abstract attribute tracking whether a value leaves its defining function instance&period;
| xref:llvm/AAInterFnReachability.adoc[`AAInterFnReachability`] 
| An abstract Attribute for computing reachability between functions&period;
| xref:llvm/AAIntraFnReachability.adoc[`AAIntraFnReachability`] 
| An abstract interface to determine reachability of point A to B&period;
| xref:llvm/AAInvariantLoadPointer.adoc[`AAInvariantLoadPointer`] 
| An abstract interface for identifying pointers from which loads can be marked invariant&period;
| xref:llvm/AAIsDead.adoc[`AAIsDead`] 
| An abstract interface for liveness abstract attribute&period;
| xref:llvm/AAMDNodes.adoc[`AAMDNodes`] 
| A collection of metadata nodes that might be associated with a memory access used by the alias&hyphen;analysis infrastructure&period;
| xref:llvm/AAManager.adoc[`AAManager`] 
| A manager for alias analyses&period;
| xref:llvm/AAMemoryBehavior.adoc[`AAMemoryBehavior`] 
| An abstract interface for memory access kind related attributes (readnone&sol;readonly&sol;writeonly)&period;
| xref:llvm/AAMemoryLocation.adoc[`AAMemoryLocation`] 
| An abstract interface for all memory location attributes (readnone&sol;argmemonly&sol;inaccessiblememonly&sol;inaccessibleorargmemonly)&period;
| xref:llvm/AAMustProgress.adoc[`AAMustProgress`] 
| An abstract interface for all nonnull attributes&period;
| xref:llvm/AANoAlias.adoc[`AANoAlias`] 
| An abstract interface for all noalias attributes&period;
| xref:llvm/AANoAliasAddrSpace.adoc[`AANoAliasAddrSpace`] 
| An abstract interface for potential address space information&period;
| xref:llvm/AANoCapture.adoc[`AANoCapture`] 
| An abstract interface for all nocapture attributes&period;
| xref:llvm/AANoFPClass.adoc[`AANoFPClass`] 
| Abstract attribute for the nofpclass property&period;
| xref:llvm/AANoFree.adoc[`AANoFree`] 
| An AbstractAttribute for nofree&period;
| xref:llvm/AANoRecurse.adoc[`AANoRecurse`] 
| An abstract attribute for norecurse&period;
| xref:llvm/AANoReturn.adoc[`AANoReturn`] 
| An AbstractAttribute for noreturn&period;
| xref:llvm/AANoSync.adoc[`AANoSync`] 
| Abstract attribute for the nosync function attribute&period;
| xref:llvm/AANoUndef.adoc[`AANoUndef`] 
| An abstract interface for all noundef attributes&period;
| xref:llvm/AANoUnwind.adoc[`AANoUnwind`] 
| Abstract attribute for the nounwind function attribute&period;
| xref:llvm/AANonConvergent.adoc[`AANonConvergent`] 
| An abstract Attribute for determining the necessity of the convergent attribute&period;
| xref:llvm/AANonNull.adoc[`AANonNull`] 
| An abstract interface for all nonnull attributes&period;
| xref:llvm/AAPointerInfo.adoc[`AAPointerInfo`] 
| An abstract interface for pointer struct and access information&period;
| xref:llvm/AAPotentialConstantValues.adoc[`AAPotentialConstantValues`] 
| An abstract interface for potential values analysis&period;
| xref:llvm/AAPotentialValues.adoc[`AAPotentialValues`] 
| Abstract attribute tracking potential LLVM values&period;
| xref:llvm/AAPrivatizablePtr.adoc[`AAPrivatizablePtr`] 
| An abstract interface for privatizability&period;
| xref:llvm/AAQueryInfo.adoc[`AAQueryInfo`] 
| State retained across or within an alias query&period;
| xref:llvm/AAResultBase.adoc[`AAResultBase`] 
| A base class to help implement the function alias analysis results concept&period;
| xref:llvm/AAResults.adoc[`AAResults`] 
| Aggregated alias analysis results for a function&period;
| xref:llvm/AAResultsWrapperPass.adoc[`AAResultsWrapperPass`] 
| A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object&period;
| xref:llvm/AAUndefinedBehavior.adoc[`AAUndefinedBehavior`] 
| An abstract attribute for undefined behavior&period;
| xref:llvm/AAUnderlyingObjects.adoc[`AAUnderlyingObjects`] 
| An abstract attribute for getting all assumption underlying objects&period;
| xref:llvm/AAValueConstantRange.adoc[`AAValueConstantRange`] 
| An abstract interface for range value analysis&period;
| xref:llvm/AAValueSimplify.adoc[`AAValueSimplify`] 
| An abstract interface for value simplify abstract attribute&period;
| xref:llvm/AAWillReturn.adoc[`AAWillReturn`] 
| An abstract attribute for willreturn&period;
| xref:llvm/AArch64AttributeParser.adoc[`AArch64AttributeParser`] 
| Parser for AArch64 ELF build attributes&period;
| xref:llvm/AArch64BuildAttrSubsections.adoc[`AArch64BuildAttrSubsections`] 
| Extracted AArch64 build&hyphen;attribute subsection values&period;
| xref:llvm/ADCEPass.adoc[`ADCEPass`] 
| A DCE pass that assumes instructions are dead until proven otherwise&period;
| xref:llvm/APFixedPoint.adoc[`APFixedPoint`] 
| Arbitrary&hyphen;precision fixed&hyphen;point value with associated semantics&period;
| xref:llvm/APFloat.adoc[`APFloat`] 
| Arbitrary&hyphen;precision floating&hyphen;point value&period;
| xref:llvm/APFloatBase.adoc[`APFloatBase`] 
| Shared type definitions for APFloat and its internal implementation classes&period;
| xref:llvm/APInt.adoc[`APInt`] 
| Arbitrary&hyphen;precision integer&period;
| xref:llvm/APSInt.adoc[`APSInt`] 
| An arbitrary precision integer that knows its signedness&period;
| xref:llvm/ARMAttributeParser.adoc[`ARMAttributeParser`] 
| Parser for ARM ELF build attributes&period;
| xref:llvm/ARMJITSymbolFlags.adoc[`ARMJITSymbolFlags`] 
| ARM&hyphen;specific JIT symbol flags&period; FIXME&colon; This should be moved into a target&hyphen;specific header&period;
| xref:llvm/ARMTargetStreamer.adoc[`ARMTargetStreamer`] 
| ARM&hyphen;specific target streamer for EHABI, EABI attributes, and WinCFI&period;
| xref:llvm/ASanAccessInfo.adoc[`ASanAccessInfo`] 
| Decoded ASan memory&hyphen;access descriptor shared by the pass and backend&period;
| xref:llvm/ASanStackFrameLayout.adoc[`ASanStackFrameLayout`] 
| Computed AddressSanitizer layout of an instrumented stack frame&period;
| xref:llvm/ASanStackVariableDescription.adoc[`ASanStackVariableDescription`] 
| Describes one stack variable for AddressSanitizer frame layout&period;
| xref:llvm/AShrOperator.adoc[`AShrOperator`] 
| Concrete operator for the AShr instruction opcode&period;
| xref:llvm/AbstractAttribute.adoc[`AbstractAttribute`] 
| Base struct for all &quot;concrete attribute&quot; deductions&period;
| xref:llvm/AbstractCallSite.adoc[`AbstractCallSite`] 
| AbstractCallSite
| xref:llvm/AbstractDependenceGraphBuilder-01.adoc[`AbstractDependenceGraphBuilder`] 
| Abstract builder defining high&hyphen;level steps for creating DDG&hyphen;like graphs&period;
| xref:llvm/AbstractLatticeFunction.adoc[`AbstractLatticeFunction`] 
| Abstract lattice interface for sparse conditional propagation&period;
| xref:llvm/AbstractSlotTrackerStorage.adoc[`AbstractSlotTrackerStorage`] 
| Abstract interface of slot tracker storage&period;
| xref:llvm/AbstractState.adoc[`AbstractState`] 
| An interface to query the internal state of an abstract attribute&period;
| xref:llvm/AccelTable-02.adoc[`AccelTable`] 
| Abstract accelerator table of buckets containing HashData entries&period;
| xref:llvm/AccelTableBase.adoc[`AccelTableBase`] 
| Non&hyphen;template base for AccelTable shared state and finalization&period;
| xref:llvm/AccelTableData.adoc[`AccelTableData`] 
| Interface for accelerator table entry data used by AccelTable&period;
| xref:llvm/ActiveBlocksOption.adoc[`ActiveBlocksOption`] 
| Base that tracks which blocks are still participating in iteration&period;
| xref:llvm/AddDiscriminatorsPass.adoc[`AddDiscriminatorsPass`] 
| Pass that adds DWARF path discriminators to the IR&period;
| xref:llvm/AddOperator.adoc[`AddOperator`] 
| Concrete operator for the Add instruction opcode&period;
| xref:llvm/AddrLabelMap.adoc[`AddrLabelMap`] 
| Maps address&hyphen;taken basic blocks to the MCSymbols that label them&period;
| xref:llvm/AddrSpaceCastInst.adoc[`AddrSpaceCastInst`] 
| Instruction that casts a pointer from one address space to another&period;
| xref:llvm/AddrSpaceCastOperator.adoc[`AddrSpaceCastOperator`] 
| Concrete operator for the AddrSpaceCast instruction opcode&period;
| xref:llvm/AddrSpaceCastSDNode.adoc[`AddrSpaceCastSDNode`] 
| SDNode representing an address&hyphen;space cast&period;
| xref:llvm/AddressProbesMap.adoc[`AddressProbesMap`] 
| Sorted map from code address to decoded pseudo probes&period;
| xref:llvm/AddressRange.adoc[`AddressRange`] 
| A class that represents an address range&period; The range is specified using a start and an end address&colon; &lsqb;Start, End)&period;&rsqb;
| xref:llvm/AddressRangeValuePair.adoc[`AddressRangeValuePair`] 
| An address range paired with an associated integer value&period;
| xref:llvm/AddressRanges.adoc[`AddressRanges`] 
| Address range collection that merges intersecting and adjacent ranges&period;
| xref:llvm/AddressRangesBase-05.adoc[`AddressRangesBase`] 
| Base class for sorted, non&hyphen;overlapping address range collections&period;
| xref:llvm/AddressRangesMap.adoc[`AddressRangesMap`] 
| Map of integer values onto normalized, non&hyphen;overlapping address ranges&period;
| xref:llvm/AddressSanitizerOptions.adoc[`AddressSanitizerOptions`] 
| Options that control AddressSanitizer instrumentation&period;
| xref:llvm/AddressSanitizerPass.adoc[`AddressSanitizerPass`] 
| Public interface to the address sanitizer module pass for instrumenting code to check for various memory errors&period;
| xref:llvm/AdvisoryLock.adoc[`AdvisoryLock`] 
| A synchronization primitive with weak mutual exclusion guarantees&period;
| xref:llvm/AggregationData.adoc[`AggregationData`] 
| Aggregated counts for a single error or warning category&period;
| xref:llvm/AggressiveInstCombinePass.adoc[`AggressiveInstCombinePass`] 
| A pass that combines expression patterns into fewer, simpler instructions&period;
| xref:llvm/AliasMatchingData.adoc[`AliasMatchingData`] 
| Tablegenerated data structures needed to match alias patterns&period;
| xref:llvm/AliasPattern.adoc[`AliasPattern`] 
| Data for each alias pattern&period; Includes feature bits, string, number of operands, and a variadic list of conditions to check&period;
| xref:llvm/AliasPatternCond.adoc[`AliasPatternCond`] 
| A single condition checked while matching an instruction alias pattern&period;
| xref:llvm/AliasResult.adoc[`AliasResult`] 
| The possible results of an alias query&period;
| xref:llvm/AliasScopeNode.adoc[`AliasScopeNode`] 
| Wrapper around an MDNode that exposes alias&hyphen;scope metadata&period;
| xref:llvm/AliasSet.adoc[`AliasSet`] 
| A set of memory locations that may alias each other&period;
| xref:llvm/AliasSetTracker.adoc[`AliasSetTracker`] 
| Tracks a collection of disjoint AliasSets over immutable IR&period;
| xref:llvm/AliasSetsPrinterPass.adoc[`AliasSetsPrinterPass`] 
| Printer pass for `AliasSetTracker` results&period;
| xref:llvm/AliasSummary.adoc[`AliasSummary`] 
| Alias summary information&period;
| xref:llvm/Align.adoc[`Align`] 
| This struct is a compact representation of a valid (non&hyphen;zero power of two) alignment&period; It is suitable for use as static global constants&period;
| xref:llvm/AlignedCharArrayUnion.adoc[`AlignedCharArrayUnion`] 
| A suitably aligned and sized character array member which can hold elements of any type&period;
| xref:llvm/AlignmentFromAssumptionsPass.adoc[`AlignmentFromAssumptionsPass`] 
| A pass that sets load&sol;store&sol;mem&hyphen;intrinsic alignments from assume bundles&period;
| xref:llvm/AllAnalysesOn.adoc[`AllAnalysesOn`] 
| This templated class represents &quot;all analyses that operate over &lt;a particular IR unit&gt;&quot; (e&period;g&period; a Function or a Module) in instances of PreservedAnalysis&period;
| xref:llvm/AllocInfo.adoc[`AllocInfo`] 
| Summary of memprof metadata on allocations&period;
| xref:llvm/AllocTokenMetadata.adoc[`AllocTokenMetadata`] 
| Metadata about an allocation used to generate a token ID&period;
| xref:llvm/AllocTokenOptions.adoc[`AllocTokenOptions`] 
| Options that control AllocToken instrumentation&period;
| xref:llvm/AllocTokenPass.adoc[`AllocTokenPass`] 
| A module pass that rewrites heap allocations to use token&hyphen;enabled allocation functions based on various source&hyphen;level properties&period;
| xref:llvm/AllocaInst.adoc[`AllocaInst`] 
| an instruction to allocate memory on the stack
| xref:llvm/AllocaPackedValues.adoc[`AllocaPackedValues`] 
| Bitfield layout for packed flags stored in an alloca bitcode record&period;
| xref:llvm/AllocationOrder.adoc[`AllocationOrder`] 
| Preferred order of physical registers for allocating a virtual register&period;
| xref:llvm/AllocatorBase-05.adoc[`AllocatorBase`] 
| CRTP base class providing obvious overloads for the core `Allocate()` methods of LLVM&hyphen;style allocators&period;
| xref:llvm/AllocatorList.adoc[`AllocatorList`] 
| A linked&hyphen;list with a custom, local allocator&period;
| xref:llvm/AlwaysInlinerPass.adoc[`AlwaysInlinerPass`] 
| Inlines functions marked as &quot;always&lowbar;inline&quot;&period;
| xref:llvm/AnalysisGetter.adoc[`AnalysisGetter`] 
| Wrapper for FunctionAnalysisManager and legacy pass&hyphen;manager analysis lookup&period;
| xref:llvm/AnalysisInfoMixin-018.adoc[`AnalysisInfoMixin`] 
| A CRTP mix&hyphen;in that provides informational APIs needed for analysis passes&period;
| xref:llvm/AnalysisInfoMixin-032.adoc[`AnalysisInfoMixin`] 
| A CRTP mix&hyphen;in that provides informational APIs needed for analysis passes&period;
| xref:llvm/AnalysisInfoMixin-0b9.adoc[`AnalysisInfoMixin`] 
| A CRTP mix&hyphen;in that provides informational APIs needed for analysis passes&period;
| xref:llvm/AnalysisKey.adoc[`AnalysisKey`] 
| A special type used by analysis passes to provide an address that identifies that particular analysis pass type&period;
| xref:llvm/AnalysisManager-0b9.adoc[`AnalysisManager`] 
| Container that lazily runs and caches analysis results for an IR unit&period;
| xref:llvm/AnalysisResolver.adoc[`AnalysisResolver`] 
| Interface used by Pass objects to pull analysis info from the pass manager&period;
| xref:llvm/AnalysisSetKey.adoc[`AnalysisSetKey`] 
| A special type used to provide an address that identifies a set of related analyses&period; These sets are primarily used below to mark sets of analyses as preserved&period;
| xref:llvm/AnalysisUsage.adoc[`AnalysisUsage`] 
| Describes which analyses a pass requires and preserves&period;
| xref:llvm/Annotation2MetadataPass.adoc[`Annotation2MetadataPass`] 
| Pass to convert llvm&period;global&period;annotations to !annotation metadata&period;
| xref:llvm/AnnotationRemarksPass.adoc[`AnnotationRemarksPass`] 
| A pass that emits optimization remarks for instructions with !annotation&period;
| xref:llvm/AnonNamespaceEmitter.adoc[`AnonNamespaceEmitter`] 
| RAII helper that emits an anonymous `namespace &lcub; &period;&period;&period; &rcub;` scope&period;
| xref:llvm/AnonymousNameInit.adoc[`AnonymousNameInit`] 
| Represents an anonymous record name&period;
| xref:llvm/AntiDepBreaker.adoc[`AntiDepBreaker`] 
| This class works in conjunction with the post&hyphen;RA scheduler to rename registers to break register anti&hyphen;dependencies (WAR hazards)&period;
| xref:llvm/Any-00.adoc[`Any`] 
| Type&hyphen;erased holder for a single copy&hyphen;constructible value&period;
| xref:llvm/AnyCoroEndInst.adoc[`AnyCoroEndInst`] 
| Common base class for llvm&period;coro&period;end and llvm&period;coro&period;end&period;async&period;
| xref:llvm/AnyCoroIdInst.adoc[`AnyCoroIdInst`] 
| This represents a common base class for llvm&period;coro&period;id instructions&period;
| xref:llvm/AnyCoroIdRetconInst.adoc[`AnyCoroIdRetconInst`] 
| This represents either the llvm&period;coro&period;id&period;retcon or llvm&period;coro&period;id&period;retcon&period;once instruction&period;
| xref:llvm/AnyCoroSuspendInst.adoc[`AnyCoroSuspendInst`] 
| Common base class for llvm&period;coro&period;suspend&period;&ast; instructions&period;
| xref:llvm/AnyMemCpyInst.adoc[`AnyMemCpyInst`] 
| This class represents any memcpy intrinsic i&period;e&period; llvm&period;element&period;unordered&period;atomic&period;memcpy and llvm&period;memcpy
| xref:llvm/AnyMemIntrinsic.adoc[`AnyMemIntrinsic`] 
| Common base for atomic or non&hyphen;atomic memset&sol;memcpy&sol;memmove intrinsics&period;
| xref:llvm/AnyMemMoveInst.adoc[`AnyMemMoveInst`] 
| This class represents any memmove intrinsic i&period;e&period; llvm&period;element&period;unordered&period;atomic&period;memmove and llvm&period;memmove
| xref:llvm/AnyMemSetInst.adoc[`AnyMemSetInst`] 
| Wrapper for any memset intrinsic (atomic or non&hyphen;atomic)&period;
| xref:llvm/AnyMemTransferInst.adoc[`AnyMemTransferInst`] 
| Wrapper for any memcpy&sol;memmove intrinsic (atomic or non&hyphen;atomic)&period;
| xref:llvm/AppendingBinaryByteStream.adoc[`AppendingBinaryByteStream`] 
| An implementation of WritableBinaryStream which can write at its end causing the underlying data to grow&period; This class owns the underlying data&period;
| xref:llvm/AppleAccelTableData.adoc[`AppleAccelTableData`] 
| Base class for Apple accelerator table entry data&period;
| xref:llvm/AppleAccelTableOffsetData.adoc[`AppleAccelTableOffsetData`] 
| Accelerator table data implementation for simple Apple accelerator tables with just a DIE reference&period;
| xref:llvm/AppleAccelTableStaticOffsetData.adoc[`AppleAccelTableStaticOffsetData`] 
| Accelerator table data implementation for simple Apple accelerator tables with a DIE offset but no actual DIE pointer&period;
| xref:llvm/AppleAccelTableStaticTypeData.adoc[`AppleAccelTableStaticTypeData`] 
| Accelerator table data implementation for type accelerator tables with a DIE offset but no actual DIE pointer&period;
| xref:llvm/AppleAccelTableTypeData.adoc[`AppleAccelTableTypeData`] 
| Accelerator table data implementation for Apple type accelerator tables&period;
| xref:llvm/AppleAcceleratorTable.adoc[`AppleAcceleratorTable`] 
| This implements the Apple accelerator table format, a precursor of the DWARF 5 accelerator table format&period;
| xref:llvm/ArgInfo.adoc[`ArgInfo`] 
| Helper struct shared between Function Specialization and SCCP Solver&period;
| xref:llvm/Argument.adoc[`Argument`] 
| This class represents an incoming formal argument to a Function&period;
| xref:llvm/ArgumentInit.adoc[`ArgumentInit`] 
| Represents a positional or named TableGen argument&period;
| xref:llvm/ArgumentPromotionPass.adoc[`ArgumentPromotionPass`] 
| Argument promotion pass&period;
| xref:llvm/ArrayRecycler-0f.adoc[`ArrayRecycler`] 
| Recycle small arrays allocated from a BumpPtrAllocator&period;
| xref:llvm/ArrayRef-08.adoc[`ArrayRef`] 
| A constant reference to consecutive elements in memory&period;
| xref:llvm/ArrayType.adoc[`ArrayType`] 
| Class to represent array types&period;
| xref:llvm/AsmCommentConsumer.adoc[`AsmCommentConsumer`] 
| A callback class which is notified of each comment in an assembly file as it is lexed&period;
| xref:llvm/AsmCond.adoc[`AsmCond`] 
| AsmCond &hyphen; Class to support conditional assembly
| xref:llvm/AsmFieldInfo.adoc[`AsmFieldInfo`] 
| Field within an assembly structure or type&period;
| xref:llvm/AsmLexer.adoc[`AsmLexer`] 
| Lexer that tokenizes assembly source for the MC assembler parser&period;
| xref:llvm/AsmParserContext.adoc[`AsmParserContext`] 
| Registry of file location information for LLVM IR constructs&period;
| xref:llvm/AsmPrinter.adoc[`AsmPrinter`] 
| This class is intended to be used as a driving class for all asm writers&period;
| xref:llvm/AsmPrinterAnalysis.adoc[`AsmPrinterAnalysis`] 
| Module analysis that holds a shared AsmPrinter for a module&period;
| xref:llvm/AsmPrinterHandler.adoc[`AsmPrinterHandler`] 
| Collects and handles AsmPrinter objects required to build debug or EH information&period;
| xref:llvm/AsmRewrite.adoc[`AsmRewrite`] 
| Description of a rewrite to apply when converting MS&hyphen;style inline assembly&period;
| xref:llvm/AsmToken.adoc[`AsmToken`] 
| Target independent representation for an assembler token&period;
| xref:llvm/AsmTypeInfo.adoc[`AsmTypeInfo`] 
| Generic type information for an assembly object&period;
| xref:llvm/AssemblerConstantPools.adoc[`AssemblerConstantPools`] 
| Manages per&hyphen;section constant pools used by the assembler ldr&hyphen;pseudo&period;
| xref:llvm/AssemblyAnnotationWriter.adoc[`AssemblyAnnotationWriter`] 
| Interface for adding special&hyphen;purpose annotations to LLVM assembly printouts&period;
| xref:llvm/AssertAlignSDNode.adoc[`AssertAlignSDNode`] 
| SDNode asserting that a value is aligned to a given alignment&period;
| xref:llvm/AssertingVH.adoc[`AssertingVH`] 
| Value handle that asserts if the Value is deleted&period;
| xref:llvm/AssignGUIDPass.adoc[`AssignGUIDPass`] 
| Module pass that assigns a globally unique identifier to every global value&period;
| xref:llvm/AssignmentTrackingAnalysis.adoc[`AssignmentTrackingAnalysis`] 
| Legacy analysis pass that computes assignment&hyphen;tracking locations&period;
| xref:llvm/AssignmentTrackingPass.adoc[`AssignmentTrackingPass`] 
| Convert dbg&period;declare intrinsics into sets of dbg&period;assign intrinsics&period;
| xref:llvm/AssumeAlignInfo.adoc[`AssumeAlignInfo`] 
| Parsed operands of an `align` assume operand bundle&period;
| xref:llvm/AssumeBuilderPass.adoc[`AssumeBuilderPass`] 
| This pass will try to build an llvm&period;assume for every instruction in the function&period; Its main purpose is testing&period;
| xref:llvm/AssumeDereferenceableInfo.adoc[`AssumeDereferenceableInfo`] 
| Parsed operands of a `dereferenceable` assume operand bundle&period;
| xref:llvm/AssumeInst.adoc[`AssumeInst`] 
| This represents the llvm&period;assume intrinsic&period;
| xref:llvm/AssumeNoUndefInfo.adoc[`AssumeNoUndefInfo`] 
| Parsed operands of a `noundef` assume operand bundle&period;
| xref:llvm/AssumeNonNullInfo.adoc[`AssumeNonNullInfo`] 
| Parsed operands of a `nonnull` assume operand bundle&period;
| xref:llvm/AssumeSeparateStorageInfo.adoc[`AssumeSeparateStorageInfo`] 
| Parsed operands of a `separate&lowbar;storage` assume operand bundle&period;
| xref:llvm/AssumeSimplifyPass.adoc[`AssumeSimplifyPass`] 
| This pass attempts to minimize the number of assume without loosing any information&period;
| xref:llvm/AssumptionAnalysis.adoc[`AssumptionAnalysis`] 
| A function analysis which provides an `AssumptionCache&period;`
| xref:llvm/AssumptionCache.adoc[`AssumptionCache`] 
| A cache of @llvm&period;assume calls within a function&period;
| xref:llvm/AssumptionCacheTracker.adoc[`AssumptionCacheTracker`] 
| An immutable pass that tracks lazily created `AssumptionCache` objects&period;
| xref:llvm/AssumptionPrinterPass.adoc[`AssumptionPrinterPass`] 
| Printer pass for the `AssumptionAnalysis` results&period;
| xref:llvm/AtomicCmpXchgInst.adoc[`AtomicCmpXchgInst`] 
| An atomic compare&hyphen;and&hyphen;exchange instruction&period;
| xref:llvm/AtomicExpandPass.adoc[`AtomicExpandPass`] 
| New PM pass that expands atomic instructions for the target&period;
| xref:llvm/AtomicInfo.adoc[`AtomicInfo`] 
| Helper for emitting IR for atomic loads, stores, and compare&hyphen;exchange&period;
| xref:llvm/AtomicRMWInst.adoc[`AtomicRMWInst`] 
| An atomic read&hyphen;modify&hyphen;write instruction&period;
| xref:llvm/AtomicSDNode.adoc[`AtomicSDNode`] 
| This is an SDNode representing atomic operations&period;
| xref:llvm/AttrBuilder.adoc[`AttrBuilder`] 
| Mutable builder used with Attribute&colon;&colon;get to assemble attributes&period;
| xref:llvm/Attribute.adoc[`Attribute`] 
| Represents a single IR attribute on a function, parameter, or return value&period;
| xref:llvm/AttributeImpl.adoc[`AttributeImpl`] 
| Internal uniquified storage for a single `Attribute` value&period;
| xref:llvm/AttributeList.adoc[`AttributeList`] 
| Holds attributes for a function, its return value, and its parameters&period;
| xref:llvm/AttributeListImpl.adoc[`AttributeListImpl`] 
| Internal uniquified storage for an `AttributeList&period;`
| xref:llvm/AttributeMask.adoc[`AttributeMask`] 
| This class stores enough information to efficiently remove some attributes from an existing AttrBuilder, AttributeSet or AttributeList&period;
| xref:llvm/AttributeSet.adoc[`AttributeSet`] 
| Immutable set of attributes for one argument, parameter, function, or return&period;
| xref:llvm/AttributeSetNode.adoc[`AttributeSetNode`] 
| Internal uniquified storage for an `AttributeSet&period;`
| xref:llvm/Attributor.adoc[`Attributor`] 
| The fixpoint analysis framework that orchestrates the attribute deduction&period;
| xref:llvm/AttributorCGSCCPass.adoc[`AttributorCGSCCPass`] 
| CGSCC pass that runs the Attributor&period;
| xref:llvm/AttributorCallGraph.adoc[`AttributorCallGraph`] 
| Call graph rooted at the Attributor&apos;s initial function set&period;
| xref:llvm/AttributorConfig.adoc[`AttributorConfig`] 
| Configuration for the Attributor&period;
| xref:llvm/AttributorLightCGSCCPass.adoc[`AttributorLightCGSCCPass`] 
| Lightweight Attributor CGSCC pass that only runs attribute inference&period;
| xref:llvm/AttributorLightPass.adoc[`AttributorLightPass`] 
| Lightweight Attributor module pass that only runs attribute inference&period;
| xref:llvm/AttributorPass.adoc[`AttributorPass`] 
| Module pass that runs the full Attributor&period;
| xref:llvm/AutoInitRemark.adoc[`AutoInitRemark`] 
| Special case for &hyphen;ftrivial&hyphen;auto&hyphen;var&hyphen;init remarks&period;
| xref:llvm/Automaton.adoc[`Automaton`] 
| A deterministic finite&hyphen;state automaton&period; The automaton is defined in TableGen&semi; this object drives an automaton defined by tblgen&hyphen;emitted tables&period;
| xref:llvm/BBClusterInfo.adoc[`BBClusterInfo`] 
| Cluster information for a machine basic block identified by a unique BB ID&period;
| xref:llvm/BCArray.adoc[`BCArray`] 
| Represents an array of some other type&period;
| xref:llvm/BCBlob.adoc[`BCBlob`] 
| Represents an untyped blob of bytes&period;
| xref:llvm/BCBlockRAII.adoc[`BCBlockRAII`] 
| RAII object to pair entering and exiting a sub&hyphen;block&period;
| xref:llvm/BCChar6.adoc[`BCChar6`] 
| Represents a character encoded in LLVM&apos;s Char6 encoding&period;
| xref:llvm/BCDumpOptions.adoc[`BCDumpOptions`] 
| Options for dumping bitstream contents while analyzing bitcode&period;
| xref:llvm/BCFixed.adoc[`BCFixed`] 
| Represents a fixed&hyphen;width value in a bitcode record&period;
| xref:llvm/BCGenericRecordLayout.adoc[`BCGenericRecordLayout`] 
| Represents a single bitcode record type&period;
| xref:llvm/BCLiteral.adoc[`BCLiteral`] 
| Represents a literal operand in a bitcode record&period;
| xref:llvm/BCRecordLayout.adoc[`BCRecordLayout`] 
| A record with a fixed record code&period;
| xref:llvm/BCVBR.adoc[`BCVBR`] 
| Represents a variable&hyphen;width value in a bitcode record&period;
| xref:llvm/BDCEPass.adoc[`BDCEPass`] 
| Bit&hyphen;Tracking Dead Code Elimination pass&period;
| xref:llvm/BFIDOTGraphTraitsBase.adoc[`BFIDOTGraphTraitsBase`] 
| DOT GraphTraits helpers for block&hyphen;frequency visualization&period;
| xref:llvm/BLAKE3.adoc[`BLAKE3`] 
| A class that wraps the BLAKE3 algorithm&period;
| xref:llvm/BPFunctionNode.adoc[`BPFunctionNode`] 
| A function with a set of utility nodes where it is beneficial to order two functions close together if they have similar utility nodes
| xref:llvm/BPFunctionNodeTest_Basic_Test.adoc[`BPFunctionNodeTest&lowbar;Basic&lowbar;Test`] 
| Test fixture with access to BPFunctionNode internals
| xref:llvm/BPIPassTrait-02.adoc[`BPIPassTrait`] 
| Simple trait class that provides a mapping between BPI passes and the corresponding BPInfo&period;
| xref:llvm/BTFContext.adoc[`BTFContext`] 
| DIContext that answers queries from BPF Type Format (BTF) debug info&period;
| xref:llvm/BTFParser.adoc[`BTFParser`] 
| Parser for BPF Type Format (&period;BTF and &period;BTF&period;ext) ELF sections&period;
| xref:llvm/BalancedPartitioning.adoc[`BalancedPartitioning`] 
| Recursive balanced graph partitioning for ordering function nodes
| xref:llvm/BalancedPartitioningConfig.adoc[`BalancedPartitioningConfig`] 
| Algorithm parameters&semi; default values are tuned on real&hyphen;world binaries
| xref:llvm/BalancedPartitioningTest_Basic_Test.adoc[`BalancedPartitioningTest&lowbar;Basic&lowbar;Test`] 
| Test fixture with access to BalancedPartitioning internals
| xref:llvm/BalancedPartitioningTest_Large_Test.adoc[`BalancedPartitioningTest&lowbar;Large&lowbar;Test`] 
| Test fixture for large BalancedPartitioning cases
| xref:llvm/BalancedPartitioningTest_MoveGain_Test.adoc[`BalancedPartitioningTest&lowbar;MoveGain&lowbar;Test`] 
| Test fixture with access to BalancedPartitioning&colon;&colon;moveGain
| xref:llvm/BaseIndexOffset.adoc[`BaseIndexOffset`] 
| Helper struct to parse and store a memory address as base &plus; index &plus; offset&period;
| xref:llvm/BaseRecord.adoc[`BaseRecord`] 
| Shared accessors for Directive and Clause records in DirectiveBase&period;td&period;
| xref:llvm/BasicAA.adoc[`BasicAA`] 
| Analysis pass providing a never&hyphen;invalidated alias analysis result&period;
| xref:llvm/BasicAAResult.adoc[`BasicAAResult`] 
| AA result for basic, local, and stateless alias analysis&period;
| xref:llvm/BasicAAWrapperPass.adoc[`BasicAAWrapperPass`] 
| Legacy wrapper pass to provide the BasicAAResult object&period;
| xref:llvm/BasicBlock.adoc[`BasicBlock`] 
| LLVM Basic Block Representation
| xref:llvm/BasicBlockEdge.adoc[`BasicBlockEdge`] 
| Directed edge between two basic blocks in a CFG&period;
| xref:llvm/BasicBlockMatchingAndInference.adoc[`BasicBlockMatchingAndInference`] 
| Pass that matches Propeller profile basic blocks and infers their weights&period;
| xref:llvm/BasicBlockSDNode.adoc[`BasicBlockSDNode`] 
| SDNode referencing a MachineBasicBlock&period;
| xref:llvm/BasicBlockSectionsProfileReader.adoc[`BasicBlockSectionsProfileReader`] 
| Reader for basic block sections profiles used to drive BB layout&period;
| xref:llvm/BasicBlockSectionsProfileReaderAnalysis.adoc[`BasicBlockSectionsProfileReaderAnalysis`] 
| Analysis pass providing the `BasicBlockSectionsProfileReader&period;`
| xref:llvm/BasicBlockSectionsProfileReaderWrapperPass.adoc[`BasicBlockSectionsProfileReaderWrapperPass`] 
| Immutable wrapper pass that owns a BasicBlockSectionsProfileReader&period;
| xref:llvm/BasicDIEUnit.adoc[`BasicDIEUnit`] 
| Concrete DIE unit used when no specialized unit behavior is required&period;
| xref:llvm/BasicSubtargetFeatureKV.adoc[`BasicSubtargetFeatureKV`] 
| Used to provide key value pairs for subtarget feature bit flags&period;
| xref:llvm/BasicSubtargetSubTypeKV.adoc[`BasicSubtargetSubTypeKV`] 
| Used to provide key value pairs for feature and CPU bit flags&period;
| xref:llvm/BasicTTIImpl.adoc[`BasicTTIImpl`] 
| Concrete BasicTTIImpl that can be used if no further customization is needed&period;
| xref:llvm/BasicTTIImplBase-03.adoc[`BasicTTIImplBase`] 
| Base class which can be used to help build a TTI implementation&period;
| xref:llvm/BatchAACrossIterationScope.adoc[`BatchAACrossIterationScope`] 
| Temporarily set the cross iteration mode on a BatchAA instance&period;
| xref:llvm/BatchAAResults.adoc[`BatchAAResults`] 
| Batch wrapper that reuses AAQueryInfo across alias queries&period;
| xref:llvm/BinOpInit.adoc[`BinOpInit`] 
| Represents a binary initializer operator&period;
| xref:llvm/BinaryByteStream.adoc[`BinaryByteStream`] 
| BinaryStream backed by a single contiguous buffer that never copies on read&period;
| xref:llvm/BinaryInstrProfCorrelator.adoc[`BinaryInstrProfCorrelator`] 
| BinaryInstrProfCorrelator &hyphen; A child of InstrProfCorrelatorImpl that takes an object file as input to correlate profiles&period;
| xref:llvm/BinaryItemStream.adoc[`BinaryItemStream`] 
| A BinaryStream over a sequence of items from an external container&period;
| xref:llvm/BinaryItemTraits-05.adoc[`BinaryItemTraits`] 
| Traits describing how to obtain the size and bytes of a stream item&period;
| xref:llvm/BinaryOpIntrinsic.adoc[`BinaryOpIntrinsic`] 
| This class represents an intrinsic that is based on a binary operation&period; This includes op&period;with&period;overflow and saturating add&sol;sub intrinsics&period;
| xref:llvm/BinaryOperator.adoc[`BinaryOperator`] 
| Instruction representing a standard binary operator&period;
| xref:llvm/BinaryStream.adoc[`BinaryStream`] 
| An interface for accessing data in a stream&hyphen;like format without copying&period;
| xref:llvm/BinaryStreamError.adoc[`BinaryStreamError`] 
| Base class for errors originating when parsing raw PDB files
| xref:llvm/BinaryStreamReader.adoc[`BinaryStreamReader`] 
| Read&hyphen;only accessor for a BinaryStream with bounds&hyphen;checked typed reads&period;
| xref:llvm/BinaryStreamRef.adoc[`BinaryStreamRef`] 
| A copyable, read&hyphen;only window into a BinaryStream&period;
| xref:llvm/BinaryStreamRefBase-0f.adoc[`BinaryStreamRefBase`] 
| Common stuff for mutable and immutable StreamRefs&period;
| xref:llvm/BinaryStreamWriter.adoc[`BinaryStreamWriter`] 
| Provides write&hyphen;only access to a subclass of `WritableBinaryStream`&period;
| xref:llvm/BinarySubstreamRef.adoc[`BinarySubstreamRef`] 
| A substream identified by an absolute offset and a BinaryStreamRef&period;
| xref:llvm/BitCastInst.adoc[`BitCastInst`] 
| Instruction that bitcasts a value to another type of the same size&period;
| xref:llvm/BitCastOperator.adoc[`BitCastOperator`] 
| Concrete operator for the BitCast instruction opcode&period;
| xref:llvm/BitCodeAbbrev.adoc[`BitCodeAbbrev`] 
| Abbreviation record that stores a complex record in a specialized format&period;
| xref:llvm/BitCodeAbbrevOp.adoc[`BitCodeAbbrevOp`] 
| One or more operands in a bitstream abbreviation&period;
| xref:llvm/BitInit.adoc[`BitInit`] 
| &apos;true&apos;&sol;&apos;false&apos; &hyphen; Represent a concrete initializer for a bit&period;
| xref:llvm/BitIntegerState-0f.adoc[`BitIntegerState`] 
| Specialization of the integer state for a bit&hyphen;wise encoding&period;
| xref:llvm/BitMaskClassIterator.adoc[`BitMaskClassIterator`] 
| Iterator over register classes selected by a bitmask&period;
| xref:llvm/BitRecTy.adoc[`BitRecTy`] 
| &apos;bit&apos; &hyphen; Represent a single bit
| xref:llvm/BitVector.adoc[`BitVector`] 
| Dynamically sized bit vector with efficient bit&hyphen;level operations&period;
| xref:llvm/BitcodeAnalyzer.adoc[`BitcodeAnalyzer`] 
| Analyzer that dumps and collects statistics from bitcode streams&period;
| xref:llvm/BitcodeFileContents.adoc[`BitcodeFileContents`] 
| Contents of a bitcode file, including modules and symbol table data&period;
| xref:llvm/BitcodeLTOInfo.adoc[`BitcodeLTOInfo`] 
| Basic information extracted from a bitcode module to be used for LTO&period;
| xref:llvm/BitcodeModule.adoc[`BitcodeModule`] 
| Represents a module in a bitcode file&period;
| xref:llvm/BitcodeWriter.adoc[`BitcodeWriter`] 
| Writer that serializes LLVM IR modules and ThinLTO indexes to bitcode&period;
| xref:llvm/BitcodeWriterPass.adoc[`BitcodeWriterPass`] 
| Pass for writing a module of IR out to a bitcode file&period;
| xref:llvm/Bitfield.adoc[`Bitfield`] 
| Holds functions to get, set or test bitfields&period;
| xref:llvm/BitsInit.adoc[`BitsInit`] 
| &apos;&lcub; a, b, c &rcub;&apos; &hyphen; Represents an initializer for a BitsRecTy value&period; It contains a vector of bits, whose size is determined by the type&period;
| xref:llvm/BitsRecTy.adoc[`BitsRecTy`] 
| &apos;bits&lt;n&gt;&apos; &hyphen; Represent a fixed number of bits
| xref:llvm/Bitset-03.adoc[`Bitset`] 
| This is a constexpr reimplementation of a subset of std&colon;&colon;bitset&period; It would be nice to use std&colon;&colon;bitset directly, but it doesn&apos;t support constant initialization&period;
| xref:llvm/BitstreamBlockInfo.adoc[`BitstreamBlockInfo`] 
| This class maintains the abbreviations read from a block info block&period;
| xref:llvm/BitstreamCursor.adoc[`BitstreamCursor`] 
| This represents a position within a bitcode file, implemented on top of a SimpleBitstreamCursor&period;
| xref:llvm/BitstreamEntry.adoc[`BitstreamEntry`] 
| When advancing through a bitstream cursor, each advance can discover a few different kinds of entries&colon;
| xref:llvm/BitstreamWriter.adoc[`BitstreamWriter`] 
| Low&hyphen;level writer for emitting an arbitrary LLVM bitstream&period;
| xref:llvm/BlendedBlockHash.adoc[`BlendedBlockHash`] 
| An object wrapping several components of a basic block hash&period;
| xref:llvm/BlockAddress.adoc[`BlockAddress`] 
| The address of a basic block&period;
| xref:llvm/BlockAddressSDNode.adoc[`BlockAddressSDNode`] 
| SDNode referencing a BlockAddress with optional offset and flags&period;
| xref:llvm/BlockCoverageInference.adoc[`BlockCoverageInference`] 
| Infers whole&hyphen;CFG execution coverage from a minimal set of instrumented blocks&period;
| xref:llvm/BlockDataT.adoc[`BlockDataT`] 
| Per&hyphen;block data saved to compare IR before and after a pass&period;
| xref:llvm/BlockExtractorPass.adoc[`BlockExtractorPass`] 
| Pass that extracts specified basic blocks into their own functions&period;
| xref:llvm/BlockFrequency.adoc[`BlockFrequency`] 
| Relative execution frequency of a basic block, stored as a 64&hyphen;bit fixed&hyphen;point value scaled by the function entry frequency&period;
| xref:llvm/BlockFrequencyAnalysis.adoc[`BlockFrequencyAnalysis`] 
| Analysis pass which computes `BlockFrequencyInfo&period;`
| xref:llvm/BlockFrequencyInfo.adoc[`BlockFrequencyInfo`] 
| BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequencies&period;
| xref:llvm/BlockFrequencyInfoImpl.adoc[`BlockFrequencyInfoImpl`] 
| Shared implementation for block frequency analysis&period;
| xref:llvm/BlockFrequencyInfoImplBase.adoc[`BlockFrequencyInfoImplBase`] 
| Base class for BlockFrequencyInfoImpl
| xref:llvm/BlockFrequencyInfoWrapperPass.adoc[`BlockFrequencyInfoWrapperPass`] 
| Legacy analysis pass which computes `BlockFrequencyInfo&period;`
| xref:llvm/BlockFrequencyPrinterPass.adoc[`BlockFrequencyPrinterPass`] 
| Printer pass for the `BlockFrequencyInfo` results&period;
| xref:llvm/BlockToIndexMapping.adoc[`BlockToIndexMapping`] 
| Bidirectional mapping between a function&apos;s basic blocks and dense indices&period;
| xref:llvm/BooleanLoopTags.adoc[`BooleanLoopTags`] 
| Single&hyphen;operand tags replacing a removed two&hyphen;operand form !&lcub;!&quot;&lt;Enable&gt;&quot;, i1 X&rcub;&colon; X &equals; true selects Enable, X &equals; false selects Disable&period;
| xref:llvm/BooleanState.adoc[`BooleanState`] 
| Simple wrapper for a single bit (boolean) state&period;
| xref:llvm/BoundsCheckingPass.adoc[`BoundsCheckingPass`] 
| A pass to instrument code and perform run&hyphen;time bounds checking on loads, stores, and other memory intrinsics&period;
| xref:llvm/BranchFolderPass.adoc[`BranchFolderPass`] 
| New PM pass that optimizes the machine CFG by folding branches&period;
| xref:llvm/BranchProbability.adoc[`BranchProbability`] 
| Branch probability as a non&hyphen;negative fraction no greater than one&period;
| xref:llvm/BranchProbabilityAnalysis.adoc[`BranchProbabilityAnalysis`] 
| Analysis pass which computes `BranchProbabilityInfo&period;`
| xref:llvm/BranchProbabilityInfo.adoc[`BranchProbabilityInfo`] 
| Analysis providing relative branch probabilities for CFG edges&period;
| xref:llvm/BranchProbabilityInfoWrapperPass.adoc[`BranchProbabilityInfoWrapperPass`] 
| Legacy analysis pass which computes `BranchProbabilityInfo&period;`
| xref:llvm/BranchProbabilityPrinterPass.adoc[`BranchProbabilityPrinterPass`] 
| Printer pass for the `BranchProbabilityAnalysis` results&period;
| xref:llvm/BranchRelaxationPass.adoc[`BranchRelaxationPass`] 
| New PM pass that relaxes out&hyphen;of&hyphen;range machine branches&period;
| xref:llvm/BreakCriticalEdgesPass.adoc[`BreakCriticalEdgesPass`] 
| Pass that breaks critical edges in the CFG by inserting dummy basic blocks&period;
| xref:llvm/BreakFalseDepsPass.adoc[`BreakFalseDepsPass`] 
| New PM pass that breaks false register dependencies which cause stalls&period;
| xref:llvm/BuildAttributeItem.adoc[`BuildAttributeItem`] 
| One tag&sol;value pair from an ELF extended build&hyphen;attributes subsection&period;
| xref:llvm/BuildAttributeSubSection.adoc[`BuildAttributeSubSection`] 
| One vendor subsection of an ELF extended build&hyphen;attributes section&period;
| xref:llvm/BuildVectorSDNode.adoc[`BuildVectorSDNode`] 
| A &quot;pseudo&hyphen;class&quot; with methods for operating on BUILD&lowbar;VECTORs&period;
| xref:llvm/BumpPtrAllocatorImpl.adoc[`BumpPtrAllocatorImpl`] 
| Allocate memory in an ever growing pool, as if by bump&hyphen;pointer&period;
| xref:llvm/ByteProvider.adoc[`ByteProvider`] 
| Represents the known origin of an individual byte in a combine pattern&period;
| xref:llvm/ByteType.adoc[`ByteType`] 
| Class to represent byte types&period;
| xref:llvm/CCState.adoc[`CCState`] 
| Tracks register and stack assignments while lowering arguments and returns&period;
| xref:llvm/CCValAssign.adoc[`CCValAssign`] 
| CCValAssign &hyphen; Represent assignment of one arg&sol;retval to a location&period;
| xref:llvm/CFGAnalyses.adoc[`CFGAnalyses`] 
| Represents analyses that only rely on functions&apos; control flow&period;
| xref:llvm/CFGMST.adoc[`CFGMST`] 
| An union&hyphen;find based Minimum Spanning Tree for CFG
| xref:llvm/CFGOnlyPrinterPass.adoc[`CFGOnlyPrinterPass`] 
| Pass that writes a function CFG to a DOT file without block bodies&period;
| xref:llvm/CFGOnlyViewerPass.adoc[`CFGOnlyViewerPass`] 
| Pass that displays a function CFG in a Graphviz viewer without block bodies&period;
| xref:llvm/CFGPrinterPass.adoc[`CFGPrinterPass`] 
| Pass that writes a function CFG to a DOT file&period;
| xref:llvm/CFGProfile.adoc[`CFGProfile`] 
| CFG profile data for a function, including block and edge counts&period;
| xref:llvm/CFGSCCPrinterPass.adoc[`CFGSCCPrinterPass`] 
| Printer pass for strongly connected components of a function CFG&period;
| xref:llvm/CFGViewerPass.adoc[`CFGViewerPass`] 
| Pass that displays a function CFG in a Graphviz viewer&period;
| xref:llvm/CFGuardPass.adoc[`CFGuardPass`] 
| New Pass Manager pass that inserts Control Flow Guard checks&period;
| xref:llvm/CFIFixupLegacy.adoc[`CFIFixupLegacy`] 
| Legacy MachineFunctionPass that inserts CFI remember&sol;restore instructions&period;
| xref:llvm/CFIFixupPass.adoc[`CFIFixupPass`] 
| New PM pass that inserts CFI remember&sol;restore instructions&period;
| xref:llvm/CFIFunctionFrameAnalyzer.adoc[`CFIFunctionFrameAnalyzer`] 
| Validates Call Frame Information across a stream of function frames&period;
| xref:llvm/CFIFunctionFrameReceiver.adoc[`CFIFunctionFrameReceiver`] 
| Abstract interface for receiving DWARF Call Frame Information for function frames&period;
| xref:llvm/CFIFunctionFrameStreamer.adoc[`CFIFunctionFrameStreamer`] 
| MCStreamer that cuts CFI and instructions into frames for a receiver&period;
| xref:llvm/CFIInstBuilder.adoc[`CFIInstBuilder`] 
| Helper class for creating CFI instructions and inserting them into MIR&period;
| xref:llvm/CFIInstrInserterPass.adoc[`CFIInstrInserterPass`] 
| New PM pass that inserts correcting CFI instructions&period;
| xref:llvm/CGDataError.adoc[`CGDataError`] 
| Typed error carrying a `cgdata&lowbar;error` code and optional message&period;
| xref:llvm/CGDataOStream.adoc[`CGDataOStream`] 
| A wrapper class to abstract writer stream with support of bytes back patching&period;
| xref:llvm/CGDataPatchItem.adoc[`CGDataPatchItem`] 
| A struct to define how the data stream should be patched&period;
| xref:llvm/CGPassBuilderOption.adoc[`CGPassBuilderOption`] 
| Options that configure the code&hyphen;generation pass pipeline&period;
| xref:llvm/CGProfilePass.adoc[`CGProfilePass`] 
| Pass that builds call&hyphen;graph profile counts and attaches them as module metadata&period;
| xref:llvm/CGSCCToFunctionPassAdaptor.adoc[`CGSCCToFunctionPassAdaptor`] 
| Adaptor that maps from a SCC to its functions&period;
| xref:llvm/CGSCCUpdateResult.adoc[`CGSCCUpdateResult`] 
| Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager infrastructure&period;
| xref:llvm/CHERICapabilityFormatBase-0e.adoc[`CHERICapabilityFormatBase`] 
| CRTP base for CHERI capability format helpers&period;
| xref:llvm/CHERIoTCapabilityFormat.adoc[`CHERIoTCapabilityFormat`] 
| CHERIoT compressed capability format helpers&period;
| xref:llvm/CRCTable.adoc[`CRCTable`] 
| A 256&hyphen;entry CRC lookup table with a print helper&period;
| xref:llvm/CSEConfigBase.adoc[`CSEConfigBase`] 
| Base configuration for CSE during GlobalISel CSEInfo analysis&period;
| xref:llvm/CSEConfigConstantOnly.adoc[`CSEConfigConstantOnly`] 
| CSE configuration that only CSEs constant&hyphen;like generic opcodes&period;
| xref:llvm/CSEConfigFull.adoc[`CSEConfigFull`] 
| CSE configuration that enables CSE for a full set of generic opcodes&period;
| xref:llvm/CSEMIRBuilder.adoc[`CSEMIRBuilder`] 
| Defines a builder that does CSE of MachineInstructions using GISelCSEInfo&period; Eg usage&period;
| xref:llvm/CSKYAttributeParser.adoc[`CSKYAttributeParser`] 
| Parser for CSKY ELF build attributes&period;
| xref:llvm/CacheCost.adoc[`CacheCost`] 
| Estimated cache&hyphen;line cost of loops in a nest&period;
| xref:llvm/CachePruningPolicy.adoc[`CachePruningPolicy`] 
| Policy for the pruneCache() function&period; A default constructed CachePruningPolicy provides a reasonable default policy&period;
| xref:llvm/CachedFileStream.adoc[`CachedFileStream`] 
| This class wraps an output stream for a file&period;
| xref:llvm/CachedHashString.adoc[`CachedHashString`] 
| A container which contains a string, which it owns, plus a precomputed hash&period;
| xref:llvm/CachedHashStringRef.adoc[`CachedHashStringRef`] 
| A container which contains a StringRef plus a precomputed hash&period;
| xref:llvm/CalculateSmallVectorDefaultInlinedElements.adoc[`CalculateSmallVectorDefaultInlinedElements`] 
| Helper class for calculating the default number of inline elements for `SmallVector&lt;T&gt;`&period;
| xref:llvm/CallBase.adoc[`CallBase`] 
| Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to calling a function&period;
| xref:llvm/CallBrInst.adoc[`CallBrInst`] 
| Call that may transfer control to a default or indirect destination&period;
| xref:llvm/CallEntryPseudoSourceValue.adoc[`CallEntryPseudoSourceValue`] 
| A PseudoSourceValue representing a call entry (GlobalValue or external symbol)&period;
| xref:llvm/CallGraph-03.adoc[`CallGraph`] 
| The basic data container for the call graph of a `Module` of IR&period;
| xref:llvm/CallGraphAnalysis.adoc[`CallGraphAnalysis`] 
| An analysis pass to compute the `CallGraph` for a `Module&period;`
| xref:llvm/CallGraphDOTPrinterPass.adoc[`CallGraphDOTPrinterPass`] 
| Pass for printing the call graph to a dot file
| xref:llvm/CallGraphNode.adoc[`CallGraphNode`] 
| A node in the call graph for a module&period;
| xref:llvm/CallGraphPrinterPass.adoc[`CallGraphPrinterPass`] 
| Printer pass for the `CallGraphAnalysis` results&period;
| xref:llvm/CallGraphSCC.adoc[`CallGraphSCC`] 
| CallGraphSCC &hyphen; This is a single SCC that a CallGraphSCCPass is run on&period;
| xref:llvm/CallGraphSCCPass.adoc[`CallGraphSCCPass`] 
| Base class for passes that run bottom&hyphen;up over call&hyphen;graph SCCs&period;
| xref:llvm/CallGraphSCCsPrinterPass.adoc[`CallGraphSCCsPrinterPass`] 
| Printer pass for the summarized `CallGraphAnalysis` results&period;
| xref:llvm/CallGraphUpdater.adoc[`CallGraphUpdater`] 
| Wrapper to unify &quot;old style&quot; CallGraph and &quot;new style&quot; LazyCallGraph&period;
| xref:llvm/CallGraphViewerPass.adoc[`CallGraphViewerPass`] 
| Pass for viewing the call graph
| xref:llvm/CallGraphWrapperPass.adoc[`CallGraphWrapperPass`] 
| The `ModulePass` which wraps up a `CallGraph` and the logic to build it&period;
| xref:llvm/CallInst.adoc[`CallInst`] 
| Represent a direct function call instruction&period;
| xref:llvm/CallLowering.adoc[`CallLowering`] 
| Interface for lowering LLVM calls and returns to GlobalISel MIR&period;
| xref:llvm/CallSiteFormat.adoc[`CallSiteFormat`] 
| Controls how call&hyphen;site locations are formatted as strings&period;
| xref:llvm/CallSiteSplittingPass.adoc[`CallSiteSplittingPass`] 
| Pass that splits call sites to expose constrained arguments&period;
| xref:llvm/CallbackVH.adoc[`CallbackVH`] 
| Value handle with callbacks on RAUW and destruction&period;
| xref:llvm/CalledValuePropagationPass.adoc[`CalledValuePropagationPass`] 
| Pass that attaches !callees metadata to indirect call sites&period;
| xref:llvm/CalleeInfo.adoc[`CalleeInfo`] 
| Class to accumulate and hold information about a callee&period;
| xref:llvm/CalleeSavedInfo.adoc[`CalleeSavedInfo`] 
| Tracks where a callee&hyphen;saved register is spilled in the current frame&period;
| xref:llvm/CallsiteID.adoc[`CallsiteID`] 
| Identifies a call site within a basic block for prefetch emission&period;
| xref:llvm/CallsiteInfo.adoc[`CallsiteInfo`] 
| Summary of memprof callsite metadata&period;
| xref:llvm/CanonicalLoopInfo.adoc[`CanonicalLoopInfo`] 
| Describes the control flow structure of an OpenMP canonical loop&period;
| xref:llvm/CanonicalizeAliasesPass.adoc[`CanonicalizeAliasesPass`] 
| Simple pass that canonicalizes aliases&period;
| xref:llvm/CanonicalizeFreezeInLoopsPass.adoc[`CanonicalizeFreezeInLoopsPass`] 
| A pass that canonicalizes freeze instructions in a loop&period;
| xref:llvm/CaptureAnalysis.adoc[`CaptureAnalysis`] 
| Virtual base class for providers of capture analysis&period;
| xref:llvm/CaptureInfo.adoc[`CaptureInfo`] 
| Represents which components of the pointer may be captured in which location&period; This represents the captures(&period;&period;&period;) attribute in IR&period;
| xref:llvm/CaptureResult.adoc[`CaptureResult`] 
| Result of a PointerMayBeCaptured query, which includes the captured components for both the case where return is considered a capture, and where it isn&apos;t&period;
| xref:llvm/CaptureTracker.adoc[`CaptureTracker`] 
| Callback interface for customizing PointerMayBeCaptured traversal&period;
| xref:llvm/CastInfo-01.adoc[`CastInfo`] 
| Customizes how casts from `From` to `To` are performed&period;
| xref:llvm/CastInst.adoc[`CastInst`] 
| Base class of casting instructions&period;
| xref:llvm/CastIsPossible-05.adoc[`CastIsPossible`] 
| Trait that reports whether a cast from `From` to `To` is possible&period;
| xref:llvm/CatchPadInst.adoc[`CatchPadInst`] 
| Enter a catch handler funclet within Windows EH&period;
| xref:llvm/CatchReturnInst.adoc[`CatchReturnInst`] 
| Transfer control from a catch pad to its resume destination&period;
| xref:llvm/CatchSwitchInst.adoc[`CatchSwitchInst`] 
| Dispatch to handler blocks within a Windows EH funclet scope&period;
| xref:llvm/CfiFunctionIndex.adoc[`CfiFunctionIndex`] 
| Encapsulate the names of CFI target functions for ThinLTO export&period;
| xref:llvm/ChangeReporter-00.adoc[`ChangeReporter`] 
| Base class for reporting IR changes under the new pass manager&period;
| xref:llvm/CheckDebugMachineModulePass.adoc[`CheckDebugMachineModulePass`] 
| New PM pass that checks Machine IR debug info after mir&hyphen;debugify&period;
| xref:llvm/Clause.adoc[`Clause`] 
| Accessors for a Clause record defined in DirectiveBase&period;td&period;
| xref:llvm/CleanupInstaller.adoc[`CleanupInstaller`] 
| Manages cleanup of a temporary tool output file&period;
| xref:llvm/CleanupPadInst.adoc[`CleanupPadInst`] 
| Enter a cleanup funclet within Windows EH&period;
| xref:llvm/CleanupReturnInst.adoc[`CleanupReturnInst`] 
| Exit a cleanup funclet, optionally unwinding to a successor block&period;
| xref:llvm/ClonedCodeInfo.adoc[`ClonedCodeInfo`] 
| This struct can be used to capture information about code being cloned, while it is being cloned&period;
| xref:llvm/ClrEHUnwindMapEntry.adoc[`ClrEHUnwindMapEntry`] 
| One entry in the CoreCLR EH unwind map&period;
| xref:llvm/CmpInst.adoc[`CmpInst`] 
| Abstract base class of comparison instructions&period;
| xref:llvm/CmpIntrinsic.adoc[`CmpIntrinsic`] 
| This class represents a ucmp&sol;scmp intrinsic
| xref:llvm/CmpPredicate.adoc[`CmpPredicate`] 
| An abstraction over a CmpInst predicate with optional samesign information&period;
| xref:llvm/CoalescerPair.adoc[`CoalescerPair`] 
| Describes a potential register coalescing opportunity&period;
| xref:llvm/CoalescingBitVector.adoc[`CoalescingBitVector`] 
| A bitvector that coalesces adjacent set bits into intervals&period;
| xref:llvm/CodeExtractor.adoc[`CodeExtractor`] 
| Utility class for extracting code into a new function&period;
| xref:llvm/CodeExtractorAnalysisCache.adoc[`CodeExtractorAnalysisCache`] 
| A cache of analysis results for CodeExtractor&period;
| xref:llvm/CodeGenCoverage.adoc[`CodeGenCoverage`] 
| Tracks which TableGen CodeGen rules have been exercised at runtime&period;
| xref:llvm/CodeGenData.adoc[`CodeGenData`] 
| Process&hyphen;wide singleton holding shared codegen data used across modules&period;
| xref:llvm/CodeGenDataReader.adoc[`CodeGenDataReader`] 
| Abstract base class for reading codegen data from binary or text sources&period;
| xref:llvm/CodeGenDataWriter.adoc[`CodeGenDataWriter`] 
| Writer for codegen data records in binary or text form&period;
| xref:llvm/CodeGenPassBuilder.adoc[`CodeGenPassBuilder`] 
| This class provides access to building LLVM&apos;s passes&period;
| xref:llvm/CodeGenPreparePass.adoc[`CodeGenPreparePass`] 
| New PM pass that prepares IR for instruction selection&period;
| xref:llvm/CodeGenTargetMachineImpl.adoc[`CodeGenTargetMachineImpl`] 
| Implements TargetMachine functionality for CodeGen&hyphen;based targets&period;
| xref:llvm/CodeMetrics.adoc[`CodeMetrics`] 
| Utility to calculate the size and a few similar metrics for a set of basic blocks&period;
| xref:llvm/CodeViewContext.adoc[`CodeViewContext`] 
| CodeViewContext has the real knowledge about this format, so let it access our members&period;
| xref:llvm/CollectorMetadataAnalysis.adoc[`CollectorMetadataAnalysis`] 
| An analysis pass which caches information about the entire Module&period; Records a cache of the &apos;active&apos; gc strategy objects for the current Module&period;
| xref:llvm/CombinationGenerator.adoc[`CombinationGenerator`] 
| Exhaustive generator of combinations across a vector&hyphen;of&hyphen;vectors choice space&period;
| xref:llvm/Combiner.adoc[`Combiner`] 
| Combiner implementation&period; This is per&hyphen;function, so passes need to recreate one of these each time they enter a new function&period;
| xref:llvm/CombinerHelper.adoc[`CombinerHelper`] 
| Helper that implements common GlobalISel combine transformations&period;
| xref:llvm/CombinerInfo.adoc[`CombinerInfo`] 
| Options that control which GlobalISel combines run and how they iterate&period;
| xref:llvm/Comdat.adoc[`Comdat`] 
| Represents a COMDAT group for global objects&period;
| xref:llvm/CompileUnitIdentifiers.adoc[`CompileUnitIdentifiers`] 
| Identifying attributes extracted from a compile or type unit&period;
| xref:llvm/ComplexDeinterleavingPass.adoc[`ComplexDeinterleavingPass`] 
| New PM pass that generates target intrinsics for complex arithmetic&period;
| xref:llvm/ConcreteOperator-05.adoc[`ConcreteOperator`] 
| A helper template for defining operators for individual opcodes&period;
| xref:llvm/ConcurrentHashTableByPtr-04.adoc[`ConcurrentHashTableByPtr`] 
| Concurrent, insert&hyphen;only hash table that stores unique `KeyDataTy` values&period;
| xref:llvm/ConcurrentHashTableInfoByPtr.adoc[`ConcurrentHashTableInfoByPtr`] 
| Default hash&sol;equality&sol;create policy for ConcurrentHashTableByPtr&period;
| xref:llvm/CondBrInst.adoc[`CondBrInst`] 
| Conditional Branch instruction&period;
| xref:llvm/CondCodeSDNode.adoc[`CondCodeSDNode`] 
| SDNode holding an ISD condition code&period;
| xref:llvm/CondContext.adoc[`CondContext`] 
| Evaluate query assuming this condition holds&period;
| xref:llvm/CondOpInit.adoc[`CondOpInit`] 
| Represents a conditional initializer&period;
| xref:llvm/ConnectedVNInfoEqClasses.adoc[`ConnectedVNInfoEqClasses`] 
| Helper that partitions VNInfos in a LiveInterval into connected components&period;
| xref:llvm/ConstMIBundleOperands.adoc[`ConstMIBundleOperands`] 
| ConstMIBundleOperands &hyphen; Iterate over all operands in a const bundle of machine instructions&period;
| xref:llvm/ConstStrippingForwardingCast.adoc[`ConstStrippingForwardingCast`] 
| Forwards const cast sources to a non&hyphen;const `CastInfo` implementation&period;
| xref:llvm/Constant.adoc[`Constant`] 
| LLVM Constant Representation
| xref:llvm/ConstantAggrKeyType.adoc[`ConstantAggrKeyType`] 
| Key type used to unique aggregate constants in the constant pool&period;
| xref:llvm/ConstantAggregate.adoc[`ConstantAggregate`] 
| Constant composed of other constants (for example arrays, structs, and vectors)&period;
| xref:llvm/ConstantAggregateZero.adoc[`ConstantAggregateZero`] 
| All zero aggregate value
| xref:llvm/ConstantArray.adoc[`ConstantArray`] 
| ConstantArray &hyphen; Constant Array Declarations
| xref:llvm/ConstantAsMetadata.adoc[`ConstantAsMetadata`] 
| Metadata wrapping a constant IR value&period;
| xref:llvm/ConstantByte.adoc[`ConstantByte`] 
| Class for constant bytes&period;
| xref:llvm/ConstantData.adoc[`ConstantData`] 
| Leaf constant with no operands (for example integers and floating&hyphen;point literals)&period;
| xref:llvm/ConstantDataArray.adoc[`ConstantDataArray`] 
| Dense array constant of simple integer, byte, or floating&hyphen;point elements&period;
| xref:llvm/ConstantDataArraySlice.adoc[`ConstantDataArraySlice`] 
| Represents offset&plus;length into a ConstantDataArray&period;
| xref:llvm/ConstantDataSequential.adoc[`ConstantDataSequential`] 
| Dense array or vector constant of simple integer, byte, or FP elements&period;
| xref:llvm/ConstantDataVector.adoc[`ConstantDataVector`] 
| Dense vector constant of simple integer or floating&hyphen;point elements&period;
| xref:llvm/ConstantExpr.adoc[`ConstantExpr`] 
| A constant value that is initialized with an expression using other constant values&period;
| xref:llvm/ConstantExprKeyType.adoc[`ConstantExprKeyType`] 
| Key type used to unique ConstantExpr values in the constant pool&period;
| xref:llvm/ConstantFP.adoc[`ConstantFP`] 
| ConstantFP &hyphen; Floating Point Values &lsqb;float, double&rsqb;
| xref:llvm/ConstantFPRange.adoc[`ConstantFPRange`] 
| This class represents a range of floating&hyphen;point values&period;
| xref:llvm/ConstantFPSDNode.adoc[`ConstantFPSDNode`] 
| SDNode representing a floating&hyphen;point constant&period;
| xref:llvm/ConstantFolder.adoc[`ConstantFolder`] 
| ConstantFolder &hyphen; Create constants with minimum, target independent, folding&period;
| xref:llvm/ConstantHoistingPass.adoc[`ConstantHoistingPass`] 
| Pass that hoists and coalesces expensive constants for codegen&period;
| xref:llvm/ConstantInt.adoc[`ConstantInt`] 
| This is the shared class of boolean and integer constants&period; This class represents both boolean and integral constants&period; Class for constant integers&period;
| xref:llvm/ConstantMergePass.adoc[`ConstantMergePass`] 
| A pass that merges duplicate global constants into a single constant&period;
| xref:llvm/ConstantPointerNull.adoc[`ConstantPointerNull`] 
| A constant pointer value that points to null&period; This represents both scalar pointer nulls and vector splats of pointer nulls&period;
| xref:llvm/ConstantPool.adoc[`ConstantPool`] 
| Tracks assembler&hyphen;generated constant pools used to implement the ldr&hyphen;pseudo&period;
| xref:llvm/ConstantPoolEntry.adoc[`ConstantPoolEntry`] 
| A single entry in an assembler&hyphen;generated constant pool&period;
| xref:llvm/ConstantPoolSDNode.adoc[`ConstantPoolSDNode`] 
| SDNode referencing a constant pool entry&period;
| xref:llvm/ConstantPtrAuth.adoc[`ConstantPtrAuth`] 
| A signed pointer, in the ptrauth sense&period;
| xref:llvm/ConstantPtrAuthKeyType.adoc[`ConstantPtrAuthKeyType`] 
| Key type used to unique ConstantPtrAuth values in the constant pool&period;
| xref:llvm/ConstantRange.adoc[`ConstantRange`] 
| This class represents a range of values&period;
| xref:llvm/ConstantRangeList.adoc[`ConstantRangeList`] 
| Ordered list of disjoint constant ranges used by attributes such as `initializes&period;`
| xref:llvm/ConstantSDNode.adoc[`ConstantSDNode`] 
| SDNode representing an integer constant&period;
| xref:llvm/ConstantStruct.adoc[`ConstantStruct`] 
| Constant struct value composed of other constants&period;
| xref:llvm/ConstantTargetNone.adoc[`ConstantTargetNone`] 
| A constant target extension type default initializer
| xref:llvm/ConstantTokenNone.adoc[`ConstantTokenNone`] 
| A constant token which is empty
| xref:llvm/ConstantUniqueMap.adoc[`ConstantUniqueMap`] 
| Map that uniques constant&hyphen;like IR values such as `InlineAsm` by key&period;
| xref:llvm/ConstantVector.adoc[`ConstantVector`] 
| Constant Vector Declarations
| xref:llvm/ConstrainedFPCmpIntrinsic.adoc[`ConstrainedFPCmpIntrinsic`] 
| Constrained floating point compare intrinsics&period;
| xref:llvm/ConstrainedFPIntrinsic.adoc[`ConstrainedFPIntrinsic`] 
| This is the common base class for constrained floating point intrinsics&period;
| xref:llvm/ConstraintEliminationPass.adoc[`ConstraintEliminationPass`] 
| Pass that eliminates conditions using constraints from dominating conditions&period;
| xref:llvm/ConstraintSystem.adoc[`ConstraintSystem`] 
| A system of linear constraints of the form &apos;c &gt;&equals; v1 &ast; c1 &plus; &period;&period;&period; &plus; vn &ast; cn&apos;&period;
| xref:llvm/ContextAndReplaceableUses.adoc[`ContextAndReplaceableUses`] 
| Pointer to the context, with optional RAUW support&period;
| xref:llvm/ContextTotalSize.adoc[`ContextTotalSize`] 
| Full stack id and total profiled size for optional hinted size reporting&period;
| xref:llvm/ContextTrieNode.adoc[`ContextTrieNode`] 
| Trie node representing a calling context and its sample profile&period;
| xref:llvm/ContextualFoldingSetTrait.adoc[`ContextualFoldingSetTrait`] 
| Like FoldingSetTrait, but for ContextualFoldingSets&period;
| xref:llvm/ControlFlowHub.adoc[`ControlFlowHub`] 
| Create a control&hyphen;flow hub that splits branches through guard blocks&period;
| xref:llvm/ControlHeightReductionPass.adoc[`ControlHeightReductionPass`] 
| Pass that merges conditional blocks to reduce branches on hot paths&period;
| xref:llvm/ConvergenceControlInst.adoc[`ConvergenceControlInst`] 
| Represents calls to the llvm&period;experimintal&period;convergence&period;&ast; intrinsics&period;
| xref:llvm/ConvergingVLIWScheduler.adoc[`ConvergingVLIWScheduler`] 
| VLIW&hyphen;aware MachineSchedStrategy that converges from top and bottom queues&period;
| xref:llvm/CopyProfPass.adoc[`CopyProfPass`] 
| Early&hyphen;stage pass that instruments special member functions to call into the CopyProf runtime&period;
| xref:llvm/CopyProfStoresPass.adoc[`CopyProfStoresPass`] 
| Late&hyphen;stage pass that instruments store instructions to detect whether an object copy has been modified before it is destructed&period;
| xref:llvm/CoroAlignInst.adoc[`CoroAlignInst`] 
| This represents the llvm&period;coro&period;align instruction&period;
| xref:llvm/CoroAllocInst.adoc[`CoroAllocInst`] 
| This represents the llvm&period;coro&period;alloc instruction&period;
| xref:llvm/CoroAllocaAllocInst.adoc[`CoroAllocaAllocInst`] 
| This represents the llvm&period;coro&period;alloca&period;alloc instruction&period;
| xref:llvm/CoroAllocaFreeInst.adoc[`CoroAllocaFreeInst`] 
| This represents the llvm&period;coro&period;alloca&period;free instruction&period;
| xref:llvm/CoroAllocaGetInst.adoc[`CoroAllocaGetInst`] 
| This represents the llvm&period;coro&period;alloca&period;get instruction&period;
| xref:llvm/CoroAnnotationElidePass.adoc[`CoroAnnotationElidePass`] 
| Pass that elides heap allocation for coroutine calls marked coro&lowbar;elide&lowbar;safe&period;
| xref:llvm/CoroAsyncContextAllocInst.adoc[`CoroAsyncContextAllocInst`] 
| This represents the llvm&period;coro&period;context&period;alloc instruction&period;
| xref:llvm/CoroAsyncContextDeallocInst.adoc[`CoroAsyncContextDeallocInst`] 
| This represents the llvm&period;coro&period;context&period;dealloc instruction&period;
| xref:llvm/CoroAsyncEndInst.adoc[`CoroAsyncEndInst`] 
| This represents the llvm&period;coro&period;end instruction&period;
| xref:llvm/CoroAsyncResumeInst.adoc[`CoroAsyncResumeInst`] 
| This represents the llvm&period;coro&period;async&period;resume instruction&period; During lowering this is replaced by the resume function of a suspend point (the continuation function)&period;
| xref:llvm/CoroAsyncSizeReplace.adoc[`CoroAsyncSizeReplace`] 
| This represents the llvm&period;coro&period;async&period;size&period;replace instruction&period;
| xref:llvm/CoroAwaitSuspendInst.adoc[`CoroAwaitSuspendInst`] 
| This represents the llvm&period;coro&period;await&period;suspend&period;&lcub;void,bool,handle&rcub; instructions&period;
| xref:llvm/CoroBeginInst.adoc[`CoroBeginInst`] 
| This class represents the llvm&period;coro&period;begin or llvm&period;coro&period;begin&period;custom&period;abi instructions&period;
| xref:llvm/CoroCleanupPass.adoc[`CoroCleanupPass`] 
| Pass that lowers all remaining coroutine intrinsics&period;
| xref:llvm/CoroConditionalWrapper.adoc[`CoroConditionalWrapper`] 
| Module pass that runs nested passes only when the module declares coroutine intrinsics&period;
| xref:llvm/CoroDeadInst.adoc[`CoroDeadInst`] 
| This represents the llvm&period;coro&period;dead instruction&period;
| xref:llvm/CoroEarlyPass.adoc[`CoroEarlyPass`] 
| Pass that lowers early coroutine intrinsics&period;
| xref:llvm/CoroElidePass.adoc[`CoroElidePass`] 
| Pass that replaces dynamic coroutine frame allocation with alloca&period;
| xref:llvm/CoroEndInst.adoc[`CoroEndInst`] 
| This represents the llvm&period;coro&period;end instruction&period;
| xref:llvm/CoroEndResults.adoc[`CoroEndResults`] 
| This represents the llvm&period;end&period;results instruction&period;
| xref:llvm/CoroFrameInst.adoc[`CoroFrameInst`] 
| This represents the llvm&period;coro&period;frame instruction&period;
| xref:llvm/CoroFreeInst.adoc[`CoroFreeInst`] 
| This represents the llvm&period;coro&period;free instruction&period;
| xref:llvm/CoroIdAsyncInst.adoc[`CoroIdAsyncInst`] 
| This represents the llvm&period;coro&period;id&period;async instruction&period;
| xref:llvm/CoroIdInst.adoc[`CoroIdInst`] 
| This represents the llvm&period;coro&period;id instruction&period;
| xref:llvm/CoroIdRetconInst.adoc[`CoroIdRetconInst`] 
| This represents the llvm&period;coro&period;id&period;retcon instruction&period;
| xref:llvm/CoroIdRetconOnceInst.adoc[`CoroIdRetconOnceInst`] 
| This represents the llvm&period;coro&period;id&period;retcon&period;once instruction&period;
| xref:llvm/CoroIsInRampInst.adoc[`CoroIsInRampInst`] 
| This represents the llvm&period;coro&period;is&lowbar;in&lowbar;ramp instruction&period;
| xref:llvm/CoroPromiseInst.adoc[`CoroPromiseInst`] 
| This represents the llvm&period;coro&period;promise instruction&period;
| xref:llvm/CoroSaveInst.adoc[`CoroSaveInst`] 
| This represents the llvm&period;coro&period;save instruction&period;
| xref:llvm/CoroSizeInst.adoc[`CoroSizeInst`] 
| This represents the llvm&period;coro&period;size instruction&period;
| xref:llvm/CoroSplitPass.adoc[`CoroSplitPass`] 
| Pass that builds the coroutine frame and outlines resume and destroy functions&period;
| xref:llvm/CoroSubFnInst.adoc[`CoroSubFnInst`] 
| This class represents the llvm&period;coro&period;subfn&period;addr instruction&period;
| xref:llvm/CoroSuspendAsyncInst.adoc[`CoroSuspendAsyncInst`] 
| This represents the llvm&period;coro&period;suspend&period;async instruction&period;
| xref:llvm/CoroSuspendInst.adoc[`CoroSuspendInst`] 
| This represents the llvm&period;coro&period;suspend instruction&period;
| xref:llvm/CoroSuspendRetconInst.adoc[`CoroSuspendRetconInst`] 
| This represents the llvm&period;coro&period;suspend&period;retcon instruction&period;
| xref:llvm/CorrelatedValuePropagationPass.adoc[`CorrelatedValuePropagationPass`] 
| Pass that propagates values correlated with control&hyphen;flow conditions&period;
| xref:llvm/CostBenefitPair.adoc[`CostBenefitPair`] 
| Pair of size cost and estimated cycle savings from cost&hyphen;benefit analysis&period;
| xref:llvm/CostModelPrinterPass.adoc[`CostModelPrinterPass`] 
| Printer pass for cost modeling results&period;
| xref:llvm/CostTblEntryT.adoc[`CostTblEntryT`] 
| Cost Table Entry
| xref:llvm/CountSumOrPercent.adoc[`CountSumOrPercent`] 
| Aggregate of profile count sums or percentages for overlap reporting&period;
| xref:llvm/CountVisitsPass.adoc[`CountVisitsPass`] 
| Pass that counts how many times each function is visited&period;
| xref:llvm/CrashRecoveryContext.adoc[`CrashRecoveryContext`] 
| Crash recovery helper object&period;
| xref:llvm/CrashRecoveryContextCleanup.adoc[`CrashRecoveryContextCleanup`] 
| Abstract base class of cleanup handlers&period;
| xref:llvm/CrashRecoveryContextCleanupBase.adoc[`CrashRecoveryContextCleanupBase`] 
| Base class of cleanup handler that controls recovery of resources of the given type&period;
| xref:llvm/CrashRecoveryContextCleanupRegistrar.adoc[`CrashRecoveryContextCleanupRegistrar`] 
| Helper class for managing resource cleanups&period;
| xref:llvm/CrashRecoveryContextDeleteCleanup.adoc[`CrashRecoveryContextDeleteCleanup`] 
| Cleanup handler that reclaims resource by calling &apos;delete&apos; on it&period;
| xref:llvm/CrashRecoveryContextDestructorCleanup.adoc[`CrashRecoveryContextDestructorCleanup`] 
| Cleanup handler that reclaims resource by calling destructor on it&period;
| xref:llvm/CrashRecoveryContextReleaseRefCleanup.adoc[`CrashRecoveryContextReleaseRefCleanup`] 
| Cleanup handler that reclaims resource by calling its method &apos;Release&apos;&period;
| xref:llvm/CriticalEdgeSplittingOptions.adoc[`CriticalEdgeSplittingOptions`] 
| Option class for critical edge splitting&period;
| xref:llvm/CrossDSOCFIPass.adoc[`CrossDSOCFIPass`] 
| Pass that exports this module&apos;s CFI checks for cross&hyphen;DSO verification&period;
| xref:llvm/CtxProfAnalysis.adoc[`CtxProfAnalysis`] 
| Analysis that loads and maintains contextual PGO profiles for a module&period;
| xref:llvm/CtxProfAnalysisPrinterPass.adoc[`CtxProfAnalysisPrinterPass`] 
| Printer pass for the `CtxProfAnalysis` results&period;
| xref:llvm/CxxUnwindMapEntry.adoc[`CxxUnwindMapEntry`] 
| One entry in the C&plus;&plus; EH unwind map for &lowbar;&lowbar;CxxFrameHandler3&period;
| xref:llvm/CycleAnalysis.adoc[`CycleAnalysis`] 
| Analysis pass which computes a xref:llvm/CycleInfo.adoc[`CycleInfo`]&period;
| xref:llvm/CycleInfo.adoc[`CycleInfo`] 
| Cycle information for LLVM IR, specialized from GenericCycleInfo&period;
| xref:llvm/CycleInfoPrinterPass.adoc[`CycleInfoPrinterPass`] 
| Printer pass for the `CycleInfo&period;`
| xref:llvm/CycleInfoVerifierPass.adoc[`CycleInfoVerifierPass`] 
| Verifier pass for the `CycleInfo&period;`
| xref:llvm/CycleInfoWrapperPass.adoc[`CycleInfoWrapperPass`] 
| Legacy analysis pass which computes a xref:llvm/CycleInfo.adoc[`CycleInfo`]&period;
| xref:llvm/CycleRef.adoc[`CycleRef`] 
| Opaque handle to a cycle within a GenericCycleInfo&period;
| xref:llvm/DAGDeltaAlgorithm.adoc[`DAGDeltaAlgorithm`] 
| Implements a &quot;delta debugging&quot; algorithm for minimizing directed acyclic graphs using a predicate function&period;
| xref:llvm/DCData.adoc[`DCData`] 
| Holds transitions between basic blocks for dot&hyphen;CFG change reporting&period;
| xref:llvm/DCEPass.adoc[`DCEPass`] 
| Basic Dead Code Elimination pass&period;
| xref:llvm/DDGAnalysis.adoc[`DDGAnalysis`] 
| Analysis pass that builds the DDG for a loop&period;
| xref:llvm/DDGAnalysisPrinterPass.adoc[`DDGAnalysisPrinterPass`] 
| Textual printer pass for the DDG of a loop&period;
| xref:llvm/DDGBuilder.adoc[`DDGBuilder`] 
| Builder that constructs a pure data dependence graph&period;
| xref:llvm/DDGDotPrinterPass.adoc[`DDGDotPrinterPass`] 
| Pass that writes the data&hyphen;dependence graph of a loop as DOT&period;
| xref:llvm/DDGEdge.adoc[`DDGEdge`] 
| Edge in a data dependence graph&period;
| xref:llvm/DDGNode.adoc[`DDGNode`] 
| Node in a data dependence graph&period;
| xref:llvm/DFAJumpThreadingPass.adoc[`DFAJumpThreadingPass`] 
| Pass that jump&hyphen;threads a predictable switch used as a DFA inside a loop&period;
| xref:llvm/DFAPacketizer.adoc[`DFAPacketizer`] 
| Deterministic finite automaton (DFA) based packetizer for VLIW resources&period;
| xref:llvm/DFCalculateWorkObject.adoc[`DFCalculateWorkObject`] 
| Work&hyphen;list entry for iterative dominance frontier calculation&period;
| xref:llvm/DGEdge-01.adoc[`DGEdge`] 
| Represent an edge in the directed graph&period; The edge contains the target node it connects to&period;
| xref:llvm/DGNode-06.adoc[`DGNode`] 
| Represent a node in the directed graph&period; The node has a (possibly empty) list of outgoing edges&period;
| xref:llvm/DIArgList.adoc[`DIArgList`] 
| List of ValueAsMetadata, to be used as an argument to a dbg&period;value intrinsic&period;
| xref:llvm/DIAssignID.adoc[`DIAssignID`] 
| Assignment ID linking stores to dbg&period;assign intrinsics&period;
| xref:llvm/DIBasicType.adoc[`DIBasicType`] 
| Basic type, like &apos;int&apos; or &apos;float&apos;&period;
| xref:llvm/DIBuilder.adoc[`DIBuilder`] 
| Builder for constructing LLVM IR debug information metadata&period;
| xref:llvm/DICommonBlock.adoc[`DICommonBlock`] 
| Debug common block&period;
| xref:llvm/DICompileUnit.adoc[`DICompileUnit`] 
| Compile unit&period;
| xref:llvm/DICompositeType.adoc[`DICompositeType`] 
| Composite types&period;
| xref:llvm/DIContext.adoc[`DIContext`] 
| Abstract interface for querying and dumping debug information&period;
| xref:llvm/DIDerivedType.adoc[`DIDerivedType`] 
| Derived types&period;
| xref:llvm/DIDumpOptions.adoc[`DIDumpOptions`] 
| Container for dump options that control which debug information will be dumped&period;
| xref:llvm/DIE.adoc[`DIE`] 
| A structured debug information entry&period; Has an abbreviation which describes its organization&period;
| xref:llvm/DIEAbbrev.adoc[`DIEAbbrev`] 
| Dwarf abbreviation, describes the organization of a debug information object&period;
| xref:llvm/DIEAbbrevData.adoc[`DIEAbbrevData`] 
| Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation&period;
| xref:llvm/DIEAbbrevSet.adoc[`DIEAbbrevSet`] 
| Helps unique DIEAbbrev objects and assigns abbreviation numbers&period;
| xref:llvm/DIEAddrOffset.adoc[`DIEAddrOffset`] 
| An address&hyphen;index plus label&hyphen;difference DIE value&period;
| xref:llvm/DIEBaseTypeRef.adoc[`DIEBaseTypeRef`] 
| A BaseTypeRef DIE&period;
| xref:llvm/DIEBlock.adoc[`DIEBlock`] 
| DIEBlock &hyphen; Represents a block of values&period;
| xref:llvm/DIEDelta.adoc[`DIEDelta`] 
| A simple label difference DIE&period;
| xref:llvm/DIEEntry.adoc[`DIEEntry`] 
| A pointer to another debug information entry&period; An instance of this class can also be used as a proxy for a debug information entry not yet defined (ie&period; types&period;)
| xref:llvm/DIEExpr.adoc[`DIEExpr`] 
| An expression DIE&period;
| xref:llvm/DIEInlineString.adoc[`DIEInlineString`] 
| A container for inline string values&period;
| xref:llvm/DIEInteger.adoc[`DIEInteger`] 
| An integer value DIE&period;
| xref:llvm/DIELabel.adoc[`DIELabel`] 
| A label DIE&period;
| xref:llvm/DIELoc.adoc[`DIELoc`] 
| DIELoc &hyphen; Represents an expression location&period;
| xref:llvm/DIELocList.adoc[`DIELocList`] 
| Represents a pointer to a location list in the debug&lowbar;loc section&period;
| xref:llvm/DIEString.adoc[`DIEString`] 
| A container for string pool string values&period;
| xref:llvm/DIEUnit.adoc[`DIEUnit`] 
| Represents a compile or type unit&period;
| xref:llvm/DIEValue.adoc[`DIEValue`] 
| A debug information entry value&period; Some of these roughly correlate to DWARF attribute classes&period;
| xref:llvm/DIEValueList.adoc[`DIEValueList`] 
| A list of DIE values&period;
| xref:llvm/DIEnumerator.adoc[`DIEnumerator`] 
| Enumeration value&period;
| xref:llvm/DIExpression.adoc[`DIExpression`] 
| DWARF expression&period;
| xref:llvm/DIExpressionCursor.adoc[`DIExpressionCursor`] 
| Holds a DIExpression and keeps track of how many operands have been consumed so far&period;
| xref:llvm/DIFile.adoc[`DIFile`] 
| File&period;
| xref:llvm/DIFixedPointType.adoc[`DIFixedPointType`] 
| Fixed&hyphen;point type&period;
| xref:llvm/DIGenericSubrange.adoc[`DIGenericSubrange`] 
| Generic array subrange with metadata&hyphen;valued bounds&period;
| xref:llvm/DIGlobal.adoc[`DIGlobal`] 
| Container for description of a global variable&period;
| xref:llvm/DIGlobalVariable.adoc[`DIGlobalVariable`] 
| Global variables&period;
| xref:llvm/DIGlobalVariableExpression.adoc[`DIGlobalVariableExpression`] 
| A pair of DIGlobalVariable and DIExpression&period;
| xref:llvm/DIImportedEntity.adoc[`DIImportedEntity`] 
| An imported module (C&plus;&plus; using directive or similar)&period;
| xref:llvm/DIInliningInfo.adoc[`DIInliningInfo`] 
| A format&hyphen;neutral container for inlined code description&period;
| xref:llvm/DILabel.adoc[`DILabel`] 
| Label&period;
| xref:llvm/DILexicalBlock.adoc[`DILexicalBlock`] 
| Debug lexical block&period;
| xref:llvm/DILexicalBlockBase.adoc[`DILexicalBlockBase`] 
| Base class for lexical&hyphen;block scopes&period;
| xref:llvm/DILexicalBlockFile.adoc[`DILexicalBlockFile`] 
| Lexical block that also encodes a DWARF discriminator or file change&period;
| xref:llvm/DILineInfo.adoc[`DILineInfo`] 
| A format&hyphen;neutral container for source line information&period;
| xref:llvm/DILineInfoSpecifier.adoc[`DILineInfoSpecifier`] 
| Controls which fields of DILineInfo container should be filled with data&period;
| xref:llvm/DILocal.adoc[`DILocal`] 
| Container for description of a local variable at an address&period;
| xref:llvm/DILocalScope.adoc[`DILocalScope`] 
| A scope for locals&period;
| xref:llvm/DILocalVariable.adoc[`DILocalVariable`] 
| Local variable&period;
| xref:llvm/DILocation.adoc[`DILocation`] 
| Debug location&period;
| xref:llvm/DIMacro.adoc[`DIMacro`] 
| Macro
| xref:llvm/DIMacroFile.adoc[`DIMacroFile`] 
| Macro file
| xref:llvm/DIMacroNode.adoc[`DIMacroNode`] 
| Macro Info DWARF&hyphen;like metadata node&period;
| xref:llvm/DIModule.adoc[`DIModule`] 
| Represents a module in the programming language, for example, a Clang module, or a Fortran module&period;
| xref:llvm/DINamespace.adoc[`DINamespace`] 
| Debug namespace scope&period;
| xref:llvm/DINode.adoc[`DINode`] 
| Tagged DWARF&hyphen;like metadata node&period;
| xref:llvm/DIObjCProperty.adoc[`DIObjCProperty`] 
| Objective&hyphen;C property&period;
| xref:llvm/DIProperty.adoc[`DIProperty`] 
| A property of a class or structure&period;
| xref:llvm/DIScope.adoc[`DIScope`] 
| Base class for scope&hyphen;like contexts&period;
| xref:llvm/DISourceLanguageName.adoc[`DISourceLanguageName`] 
| Wrapper structure that holds source language identity metadata that includes language name, optional language version, and an optional language dialect&period;
| xref:llvm/DIStringType.adoc[`DIStringType`] 
| String type, Fortran CHARACTER(n)
| xref:llvm/DISubprogram.adoc[`DISubprogram`] 
| Subprogram description&period; Uses SubclassData1&period;
| xref:llvm/DISubrange.adoc[`DISubrange`] 
| Array subrange&period;
| xref:llvm/DISubrangeType.adoc[`DISubrangeType`] 
| Subrange type&period; This is somewhat similar to DISubrange, but it is also a DIType&period;
| xref:llvm/DISubroutineType.adoc[`DISubroutineType`] 
| Type array for a subprogram&period;
| xref:llvm/DITemplateParameter.adoc[`DITemplateParameter`] 
| Base class for template parameters&period;
| xref:llvm/DITemplateTypeParameter.adoc[`DITemplateTypeParameter`] 
| Type template parameter&period;
| xref:llvm/DITemplateValueParameter.adoc[`DITemplateValueParameter`] 
| Non&hyphen;type (value) template parameter&period;
| xref:llvm/DIType.adoc[`DIType`] 
| Base class for types&period;
| xref:llvm/DIVariable.adoc[`DIVariable`] 
| Base class for variables&period;
| xref:llvm/DOTFuncInfo.adoc[`DOTFuncInfo`] 
| Context for rendering a function CFG as a DOT graph&period;
| xref:llvm/DOTGraphTraits-077.adoc[`DOTGraphTraits`] 
| Traits that customize how a graph type is converted to DOT&period;
| xref:llvm/DOTGraphTraitsModulePrinterWrapperPass.adoc[`DOTGraphTraitsModulePrinterWrapperPass`] 
| Legacy module pass that writes an analysis graph to a DOT file&period;
| xref:llvm/DOTGraphTraitsModuleViewerWrapperPass.adoc[`DOTGraphTraitsModuleViewerWrapperPass`] 
| Legacy module pass that displays an analysis graph in a viewer&period;
| xref:llvm/DOTGraphTraitsPrinter-097.adoc[`DOTGraphTraitsPrinter`] 
| Pass mixin that writes an analysis graph for a function to a DOT file&period;
| xref:llvm/DOTGraphTraitsPrinterWrapperPass.adoc[`DOTGraphTraitsPrinterWrapperPass`] 
| Legacy function pass that writes an analysis graph to a DOT file&period;
| xref:llvm/DOTGraphTraitsViewer-03.adoc[`DOTGraphTraitsViewer`] 
| Pass mixin that displays an analysis graph for a function in a viewer&period;
| xref:llvm/DOTGraphTraitsViewerWrapperPass.adoc[`DOTGraphTraitsViewerWrapperPass`] 
| Legacy function pass that displays an analysis graph in a viewer&period;
| xref:llvm/DOTMachineFuncInfo.adoc[`DOTMachineFuncInfo`] 
| Context for rendering a machine function CFG as a DOT graph&period;
| xref:llvm/DSEPass.adoc[`DSEPass`] 
| This class implements a trivial dead store elimination&period; We consider only the redundant stores that are local to a single Basic Block&period;
| xref:llvm/DSOLocalEquivalent.adoc[`DSOLocalEquivalent`] 
| Constant wrapper for a DSO&hyphen;local equivalent of a global value&period;
| xref:llvm/DWARF5AccelTable.adoc[`DWARF5AccelTable`] 
| DWARF v5 accelerator table specializing AccelTable for DWARF5AccelTableData&period;
| xref:llvm/DWARF5AccelTableData.adoc[`DWARF5AccelTableData`] 
| DIE&hyphen;backed entry data for a DWARF v5 accelerator table&period;
| xref:llvm/DWARFAbbreviationDeclaration.adoc[`DWARFAbbreviationDeclaration`] 
| A single DWARF abbreviation declaration (code, tag, children, attributes)&period;
| xref:llvm/DWARFAbbreviationDeclarationSet.adoc[`DWARFAbbreviationDeclarationSet`] 
| A set of DWARF abbreviation declarations&period;
| xref:llvm/DWARFAcceleratorTable.adoc[`DWARFAcceleratorTable`] 
| Common base for Apple and DWARF 5 accelerator tables&period;
| xref:llvm/DWARFAddressRange.adoc[`DWARFAddressRange`] 
| An absolute address range &lsqb;LowPC, HighPC) within a section&period;&rsqb;
| xref:llvm/DWARFAttribute.adoc[`DWARFAttribute`] 
| Encapsulates a DWARF attribute value and all of the data required to describe the attribute value&period;
| xref:llvm/DWARFCFIAnalysis.adoc[`DWARFCFIAnalysis`] 
| Validates the DWARF Call Frame Information one machine instruction at a time&period;
| xref:llvm/DWARFCFIState.adoc[`DWARFCFIState`] 
| Maintains a CFI unwinding row during Call Frame Information analysis&period;
| xref:llvm/DWARFCompileUnit-05.adoc[`DWARFCompileUnit`] 
| A DWARF compile unit and its parsed DIEs&period;
| xref:llvm/DWARFContext.adoc[`DWARFContext`] 
| DWARFContext This data structure is the top level entity that deals with dwarf debug information parsing&period; The actual data is supplied through DWARFObj&period;
| xref:llvm/DWARFDataExtractor.adoc[`DWARFDataExtractor`] 
| A DWARFDataExtractor (typically for an in&hyphen;memory copy of an object&hyphen;file section) plus a relocation map for that section, if there is one&period;
| xref:llvm/DWARFDataExtractorBase-03.adoc[`DWARFDataExtractorBase`] 
| A DataExtractor suitable use for parsing dwarf from memory&period; Clients use Relocator&colon;&colon;getRelocatedValueImpl to relocate values as appropriate&period;
| xref:llvm/DWARFDataExtractorSimple.adoc[`DWARFDataExtractorSimple`] 
| Non&hyphen;relocating DWARF data extractor for memory&hyphen;backed debug info&period;
| xref:llvm/DWARFDebugAbbrev.adoc[`DWARFDebugAbbrev`] 
| Parsed &period;debug&lowbar;abbrev abbreviations for a DWARF object&period;
| xref:llvm/DWARFDebugAddrTable.adoc[`DWARFDebugAddrTable`] 
| A class representing an address table as specified in DWARF v5&period; The table consists of a header followed by an array of address values from &period;debug&lowbar;addr section&period;
| xref:llvm/DWARFDebugArangeSet.adoc[`DWARFDebugArangeSet`] 
| A single address range set from the &period;debug&lowbar;aranges section&period;
| xref:llvm/DWARFDebugAranges.adoc[`DWARFDebugAranges`] 
| A collection of address ranges mapped to compile unit offsets&period;
| xref:llvm/DWARFDebugFrame.adoc[`DWARFDebugFrame`] 
| A parsed &period;debug&lowbar;frame or &period;eh&lowbar;frame section
| xref:llvm/DWARFDebugInfoEntry.adoc[`DWARFDebugInfoEntry`] 
| DWARFDebugInfoEntry &hyphen; A DIE with only the minimum required data&period;
| xref:llvm/DWARFDebugLine.adoc[`DWARFDebugLine`] 
| Parser and cache for DWARF &period;debug&lowbar;line line&hyphen;number program tables&period;
| xref:llvm/DWARFDebugLoc.adoc[`DWARFDebugLoc`] 
| A parser for the DWARF &period;debug&lowbar;loc section (pre&hyphen;DWARF5 location lists)&period;
| xref:llvm/DWARFDebugLoclists.adoc[`DWARFDebugLoclists`] 
| A parser for the DWARF &period;debug&lowbar;loclists section (DWARF5 location lists)&period;
| xref:llvm/DWARFDebugMacro.adoc[`DWARFDebugMacro`] 
| Parser for DWARF &period;debug&lowbar;macinfo and &period;debug&lowbar;macro sections&period;
| xref:llvm/DWARFDebugNames.adoc[`DWARFDebugNames`] 
| Parser for the DWARF v5 &period;debug&lowbar;names accelerator section&period;
| xref:llvm/DWARFDebugPubTable.adoc[`DWARFDebugPubTable`] 
| Represents structure for holding and parsing &period;debug&lowbar;pub&ast; tables&period;
| xref:llvm/DWARFDebugRangeList.adoc[`DWARFDebugRangeList`] 
| A DWARF &period;debug&lowbar;ranges range list&period;
| xref:llvm/DWARFDebugRnglist.adoc[`DWARFDebugRnglist`] 
| A class representing a single rangelist&period;
| xref:llvm/DWARFDebugRnglistTable.adoc[`DWARFDebugRnglistTable`] 
| A class representing a range list table from the &period;debug&lowbar;rnglists section&period;
| xref:llvm/DWARFDie.adoc[`DWARFDie`] 
| Utility class that carries the DWARF compile&sol;type unit and the debug info entry in an object&period;
| xref:llvm/DWARFExpression.adoc[`DWARFExpression`] 
| A DWARF expression consisting of a sequence of operations&period;
| xref:llvm/DWARFFormValue.adoc[`DWARFFormValue`] 
| A parsed DWARF attribute form and its extracted value&period;
| xref:llvm/DWARFGdbIndex.adoc[`DWARFGdbIndex`] 
| Parser and dump helper for the GDB `&period;gdb&lowbar;index` section&period;
| xref:llvm/DWARFListEntryBase.adoc[`DWARFListEntryBase`] 
| A base class for DWARF list entries, such as range or location list entries&period;
| xref:llvm/DWARFListTableBase-00.adoc[`DWARFListTableBase`] 
| A class representing a DWARF v5 table of location or range lists&period;
| xref:llvm/DWARFListTableHeader.adoc[`DWARFListTableHeader`] 
| A class representing the header of a list table such as the range list table in the &period;debug&lowbar;rnglists section&period;
| xref:llvm/DWARFListType-03.adoc[`DWARFListType`] 
| A base class for lists of entries that are extracted from a particular section, such as range lists or location lists&period;
| xref:llvm/DWARFLocationEntry.adoc[`DWARFLocationEntry`] 
| A single location within a location list&period; Entries are stored in the DWARF5 form even if they originally come from a DWARF&lt;&equals;4 location list&period;
| xref:llvm/DWARFLocationExpression.adoc[`DWARFLocationExpression`] 
| Represents a single DWARF expression, whose value is location&hyphen;dependent&period; Typically used in DW&lowbar;AT&lowbar;location attributes to describe the location of objects&period;
| xref:llvm/DWARFLocationTable.adoc[`DWARFLocationTable`] 
| Table of DWARF location list entries for a unit&period;
| xref:llvm/DWARFObject.adoc[`DWARFObject`] 
| Low&hyphen;level access to DWARF sections in an object file&period;
| xref:llvm/DWARFSection.adoc[`DWARFSection`] 
| Contents and load address of a DWARF debug section&period;
| xref:llvm/DWARFTypePrinter.adoc[`DWARFTypePrinter`] 
| Pretty&hyphen;printer for DWARF type DIEs, formatting names in a C&plus;&plus;&hyphen;like style&period;
| xref:llvm/DWARFTypeUnit-07.adoc[`DWARFTypeUnit`] 
| A DWARF type unit and its parsed DIEs&period;
| xref:llvm/DWARFUnit.adoc[`DWARFUnit`] 
| A DWARF compile or type unit and its parsed DIEs&period;
| xref:llvm/DWARFUnitHeader.adoc[`DWARFUnitHeader`] 
| Base class describing the header of any kind of DWARF unit&period;
| xref:llvm/DWARFUnitIndex.adoc[`DWARFUnitIndex`] 
| A parsed &period;debug&lowbar;cu&lowbar;index or &period;debug&lowbar;tu&lowbar;index table from a DWARF package file&period;
| xref:llvm/DWARFUnitVector.adoc[`DWARFUnitVector`] 
| Describe a collection of units&period; Intended to hold all units either from &period;debug&lowbar;info and &period;debug&lowbar;types, or from &period;debug&lowbar;info&period;dwo and &period;debug&lowbar;types&period;dwo&period;
| xref:llvm/DWARFVerifier.adoc[`DWARFVerifier`] 
| A class that verifies DWARF debug information given a DWARF Context&period;
| xref:llvm/DWPError.adoc[`DWPError`] 
| Error type for failures while building or writing DWP files&period;
| xref:llvm/DWPStringPool.adoc[`DWPStringPool`] 
| Deduplicating string pool that emits unique strings into a DWPWriter&period;
| xref:llvm/DWPWriter.adoc[`DWPWriter`] 
| Direct ELF writer for DWP output&period;
| xref:llvm/DXContainerObjectWriter.adoc[`DXContainerObjectWriter`] 
| DXContainer object writer that emits DXContainer files from an MCAssembler&period;
| xref:llvm/DXILMetadataAnalysis.adoc[`DXILMetadataAnalysis`] 
| Analysis that gathers DXIL module metadata for the new pass manager&period;
| xref:llvm/DXILMetadataAnalysisPrinterPass.adoc[`DXILMetadataAnalysisPrinterPass`] 
| Printer pass for the `DXILMetadataAnalysis` results&period;
| xref:llvm/DXILMetadataAnalysisWrapperPass.adoc[`DXILMetadataAnalysisWrapperPass`] 
| Legacy module pass wrapping `dxil&colon;&colon;ModuleMetadataInfo&period;`
| xref:llvm/DXILResourceAnalysis.adoc[`DXILResourceAnalysis`] 
| Analysis that builds a `DXILResourceMap` for a module&period;
| xref:llvm/DXILResourceBindingAnalysis.adoc[`DXILResourceBindingAnalysis`] 
| Analysis that builds a `DXILResourceBindingInfo` for a module&period;
| xref:llvm/DXILResourceBindingInfo.adoc[`DXILResourceBindingInfo`] 
| Binding&hyphen;slot occupancy for DXIL resources in a module&period;
| xref:llvm/DXILResourceBindingWrapperPass.adoc[`DXILResourceBindingWrapperPass`] 
| Legacy module pass wrapping a `DXILResourceBindingInfo&period;`
| xref:llvm/DXILResourceMap.adoc[`DXILResourceMap`] 
| Map of DXIL resources discovered in a module&period;
| xref:llvm/DXILResourcePrinterPass.adoc[`DXILResourcePrinterPass`] 
| Printer pass for the `DXILResourceAnalysis` results&period;
| xref:llvm/DXILResourceTypeAnalysis.adoc[`DXILResourceTypeAnalysis`] 
| Analysis that provides a `DXILResourceTypeMap` for a module&period;
| xref:llvm/DXILResourceTypeMap.adoc[`DXILResourceTypeMap`] 
| Lazy map from resource handle types to `ResourceTypeInfo&period;`
| xref:llvm/DXILResourceTypeWrapperPass.adoc[`DXILResourceTypeWrapperPass`] 
| Legacy immutable pass wrapping a `DXILResourceTypeMap&period;`
| xref:llvm/DXILResourceWrapperPass.adoc[`DXILResourceWrapperPass`] 
| Legacy module pass wrapping a `DXILResourceMap&period;`
| xref:llvm/DXILUpgradePass.adoc[`DXILUpgradePass`] 
| Upgrade DXIL&hyphen;style metadata into their LLVM representations
| xref:llvm/DagInit.adoc[`DagInit`] 
| Represents a DAG initializer&period;
| xref:llvm/DagRecTy.adoc[`DagRecTy`] 
| &apos;dag&apos; &hyphen; Represent a dag fragment
| xref:llvm/DataDependenceGraph.adoc[`DataDependenceGraph`] 
| Data Dependency Graph
| xref:llvm/DataExtractor.adoc[`DataExtractor`] 
| Helper for extracting integers and strings from a binary buffer&period;
| xref:llvm/DataFlowSanitizerPass.adoc[`DataFlowSanitizerPass`] 
| Module pass that instruments code for dynamic data&hyphen;flow analysis (DFSan)&period;
| xref:llvm/DataLayout.adoc[`DataLayout`] 
| A parsed version of the target data layout string in and methods for querying it&period;
| xref:llvm/DbgAssignIntrinsic.adoc[`DbgAssignIntrinsic`] 
| This represents the llvm&period;dbg&period;assign instruction&period;
| xref:llvm/DbgDeclareInst.adoc[`DbgDeclareInst`] 
| This represents the llvm&period;dbg&period;declare instruction&period;
| xref:llvm/DbgInfoIntrinsic.adoc[`DbgInfoIntrinsic`] 
| Forward declaration of the intrinsic wrapper for llvm&period;dbg&period;&ast; info calls&period;
| xref:llvm/DbgLabelInst.adoc[`DbgLabelInst`] 
| This represents the llvm&period;dbg&period;label instruction&period;
| xref:llvm/DbgLabelInstrMap.adoc[`DbgLabelInstrMap`] 
| Maps each inlined source&hyphen;level label to its DBG&lowbar;LABEL instruction&period;
| xref:llvm/DbgLabelRecord.adoc[`DbgLabelRecord`] 
| Records a position in IR for a source label (DILabel)&period; Corresponds to the llvm&period;dbg&period;label intrinsic&period;
| xref:llvm/DbgMarker.adoc[`DbgMarker`] 
| Per&hyphen;instruction holder for debug&hyphen;info records attached before an instruction&period;
| xref:llvm/DbgRangeEntry.adoc[`DbgRangeEntry`] 
| Interval in a basic block where a single debug value is live&period;
| xref:llvm/DbgRecord.adoc[`DbgRecord`] 
| Base class for non&hyphen;instruction debug metadata records positioned in IR&period;
| xref:llvm/DbgRecordParamRef.adoc[`DbgRecordParamRef`] 
| Typed tracking MDNode reference that avoids needing the parameter type defined&period;
| xref:llvm/DbgSSABlock.adoc[`DbgSSABlock`] 
| Wrapper around an IR `BasicBlock` for debug&hyphen;variable SSA construction&period;
| xref:llvm/DbgSSABlockPredIterator.adoc[`DbgSSABlockPredIterator`] 
| Thin wrapper around a block successor iterator&period;
| xref:llvm/DbgSSABlockSuccIterator.adoc[`DbgSSABlockSuccIterator`] 
| Thin wrapper around a block successor iterator&period;
| xref:llvm/DbgSSAPhi.adoc[`DbgSSAPhi`] 
| PHI node that merges live debug&hyphen;value definitions from predecessor blocks&period;
| xref:llvm/DbgValueDef.adoc[`DbgValueDef`] 
| A definition of a variable&semi; can represent either a debug&period;
| xref:llvm/DbgValueHistoryMap.adoc[`DbgValueHistoryMap`] 
| For each user variable, keep a list of instruction ranges where this variable is accessible&period; The variables are listed in order of appearance&period;
| xref:llvm/DbgValueInst.adoc[`DbgValueInst`] 
| This represents the llvm&period;dbg&period;value instruction&period;
| xref:llvm/DbgValueRangeTable.adoc[`DbgValueRangeTable`] 
| Utility class used to find and store the live debug ranges for variables in a module&period;
| xref:llvm/DbgVariableFragmentInfo.adoc[`DbgVariableFragmentInfo`] 
| Describes a fragment of a debug variable as a bit size and offset&period;
| xref:llvm/DbgVariableIntrinsic.adoc[`DbgVariableIntrinsic`] 
| This is the common base class for debug info intrinsics for variables&period;
| xref:llvm/DbgVariableLocation.adoc[`DbgVariableLocation`] 
| Represents the location at which a variable is stored&period;
| xref:llvm/DbgVariableRecord.adoc[`DbgVariableRecord`] 
| Record of a variable value&hyphen;assignment, aka a non instruction representation of the dbg&period;value intrinsic&period;
| xref:llvm/DeactivationSymbolSDNode.adoc[`DeactivationSymbolSDNode`] 
| SDNode representing a deactivation symbol global&period;
| xref:llvm/DeadArgumentEliminationPass.adoc[`DeadArgumentEliminationPass`] 
| Eliminate dead arguments (and return values) from functions&period;
| xref:llvm/DeadLaneDetector.adoc[`DeadLaneDetector`] 
| Detects dead and undefined subregister lanes across COPY&hyphen;like instructions&period;
| xref:llvm/DeadMachineInstructionElimPass.adoc[`DeadMachineInstructionElimPass`] 
| New PM pass that removes dead machine instructions&period;
| xref:llvm/DeadOnReturnInfo.adoc[`DeadOnReturnInfo`] 
| Describes how many bytes are dead when a pointer argument is returned from a call&period; Used by the `dead&lowbar;on&lowbar;return` parameter attribute&period;
| xref:llvm/DebugAssignmentTrackingAnalysis.adoc[`DebugAssignmentTrackingAnalysis`] 
| New pass manager analysis that computes assignment&hyphen;tracking locations&period;
| xref:llvm/DebugAssignmentTrackingPrinterPass.adoc[`DebugAssignmentTrackingPrinterPass`] 
| Printer pass for `DebugAssignmentTrackingAnalysis` results&period;
| xref:llvm/DebugCounter.adoc[`DebugCounter`] 
| Manages named debug counters that enable or skip instrumented events&period;
| xref:llvm/DebugEpochBase.adoc[`DebugEpochBase`] 
| Empty stub of DebugEpochBase used when ABI&hyphen;breaking checks are disabled&period;
| xref:llvm/DebugHandlerBase.adoc[`DebugHandlerBase`] 
| Base class for debug information backends&period; Common functionality related to tracking which variables and scopes are alive at a given PC live here&period;
| xref:llvm/DebugInfoFinder.adoc[`DebugInfoFinder`] 
| Utility to find all debug info in a module&period;
| xref:llvm/DebugInlineInfo.adoc[`DebugInlineInfo`] 
| Inlining location extracted from debug info&period;
| xref:llvm/DebugLoc.adoc[`DebugLoc`] 
| A debug info location&period;
| xref:llvm/DebugNamesAbbrev.adoc[`DebugNamesAbbrev`] 
| Abbreviation describing a DWARF v5 &period;debug&lowbar;names entry form&period;
| xref:llvm/DebugSSAUpdater.adoc[`DebugSSAUpdater`] 
| Class used to determine the live ranges of debug variables in IR using SSA construction (via the SSAUpdaterImpl class), used for analysis purposes&period;
| xref:llvm/DebugValueUser.adoc[`DebugValueUser`] 
| Base class for tracking ValueAsMetadata&sol;DIArgLists with user lookups and Owner callbacks outside of ValueAsMetadata&period;
| xref:llvm/DebugVariable.adoc[`DebugVariable`] 
| Identifies a unique instance of a variable&period;
| xref:llvm/DebugVariableAggregate.adoc[`DebugVariableAggregate`] 
| Identifies a unique instance of a whole variable (discards&sol;ignores fragment information)&period;
| xref:llvm/DebugifyCustomPassManager.adoc[`DebugifyCustomPassManager`] 
| Legacy pass manager that wraps each pass with debugify when enabled&period;
| xref:llvm/DebugifyEachInstrumentation.adoc[`DebugifyEachInstrumentation`] 
| Registers NewPM callbacks that run debugify around each pass&period;
| xref:llvm/DebuginfodCollection.adoc[`DebuginfodCollection`] 
| Tracks a collection of debuginfod artifacts on the local filesystem&period;
| xref:llvm/DebuginfodFetcher.adoc[`DebuginfodFetcher`] 
| BuildIDFetcher that also queries debuginfod servers for debug info&period;
| xref:llvm/DebuginfodLog.adoc[`DebuginfodLog`] 
| Thread&hyphen;safe queue of debuginfod log entries&period;
| xref:llvm/DebuginfodLogEntry.adoc[`DebuginfodLogEntry`] 
| A single log message produced by the debuginfod server or collection&period;
| xref:llvm/DebuginfodServer.adoc[`DebuginfodServer`] 
| Debuginfod HTTP server that serves artifacts from a DebuginfodCollection&period;
| xref:llvm/DecIntegerState.adoc[`DecIntegerState`] 
| Specialization of the integer state for a decreasing value, hence 0 is the best state and &#126;0u the worst&period;
| xref:llvm/DeclareRuntimeLibcallsPass.adoc[`DeclareRuntimeLibcallsPass`] 
| Pass that inserts declarations for all runtime library calls known for the target&period;
| xref:llvm/DecomposedBitTest.adoc[`DecomposedBitTest`] 
| Represents the operation icmp (X &amp; Mask) pred C, where pred can only be eq or ne&period;
| xref:llvm/DefInit.adoc[`DefInit`] 
| AL &hyphen; Represent a reference to a &apos;def&apos; in the description
| xref:llvm/DefaultAnalysisGraphTraits.adoc[`DefaultAnalysisGraphTraits`] 
| Default traits class for extracting a graph from an analysis pass&period;
| xref:llvm/DefaultContextualFoldingSetTrait.adoc[`DefaultContextualFoldingSetTrait`] 
| Like DefaultFoldingSetTrait, but for ContextualFoldingSets&period;
| xref:llvm/DefaultDOTGraphTraits.adoc[`DefaultDOTGraphTraits`] 
| Default implementations of all DOTGraphTraits customization hooks&period;
| xref:llvm/DefaultDoCastIfPossible.adoc[`DefaultDoCastIfPossible`] 
| Provides a default `doCastIfPossible` that uses `isPossible` and `doCast&period;`
| xref:llvm/DefaultEvictionAdvisor.adoc[`DefaultEvictionAdvisor`] 
| Default heuristic eviction advisor used by greedy register allocation&period;
| xref:llvm/DefaultFoldingSetTrait-0847.adoc[`DefaultFoldingSetTrait`] 
| Default implementations for FoldingSetTrait operations on type `T&period;`
| xref:llvm/DefaultInlineAdvice.adoc[`DefaultInlineAdvice`] 
| Default InlineAdvice that records outcomes using an optional InlineCost&period;
| xref:llvm/DefaultInlineAdvisor.adoc[`DefaultInlineAdvisor`] 
| The default (manual heuristics) implementation of the InlineAdvisor&period;
| xref:llvm/DefaultPriorityAdvisor.adoc[`DefaultPriorityAdvisor`] 
| Default heuristic priority advisor used by greedy register allocation&period;
| xref:llvm/DefaultVLIWScheduler.adoc[`DefaultVLIWScheduler`] 
| VLIW scheduler that builds the dependence graph used for packetizing&period;
| xref:llvm/DefinitionAndSourceRegister.adoc[`DefinitionAndSourceRegister`] 
| Simple struct used to hold a Register value and the instruction which defines it&period;
| xref:llvm/DelimitedScope.adoc[`DelimitedScope`] 
| RAII base for opening and closing a delimited printer scope&period;
| xref:llvm/DelinearizationPrinterPass.adoc[`DelinearizationPrinterPass`] 
| Printer pass that delinearizes memory accesses in a function&period;
| xref:llvm/DeltaAlgorithm.adoc[`DeltaAlgorithm`] 
| Implements the delta debugging algorithm (A&period; Zeller &apos;99) for minimizing arbitrary sets using a predicate function&period;
| xref:llvm/DeltaTree.adoc[`DeltaTree`] 
| B&hyphen;tree mapping file indices to rewrite deltas with fast accumulated lookup&period;
| xref:llvm/DemandedBits.adoc[`DemandedBits`] 
| Analysis that computes which bits of each instruction result are demanded&period;
| xref:llvm/DemandedBitsAnalysis.adoc[`DemandedBitsAnalysis`] 
| An analysis that produces `DemandedBits` for a function&period;
| xref:llvm/DemandedBitsPrinterPass.adoc[`DemandedBitsPrinterPass`] 
| Printer pass for DemandedBits
| xref:llvm/DenormalFPEnv.adoc[`DenormalFPEnv`] 
| Represents the full denormal controls for a function, including the default mode and the f32 specific override&period;
| xref:llvm/DenormalFPMathState.adoc[`DenormalFPMathState`] 
| State for denormal floating&hyphen;point math modes&period;
| xref:llvm/DenormalMode.adoc[`DenormalMode`] 
| Represent subnormal handling kind for floating point instruction inputs and outputs&period;
| xref:llvm/DenseMap-0c.adoc[`DenseMap`] 
| Heap&hyphen;allocated dense probed hash map from keys to values&period;
| xref:llvm/DenseMapBase-0d8.adoc[`DenseMapBase`] 
| CRTP base implementing a dense probed hash map from keys to values&period;
| xref:llvm/DenseMapInfo-034d.adoc[`DenseMapInfo`] 
| Traits type that supplies DenseMap hashing and equality for value type `T&period;`
| xref:llvm/DenseMapIterator.adoc[`DenseMapIterator`] 
| Forward iterator over occupied DenseMap &sol; SmallDenseMap buckets&period;
| xref:llvm/DenseSet.adoc[`DenseSet`] 
| Implements a dense probed hash&hyphen;table based set&period;
| xref:llvm/Dependence.adoc[`Dependence`] 
| Minimal dependence between two memory references in a function&period;
| xref:llvm/DependenceAnalysis.adoc[`DependenceAnalysis`] 
| AnalysisPass to compute dependence information in a function
| xref:llvm/DependenceAnalysisPrinterPass.adoc[`DependenceAnalysisPrinterPass`] 
| Printer pass to dump DA results&period;
| xref:llvm/DependenceAnalysisWrapperPass.adoc[`DependenceAnalysisWrapperPass`] 
| Legacy pass manager pass to access dependence information
| xref:llvm/DependenceGraphInfo-04.adoc[`DependenceGraphInfo`] 
| Encapsulate some common data and functionality needed for different variations of data dependence graphs&period;
| xref:llvm/DependenceInfo.adoc[`DependenceInfo`] 
| DependenceInfo &hyphen; This class is the main dependence&hyphen;analysis driver&period;
| xref:llvm/DerefState.adoc[`DerefState`] 
| State for dereferenceable attribute information&period;
| xref:llvm/DerivedUser.adoc[`DerivedUser`] 
| Extension point for User subclasses defined outside of lib&sol;IR&period;
| xref:llvm/DestSourcePair.adoc[`DestSourcePair`] 
| Pair of destination and source machine operands for a copy&hyphen;like instruction&period;
| xref:llvm/DetectDeadLanesPass.adoc[`DetectDeadLanesPass`] 
| Pass that detects dead and undefined subregister lanes in a machine function&period;
| xref:llvm/DevirtCallSite.adoc[`DevirtCallSite`] 
| A call site that could be devirtualized&period;
| xref:llvm/DevirtSCCRepeatedPass.adoc[`DevirtSCCRepeatedPass`] 
| A helper that repeats an SCC pass each time an indirect call is refined to a direct call by that pass&period;
| xref:llvm/DiagnosticHandler.adoc[`DiagnosticHandler`] 
| This is the base class for diagnostic handling in LLVM&period;
| xref:llvm/DiagnosticInfo.adoc[`DiagnosticInfo`] 
| Abstract base class for backend diagnostic reporting&period;
| xref:llvm/DiagnosticInfoDebugMetadataVersion.adoc[`DiagnosticInfoDebugMetadataVersion`] 
| Diagnostic information for debug metadata version reporting&period; This is basically a module and a version&period;
| xref:llvm/DiagnosticInfoDontCall.adoc[`DiagnosticInfoDontCall`] 
| Diagnostic for a call that violates a dontcall attribute&period;
| xref:llvm/DiagnosticInfoGeneric.adoc[`DiagnosticInfoGeneric`] 
| Generic diagnostic carrying a message and optional instruction&period;
| xref:llvm/DiagnosticInfoGenericWithLoc.adoc[`DiagnosticInfoGenericWithLoc`] 
| Generic location&hyphen;aware diagnostic with a message&period;
| xref:llvm/DiagnosticInfoIROptimization.adoc[`DiagnosticInfoIROptimization`] 
| Common features for diagnostics dealing with optimization remarks that are used by IR passes&period;
| xref:llvm/DiagnosticInfoISelFallback.adoc[`DiagnosticInfoISelFallback`] 
| Diagnostic information for ISel fallback path&period;
| xref:llvm/DiagnosticInfoIgnoringInvalidDebugMetadata.adoc[`DiagnosticInfoIgnoringInvalidDebugMetadata`] 
| Diagnostic information for stripping invalid debug metadata&period;
| xref:llvm/DiagnosticInfoInlineAsm.adoc[`DiagnosticInfoInlineAsm`] 
| Diagnostic information for inline asm reporting&period; This is basically a message and an optional location&period;
| xref:llvm/DiagnosticInfoInstrumentation.adoc[`DiagnosticInfoInstrumentation`] 
| Diagnostic information for IR instrumentation reporting&period;
| xref:llvm/DiagnosticInfoLegalizationFailure.adoc[`DiagnosticInfoLegalizationFailure`] 
| Diagnostic for a legalization failure at a given location&period;
| xref:llvm/DiagnosticInfoMIROptimization.adoc[`DiagnosticInfoMIROptimization`] 
| Common features for diagnostics dealing with optimization remarks that are used by machine passes&period;
| xref:llvm/DiagnosticInfoMIRParser.adoc[`DiagnosticInfoMIRParser`] 
| Diagnostic information for machine IR parser&period;
| xref:llvm/DiagnosticInfoMisExpect.adoc[`DiagnosticInfoMisExpect`] 
| Diagnostic information for MisExpect analysis&period;
| xref:llvm/DiagnosticInfoOptimizationBase.adoc[`DiagnosticInfoOptimizationBase`] 
| Common features for diagnostics dealing with optimization remarks that are used by both IR and MIR passes&period;
| xref:llvm/DiagnosticInfoOptimizationFailure.adoc[`DiagnosticInfoOptimizationFailure`] 
| Diagnostic information for optimization failures&period;
| xref:llvm/DiagnosticInfoPGOProfile.adoc[`DiagnosticInfoPGOProfile`] 
| Diagnostic information for the PGO profiler&period;
| xref:llvm/DiagnosticInfoRegAllocFailure.adoc[`DiagnosticInfoRegAllocFailure`] 
| Diagnostic for a register allocation failure&period;
| xref:llvm/DiagnosticInfoResourceLimit.adoc[`DiagnosticInfoResourceLimit`] 
| Diagnostic information for stack size etc&period; reporting&period; This is basically a function and a size&period;
| xref:llvm/DiagnosticInfoSampleProfile.adoc[`DiagnosticInfoSampleProfile`] 
| Diagnostic information for the sample profiler&period;
| xref:llvm/DiagnosticInfoSrcMgr.adoc[`DiagnosticInfoSrcMgr`] 
| Diagnostic information for SMDiagnostic reporting&period;
| xref:llvm/DiagnosticInfoStackSize.adoc[`DiagnosticInfoStackSize`] 
| Diagnostic for a stack frame size limit being exceeded&period;
| xref:llvm/DiagnosticInfoUnsupported.adoc[`DiagnosticInfoUnsupported`] 
| Diagnostic information for unsupported feature in backend&period;
| xref:llvm/DiagnosticInfoUnsupportedTargetIntrinsic.adoc[`DiagnosticInfoUnsupportedTargetIntrinsic`] 
| Diagnostic information for unsupported target intrinsics in backend&period;
| xref:llvm/DiagnosticInfoWithLocationBase.adoc[`DiagnosticInfoWithLocationBase`] 
| Common features for diagnostics with an associated location&period;
| xref:llvm/DiagnosticLocation.adoc[`DiagnosticLocation`] 
| Source location used when emitting diagnostics&period;
| xref:llvm/DiagnosticPredicate.adoc[`DiagnosticPredicate`] 
| Lightweight match &sol; near&hyphen;match &sol; no&hyphen;match result for operand predicates&period;
| xref:llvm/DiagnosticPrinter.adoc[`DiagnosticPrinter`] 
| Interface for custom diagnostic printing&period;
| xref:llvm/DiagnosticPrinterRawOStream.adoc[`DiagnosticPrinterRawOStream`] 
| Basic diagnostic printer that uses an underlying raw&lowbar;ostream&period;
| xref:llvm/DictScope.adoc[`DictScope`] 
| RAII helper that opens and closes an object scope on a printer&period;
| xref:llvm/DirectedGraph-0d.adoc[`DirectedGraph`] 
| Directed graph
| xref:llvm/Directive-02.adoc[`Directive`] 
| Accessors for a Directive record defined in DirectiveBase&period;td&period;
| xref:llvm/DirectiveLanguage.adoc[`DirectiveLanguage`] 
| Accessors for a DirectiveLanguage record defined in DirectiveBase&period;td&period;
| xref:llvm/DisableLIRP.adoc[`DisableLIRP`] 
| Options to disable Loop Idiom Recognize, which can be shared with other passes&period;
| xref:llvm/DistinctMDOperandPlaceholder.adoc[`DistinctMDOperandPlaceholder`] 
| Placeholder metadata for operands of distinct MDNodes&period;
| xref:llvm/DivRemMapKey.adoc[`DivRemMapKey`] 
| Key identifying a div&sol;rem operation by signedness and operands&period;
| xref:llvm/DivRemPairsPass.adoc[`DivRemPairsPass`] 
| Hoist&sol;decompose integer division and remainder instructions to enable CFG improvements and better codegen&period;
| xref:llvm/DivergencePropagator.adoc[`DivergencePropagator`] 
| Compute divergence starting with a divergent branch&period;
| xref:llvm/DoNothingMemorySSAWalker.adoc[`DoNothingMemorySSAWalker`] 
| MemorySSAWalker that returns builder links without alias queries&period;
| xref:llvm/DomConditionCache.adoc[`DomConditionCache`] 
| Cache of branch conditions that affect values, for use by ValueTracking&period;
| xref:llvm/DomOnlyPrinter.adoc[`DomOnlyPrinter`] 
| Pass that writes a function dominator tree to a DOT file without block bodies&period;
| xref:llvm/DomOnlyViewer.adoc[`DomOnlyViewer`] 
| Pass that displays a function dominator tree without block bodies&period;
| xref:llvm/DomPrinter.adoc[`DomPrinter`] 
| Pass that writes a function dominator tree to a DOT file&period;
| xref:llvm/DomTreeGraphTraitsBase-0e.adoc[`DomTreeGraphTraitsBase`] 
| GraphTraits helpers for walking dominator&hyphen;tree nodes depth&hyphen;first&period;
| xref:llvm/DomTreeNodeBase-0b.adoc[`DomTreeNodeBase`] 
| Base class for the actual dominator tree node&period;
| xref:llvm/DomTreeNodeTraits-094.adoc[`DomTreeNodeTraits`] 
| Default DomTreeNode traits for NodeT&period; The default implementation assume a Function&hyphen;like NodeT&period; Can be specialized to support different node types&period;
| xref:llvm/DomTreeUpdater.adoc[`DomTreeUpdater`] 
| Updates DominatorTree and PostDominatorTree for LLVM IR basic blocks&period;
| xref:llvm/DomViewer.adoc[`DomViewer`] 
| Pass that displays a function dominator tree in a Graphviz viewer&period;
| xref:llvm/DomainValue.adoc[`DomainValue`] 
| A DomainValue is a bit like LiveIntervals&apos; ValNo, but it also keeps track of execution domains&period;
| xref:llvm/DominanceFrontier.adoc[`DominanceFrontier`] 
| Dominance frontier analysis result for a Function&apos;s BasicBlocks&period;
| xref:llvm/DominanceFrontierAnalysis.adoc[`DominanceFrontierAnalysis`] 
| Analysis pass which computes a `DominanceFrontier&period;`
| xref:llvm/DominanceFrontierBase-06.adoc[`DominanceFrontierBase`] 
| Common base class for computing forward and inverse dominance frontiers&period;
| xref:llvm/DominanceFrontierPrinterPass.adoc[`DominanceFrontierPrinterPass`] 
| Printer pass for the `DominanceFrontier&period;`
| xref:llvm/DominanceFrontierWrapperPass.adoc[`DominanceFrontierWrapperPass`] 
| Legacy analysis pass which computes a `DominanceFrontier&period;`
| xref:llvm/DominatorTree.adoc[`DominatorTree`] 
| Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree&period;
| xref:llvm/DominatorTreeAnalysis.adoc[`DominatorTreeAnalysis`] 
| Analysis pass which computes a `DominatorTree&period;`
| xref:llvm/DominatorTreeBase-0f8.adoc[`DominatorTreeBase`] 
| Core dominator tree base class&period;
| xref:llvm/DominatorTreePrinterPass.adoc[`DominatorTreePrinterPass`] 
| Printer pass for the `DominatorTree&period;`
| xref:llvm/DominatorTreeVerifierPass.adoc[`DominatorTreeVerifierPass`] 
| Verifier pass for the `DominatorTree&period;`
| xref:llvm/DominatorTreeWrapperPass.adoc[`DominatorTreeWrapperPass`] 
| Legacy analysis pass which computes a `DominatorTree&period;`
| xref:llvm/DotCfgChangeReporter.adoc[`DotCfgChangeReporter`] 
| Builds a website with PDF CFGs highlighting changed instructions&period;
| xref:llvm/DotFuncBCIInfo.adoc[`DotFuncBCIInfo`] 
| Helper information for rendering a BlockCoverageInference CFG as a DOT graph&period;
| xref:llvm/DropTypeTestsPass.adoc[`DropTypeTestsPass`] 
| Pass that drops type&hyphen;test intrinsics and related uses&period;
| xref:llvm/DropUnnecessaryAssumesPass.adoc[`DropUnnecessaryAssumesPass`] 
| Pass that drops assume intrinsics that are unlikely to be useful&period;
| xref:llvm/DroppedVariableStats.adoc[`DroppedVariableStats`] 
| A base class to collect and print dropped debug information variable statistics&period;
| xref:llvm/DroppedVariableStatsIR.adoc[`DroppedVariableStatsIR`] 
| Collects and prints debug values dropped by LLVM IR optimization passes&period;
| xref:llvm/DroppedVariableStatsMIR.adoc[`DroppedVariableStatsMIR`] 
| A class to collect and print dropped debug information due to MIR optimization passes&period;
| xref:llvm/DstOp.adoc[`DstOp`] 
| Destination operand accepted by MachineIRBuilder helpers&period;
| xref:llvm/DummyCGSCCPass.adoc[`DummyCGSCCPass`] 
| This pass is required by interprocedural register allocation&period; It forces codegen to follow bottom up order on call graph&period;
| xref:llvm/DummyPriorityAdvisor.adoc[`DummyPriorityAdvisor`] 
| Stupid priority advisor which just enqueues in virtual register number order, for debug purposes only&period;
| xref:llvm/Duration.adoc[`Duration`] 
| Duration value type&period;
| xref:llvm/DwarfCompileUnit-0d.adoc[`DwarfCompileUnit`] 
| DWARF compile unit that owns type units and related debug metadata&period;
| xref:llvm/DwarfDebug.adoc[`DwarfDebug`] 
| DWARF debug info emitter that owns compile units and related metadata&period;
| xref:llvm/DwarfEHPreparePass.adoc[`DwarfEHPreparePass`] 
| New PM pass that prepares DWARF exception handling for code generation&period;
| xref:llvm/DwarfInstrProfCorrelator.adoc[`DwarfInstrProfCorrelator`] 
| DwarfInstrProfCorrelator &hyphen; A child of InstrProfCorrelatorImpl that takes DWARF debug info as input to correlate profiles&period;
| xref:llvm/DwarfStringPoolEntry.adoc[`DwarfStringPoolEntry`] 
| Data for a string pool entry&period;
| xref:llvm/DwarfStringPoolEntryRef.adoc[`DwarfStringPoolEntryRef`] 
| DwarfStringPoolEntryRef&colon; Dwarf string pool entry reference&period;
| xref:llvm/DwarfStringPoolEntryWithExtString.adoc[`DwarfStringPoolEntryWithExtString`] 
| DwarfStringPoolEntry with string keeping externally&period;
| xref:llvm/DwarfTypeUnit-0a.adoc[`DwarfTypeUnit`] 
| DWARF type unit used when emitting type entries into accelerator tables&period;
| xref:llvm/DynamicAPInt.adoc[`DynamicAPInt`] 
| Dynamically sized arbitrary&hyphen;precision integer&period;
| xref:llvm/ECError.adoc[`ECError`] 
| This class wraps a std&colon;&colon;error&lowbar;code in a Error&period;
| xref:llvm/EHContGuardTargetsPass.adoc[`EHContGuardTargetsPass`] 
| New PM pass that records Windows EH Continuation Guard targets&period;
| xref:llvm/EHStreamer.adoc[`EHStreamer`] 
| Emits exception&hyphen;handling unwind information for an AsmPrinter&period;
| xref:llvm/ELFAttributeParser.adoc[`ELFAttributeParser`] 
| Abstract parser for ELF build&hyphen;attribute sections&period;
| xref:llvm/ELFCompactAttrParser.adoc[`ELFCompactAttrParser`] 
| Parser for ELF build attributes held in a single compact attributes subsection&period;
| xref:llvm/ELFExtendedAttrParser.adoc[`ELFExtendedAttrParser`] 
| Parser for ELF extended build&hyphen;attribute sections&period;
| xref:llvm/ELFObjectWriter.adoc[`ELFObjectWriter`] 
| ELF object writer that emits ELF object files from an MCAssembler&period;
| xref:llvm/ELFRelocationEntry.adoc[`ELFRelocationEntry`] 
| A single ELF relocation to be emitted for a section&period;
| xref:llvm/ETMDecoder.adoc[`ETMDecoder`] 
| Decoder for Arm Embedded Trace Macrocell (ETM) instruction traces&period;
| xref:llvm/EVT.adoc[`EVT`] 
| Extended Value Type&period; Capable of holding value types which are not native for any processor (such as the i12345 type), as well as the types an MVT can represent&period;
| xref:llvm/EarliestEscapeAnalysis.adoc[`EarliestEscapeAnalysis`] 
| Context&hyphen;sensitive CaptureAnalysis using earliest common dominators&period;
| xref:llvm/EarlyCSEPass.adoc[`EarlyCSEPass`] 
| A simple and fast domtree&hyphen;based CSE pass&period;
| xref:llvm/EarlyIfConverterPass.adoc[`EarlyIfConverterPass`] 
| New PM pass that performs early if&hyphen;conversion on SSA form&period;
| xref:llvm/EarlyMachineLICMPass.adoc[`EarlyMachineLICMPass`] 
| New PM pass that performs machine LICM before register allocation&period;
| xref:llvm/EarlyTailDuplicatePass.adoc[`EarlyTailDuplicatePass`] 
| New PM pass that performs early (pre&hyphen;regalloc) tail duplication&period;
| xref:llvm/EdgeBundles.adoc[`EdgeBundles`] 
| Equivalence classes of CFG edges that share an incoming or outgoing block&period;
| xref:llvm/EdgeBundlesAnalysis.adoc[`EdgeBundlesAnalysis`] 
| Analysis pass that computes `EdgeBundles` for a machine function&period;
| xref:llvm/EdgeBundlesWrapperLegacy.adoc[`EdgeBundlesWrapperLegacy`] 
| Legacy MachineFunctionPass wrapper that computes and owns `EdgeBundles&period;`
| xref:llvm/ElementCount.adoc[`ElementCount`] 
| Describes how many elements a type holds, either fixed or scaled by vscale&period;
| xref:llvm/EliminateAvailableExternallyPass.adoc[`EliminateAvailableExternallyPass`] 
| A pass that transforms external global definitions into declarations&period;
| xref:llvm/EmbedBitcodeOptions.adoc[`EmbedBitcodeOptions`] 
| Options controlling how bitcode is embedded into a module&period;
| xref:llvm/EmbedBitcodePass.adoc[`EmbedBitcodePass`] 
| Pass embeds a copy of the module optimized with the provided pass pipeline into a global variable&period;
| xref:llvm/EmbeddedModelRunnerOptions.adoc[`EmbeddedModelRunnerOptions`] 
| Options for feed&sol;fetch prefixes and model selection in ReleaseModeModelRunner&period;
| xref:llvm/EmitCModelRunner.adoc[`EmitCModelRunner`] 
| MLModelRunner that evaluates an EmitC&hyphen;compiled ML model&period;
| xref:llvm/EmptyData.adoc[`EmptyData`] 
| Empty per&hyphen;block payload for patch&hyphen;style change reporters&period;
| xref:llvm/EmptyStringSetTag.adoc[`EmptyStringSetTag`] 
| The &quot;value type&quot; of StringSet represented as an empty struct&period;
| xref:llvm/EngineBuilder.adoc[`EngineBuilder`] 
| Builder class for ExecutionEngines&period; Use this by stack&hyphen;allocating a builder, chaining the various set&ast; methods, and terminating it with a &period;create() call&period;
| xref:llvm/Ensemble.adoc[`Ensemble`] 
| Strategy&hyphen;specific collection of preferred traces through a function&period;
| xref:llvm/EntryExitInstrumenterPass.adoc[`EntryExitInstrumenterPass`] 
| Pass that instruments function entry and exit with profiling hooks&period;
| xref:llvm/EnumString.adoc[`EnumString`] 
| Compact runtime entry mapping an enumeration value to name string(s)&period;
| xref:llvm/EnumStringDef.adoc[`EnumStringDef`] 
| Compile&hyphen;time data representation of enum entries&period;
| xref:llvm/EnumStrings-03.adoc[`EnumStrings`] 
| Lookup table wrapping compact enum&hyphen;to&hyphen;string storage&period;
| xref:llvm/EnumStringsStorage.adoc[`EnumStringsStorage`] 
| Compile&hyphen;time storage packing enum string entries and character data&period;
| xref:llvm/EnumVal.adoc[`EnumVal`] 
| Accessors for an enumeration value record used by clauses&period;
| xref:llvm/EnumeratedArray.adoc[`EnumeratedArray`] 
| Fixed&hyphen;size array indexed by values of a scoped enumeration&period;
| xref:llvm/EphemeralValuesAnalysis.adoc[`EphemeralValuesAnalysis`] 
| A function analysis which provides an `EphemeralValuesCache&period;`
| xref:llvm/EphemeralValuesCache.adoc[`EphemeralValuesCache`] 
| A cache of ephemeral values within a function&period;
| xref:llvm/EquivalenceClasses.adoc[`EquivalenceClasses`] 
| Collection of equivalence classes with insert, union, and find operations&period;
| xref:llvm/Error.adoc[`Error`] 
| Lightweight error class with error context and mandatory checking&period;
| xref:llvm/ErrorAsOutParameter.adoc[`ErrorAsOutParameter`] 
| Helper for Errors used as out&hyphen;parameters&period;
| xref:llvm/ErrorHandlerTraits-0a.adoc[`ErrorHandlerTraits`] 
| Helper for testing applicability of, and applying, handlers for ErrorInfo types&period;
| xref:llvm/ErrorInfo-09a.adoc[`ErrorInfo`] 
| Base class for user error types&period; Users should declare their error types like&colon;
| xref:llvm/ErrorInfoBase.adoc[`ErrorInfoBase`] 
| Base class for error info classes&period; Do not extend this directly&colon; Extend the ErrorInfo template subclass instead&period;
| xref:llvm/ErrorList.adoc[`ErrorList`] 
| Special ErrorInfo subclass representing a list of ErrorInfos&period; Instances of this class are constructed by joinError&period;
| xref:llvm/ErrorOr.adoc[`ErrorOr`] 
| Represents either an error or a value T&period;
| xref:llvm/ErrorSuccess.adoc[`ErrorSuccess`] 
| Subclass of Error that represents success in the type system&period;
| xref:llvm/EscapeEnumerator.adoc[`EscapeEnumerator`] 
| Find all escape points from a function for finally&hyphen;style insertion&period;
| xref:llvm/Evaluator.adoc[`Evaluator`] 
| This class evaluates LLVM IR, producing the Constant representing each SSA instruction&period;
| xref:llvm/EvictionCost.adoc[`EvictionCost`] 
| Cost of evicting interference &hyphen; used by default advisor, and the eviction chain heuristic in RegAllocGreedy&period;
| xref:llvm/ExecutionDomainFix.adoc[`ExecutionDomainFix`] 
| Machine function pass that rewrites variant instructions to minimize execution domain crossings&period;
| xref:llvm/ExecutionEngine.adoc[`ExecutionEngine`] 
| Abstract interface for implementation execution of LLVM modules, designed to support both interpreter and just&hyphen;in&hyphen;time (JIT) compiler implementations&period;
| xref:llvm/ExecutionEngineState.adoc[`ExecutionEngineState`] 
| Helper class for helping synchronize access to the global address map table&period; Access to this class should be serialized under a mutex&period;
| xref:llvm/ExistsOpInit.adoc[`ExistsOpInit`] 
| !exists&lt;type&gt;(expr) &hyphen; Dynamically determine if a record of `type` named `expr` exists&period;
| xref:llvm/ExitOnError.adoc[`ExitOnError`] 
| Helper for check&hyphen;and&hyphen;exit error handling&period;
| xref:llvm/ExpandIRInstsPass.adoc[`ExpandIRInstsPass`] 
| New PM pass that expands certain IR instructions for the target&period;
| xref:llvm/ExpandMemCmpPass.adoc[`ExpandMemCmpPass`] 
| Pass that expands memcmp calls into loads and stores&period;
| xref:llvm/ExpandPostRAPseudosPass.adoc[`ExpandPostRAPseudosPass`] 
| New PM pass that expands post&hyphen;RA pseudo instructions&period;
| xref:llvm/ExpandReductionsPass.adoc[`ExpandReductionsPass`] 
| New PM pass that expands reduction intrinsics for the target&period;
| xref:llvm/ExpandVariadicsPass.adoc[`ExpandVariadicsPass`] 
| Pass that expands variadic functions into fixed&hyphen;arity equivalents&period;
| xref:llvm/Expected.adoc[`Expected`] 
| Tagged union holding either a T or a Error&period;
| xref:llvm/ExpectedAsOutParameter.adoc[`ExpectedAsOutParameter`] 
| Helper for Expected&lt;T&gt;s used as out&hyphen;parameters&period;
| xref:llvm/ExponentialBackoff.adoc[`ExponentialBackoff`] 
| A class to help implement exponential backoff&period;
| xref:llvm/ExtAddrMode.adoc[`ExtAddrMode`] 
| Describes a target addressing mode similar to ExtAddrMode in CodeGenPrepare&period;
| xref:llvm/ExternalAAWrapperPass.adoc[`ExternalAAWrapperPass`] 
| A wrapper pass for external alias analyses&period; This just squirrels away the callback used to run any analyses and register their results&period;
| xref:llvm/ExternalSymbolPseudoSourceValue.adoc[`ExternalSymbolPseudoSourceValue`] 
| A specialized pseudo source value for holding external symbol values&period;
| xref:llvm/ExternalSymbolSDNode.adoc[`ExternalSymbolSDNode`] 
| SDNode referencing an external symbol name&period;
| xref:llvm/ExtraFunctionPassManager.adoc[`ExtraFunctionPassManager`] 
| A pass manager that runs extra function passes when a marker analysis is present&period;
| xref:llvm/ExtraLoopPassManager.adoc[`ExtraLoopPassManager`] 
| A pass manager that runs extra loop passes when a marker analysis is present&period;
| xref:llvm/ExtractElementInst.adoc[`ExtractElementInst`] 
| Extract a single scalar element from a vector value&period;
| xref:llvm/ExtractGVPass.adoc[`ExtractGVPass`] 
| Pass that extracts or deletes specified global values from a module&period;
| xref:llvm/ExtractValueInst.adoc[`ExtractValueInst`] 
| Extract a struct field or array element from an aggregate value&period;
| xref:llvm/EytzingerTable.adoc[`EytzingerTable`] 
| Owning container that stores elements in a complete binary search tree formatted in Eytzinger (breadth&hyphen;first) order&period;
| xref:llvm/EytzingerTableSpan.adoc[`EytzingerTableSpan`] 
| Non&hyphen;owning view of a buffer formatted as a complete binary search tree in Eytzinger (breadth&hyphen;first) order&period;
| xref:llvm/FCmpInst.adoc[`FCmpInst`] 
| Represents a floating point comparison operator&period;
| xref:llvm/FEntryInserterPass.adoc[`FEntryInserterPass`] 
| New PM pass that inserts fentry calls into function prologues&period;
| xref:llvm/FMFSource.adoc[`FMFSource`] 
| This provides a helper for copying FMF from an instruction or setting specified flags&period;
| xref:llvm/FPBinaryOperator.adoc[`FPBinaryOperator`] 
| Binary operator with fast&hyphen;math flags&period;
| xref:llvm/FPExtInst.adoc[`FPExtInst`] 
| This class represents an extension of floating point types&period;
| xref:llvm/FPMathOperator.adoc[`FPMathOperator`] 
| Floating&hyphen;point operator view that exposes FastMathFlags (defined in Operator&period;h)&period;
| xref:llvm/FPPassManager.adoc[`FPPassManager`] 
| FPPassManager manages BBPassManagers and FunctionPasses&period;
| xref:llvm/FPStateAccessSDNode.adoc[`FPStateAccessSDNode`] 
| SDNode for get&sol;set FP environment memory accesses&period;
| xref:llvm/FPToSIInst.adoc[`FPToSIInst`] 
| This class represents a cast from floating point to signed integer&period;
| xref:llvm/FPToUIInst.adoc[`FPToUIInst`] 
| Instruction that converts floating point to an unsigned integer&period;
| xref:llvm/FPTruncInst.adoc[`FPTruncInst`] 
| Instruction that truncates a floating&hyphen;point value to a smaller FP type&period;
| xref:llvm/FPUnaryOperator.adoc[`FPUnaryOperator`] 
| Unary operator with fast&hyphen;math flags&period;
| xref:llvm/FPValueAndVReg.adoc[`FPValueAndVReg`] 
| Simple struct used to hold a constant floating&hyphen;point value and a virtual register&period;
| xref:llvm/FailureOr.adoc[`FailureOr`] 
| Either a failure, or a valid value of type `T&period;`
| xref:llvm/FastFoldingSetNode.adoc[`FastFoldingSetNode`] 
| FoldingSetNode that caches a precomputed FoldingSetNodeID&period;
| xref:llvm/FastISel.adoc[`FastISel`] 
| This is a fast&hyphen;path instruction selection class that generates poor code and doesn&apos;t support illegal types or non&hyphen;trivial lowering, but runs quickly&period;
| xref:llvm/FastMathFlags.adoc[`FastMathFlags`] 
| Convenience struct for specifying and reasoning about fast&hyphen;math flags&period;
| xref:llvm/FastMathFlagsStorage.adoc[`FastMathFlagsStorage`] 
| Provide fast&hyphen;math flags storage, instructions that support fast&hyphen;math flags should inherit from this class&period;
| xref:llvm/FatLtoCleanup.adoc[`FatLtoCleanup`] 
| Pass that cleans up IR for the FatLTO pipeline&period;
| xref:llvm/FaultMapParser.adoc[`FaultMapParser`] 
| A parser for the &lowbar;&lowbar;llvm&lowbar;faultmaps section&period;
| xref:llvm/FaultMaps.adoc[`FaultMaps`] 
| Collects potentially&hyphen;faulting operations and serializes the &lowbar;&lowbar;llvm&lowbar;faultmaps section&period;
| xref:llvm/FeatureBitArray.adoc[`FeatureBitArray`] 
| Class used to store the subtarget bits in the tables created by tablegen&period;
| xref:llvm/FeatureBitset.adoc[`FeatureBitset`] 
| Container class for subtarget features&period;
| xref:llvm/FenceInst.adoc[`FenceInst`] 
| An instruction for ordering other memory operations&period;
| xref:llvm/FieldInit.adoc[`FieldInit`] 
| X&period;Y &hyphen; Represent a reference to a subfield of a variable
| xref:llvm/FileBufferByteStream.adoc[`FileBufferByteStream`] 
| An implementation of WritableBinaryStream backed by an llvm FileOutputBuffer&period;
| xref:llvm/FileCache.adoc[`FileCache`] 
| This type represents a file cache system that manages caching of files&period;
| xref:llvm/FileCheck.adoc[`FileCheck`] 
| FileCheck class takes the request and exposes various methods that use information from the request&period;
| xref:llvm/FileCheckDiag.adoc[`FileCheckDiag`] 
| Abstract base class for recording a FileCheck diagnostic for a pattern (e&period;g&period;, `CHECK&hyphen;NEXT` directive or `&hyphen;&hyphen;implicit&hyphen;check&hyphen;not)&period;`
| xref:llvm/FileCheckDiagList.adoc[`FileCheckDiagList`] 
| A `FileCheckDiag` series emitted by the FileCheck library&period;
| xref:llvm/FileCheckPatternContext.adoc[`FileCheckPatternContext`] 
| Holds pattern&hyphen;matching context shared while checking an input&period;
| xref:llvm/FileCheckRequest.adoc[`FileCheckRequest`] 
| Contains info about various FileCheck options&period;
| xref:llvm/FileCheckString.adoc[`FileCheckString`] 
| A CHECK string and its associated patterns from the check file&period;
| xref:llvm/FileCollector.adoc[`FileCollector`] 
| Captures file system interaction and generates data to be later replayed with the RedirectingFileSystem&period;
| xref:llvm/FileCollectorBase.adoc[`FileCollectorBase`] 
| Base class for collecting unique file and directory paths&period;
| xref:llvm/FileCollectorFileSystem.adoc[`FileCollectorFileSystem`] 
| Virtual file system that records accessed paths in a FileCollector&period;
| xref:llvm/FileError.adoc[`FileError`] 
| This class wraps a filename and another Error&period;
| xref:llvm/FileLoc.adoc[`FileLoc`] 
| Struct holding Line&colon;Column location
| xref:llvm/FileLocRange.adoc[`FileLocRange`] 
| Struct holding a semiopen range &lsqb;Start&semi; End)&rsqb;
| xref:llvm/FileOutputBuffer.adoc[`FileOutputBuffer`] 
| In&hyphen;memory buffer that is written to a file when committed&period;
| xref:llvm/FilePermissionsApplier.adoc[`FilePermissionsApplier`] 
| Copies permissions (and optionally dates) from an input file to an output&period;
| xref:llvm/FileRemover.adoc[`FileRemover`] 
| RAII helper that deletes a file when destroyed, typically on exceptions&period;
| xref:llvm/FinalizeBundleTestPass.adoc[`FinalizeBundleTestPass`] 
| New PM test pass that finalizes a bundle for each basic block&period;
| xref:llvm/FinalizeISelPass.adoc[`FinalizeISelPass`] 
| New PM pass that finalizes ISel and expands pseudo&hyphen;instructions&period;
| xref:llvm/FirstIndexOfType-0d.adoc[`FirstIndexOfType`] 
| Find the first index where a type appears in a list of types&period;
| xref:llvm/FixIrreduciblePass.adoc[`FixIrreduciblePass`] 
| Pass that converts irreducible control&hyphen;flow into natural loops&period;
| xref:llvm/FixedNumOperandTraits-09b87.adoc[`FixedNumOperandTraits`] 
| Traits for a compile&hyphen;time&hyphen;fixed prefix Use array&period;
| xref:llvm/FixedPointBuilder.adoc[`FixedPointBuilder`] 
| Helper for lowering fixed&hyphen;point arithmetic operations to LLVM IR&period;
| xref:llvm/FixedPointSemantics.adoc[`FixedPointSemantics`] 
| Fixed&hyphen;point layout and saturation flags, similar to fltSemantics&period;
| xref:llvm/FixedStackPseudoSourceValue.adoc[`FixedStackPseudoSourceValue`] 
| A specialized PseudoSourceValue for holding FixedStack values, which must include a frame index&period;
| xref:llvm/FixedStreamArray-07.adoc[`FixedStreamArray`] 
| Array of fixed&hyphen;size records backed by a BinaryStream&period;
| xref:llvm/FixedStreamArrayIterator.adoc[`FixedStreamArrayIterator`] 
| Random&hyphen;access iterator over the elements of a FixedStreamArray&period;
| xref:llvm/FixedVectorType.adoc[`FixedVectorType`] 
| Class to represent fixed width SIMD vectors
| xref:llvm/FixupStatepointCallerSavedPass.adoc[`FixupStatepointCallerSavedPass`] 
| New PM pass that spills caller&hyphen;saved registers used by statepoints&period;
| xref:llvm/FlagEntry.adoc[`FlagEntry`] 
| A named flag bit or value used when printing flag sets&period;
| xref:llvm/FlatIt.adoc[`FlatIt`] 
| Marker class to iterate over the elements of a Region in flat mode&period;
| xref:llvm/FlattenCFGPass.adoc[`FlattenCFGPass`] 
| Pass that flattens a function&apos;s CFG&period;
| xref:llvm/Float2IntPass.adoc[`Float2IntPass`] 
| Pass that demotes lossless floating&hyphen;point operations to integers&period;
| xref:llvm/FlowBlock.adoc[`FlowBlock`] 
| A wrapper of a binary basic block&period;
| xref:llvm/FlowFunction.adoc[`FlowFunction`] 
| A wrapper of binary function with basic blocks and jumps&period;
| xref:llvm/FlowJump.adoc[`FlowJump`] 
| A wrapper of a jump between two basic blocks&period;
| xref:llvm/FmtAlign.adoc[`FmtAlign`] 
| Helper class to format to a `Width` wide field, with alignment `Where` within that field&period;
| xref:llvm/FoldOpInit.adoc[`FoldOpInit`] 
| !foldl (a, b, expr, start, lst) &hyphen; Fold over a list&period;
| xref:llvm/FoldingSetBase.adoc[`FoldingSetBase`] 
| Non&hyphen;templated base class for FoldingSet and ContextualFoldingSet, holding the memory management and probing that does not depend on the node type&period;
| xref:llvm/FoldingSetImpl.adoc[`FoldingSetImpl`] 
| An implementation detail that lets us share code between FoldingSet and ContextualFoldingSet&period;
| xref:llvm/FoldingSetIterator.adoc[`FoldingSetIterator`] 
| Forward iterator for FoldingSet and ContextualFoldingSet&period;
| xref:llvm/FoldingSetNodeID.adoc[`FoldingSetNodeID`] 
| Folding set node identifier&period;
| xref:llvm/FoldingSetNodeIDRef.adoc[`FoldingSetNodeIDRef`] 
| Reference to interned FoldingSetNodeID profile bits&period;
| xref:llvm/FoldingSetNodeWrapper.adoc[`FoldingSetNodeWrapper`] 
| This template class is used to &quot;wrap&quot; arbitrary types in an enclosing object so that they can be inserted into FoldingSets&period;
| xref:llvm/FoldingSetTrait-0b.adoc[`FoldingSetTrait`] 
| Trait that defines how to profile an object of type `T` for a FoldingSet&period;
| xref:llvm/FoldingSetVector.adoc[`FoldingSetVector`] 
| FoldingSet with deterministic insertion&hyphen;order iteration&period;
| xref:llvm/ForceFunctionAttrsPass.adoc[`ForceFunctionAttrsPass`] 
| Pass which forces specific function attributes into the IR, primarily as a debugging tool&period;
| xref:llvm/FormatAdapter-06.adoc[`FormatAdapter`] 
| Base class for format adapters that wrap a value of type `T&period;`
| xref:llvm/FormattedBytes.adoc[`FormattedBytes`] 
| Helper that formats a byte sequence as a hex dump for streaming&period;
| xref:llvm/FormattedNumber.adoc[`FormattedNumber`] 
| This is a helper class used for format&lowbar;hex() and format&lowbar;decimal()&period;
| xref:llvm/FormattedString.adoc[`FormattedString`] 
| This is a helper class for left&lowbar;justify, right&lowbar;justify, and center&lowbar;justify&period;
| xref:llvm/FortifiedLibCallSimplifier.adoc[`FortifiedLibCallSimplifier`] 
| This class implements simplifications for calls to fortified library functions&period;
| xref:llvm/ForwardToPointerCast.adoc[`ForwardToPointerCast`] 
| Implements reference casts by forwarding through a pointer `CastInfo&period;`
| xref:llvm/ForwardedRegister.adoc[`ForwardedRegister`] 
| Describes a register that needs to be forwarded from the prologue to a musttail call&period;
| xref:llvm/FrameIndexSDNode.adoc[`FrameIndexSDNode`] 
| SDNode representing a stack frame index&period;
| xref:llvm/FreeDeleter.adoc[`FreeDeleter`] 
| Deleter that calls `free` on a pointer allocated with `malloc&period;`
| xref:llvm/FreeMachineFunctionPass.adoc[`FreeMachineFunctionPass`] 
| Pass that explicitly frees the MachineFunction for a function&period;
| xref:llvm/FreezeInst.adoc[`FreezeInst`] 
| Instruction that replaces undef or poison operands with a concrete value&period;
| xref:llvm/FullDependence.adoc[`FullDependence`] 
| Detailed dependence between two memory references in a function&period;
| xref:llvm/FuncDataT.adoc[`FuncDataT`] 
| Per&hyphen;function block map saved for comparing functions&period;
| xref:llvm/FuncletLayoutPass.adoc[`FuncletLayoutPass`] 
| New PM pass that lays out funclets contiguously&period;
| xref:llvm/FuncletPadInst.adoc[`FuncletPadInst`] 
| Base class for funclet pad instructions used in Windows EH&period;
| xref:llvm/Function.adoc[`Function`] 
| A single function or procedure in LLVM IR&period;
| xref:llvm/FunctionAnalysisManagerCGSCCProxy.adoc[`FunctionAnalysisManagerCGSCCProxy`] 
| A proxy from a `FunctionAnalysisManager` to an `SCC&period;`
| xref:llvm/FunctionAnalysisManagerMachineFunctionProxy.adoc[`FunctionAnalysisManagerMachineFunctionProxy`] 
| A proxy from a `FunctionAnalysisManager` to a `MachineFunction&period;`
| xref:llvm/FunctionCallee.adoc[`FunctionCallee`] 
| Container for a FunctionType and callee Value pair&period;
| xref:llvm/FunctionComparator.adoc[`FunctionComparator`] 
| FunctionComparator &hyphen; Compares two functions to determine whether or not&period;
| xref:llvm/FunctionHashInfo.adoc[`FunctionHashInfo`] 
| Holds a function&apos;s structural hash and maps for ignored&hyphen;operand analysis&period;
| xref:llvm/FunctionImportGlobalProcessing.adoc[`FunctionImportGlobalProcessing`] 
| Class to handle necessary GlobalValue changes required by ThinLTO function importing, including linkage changes and any necessary renaming&period;
| xref:llvm/FunctionImportPass.adoc[`FunctionImportPass`] 
| The function importing pass
| xref:llvm/FunctionImporter.adoc[`FunctionImporter`] 
| The function importer is automatically importing function from other modules based on the provided summary informations&period;
| xref:llvm/FunctionLoweringInfo.adoc[`FunctionLoweringInfo`] 
| FunctionLoweringInfo &hyphen; This contains information that is global to a function that is used when lowering a region of the function&period;
| xref:llvm/FunctionOptimizationProfile.adoc[`FunctionOptimizationProfile`] 
| Raw optimization profile for a function, including CFG and layout data&period;
| xref:llvm/FunctionPass.adoc[`FunctionPass`] 
| FunctionPass class &hyphen; This class is used to implement most global optimizations&period; Optimizations should subclass this class if they meet the following constraints&colon;
| xref:llvm/FunctionPointerLikeTypeTraits.adoc[`FunctionPointerLikeTypeTraits`] 
| Provide suitable custom traits struct for function pointers&period;
| xref:llvm/FunctionPropertiesAnalysis.adoc[`FunctionPropertiesAnalysis`] 
| Analysis pass that computes FunctionPropertiesInfo for a function&period;
| xref:llvm/FunctionPropertiesInfo.adoc[`FunctionPropertiesInfo`] 
| Collection of numeric and embedding properties for a single function&period;
| xref:llvm/FunctionPropertiesPrinterPass.adoc[`FunctionPropertiesPrinterPass`] 
| Printer pass for the FunctionPropertiesAnalysis results&period;
| xref:llvm/FunctionPropertiesStatisticsPass.adoc[`FunctionPropertiesStatisticsPass`] 
| Statistics pass for the FunctionPropertiesAnalysis results&period;
| xref:llvm/FunctionPropertiesUpdater.adoc[`FunctionPropertiesUpdater`] 
| Helper that updates FunctionPropertiesInfo after inlining&period;
| xref:llvm/FunctionSpecializer.adoc[`FunctionSpecializer`] 
| Clones functions specialized for constant call arguments under IPSCCP&period;
| xref:llvm/FunctionSummary.adoc[`FunctionSummary`] 
| Function summary information to aid decisions and implementation of importing&period;
| xref:llvm/FunctionToLoopPassAdaptor.adoc[`FunctionToLoopPassAdaptor`] 
| Adaptor that maps from a function to its loops&period;
| xref:llvm/FunctionToMachineFunctionPassAdaptor.adoc[`FunctionToMachineFunctionPassAdaptor`] 
| Trivial adaptor that maps from a function to its machine function&period;
| xref:llvm/FunctionType.adoc[`FunctionType`] 
| Class to represent function types&period;
| xref:llvm/FunctionVarLocs.adoc[`FunctionVarLocs`] 
| Describes the variable locations in a function&period;
| xref:llvm/GAdd.adoc[`GAdd`] 
| Represents an integer addition&period;
| xref:llvm/GAddCarryOut.adoc[`GAddCarryOut`] 
| Represents overflowing add operations&period; G&lowbar;UADDO, G&lowbar;SADDO
| xref:llvm/GAddSubCarryInOut.adoc[`GAddSubCarryInOut`] 
| Represents overflowing add&sol;sub operations that also consume a carry&hyphen;in&period; G&lowbar;UADDE, G&lowbar;SADDE, G&lowbar;USUBE, G&lowbar;SSUBE
| xref:llvm/GAddSubCarryOut.adoc[`GAddSubCarryOut`] 
| Represents overflowing add&sol;sub operations&period; Only carry&hyphen;out&colon; G&lowbar;UADDO, G&lowbar;SADDO, G&lowbar;USUBO, G&lowbar;SSUBO Carry&hyphen;in and carry&hyphen;out&colon; G&lowbar;UADDE, G&lowbar;SADDE, G&lowbar;USUBE, G&lowbar;SSUBE
| xref:llvm/GAnd.adoc[`GAnd`] 
| Represents a logical and&period;
| xref:llvm/GAnyCmp.adoc[`GAnyCmp`] 
| Represent a G&lowbar;ICMP or G&lowbar;FCMP&period;
| xref:llvm/GAnyExt.adoc[`GAnyExt`] 
| Represents an any ext&period;
| xref:llvm/GAnyLoad.adoc[`GAnyLoad`] 
| Represents any generic load, including sign&sol;zero extending variants&period;
| xref:llvm/GAnyStore.adoc[`GAnyStore`] 
| Represents any generic store, including truncating variants&period;
| xref:llvm/GBinOp.adoc[`GBinOp`] 
| Represents a binary operation, i&period;e, x &equals; y op z&period;
| xref:llvm/GBinOpCarryOut.adoc[`GBinOpCarryOut`] 
| Represents overflowing binary operations&period;
| xref:llvm/GBuildVector.adoc[`GBuildVector`] 
| Represents a G&lowbar;BUILD&lowbar;VECTOR&period;
| xref:llvm/GBuildVectorTrunc.adoc[`GBuildVectorTrunc`] 
| Represents a G&lowbar;BUILD&lowbar;VECTOR&lowbar;TRUNC&period;
| xref:llvm/GCEmptyBasicBlocksPass.adoc[`GCEmptyBasicBlocksPass`] 
| New PM pass that garbage&hyphen;collects empty machine basic blocks&period;
| xref:llvm/GCFunctionAnalysis.adoc[`GCFunctionAnalysis`] 
| Analysis pass that caches per&hyphen;function GC root metadata&period;
| xref:llvm/GCFunctionInfo.adoc[`GCFunctionInfo`] 
| Garbage collection metadata for a single function&period; Currently, this information only applies to GCStrategies which use GCRoot&period;
| xref:llvm/GCLoweringPass.adoc[`GCLoweringPass`] 
| Pass that lowers GC read&sol;write intrinsics and initializes roots&period;
| xref:llvm/GCMetadataPrinter.adoc[`GCMetadataPrinter`] 
| Emits GC metadata as assembly code for an AsmPrinter&period;
| xref:llvm/GCModuleInfo.adoc[`GCModuleInfo`] 
| Module analysis that caches per&hyphen;function GC info and active strategies&period;
| xref:llvm/GCOVArc.adoc[`GCOVArc`] 
| Directed edge between two basic blocks in a gcov CFG&period;
| xref:llvm/GCOVBlock.adoc[`GCOVBlock`] 
| GCOVBlock &hyphen; Collects block information&period;
| xref:llvm/GCOVBlockLocation.adoc[`GCOVBlockLocation`] 
| Represent file of lines same with block&lowbar;location&lowbar;info in gcc&period;
| xref:llvm/GCOVBuffer.adoc[`GCOVBuffer`] 
| GCOVBuffer &hyphen; A wrapper around MemoryBuffer to provide GCOV specific read operations&period;
| xref:llvm/GCOVFile.adoc[`GCOVFile`] 
| GCOVFile &hyphen; Collects coverage information for one pair of coverage file (&period;gcno and &period;gcda)&period;
| xref:llvm/GCOVFunction.adoc[`GCOVFunction`] 
| GCOVFunction &hyphen; Collects function information&period;
| xref:llvm/GCOVOptions.adoc[`GCOVOptions`] 
| Options controlling GCOV&hyphen;style profiling instrumentation&period;
| xref:llvm/GCOVProfilerPass.adoc[`GCOVProfilerPass`] 
| The gcov&hyphen;style instrumentation pass
| xref:llvm/GCPoint.adoc[`GCPoint`] 
| GCPoint &hyphen; Metadata for a collector&hyphen;safe point in machine code&period;
| xref:llvm/GCProjectionInst.adoc[`GCProjectionInst`] 
| Common base class for representing values projected from a statepoint&period; Currently, the only projections available are gc&period;result and gc&period;relocate&period;
| xref:llvm/GCRelocateInst.adoc[`GCRelocateInst`] 
| Represents calls to the gc&period;relocate intrinsic&period;
| xref:llvm/GCResultInst.adoc[`GCResultInst`] 
| Represents calls to the gc&period;result intrinsic&period;
| xref:llvm/GCRoot.adoc[`GCRoot`] 
| GCRoot &hyphen; Metadata for a pointer to an object managed by the garbage collector&period;
| xref:llvm/GCStatepointInst.adoc[`GCStatepointInst`] 
| Represents a gc&period;statepoint intrinsic call&period; This extends directly from CallBase as the IntrinsicInst only supports calls and gc&period;statepoint is invokable&period;
| xref:llvm/GCStrategy.adoc[`GCStrategy`] 
| Describes a garbage collector algorithm&apos;s code generation requirements&period;
| xref:llvm/GCStrategyMap.adoc[`GCStrategyMap`] 
| Map from GC strategy name to the corresponding GCStrategy instance&period;
| xref:llvm/GCastOp.adoc[`GCastOp`] 
| Represents a cast operation&period; It models the llvm&colon;&colon;CastInst concept&period; The exception is bitcast&period;
| xref:llvm/GConcatVectors.adoc[`GConcatVectors`] 
| Represents a G&lowbar;CONCAT&lowbar;VECTORS&period;
| xref:llvm/GConstant.adoc[`GConstant`] 
| Represents a G&lowbar;CONSTANT&period;
| xref:llvm/GEPNoWrapFlags.adoc[`GEPNoWrapFlags`] 
| Represents nowrap flags for a getelementptr instruction or expression&period;
| xref:llvm/GEPOperator.adoc[`GEPOperator`] 
| Concrete operator for the GetElementPtr instruction opcode&period;
| xref:llvm/GExtLoad.adoc[`GExtLoad`] 
| Represents either a G&lowbar;SEXTLOAD, G&lowbar;ZEXTLOAD, or G&lowbar;FPEXTLOAD&period;
| xref:llvm/GExtOp.adoc[`GExtOp`] 
| Represents an integer&hyphen;like extending operation&period;
| xref:llvm/GExtOrTruncOp.adoc[`GExtOrTruncOp`] 
| Represents an integer&hyphen;like extending or truncating operation&period;
| xref:llvm/GExtractSubvector.adoc[`GExtractSubvector`] 
| Represents an extract subvector&period;
| xref:llvm/GExtractVectorElement.adoc[`GExtractVectorElement`] 
| Represents an extract vector element&period;
| xref:llvm/GFBinOp.adoc[`GFBinOp`] 
| Represents a floating point binary operation&period;
| xref:llvm/GFCmp.adoc[`GFCmp`] 
| Represent a G&lowbar;FCMP&period;
| xref:llvm/GFConstant.adoc[`GFConstant`] 
| An floating&hyphen;point&hyphen;like constant&period;
| xref:llvm/GFPExtLoad.adoc[`GFPExtLoad`] 
| Represents a G&lowbar;FPEXTLOAD&period;
| xref:llvm/GFPTruncStore.adoc[`GFPTruncStore`] 
| Represents a G&lowbar;FPTRUNCSTORE&period;
| xref:llvm/GFreeze.adoc[`GFreeze`] 
| Represents a freeze&period;
| xref:llvm/GICmp.adoc[`GICmp`] 
| Represent a G&lowbar;ICMP&period;
| xref:llvm/GIConstant.adoc[`GIConstant`] 
| An integer&hyphen;like constant&period;
| xref:llvm/GIMatchTableExecutor.adoc[`GIMatchTableExecutor`] 
| Executes GlobalISel match tables for instruction selection and combining&period;
| xref:llvm/GISelCSEAnalysis.adoc[`GISelCSEAnalysis`] 
| Analysis that computes GISelCSEInfo for a MachineFunction&period;
| xref:llvm/GISelCSEAnalysisWrapper.adoc[`GISelCSEAnalysisWrapper`] 
| Lazily computed wrapper around GISelCSEInfo with configurable CSE opcodes&period;
| xref:llvm/GISelCSEAnalysisWrapperPass.adoc[`GISelCSEAnalysisWrapperPass`] 
| The actual analysis pass wrapper&period;
| xref:llvm/GISelCSEInfo.adoc[`GISelCSEInfo`] 
| CSE analysis that tracks instructions for common&hyphen;subexpression elimination&period;
| xref:llvm/GISelChangeObserver.adoc[`GISelChangeObserver`] 
| Abstract base for clients that observe GlobalISel instruction changes&period;
| xref:llvm/GISelInstProfileBuilder.adoc[`GISelInstProfileBuilder`] 
| Builder that profiles MachineInstr properties into a FoldingSetNodeID&period;
| xref:llvm/GISelObserverWrapper.adoc[`GISelObserverWrapper`] 
| Wrapper that forwards each change event to a list of observers&period;
| xref:llvm/GISelValueTracking.adoc[`GISelValueTracking`] 
| Analysis that computes KnownBits and related facts for GlobalISel&period;
| xref:llvm/GISelValueTrackingAnalysis.adoc[`GISelValueTrackingAnalysis`] 
| Analysis that computes GISelValueTracking for a MachineFunction&period;
| xref:llvm/GISelValueTrackingAnalysisLegacy.adoc[`GISelValueTrackingAnalysisLegacy`] 
| Legacy MachineFunctionPass that owns a GISelValueTracking instance&period;
| xref:llvm/GISelValueTrackingPrinterPass.adoc[`GISelValueTrackingPrinterPass`] 
| Printer pass for GISelValueTracking analysis results&period;
| xref:llvm/GISelWorkList.adoc[`GISelWorkList`] 
| Worklist of MachineInstrs similar to InstCombineWorkList&period;
| xref:llvm/GImplicitDef.adoc[`GImplicitDef`] 
| Represents a G&lowbar;IMPLICIT&lowbar;DEF&period;
| xref:llvm/GIndexedAnyExtLoad.adoc[`GIndexedAnyExtLoad`] 
| Represents either G&lowbar;INDEXED&lowbar;LOAD, G&lowbar;INDEXED&lowbar;ZEXTLOAD or G&lowbar;INDEXED&lowbar;SEXTLOAD&period;
| xref:llvm/GIndexedExtLoad.adoc[`GIndexedExtLoad`] 
| Represents a G&lowbar;INDEX&lowbar;ZEXTLOAD&sol;G&lowbar;INDEXED&lowbar;SEXTLOAD&period;
| xref:llvm/GIndexedLoad.adoc[`GIndexedLoad`] 
| Represents indexed loads&period;
| xref:llvm/GIndexedSExtLoad.adoc[`GIndexedSExtLoad`] 
| Represents a G&lowbar;SEXTLOAD&period;
| xref:llvm/GIndexedStore.adoc[`GIndexedStore`] 
| Represents indexed stores&period;
| xref:llvm/GIndexedZExtLoad.adoc[`GIndexedZExtLoad`] 
| Represents a G&lowbar;ZEXTLOAD&period;
| xref:llvm/GInsertSubvector.adoc[`GInsertSubvector`] 
| Represents a insert subvector&period;
| xref:llvm/GInsertVectorElement.adoc[`GInsertVectorElement`] 
| Represents an insert vector element&period;
| xref:llvm/GIntBinOp.adoc[`GIntBinOp`] 
| Represents an integer binary operation&period;
| xref:llvm/GIntrinsic.adoc[`GIntrinsic`] 
| Represents a call to an intrinsic&period;
| xref:llvm/GLoad.adoc[`GLoad`] 
| Represents a G&lowbar;LOAD&period;
| xref:llvm/GLoadStore.adoc[`GLoadStore`] 
| Represents any type of generic load or store&period; G&lowbar;LOAD, G&lowbar;STORE, G&lowbar;ZEXTLOAD, G&lowbar;SEXTLOAD, G&lowbar;FPEXTLOAD, G&lowbar;FPTRUNCSTORE&period;
| xref:llvm/GLogicalBinOp.adoc[`GLogicalBinOp`] 
| Represents a logical binary operation&period;
| xref:llvm/GMemOperation.adoc[`GMemOperation`] 
| Provides common memory operand functionality&period;
| xref:llvm/GMerge.adoc[`GMerge`] 
| Represents a G&lowbar;MERGE&lowbar;VALUES&period;
| xref:llvm/GMergeLikeInstr.adoc[`GMergeLikeInstr`] 
| Represents G&lowbar;BUILD&lowbar;VECTOR, G&lowbar;CONCAT&lowbar;VECTORS or G&lowbar;MERGE&lowbar;VALUES&period; All these have the common property of generating a single value from multiple sources&period;
| xref:llvm/GMul.adoc[`GMul`] 
| Represents an integer multiplication&period;
| xref:llvm/GOFFObjectWriter.adoc[`GOFFObjectWriter`] 
| GOFF object writer that emits GOFF object files from an MCAssembler&period;
| xref:llvm/GOFFRelocationEntry.adoc[`GOFFRelocationEntry`] 
| A single GOFF relocation to be emitted&period;
| xref:llvm/GOr.adoc[`GOr`] 
| Represents a logical or&period;
| xref:llvm/GPhi.adoc[`GPhi`] 
| Represents a G&lowbar;PHI&period;
| xref:llvm/GPtrAdd.adoc[`GPtrAdd`] 
| Represents a G&lowbar;PTR&lowbar;ADD&period;
| xref:llvm/GSExtLoad.adoc[`GSExtLoad`] 
| Represents a G&lowbar;SEXTLOAD&period;
| xref:llvm/GSUCmp.adoc[`GSUCmp`] 
| Represents a threeway compare&period;
| xref:llvm/GSelect.adoc[`GSelect`] 
| Represents a G&lowbar;SELECT&period;
| xref:llvm/GSext.adoc[`GSext`] 
| Represents a sext&period;
| xref:llvm/GShl.adoc[`GShl`] 
| Represents a shift left&period;
| xref:llvm/GShuffleVector.adoc[`GShuffleVector`] 
| Represents a G&lowbar;SHUFFLE&lowbar;VECTOR&period;
| xref:llvm/GSplatVector.adoc[`GSplatVector`] 
| Represents a splat vector&period;
| xref:llvm/GStepVector.adoc[`GStepVector`] 
| Represents a step vector&period;
| xref:llvm/GStore.adoc[`GStore`] 
| Represents a G&lowbar;STORE&period;
| xref:llvm/GSub.adoc[`GSub`] 
| Represents an integer subtraction&period;
| xref:llvm/GSubCarryOut.adoc[`GSubCarryOut`] 
| Represents overflowing sub operations&period; G&lowbar;USUBO, G&lowbar;SSUBO
| xref:llvm/GTrunc.adoc[`GTrunc`] 
| Represents a trunc&period;
| xref:llvm/GUIDProbeFunctionMap.adoc[`GUIDProbeFunctionMap`] 
| Sorted map from function GUID to `MCPseudoProbeFuncDesc`&period;
| xref:llvm/GUnmerge.adoc[`GUnmerge`] 
| Represents a G&lowbar;UNMERGE&lowbar;VALUES&period;
| xref:llvm/GVMaterializer.adoc[`GVMaterializer`] 
| Abstract interface for lazily loading global values from an external source&period;
| xref:llvm/GVNHoist.adoc[`GVNHoist`] 
| Pass allowed to call internal MemorySSA utilities&period;
| xref:llvm/GVNHoistPass.adoc[`GVNHoistPass`] 
| A simple and fast domtree&hyphen;based GVN pass to hoist common expressions from sibling branches&period;
| xref:llvm/GVNLegacyPass.adoc[`GVNLegacyPass`] 
| Legacy FunctionPass wrapper around GVNPass&period;
| xref:llvm/GVNOptions.adoc[`GVNOptions`] 
| Parameters controlling which transforms GVN may perform&period;
| xref:llvm/GVNPass.adoc[`GVNPass`] 
| The core GVN pass object&period;
| xref:llvm/GVNSinkPass.adoc[`GVNSinkPass`] 
| Uses an &quot;inverted&quot; value numbering to decide the similarity of expressions and sinks similar expressions into successors&period;
| xref:llvm/GVScale.adoc[`GVScale`] 
| Represents a vscale&period;
| xref:llvm/GVecReduce.adoc[`GVecReduce`] 
| Represents a (non&hyphen;sequential) vector reduction operation&period;
| xref:llvm/GZExtLoad.adoc[`GZExtLoad`] 
| Represents a G&lowbar;ZEXTLOAD&period;
| xref:llvm/GZext.adoc[`GZext`] 
| Represents a zext&period;
| xref:llvm/GenericConvergenceVerifier.adoc[`GenericConvergenceVerifier`] 
| Verifier for static convergence&hyphen;control token rules over IR or MIR&period;
| xref:llvm/GenericCycleInfo-08.adoc[`GenericCycleInfo`] 
| Cycle information for a function&period;
| xref:llvm/GenericCycleInfoCompute.adoc[`GenericCycleInfoCompute`] 
| Helper class for computing cycle information&period;
| xref:llvm/GenericDINode.adoc[`GenericDINode`] 
| Generic tagged DWARF&hyphen;like metadata node&period;
| xref:llvm/GenericDomTreeUpdater-02.adoc[`GenericDomTreeUpdater`] 
| Provides a uniform way to update dominator tree related data structures&period;
| xref:llvm/GenericFloatingPointPredicateUtils.adoc[`GenericFloatingPointPredicateUtils`] 
| Utilities that map floating&hyphen;point compares to FP class tests over IR or MIR&period;
| xref:llvm/GenericMachineInstr.adoc[`GenericMachineInstr`] 
| A base class for all GenericMachineInstrs&period;
| xref:llvm/GenericSSAContext-03.adoc[`GenericSSAContext`] 
| Thin IR&hyphen;agnostic context for SSA analyses over LLVM IR or Machine IR&period;
| xref:llvm/GenericSSATraits-0b.adoc[`GenericSSATraits`] 
| Traits providing IR&hyphen;specific type aliases for `GenericSSAContext&period;`
| xref:llvm/GenericScheduler.adoc[`GenericScheduler`] 
| GenericScheduler shrinks the unscheduled zone using heuristics to balance the schedule&period;
| xref:llvm/GenericSchedulerBase.adoc[`GenericSchedulerBase`] 
| Base class for GenericScheduler candidate heuristics&period;
| xref:llvm/GenericSyncDependenceAnalysis.adoc[`GenericSyncDependenceAnalysis`] 
| Sync&hyphen;dependence analysis that finds join points and divergent cycle exits caused by divergent terminators&period;
| xref:llvm/GenericUniformityAnalysisImpl.adoc[`GenericUniformityAnalysisImpl`] 
| Analysis that identifies uniform values in a data&hyphen;parallel execution&period;
| xref:llvm/GenericUniformityAnalysisImplDeleter.adoc[`GenericUniformityAnalysisImplDeleter`] 
| Deleter for `GenericUniformityAnalysisImpl` stored in a unique&lowbar;ptr&period;
| xref:llvm/GenericUniformityInfo.adoc[`GenericUniformityInfo`] 
| Computes which values and terminators are uniform vs divergent in a function&period;
| xref:llvm/GenericValue.adoc[`GenericValue`] 
| Holds an LLVM value of arbitrary type for the interpreter and related tools&period;
| xref:llvm/GetElementPtrInst.adoc[`GetElementPtrInst`] 
| an instruction for type&hyphen;safe pointer arithmetic to access elements of arrays and structs
| xref:llvm/GlobPattern.adoc[`GlobPattern`] 
| Glob pattern matcher similar to bash with some key differences&period;
| xref:llvm/GlobalAddressSDNode.adoc[`GlobalAddressSDNode`] 
| SDNode referencing a GlobalValue with optional offset and flags&period;
| xref:llvm/GlobalAlias.adoc[`GlobalAlias`] 
| Represents a single function or variable alias in the IR&period;
| xref:llvm/GlobalDCEPass.adoc[`GlobalDCEPass`] 
| Pass to remove unused function declarations&period;
| xref:llvm/GlobalIFunc.adoc[`GlobalIFunc`] 
| Represents a single ELF indirect function (ifunc) in the IR&period;
| xref:llvm/GlobalMergeFunc.adoc[`GlobalMergeFunc`] 
| Module pass that merges functions using stable function hashes&period;
| xref:llvm/GlobalMergeFuncPass.adoc[`GlobalMergeFuncPass`] 
| Global function merging pass for new pass manager&period;
| xref:llvm/GlobalMergeOptions.adoc[`GlobalMergeOptions`] 
| Options that control how the global&hyphen;merge pass groups and merges globals&period;
| xref:llvm/GlobalMergePass.adoc[`GlobalMergePass`] 
| New PM pass that merges globals to reduce address&hyphen;materialization cost&period;
| xref:llvm/GlobalNumberState.adoc[`GlobalNumberState`] 
| Assigns stable serial numbers to global values for ordering comparisons&period;
| xref:llvm/GlobalObject.adoc[`GlobalObject`] 
| Base class for independently defined globals such as functions and variables&period;
| xref:llvm/GlobalOptPass.adoc[`GlobalOptPass`] 
| Optimize globals that never have their address taken&period;
| xref:llvm/GlobalSplitPass.adoc[`GlobalSplitPass`] 
| Pass to perform split of global variables&period;
| xref:llvm/GlobalStatus.adoc[`GlobalStatus`] 
| Status of how a global or thread&hyphen;local variable is used&period;
| xref:llvm/GlobalValue.adoc[`GlobalValue`] 
| Base class of globally definable objects such as functions, variables, and aliases&period;
| xref:llvm/GlobalValuePseudoSourceValue.adoc[`GlobalValuePseudoSourceValue`] 
| A specialized pseudo source value for holding GlobalValue values&period;
| xref:llvm/GlobalValueSummary.adoc[`GlobalValueSummary`] 
| Function and variable summary information to aid decisions and implementation of importing&period;
| xref:llvm/GlobalValueSummaryInfo.adoc[`GlobalValueSummaryInfo`] 
| Summary information for one GUID in the global value summary map&period;
| xref:llvm/GlobalValueSummaryMap.adoc[`GlobalValueSummaryMap`] 
| Map from global value GUID to corresponding summary structures&period;
| xref:llvm/GlobalVarSummary.adoc[`GlobalVarSummary`] 
| Global variable summary information to aid decisions and implementation of importing&period;
| xref:llvm/GlobalVariable.adoc[`GlobalVariable`] 
| Represents a single global variable (or constant) in the IR&period;
| xref:llvm/GlobalsAA.adoc[`GlobalsAA`] 
| Analysis pass providing a never&hyphen;invalidated alias analysis result&period;
| xref:llvm/GlobalsAAResult.adoc[`GlobalsAAResult`] 
| An alias analysis result set for globals&period;
| xref:llvm/GlobalsAAWrapperPass.adoc[`GlobalsAAWrapperPass`] 
| Legacy wrapper pass to provide the GlobalsAAResult object&period;
| xref:llvm/GraphDiff.adoc[`GraphDiff`] 
| CFG snapshot that overlays insert&sol;delete edge updates on a graph&period;
| xref:llvm/GraphTraits-061.adoc[`GraphTraits`] 
| Traits for traversing a graph type without copying it&period;
| xref:llvm/GraphWriter.adoc[`GraphWriter`] 
| Default DOT graph writer for a graph type&period;
| xref:llvm/GraphWriterBase.adoc[`GraphWriterBase`] 
| CRTP base that emits a Graphviz DOT representation of a graph&period;
| xref:llvm/GuardWideningPass.adoc[`GuardWideningPass`] 
| Pass that widens llvm&period;experimental&period;guard intrinsics by combining them&period;
| xref:llvm/HTTPClient.adoc[`HTTPClient`] 
| A reusable client that can perform HTTPRequests through a network socket&period;
| xref:llvm/HTTPRequest.adoc[`HTTPRequest`] 
| A stateless description of an outbound HTTP request&period;
| xref:llvm/HTTPResponse.adoc[`HTTPResponse`] 
| A complete buffered HTTP response with status, content type, and body&period;
| xref:llvm/HTTPResponseHandler.adoc[`HTTPResponseHandler`] 
| Handler for state updates while an HTTPRequest is performed&period;
| xref:llvm/HTTPServer.adoc[`HTTPServer`] 
| An HTTP server which can listen on a single TCP&sol;IP port for HTTP requests and delgate them to the appropriate registered handler&period;
| xref:llvm/HTTPServerError.adoc[`HTTPServerError`] 
| Error info for failures originating in the HTTP server&period;
| xref:llvm/HTTPServerRequest.adoc[`HTTPServerRequest`] 
| An inbound HTTP request being handled by HTTPServer&period;
| xref:llvm/HWAddressSanitizerOptions.adoc[`HWAddressSanitizerOptions`] 
| Options that control Hardware AddressSanitizer instrumentation&period;
| xref:llvm/HWAddressSanitizerPass.adoc[`HWAddressSanitizerPass`] 
| This is a public interface to the hardware address sanitizer&period;
| xref:llvm/HandleSDNode.adoc[`HandleSDNode`] 
| Persistent handle around another node updated across RAUW&period;
| xref:llvm/HardwareLoopInfo.adoc[`HardwareLoopInfo`] 
| Attributes of a target dependent hardware loop&period;
| xref:llvm/HardwareLoopOptions.adoc[`HardwareLoopOptions`] 
| Options that control how the hardware&hyphen;loops pass inserts loop intrinsics&period;
| xref:llvm/HardwareLoopsPass.adoc[`HardwareLoopsPass`] 
| New PM pass that inserts hardware&hyphen;loop intrinsics into profitable loops&period;
| xref:llvm/HasReferenceResolver.adoc[`HasReferenceResolver`] 
| Do not resolve anything, but keep track of whether a given variable was referenced&period;
| xref:llvm/HashBuilder.adoc[`HashBuilder`] 
| Interface to help hash various types through a hasher type&period;
| xref:llvm/HashBuilderBase.adoc[`HashBuilderBase`] 
| Declares the hasher member, and functions forwarding directly to the hasher&period;
| xref:llvm/HashNode.adoc[`HashNode`] 
| An entry in an OutlinedHashTree&period;
| xref:llvm/HashNodeStable.adoc[`HashNodeStable`] 
| HashNodeStable is the serialized, stable, and compact representation of a HashNode&period;
| xref:llvm/HashRecognize.adoc[`HashRecognize`] 
| Analysis that recognizes hash algorithms such as CRC in loops&period;
| xref:llvm/HashRecognizePrinterPass.adoc[`HashRecognizePrinterPass`] 
| Printer pass for the HashRecognize analysis&period;
| xref:llvm/HelloWorldPass.adoc[`HelloWorldPass`] 
| Example pass that prints each function&apos;s name&period;
| xref:llvm/HexNumber.adoc[`HexNumber`] 
| A numeric value formatted as hexadecimal when streamed&period;
| xref:llvm/HexagonAttributeParser.adoc[`HexagonAttributeParser`] 
| Parser for Hexagon ELF build attributes&period;
| xref:llvm/HipStdParAcceleratorCodeSelectionPass.adoc[`HipStdParAcceleratorCodeSelectionPass`] 
| Pass that keeps only functions reachable from HIPSTDPAR kernels&period;
| xref:llvm/HipStdParAllocationInterpositionPass.adoc[`HipStdParAllocationInterpositionPass`] 
| Pass that redirects allocations to accelerator&hyphen;accessible runtime APIs&period;
| xref:llvm/HipStdParMathFixupPass.adoc[`HipStdParMathFixupPass`] 
| Pass that rewrites math calls through the HIPSTDPAR forwarding layer&period;
| xref:llvm/HistogramInfo.adoc[`HistogramInfo`] 
| Details of a histogram load&hyphen;update&hyphen;store sequence&period;
| xref:llvm/HotColdSplitting.adoc[`HotColdSplitting`] 
| Outlines cold regions of functions into separate cold functions&period;
| xref:llvm/HotColdSplittingPass.adoc[`HotColdSplittingPass`] 
| Pass to outline cold regions&period;
| xref:llvm/HungoffOperandTraits.adoc[`HungoffOperandTraits`] 
| HungoffOperandTraits &hyphen; determine the allocation regime of the Use array when it is not a prefix to the User object, but allocated at an unrelated heap address&period;
| xref:llvm/ICFLoopSafetyInfo.adoc[`ICFLoopSafetyInfo`] 
| Precise LoopSafetyInfo based on ImplicitControlFlowTracking&period;
| xref:llvm/ICallPromotionAnalysis.adoc[`ICallPromotionAnalysis`] 
| Identifies profitable indirect call promotion candidates&period;
| xref:llvm/ICmpInst.adoc[`ICmpInst`] 
| Represent an integer comparison operator&period;
| xref:llvm/IDFCalculator.adoc[`IDFCalculator`] 
| Iterated dominance frontier calculator specialized for BasicBlock&period;
| xref:llvm/IDFCalculatorBase.adoc[`IDFCalculatorBase`] 
| Determine the iterated dominance frontier, given a set of defining blocks, and optionally, a set of live&hyphen;in blocks&period;
| xref:llvm/ILPValue.adoc[`ILPValue`] 
| Represent the ILP of the subDAG rooted at a DAG node&period;
| xref:llvm/IPSCCPOptions.adoc[`IPSCCPOptions`] 
| A set of parameters to control various transforms performed by IPSCCP pass&period;
| xref:llvm/IPSCCPPass.adoc[`IPSCCPPass`] 
| Pass to perform interprocedural constant propagation&period;
| xref:llvm/IR2VecPrinterPass.adoc[`IR2VecPrinterPass`] 
| This pass prints the IR2Vec embeddings for instructions, basic blocks, and functions&period;
| xref:llvm/IR2VecVocabAnalysis.adoc[`IR2VecVocabAnalysis`] 
| Analysis that produces the IR2Vec vocabulary for a module&period;
| xref:llvm/IR2VecVocabPrinterPass.adoc[`IR2VecVocabPrinterPass`] 
| This pass prints the embeddings in the vocabulary
| xref:llvm/IRAttribute-023.adoc[`IRAttribute`] 
| Helper class that provides common functionality to manifest IR attributes&period;
| xref:llvm/IRBuilder-0b.adoc[`IRBuilder`] 
| Uniform API for creating and inserting LLVM IR instructions&period;
| xref:llvm/IRBuilderBase.adoc[`IRBuilderBase`] 
| Common base class shared among various IRBuilders&period;
| xref:llvm/IRBuilderCallbackInserter.adoc[`IRBuilderCallbackInserter`] 
| Provides an &apos;InsertHelper&apos; that calls a user&hyphen;provided callback after performing the default insertion&period;
| xref:llvm/IRBuilderDefaultInserter.adoc[`IRBuilderDefaultInserter`] 
| Default helper that inserts IRBuilder&hyphen;created instructions&period;
| xref:llvm/IRBuilderFolder.adoc[`IRBuilderFolder`] 
| IRBuilderFolder &hyphen; Interface for constant folding in IRBuilder&period;
| xref:llvm/IRCEPass.adoc[`IRCEPass`] 
| Pass that eliminates inductive range checks from loops&period;
| xref:llvm/IRChangedPrinter.adoc[`IRChangedPrinter`] 
| Change printer based on the string IR from unwrapAndPrint&period;
| xref:llvm/IRChangedTester.adoc[`IRChangedTester`] 
| Tester that asserts when interesting IR changes under print&hyphen;changed&period;
| xref:llvm/IRComparer.adoc[`IRComparer`] 
| Compares two IR snapshots and reports per&hyphen;function differences&period;
| xref:llvm/IRDataT.adoc[`IRDataT`] 
| Per&hyphen;module (or IR&hyphen;unit) function map saved for comparing IRs&period;
| xref:llvm/IRMover.adoc[`IRMover`] 
| Moves IR from source modules into a composite destination module&period;
| xref:llvm/IRMutationStrategy.adoc[`IRMutationStrategy`] 
| Base class for describing how to mutate a module&period; mutation functions for each IR unit forward to the contained unit&period;
| xref:llvm/IRMutator.adoc[`IRMutator`] 
| Entry point for configuring and running IR mutations&period;
| xref:llvm/IRNormalizerOptions.adoc[`IRNormalizerOptions`] 
| Options controlling how IRNormalizerPass rewrites a function&period;
| xref:llvm/IRNormalizerPass.adoc[`IRNormalizerPass`] 
| IRNormalizer aims to transform LLVM IR into normal form&period;
| xref:llvm/IRPosition.adoc[`IRPosition`] 
| Helper to describe and deal with positions in the LLVM&hyphen;IR&period;
| xref:llvm/IRTranslatorImpl.adoc[`IRTranslatorImpl`] 
| Shared implementation for legacy and new&hyphen;PM IR translation passes&period;
| xref:llvm/IRTranslatorLegacy.adoc[`IRTranslatorLegacy`] 
| Legacy pass that translates LLVM IR into MachineInstr for GlobalISel&period;
| xref:llvm/IRTranslatorPass.adoc[`IRTranslatorPass`] 
| New PM pass that translates LLVM IR into MachineInstr for GlobalISel&period;
| xref:llvm/IRUnitKindTraits-04.adoc[`IRUnitKindTraits`] 
| Map an IR unit type to its IRUnitKind&period;
| xref:llvm/IRUnitRef.adoc[`IRUnitRef`] 
| A type&hyphen;erased reference to the IR unit a pass or analysis is running on, together with the kind of IR unit it refers to&period;
| xref:llvm/IVConditionInfo.adoc[`IVConditionInfo`] 
| Struct to hold information about a partially invariant condition&period;
| xref:llvm/IVStrideUse.adoc[`IVStrideUse`] 
| Tracks one use of a strided induction variable&period;
| xref:llvm/IVUsers.adoc[`IVUsers`] 
| Bookkeeping for interesting users of induction&hyphen;variable expressions&period;
| xref:llvm/IVUsersAnalysis.adoc[`IVUsersAnalysis`] 
| Analysis pass that exposes the `IVUsers` for a loop&period;
| xref:llvm/IVUsersPrinterPass.adoc[`IVUsersPrinterPass`] 
| Printer pass for the `IVUsers` for a loop&period;
| xref:llvm/IVUsersWrapperPass.adoc[`IVUsersWrapperPass`] 
| Legacy analysis pass which computes `IVUsers` for a loop&period;
| xref:llvm/IVVisitor.adoc[`IVVisitor`] 
| Interface for visiting interesting IV users that are recognized but not simplified by this utility&period;
| xref:llvm/IdentifyingPassPtr.adoc[`IdentifyingPassPtr`] 
| Discriminated union of Pass ID types&period;
| xref:llvm/IfDefEmitter.adoc[`IfDefEmitter`] 
| RAII helper that emits an `&num;ifdef` &sol; `&num;undef` &sol; `&num;endif` scope&period;
| xref:llvm/IfDefGuardEmitter.adoc[`IfDefGuardEmitter`] 
| RAII emitter for an `&num;ifdef &lt;Condition&gt;` &sol; `&num;endif` guard&period;
| xref:llvm/IfGuardEmitter.adoc[`IfGuardEmitter`] 
| RAII emitter for an `&num;if &lt;Condition&gt;` &sol; `&num;endif` guard&period;
| xref:llvm/IfGuardEmitterBase.adoc[`IfGuardEmitterBase`] 
| Base class for RAII helpers that emit `&num;if`&hyphen;family guards and matching `&num;endif`&period;
| xref:llvm/IfNDefGuardEmitter.adoc[`IfNDefGuardEmitter`] 
| RAII emitter for an `&num;ifndef &lt;Condition&gt;` &sol; `&num;endif` guard&period;
| xref:llvm/ImmutableList.adoc[`ImmutableList`] 
| Immutable (functional) list of elements of type `T&period;`
| xref:llvm/ImmutableListFactory.adoc[`ImmutableListFactory`] 
| Factory that allocates and uniques immutable lists of element type `T&period;`
| xref:llvm/ImmutableListImpl.adoc[`ImmutableListImpl`] 
| Cons&hyphen;cell node for an immutable list&colon; a head element and a tail pointer&period;
| xref:llvm/ImmutableMap.adoc[`ImmutableMap`] 
| Persistent map of `KeyT` to `ValT` backed by an immutable AVL tree&period;
| xref:llvm/ImmutableMapRef.adoc[`ImmutableMapRef`] 
| Factory&hyphen;backed mutable view of an immutable map&period;
| xref:llvm/ImmutableModuleSummaryIndexAnalysis.adoc[`ImmutableModuleSummaryIndexAnalysis`] 
| NPM analysis to provide an externally&hyphen;built ModuleSummaryIndex (e&period;g&period; the combined index from LTO)&period;
| xref:llvm/ImmutableModuleSummaryIndexWrapperPass.adoc[`ImmutableModuleSummaryIndexWrapperPass`] 
| Legacy wrapper pass to provide the ModuleSummaryIndex object&period;
| xref:llvm/ImmutablePass.adoc[`ImmutablePass`] 
| ImmutablePass class &hyphen; This class is used to provide information that does not need to be run&period; This is useful for things like target information&period;
| xref:llvm/ImmutableSet.adoc[`ImmutableSet`] 
| An immutable (persistent) ordered set backed by a reference&hyphen;counted AVL tree&period;
| xref:llvm/ImmutableSetRef.adoc[`ImmutableSetRef`] 
| A factory&hyphen;backed mutable view of an immutable set&period;
| xref:llvm/ImplicitControlFlowTracking.adoc[`ImplicitControlFlowTracking`] 
| Tracks instructions with implicit control flow within basic blocks&period;
| xref:llvm/ImplicitNullChecksPass.adoc[`ImplicitNullChecksPass`] 
| New PM pass that folds null pointer checks into nearby memory operations&period;
| xref:llvm/ImportedFunctionsInliningStatistics.adoc[`ImportedFunctionsInliningStatistics`] 
| Calculate and dump ThinLTO&hyphen;specific inliner statistics&period;
| xref:llvm/ImutAVLFactory.adoc[`ImutAVLFactory`] 
| Factory for creating and updating persistent AVL trees&period;
| xref:llvm/ImutAVLTree.adoc[`ImutAVLTree`] 
| A reference&hyphen;counted node in a persistent (functional) AVL tree&period;
| xref:llvm/ImutAVLTreeInOrderIterator.adoc[`ImutAVLTreeInOrderIterator`] 
| Bidirectional in&hyphen;order iterator over the nodes of an ImutAVLTree&period;
| xref:llvm/ImutAVLValueIterator.adoc[`ImutAVLValueIterator`] 
| Generic iterator that wraps a T&colon;&colon;TreeTy&colon;&colon;iterator and exposes iterator&colon;&colon;getValue() on dereference&period;
| xref:llvm/ImutContainerInfo-08.adoc[`ImutContainerInfo`] 
| Comparison and key&sol;data accessors for elements of immutable containers&period;
| xref:llvm/ImutIntervalAVLFactory.adoc[`ImutIntervalAVLFactory`] 
| Forward declaration of a factory for interval&hyphen;keyed immutable AVL trees&period; Declared here so it can be a friend of xref:llvm/ImutAVLTree.adoc[`ImutAVLTree`] and access internal node APIs&period;
| xref:llvm/ImutKeyValueInfo.adoc[`ImutKeyValueInfo`] 
| Traits class used by ImmutableMap&period;
| xref:llvm/ImutProfileInfo-01a.adoc[`ImutProfileInfo`] 
| Profile traits that hash values into a `FoldingSetNodeID&period;`
| xref:llvm/ImutProfileInteger-0a1.adoc[`ImutProfileInteger`] 
| Profile traits for integers&period;
| xref:llvm/InLineChangePrinter.adoc[`InLineChangePrinter`] 
| Change printer that shows in&hyphen;line basic&hyphen;block diffs with &plus;&sol;&hyphen; markers&period;
| xref:llvm/IncIntegerState-03.adoc[`IncIntegerState`] 
| Specialization of the integer state for an increasing value, hence &#126;0u is the best state and 0 the worst&period;
| xref:llvm/IncludeGuardEmitter.adoc[`IncludeGuardEmitter`] 
| RAII helper that emits a header include guard (`&num;ifndef` &sol; `&num;define` &sol; `&num;endif`)&period;
| xref:llvm/IndVarSimplifyPass.adoc[`IndVarSimplifyPass`] 
| Pass that simplifies induction variables in a loop&period;
| xref:llvm/IndexListEntry.adoc[`IndexListEntry`] 
| An entry in the SlotIndexes index list&period;
| xref:llvm/IndexedCodeGenDataReader.adoc[`IndexedCodeGenDataReader`] 
| Reader for binary (indexed) codegen data&period;
| xref:llvm/IndexedInstrProfReader.adoc[`IndexedInstrProfReader`] 
| Reader for the indexed binary instrprof format&period;
| xref:llvm/IndexedLoadStoreMatchInfo.adoc[`IndexedLoadStoreMatchInfo`] 
| Match info for rewriting a load&sol;store into an indexed form&period;
| xref:llvm/IndexedMap.adoc[`IndexedMap`] 
| Dense map from keys to values, indexed through a key&hyphen;to&hyphen;index functor&period;
| xref:llvm/IndexedMemProfReader.adoc[`IndexedMemProfReader`] 
| Reader for the MemProf section of an indexed instrumentation profile&period;
| xref:llvm/IndexedReference.adoc[`IndexedReference`] 
| A memory reference as a base pointer and a set of indexing operations&period;
| xref:llvm/IndirectBrExpandPass.adoc[`IndirectBrExpandPass`] 
| New PM pass that expands `indirectbr` instructions into switches&period;
| xref:llvm/IndirectBrInst.adoc[`IndirectBrInst`] 
| Indirect Branch Instruction&period;
| xref:llvm/InductionDescriptor.adoc[`InductionDescriptor`] 
| A struct for saving information about induction variables&period;
| xref:llvm/InferAddressSpacesPass.adoc[`InferAddressSpacesPass`] 
| Pass that infers specific address spaces for generic pointers&period;
| xref:llvm/InferAlignmentPass.adoc[`InferAlignmentPass`] 
| Pass that infers stronger alignments for memory operations&period;
| xref:llvm/InferFunctionAttrsPass.adoc[`InferFunctionAttrsPass`] 
| A pass which infers function attributes from the names and signatures of function declarations in a module&period;
| xref:llvm/InfoSectionUnitHeader.adoc[`InfoSectionUnitHeader`] 
| Parsed header fields from a &period;debug&lowbar;info(&period;dwo) unit&period;
| xref:llvm/InformationCache.adoc[`InformationCache`] 
| Data structure to hold cached (LLVM&hyphen;IR) information&period;
| xref:llvm/Init.adoc[`Init`] 
| Represents a TableGen initializer value&period;
| xref:llvm/InitLLVM.adoc[`InitLLVM`] 
| RAII helper that performs one&hyphen;time LLVM tool process initialization&period;
| xref:llvm/InitUndefPass.adoc[`InitUndefPass`] 
| New PM pass that initializes undef values with temporary pseudos&period;
| xref:llvm/InjectTLIMappings.adoc[`InjectTLIMappings`] 
| Pass that injects VFABI mappings from TargetLibraryInfo&period;
| xref:llvm/InjectorIRStrategy.adoc[`InjectorIRStrategy`] 
| Strategy that injects operations into the function&period;
| xref:llvm/InlineAdvice.adoc[`InlineAdvice`] 
| Captures state between an inlining decision and observing its impact&period;
| xref:llvm/InlineAdvisor.adoc[`InlineAdvisor`] 
| Interface for deciding whether to inline a call site or not&period;
| xref:llvm/InlineAdvisorAnalysis.adoc[`InlineAdvisorAnalysis`] 
| The InlineAdvisorAnalysis is a module pass because the InlineAdvisor needs to capture state right before inlining commences over a module&period;
| xref:llvm/InlineAdvisorAnalysisPrinterPass.adoc[`InlineAdvisorAnalysisPrinterPass`] 
| Printer pass for the InlineAdvisorAnalysis results&period;
| xref:llvm/InlineAsm.adoc[`InlineAsm`] 
| Value representing an inline assembly string used as a call callee&period;
| xref:llvm/InlineAsmIdentifierInfo.adoc[`InlineAsmIdentifierInfo`] 
| Parsed identity of an identifier in MS&hyphen;style inline assembly&period;
| xref:llvm/InlineAsmKeyType.adoc[`InlineAsmKeyType`] 
| Lookup key used to uniquify `InlineAsm` values in `ConstantUniqueMap&period;`
| xref:llvm/InlineAsmLowering.adoc[`InlineAsmLowering`] 
| Interface for lowering LLVM inline asm to GlobalISel MIR&period;
| xref:llvm/InlineAsmPreparePass.adoc[`InlineAsmPreparePass`] 
| New PM pass that prepares inline asm for SelectionDAG codegen&period;
| xref:llvm/InlineContext.adoc[`InlineContext`] 
| Provides context on when an inline advisor is constructed in the pipeline (e&period;g&period;, link phase, inline driver)&period;
| xref:llvm/InlineCost.adoc[`InlineCost`] 
| Represents the cost of inlining a function&period;
| xref:llvm/InlineCostAnnotationPrinterPass.adoc[`InlineCostAnnotationPrinterPass`] 
| Pass that prints per&hyphen;instruction inline cost annotations for debugging&period;
| xref:llvm/InlineFunctionInfo.adoc[`InlineFunctionInfo`] 
| This class captures the data input to the InlineFunction call, and records the auxiliary results produced by it&period;
| xref:llvm/InlineOrder.adoc[`InlineOrder`] 
| Priority queue of call sites that defines the order of inlining attempts&period;
| xref:llvm/InlineParams.adoc[`InlineParams`] 
| Parameters that tune thresholds used by inline cost analysis&period;
| xref:llvm/InlineResult.adoc[`InlineResult`] 
| InlineResult is basically true or false&period; For false results the message describes a reason&period;
| xref:llvm/InlinerPass.adoc[`InlinerPass`] 
| The inliner pass for the new pass manager&period;
| xref:llvm/InnerAnalysisManagerProxy-00.adoc[`InnerAnalysisManagerProxy`] 
| Proxies an inner analysis manager through an analysis of an outer IR unit&period;
| xref:llvm/InsertCFGStrategy.adoc[`InsertCFGStrategy`] 
| Strategy to split a random block and insert a random CFG in between&period;
| xref:llvm/InsertElementInst.adoc[`InsertElementInst`] 
| Insert a single scalar element into a vector value&period;
| xref:llvm/InsertFunctionStrategy.adoc[`InsertFunctionStrategy`] 
| Strategy that generates new function calls and inserts function signatures to the modules&period; If any signatures are present in the module it will be called&period;
| xref:llvm/InsertPHIStrategy.adoc[`InsertPHIStrategy`] 
| Strategy to insert PHI Nodes at the head of each basic block&period;
| xref:llvm/InsertPosition.adoc[`InsertPosition`] 
| Represents a position in a basic block&apos;s instruction list for insertion&period;
| xref:llvm/InsertValueInst.adoc[`InsertValueInst`] 
| Insert a struct field or array element into an aggregate value&period;
| xref:llvm/InstCombineOptions.adoc[`InstCombineOptions`] 
| Options that control how InstCombine iterates and verifies its result&period;
| xref:llvm/InstCombinePass.adoc[`InstCombinePass`] 
| A pass that combines instructions to form fewer, simpler instructions&period;
| xref:llvm/InstCombiner.adoc[`InstCombiner`] 
| The core instruction combiner logic&period;
| xref:llvm/InstCostVisitor.adoc[`InstCostVisitor`] 
| Estimates codesize and latency savings from specializing on constants&period;
| xref:llvm/InstCountPass.adoc[`InstCountPass`] 
| Pass that counts instructions and reports them as statistics&period;
| xref:llvm/InstDeleterIRStrategy.adoc[`InstDeleterIRStrategy`] 
| Strategy that deletes instructions when the Module is too large&period;
| xref:llvm/InstIterator.adoc[`InstIterator`] 
| Grant `InstIterator` access to the basic&hyphen;block list&period;
| xref:llvm/InstModificationIRStrategy.adoc[`InstModificationIRStrategy`] 
| Strategy that modifies instruction attributes and operands&period;
| xref:llvm/InstSimplifyFolder.adoc[`InstSimplifyFolder`] 
| InstSimplifyFolder &hyphen; Fold IRBuilder operations via InstructionSimplify&period;
| xref:llvm/InstSimplifyPass.adoc[`InstSimplifyPass`] 
| Run instruction simplification across each instruction in the function&period;
| xref:llvm/InstVisitor-04.adoc[`InstVisitor`] 
| Base class for instruction visitors
| xref:llvm/InstancesOpInit.adoc[`InstancesOpInit`] 
| Represents an initializer that finds matching records&period;
| xref:llvm/InstrInfoQuery.adoc[`InstrInfoQuery`] 
| Query wrapper for instruction metadata and wrap flags&period;
| xref:llvm/InstrItinerary.adoc[`InstrItinerary`] 
| Scheduling information for an instruction&period;
| xref:llvm/InstrItineraryData.adoc[`InstrItineraryData`] 
| Itinerary data supplied by a subtarget to be used by a target&period;
| xref:llvm/InstrProfCallsite.adoc[`InstrProfCallsite`] 
| Wrapper for the llvm&period;instrprof&period;callsite intrinsic&period;
| xref:llvm/InstrProfCntrInstBase.adoc[`InstrProfCntrInstBase`] 
| A base class for all instrprof counter intrinsics&period;
| xref:llvm/InstrProfCorrelator.adoc[`InstrProfCorrelator`] 
| InstrProfCorrelator &hyphen; A base class used to create raw instrumentation data to their functions&period;
| xref:llvm/InstrProfCorrelatorImpl.adoc[`InstrProfCorrelatorImpl`] 
| InstrProfCorrelatorImpl &hyphen; A child of InstrProfCorrelator with a template pointer type so that the ProfileData vector can be materialized&period;
| xref:llvm/InstrProfCoverInst.adoc[`InstrProfCoverInst`] 
| This represents the llvm&period;instrprof&period;cover intrinsic&period;
| xref:llvm/InstrProfError.adoc[`InstrProfError`] 
| ErrorInfo specialization carrying an instrprof&lowbar;error and message&period;
| xref:llvm/InstrProfIncrementInst.adoc[`InstrProfIncrementInst`] 
| This represents the llvm&period;instrprof&period;increment intrinsic&period;
| xref:llvm/InstrProfIncrementInstStep.adoc[`InstrProfIncrementInstStep`] 
| This represents the llvm&period;instrprof&period;increment&period;step intrinsic&period;
| xref:llvm/InstrProfInstBase.adoc[`InstrProfInstBase`] 
| A base class for all instrprof intrinsics&period;
| xref:llvm/InstrProfIterator.adoc[`InstrProfIterator`] 
| A file format agnostic iterator over profiling data&period;
| xref:llvm/InstrProfLookupTrait.adoc[`InstrProfLookupTrait`] 
| Trait for lookups into the on&hyphen;disk hash table for the binary instrprof format&period;
| xref:llvm/InstrProfMCDCBitmapInstBase.adoc[`InstrProfMCDCBitmapInstBase`] 
| A base class for instrprof mcdc intrinsics that require global bitmap bytes&period;
| xref:llvm/InstrProfMCDCBitmapParameters.adoc[`InstrProfMCDCBitmapParameters`] 
| This represents the llvm&period;instrprof&period;mcdc&period;parameters intrinsic&period;
| xref:llvm/InstrProfMCDCTVBitmapUpdate.adoc[`InstrProfMCDCTVBitmapUpdate`] 
| This represents the llvm&period;instrprof&period;mcdc&period;tvbitmap&period;update intrinsic&period;
| xref:llvm/InstrProfOptions.adoc[`InstrProfOptions`] 
| Options for the frontend instrumentation based profiling pass&period;
| xref:llvm/InstrProfReader.adoc[`InstrProfReader`] 
| Base class and interface for reading profiling data of any known instrprof format&period; Provides an iterator over NamedInstrProfRecords&period;
| xref:llvm/InstrProfReaderIndex.adoc[`InstrProfReaderIndex`] 
| Index over an on&hyphen;disk hash table of named instrumentation profile records&period;
| xref:llvm/InstrProfReaderIndexBase.adoc[`InstrProfReaderIndexBase`] 
| Base interface for iterating and looking up records in an indexed profile&period;
| xref:llvm/InstrProfReaderItaniumRemapper.adoc[`InstrProfReaderItaniumRemapper`] 
| Remapper that matches Itanium&hyphen;mangled names to indexed profile keys&period;
| xref:llvm/InstrProfReaderRemapper.adoc[`InstrProfReaderRemapper`] 
| Name matcher supporting fuzzy matching of symbol names to names in profiles&period;
| xref:llvm/InstrProfRecord.adoc[`InstrProfRecord`] 
| Profiling information for a single function&period;
| xref:llvm/InstrProfRecordWriterTrait.adoc[`InstrProfRecordWriterTrait`] 
| Trait for serializing instrumentation profile records into an on&hyphen;disk hash table&period;
| xref:llvm/InstrProfSummaryBuilder.adoc[`InstrProfSummaryBuilder`] 
| Builder that constructs a ProfileSummary from instrumentation profile records&period;
| xref:llvm/InstrProfSymtab.adoc[`InstrProfSymtab`] 
| Symbol table mapping PGO name keys to functions and globals&period;
| xref:llvm/InstrProfTimestampInst.adoc[`InstrProfTimestampInst`] 
| This represents the llvm&period;instrprof&period;timestamp intrinsic&period;
| xref:llvm/InstrProfValueProfileInst.adoc[`InstrProfValueProfileInst`] 
| This represents the llvm&period;instrprof&period;value&period;profile intrinsic&period;
| xref:llvm/InstrProfValueSiteRecord.adoc[`InstrProfValueSiteRecord`] 
| Value&hyphen;profile data recorded at a single value site&period;
| xref:llvm/InstrProfWriter.adoc[`InstrProfWriter`] 
| Writer for instrumentation based profile data&period;
| xref:llvm/InstrProfilingLoweringPass.adoc[`InstrProfilingLoweringPass`] 
| Instrumentation based profiling lowering pass&period; This pass lowers the profile instrumented code generated by FE or the IR based instrumentation pass&period;
| xref:llvm/InstrStage.adoc[`InstrStage`] 
| Represents a non&hyphen;pipelined step in the execution of an instruction&period;
| xref:llvm/Instruction.adoc[`Instruction`] 
| Base class for all LLVM IR instructions&period;
| xref:llvm/InstructionBuildSteps.adoc[`InstructionBuildSteps`] 
| Description of one instruction to emit during a multi&hyphen;step combine&period;
| xref:llvm/InstructionCombiningPass.adoc[`InstructionCombiningPass`] 
| The legacy pass manager&apos;s instcombine pass&period;
| xref:llvm/InstructionCost.adoc[`InstructionCost`] 
| Class used when calculating the cost of an instruction or a group of instructions&period;
| xref:llvm/InstructionNamerPass.adoc[`InstructionNamerPass`] 
| Pass that assigns names to anonymous arguments, blocks, and instructions&period;
| xref:llvm/InstructionOrdering.adoc[`InstructionOrdering`] 
| Tracks relative instruction order within a machine function&period;
| xref:llvm/InstructionPrecedenceTracking.adoc[`InstructionPrecedenceTracking`] 
| Tracks &quot;special&quot; instructions and answers precedence queries efficiently&period;
| xref:llvm/InstructionSelectImpl.adoc[`InstructionSelectImpl`] 
| Shared implementation for legacy and new&hyphen;PM instruction selection passes&period;
| xref:llvm/InstructionSelectLegacy.adoc[`InstructionSelectLegacy`] 
| Legacy pass that selects generic machine instructions to target instructions&period;
| xref:llvm/InstructionSelectPass.adoc[`InstructionSelectPass`] 
| New PM pass that selects generic machine instructions to target instructions&period;
| xref:llvm/InstructionSelector.adoc[`InstructionSelector`] 
| Selects (possibly generic) machine instructions to target&hyphen;specific opcodes&period;
| xref:llvm/InstructionStepsMatchInfo.adoc[`InstructionStepsMatchInfo`] 
| Match info describing a sequence of instructions to build for a combine&period;
| xref:llvm/InstructionWorklist.adoc[`InstructionWorklist`] 
| InstructionWorklist &hyphen; This is the worklist management logic for InstCombine and other simplification passes&period;
| xref:llvm/InstrumentationIRBuilder.adoc[`InstrumentationIRBuilder`] 
| IRBuilder that ensures inserted instrumentation has a DebugLocation&period;
| xref:llvm/InstrumentorPass.adoc[`InstrumentorPass`] 
| The Instrumentor pass&period;
| xref:llvm/IntEqClasses.adoc[`IntEqClasses`] 
| Equivalence classes over the small integers 0 &period;&period; N&hyphen;1&period;
| xref:llvm/IntInit.adoc[`IntInit`] 
| &apos;7&apos; &hyphen; Represent an initialization by a literal integer value&period;
| xref:llvm/IntRecTy.adoc[`IntRecTy`] 
| &apos;int&apos; &hyphen; Represent an integer value of no particular size
| xref:llvm/IntToPtrInst.adoc[`IntToPtrInst`] 
| Instruction that casts an integer to a pointer&period;
| xref:llvm/IntegerInclusiveInterval.adoc[`IntegerInclusiveInterval`] 
| Represents an inclusive integer interval &lsqb;Begin, End&rsqb;where Begin &lt;&equals; End&period;
| xref:llvm/IntegerRangeState.adoc[`IntegerRangeState`] 
| State for an integer range&period;
| xref:llvm/IntegerStateBase-0f2.adoc[`IntegerStateBase`] 
| Simple state with integers encoding&period;
| xref:llvm/IntegerType.adoc[`IntegerType`] 
| Class to represent integer types&period;
| xref:llvm/IntelExpr.adoc[`IntelExpr`] 
| Parts of an Intel&hyphen;style memory expression used when emitting compound forms&period;
| xref:llvm/IntelJITEventsWrapper.adoc[`IntelJITEventsWrapper`] 
| Wrapper around the Intel JIT Events API used for testing and reporting&period;
| xref:llvm/InteractiveModelRunner.adoc[`InteractiveModelRunner`] 
| MLModelRunner that requests advice from an external agent over two files&period;
| xref:llvm/InterestingMemoryOperand.adoc[`InterestingMemoryOperand`] 
| Describes a memory reference of interest for analysis&period;
| xref:llvm/InterleaveGroup.adoc[`InterleaveGroup`] 
| The group of interleaved loads&sol;stores sharing the same stride and close to each other&period;
| xref:llvm/InterleavedAccessInfo.adoc[`InterleavedAccessInfo`] 
| Drive the analysis of interleaved memory accesses in the loop&period;
| xref:llvm/InterleavedAccessPass.adoc[`InterleavedAccessPass`] 
| New PM pass that matches interleaved memory accesses to target intrinsics&period;
| xref:llvm/InterleavedLoadCombinePass.adoc[`InterleavedLoadCombinePass`] 
| New PM pass that combines interleaved loads into wide loads&period;
| xref:llvm/InterleavedRange.adoc[`InterleavedRange`] 
| Format object that prints a range with a separator and optional surroundings&period;
| xref:llvm/InternalizePass.adoc[`InternalizePass`] 
| A pass that internalizes all functions and variables other than those that must be preserved according to `MustPreserveGV&period;`
| xref:llvm/IntervalData.adoc[`IntervalData`] 
| Interval with closed endpoints and an associated value&period;
| xref:llvm/IntervalMap-06.adoc[`IntervalMap`] 
| Coalescing map from key intervals to values, stored as a compact B&plus;&hyphen;tree&period;
| xref:llvm/IntervalMapHalfOpenInfo-08.adoc[`IntervalMapHalfOpenInfo`] 
| Traits for half&hyphen;open intervals &lsqb;a&semi;b) used by IntervalMap&period;&rsqb;
| xref:llvm/IntervalMapInfo-07.adoc[`IntervalMapInfo`] 
| Traits for closed intervals &lsqb;a&semi;b&rsqb;used by IntervalMap&period;
| xref:llvm/IntervalMapOverlaps.adoc[`IntervalMapOverlaps`] 
| Iterate over the overlaps of mapped intervals in two IntervalMaps&period;
| xref:llvm/IntervalPressure.adoc[`IntervalPressure`] 
| Register pressure computed over a SlotIndex&hyphen;delimited instruction region&period;
| xref:llvm/IntervalTree-08.adoc[`IntervalTree`] 
| Interval tree that stores closed intervals and answers point queries&period;
| xref:llvm/IntrinsicCostAttributes.adoc[`IntrinsicCostAttributes`] 
| Attributes describing an intrinsic for cost modeling&period;
| xref:llvm/IntrinsicInst.adoc[`IntrinsicInst`] 
| A wrapper class for inspecting calls to intrinsic functions&period; This allows the standard isa&sol;dyncast&sol;cast functionality to work with calls to intrinsic functions&period;
| xref:llvm/IntrinsicLowering.adoc[`IntrinsicLowering`] 
| Lowers intrinsic function calls into non&hyphen;intrinsic IR when possible&period;
| xref:llvm/IntrusiveBackList-0bf.adoc[`IntrusiveBackList`] 
| Intrusive circular back&hyphen;list of nodes of type `T&period;`
| xref:llvm/IntrusiveBackListBase.adoc[`IntrusiveBackListBase`] 
| Untyped intrusive circular back&hyphen;list of _IntrusiveBackListNode&period;_
| xref:llvm/IntrusiveBackListNode.adoc[`IntrusiveBackListNode`] 
| Node in an intrusive circular back&hyphen;list&period;
| xref:llvm/IntrusiveRefCntPtr.adoc[`IntrusiveRefCntPtr`] 
| A smart pointer to a reference&hyphen;counted object that inherits from RefCountedBase or ThreadSafeRefCountedBase&period;
| xref:llvm/IntrusiveRefCntPtrInfo-02.adoc[`IntrusiveRefCntPtrInfo`] 
| Class you can specialize to provide custom retain&sol;release functionality for a type&period;
| xref:llvm/InvalidateAllAnalysesPass.adoc[`InvalidateAllAnalysesPass`] 
| A utility pass that does nothing, but preserves no analyses&period;
| xref:llvm/InvalidateAnalysisPass.adoc[`InvalidateAnalysisPass`] 
| A no&hyphen;op pass template which simply forces a specific analysis result to be invalidated&period;
| xref:llvm/Inverse.adoc[`Inverse`] 
| Marker wrapping a graph so iterators traverse it in inverse order&period;
| xref:llvm/InvokeInst.adoc[`InvokeInst`] 
| Call that transfers control to normal or unwind destinations on completion&period;
| xref:llvm/IsAOpInit.adoc[`IsAOpInit`] 
| !isa&lt;type&gt;(expr) &hyphen; Dynamically determine the type of an expression&period;
| xref:llvm/ItaniumManglingCanonicalizer.adoc[`ItaniumManglingCanonicalizer`] 
| Canonicalizer for mangled names&period;
| xref:llvm/ItaniumPartialDemangler.adoc[`ItaniumPartialDemangler`] 
| Partial Itanium demangler for AST queries and selective printing&period;
| xref:llvm/JITEvaluatedSymbol.adoc[`JITEvaluatedSymbol`] 
| Represents a symbol that has been evaluated to an address already&period;
| xref:llvm/JITEventListener.adoc[`JITEventListener`] 
| Abstract interface used by the JIT to notify clients about significant compilation events&period;
| xref:llvm/JITSymbol.adoc[`JITSymbol`] 
| Represents a symbol in the JIT&period;
| xref:llvm/JITSymbolFlags.adoc[`JITSymbolFlags`] 
| Flags for symbols in the JIT&period;
| xref:llvm/JITSymbolResolver.adoc[`JITSymbolResolver`] 
| Symbol resolution interface&period;
| xref:llvm/JMCInstrumenterPass.adoc[`JMCInstrumenterPass`] 
| New PM pass that instruments functions for Just My Code debugging&period;
| xref:llvm/JSONScopedPrinter.adoc[`JSONScopedPrinter`] 
| Scoped printer that emits JSON objects and arrays&period;
| xref:llvm/JamCRC.adoc[`JamCRC`] 
| Computes JamCRC checksums over a byte stream&period;
| xref:llvm/JobSlot.adoc[`JobSlot`] 
| A JobSlot represents a single job slot that can be acquired from or released to a jobserver pool&period; This class is move&hyphen;only&period;
| xref:llvm/JobserverClient.adoc[`JobserverClient`] 
| The public interface for a jobserver client&period; This client is a lazy&hyphen;initialized singleton that is created on first use&period;
| xref:llvm/JobserverClientImpl.adoc[`JobserverClientImpl`] 
| Concrete platform&hyphen;specific implementation of JobserverClient&period;
| xref:llvm/JumpTableSDNode.adoc[`JumpTableSDNode`] 
| SDNode referencing a jump table index&period;
| xref:llvm/JumpTableToSwitchPass.adoc[`JumpTableToSwitchPass`] 
| Pass that replaces jump tables of small functions with switches&period;
| xref:llvm/JumpThreadingPass.adoc[`JumpThreadingPass`] 
| Pass that performs jump threading across multi&hyphen;predecessor blocks&period;
| xref:llvm/KCFIPass.adoc[`KCFIPass`] 
| A pass that emits generic KCFI indirect call checks for targets that do not lower KCFI operand bundles in the back&hyphen;end&period;
| xref:llvm/KernelInfoPrinter.adoc[`KernelInfoPrinter`] 
| Pass that emits optimization remarks about GPU kernel function properties&period;
| xref:llvm/KnownAssumptionString.adoc[`KnownAssumptionString`] 
| Helper that allows to insert a new assumption string in the known assumption set by creating a (static) object&period;
| xref:llvm/KnownBits.adoc[`KnownBits`] 
| Tracks known zero and one bits of an integer value&period;
| xref:llvm/KnownFPClass.adoc[`KnownFPClass`] 
| Tracks which floating&hyphen;point classes a value may belong to&period;
| xref:llvm/LCSSAPass.adoc[`LCSSAPass`] 
| Converts loops into loop&hyphen;closed SSA form&period;
| xref:llvm/LCSSAVerificationPass.adoc[`LCSSAVerificationPass`] 
| Function pass that verifies LCSSA form is preserved by loop passes&period;
| xref:llvm/LICMOptions.adoc[`LICMOptions`] 
| Options controlling MemorySSA caps and speculation in LICM&period;
| xref:llvm/LICMPass.adoc[`LICMPass`] 
| Performs Loop Invariant Code Motion Pass&period;
| xref:llvm/LLLexer.adoc[`LLLexer`] 
| Lexer for LLVM IR textual assembly (`&period;ll` files)&period;
| xref:llvm/LLParser.adoc[`LLParser`] 
| Recursive&hyphen;descent parser for LLVM IR textual assembly (`&period;ll` files)&period;
| xref:llvm/LLT.adoc[`LLT`] 
| Low&hyphen;level type used at MachineInstr selection time, capturing size, vector lane count, and kind (scalar&sol;integer&sol;float&sol;pointer and vector variants)&period;
| xref:llvm/LLVMContext.adoc[`LLVMContext`] 
| This is an important class for using LLVM in a threaded context&period; It (opaquely) owns and manages the core &quot;global&quot; data of LLVM&apos;s core infrastructure, including the type and constant uniquing tables&period; LLVMContext itself provides no locking guarantees, so you should be careful to have one context per thread&period;
| xref:llvm/LLVMContextImpl.adoc[`LLVMContextImpl`] 
| Private implementation details of `LLVMContext&period;`
| xref:llvm/LLVMRemarkFileHandle.adoc[`LLVMRemarkFileHandle`] 
| RAII handle that manages the lifetime of the ToolOutputFile used to output remarks&period;
| xref:llvm/LLVMRemarkSetupErrorInfo-00.adoc[`LLVMRemarkSetupErrorInfo`] 
| CRTP base for errors raised while setting up optimization remarks&period;
| xref:llvm/LLVMRemarkSetupFileError.adoc[`LLVMRemarkSetupFileError`] 
| Error raised when the remarks output file cannot be opened&period;
| xref:llvm/LLVMRemarkSetupFormatError.adoc[`LLVMRemarkSetupFormatError`] 
| Error raised when a remark serialization format is invalid&period;
| xref:llvm/LLVMRemarkSetupPatternError.adoc[`LLVMRemarkSetupPatternError`] 
| Error raised when a remark pass filter pattern is invalid&period;
| xref:llvm/LLVMRemarkStreamer.adoc[`LLVMRemarkStreamer`] 
| Streams LLVM remark diagnostics from IR and MIR passes&period;
| xref:llvm/LNICMPass.adoc[`LNICMPass`] 
| Performs LoopNest Invariant Code Motion Pass&period;
| xref:llvm/LPMUpdater.adoc[`LPMUpdater`] 
| This class provides an interface for updating the loop pass manager based on mutations to the loop nest&period;
| xref:llvm/LPPassManager.adoc[`LPPassManager`] 
| Pass manager that schedules and runs LoopPasses on a function&period;
| xref:llvm/LSBaseSDNode.adoc[`LSBaseSDNode`] 
| Base class for LoadSDNode and StoreSDNode&period;
| xref:llvm/LShrOperator.adoc[`LShrOperator`] 
| Concrete operator for the LShr instruction opcode&period;
| xref:llvm/LTOCodeGenerator.adoc[`LTOCodeGenerator`] 
| C&plus;&plus; class which implements the opaque lto&lowbar;code&lowbar;gen&lowbar;t type&period;
| xref:llvm/LTOModule.adoc[`LTOModule`] 
| C&plus;&plus; class which implements the opaque lto&lowbar;module&lowbar;t type&period;
| xref:llvm/LabelSDNode.adoc[`LabelSDNode`] 
| SDNode wrapping an MCSymbol label&period;
| xref:llvm/LandingPadInfo.adoc[`LandingPadInfo`] 
| Landing&hyphen;pad metadata retained for the current machine function&period;
| xref:llvm/LandingPadInst.adoc[`LandingPadInst`] 
| Landing pad instruction for exception handling in an unwind block&period;
| xref:llvm/LaneBitmask.adoc[`LaneBitmask`] 
| Bitmask representing which sub&hyphen;register lanes cover a register&period;
| xref:llvm/LastRunTrackingAnalysis.adoc[`LastRunTrackingAnalysis`] 
| A function&sol;module analysis which provides an empty `LastRunTrackingInfo&period;`
| xref:llvm/LastRunTrackingInfo.adoc[`LastRunTrackingInfo`] 
| Tracks the last run of a set of module&sol;function passes&period;
| xref:llvm/LatencyPriorityQueue.adoc[`LatencyPriorityQueue`] 
| Priority queue that schedules nodes by latency to shorten the critical path&period;
| xref:llvm/LatticeKeyInfo.adoc[`LatticeKeyInfo`] 
| A template for translating between LLVM Values and LatticeKeys&period; Clients must provide a specialization of LatticeKeyInfo for their LatticeKey type&period;
| xref:llvm/LazyAtomicPointer.adoc[`LazyAtomicPointer`] 
| Lock&hyphen;free atomic pointer that coordinates concurrent writes from a lazy generator&period;
| xref:llvm/LazyBlockFrequencyInfo.adoc[`LazyBlockFrequencyInfo`] 
| Wraps a BFI to allow lazy computation of the block frequencies&period;
| xref:llvm/LazyBlockFrequencyInfoPass.adoc[`LazyBlockFrequencyInfoPass`] 
| Alternative analysis pass that computes block frequencies on demand&period;
| xref:llvm/LazyBranchProbabilityInfoPass.adoc[`LazyBranchProbabilityInfoPass`] 
| Alternative analysis pass that computes branch probabilities on demand&period;
| xref:llvm/LazyCallGraph.adoc[`LazyCallGraph`] 
| A lazily constructed view of the call graph of a module&period;
| xref:llvm/LazyCallGraphAnalysis.adoc[`LazyCallGraphAnalysis`] 
| An analysis pass which computes the call graph for a module&period;
| xref:llvm/LazyCallGraphDOTPrinterPass.adoc[`LazyCallGraphDOTPrinterPass`] 
| A pass which prints the call graph as a DOT file to a `raw&lowbar;ostream&period;`
| xref:llvm/LazyCallGraphPrinterPass.adoc[`LazyCallGraphPrinterPass`] 
| A pass which prints the call graph to a `raw&lowbar;ostream&period;`
| xref:llvm/LazyMachineBlockFrequencyInfoPass.adoc[`LazyMachineBlockFrequencyInfoPass`] 
| Alternative analysis pass that computes machine block frequencies on demand&period;
| xref:llvm/LazyValueAnalysis.adoc[`LazyValueAnalysis`] 
| Analysis to compute lazy value information&period;
| xref:llvm/LazyValueInfo.adoc[`LazyValueInfo`] 
| This pass computes, caches, and vends lazy value constraint information&period;
| xref:llvm/LazyValueInfoImpl.adoc[`LazyValueInfoImpl`] 
| Opaque implementation of LazyValueInfo constraint analysis&period;
| xref:llvm/LazyValueInfoPrinterPass.adoc[`LazyValueInfoPrinterPass`] 
| Printer pass for the LazyValueAnalysis results&period;
| xref:llvm/LazyValueInfoWrapperPass.adoc[`LazyValueInfoWrapperPass`] 
| Wrapper around LazyValueInfo&period;
| xref:llvm/LegacyDefaultAnalysisGraphTraits.adoc[`LegacyDefaultAnalysisGraphTraits`] 
| Default traits class for extracting a graph from an analysis pass&period;
| xref:llvm/LegacyJITSymbolResolver.adoc[`LegacyJITSymbolResolver`] 
| Legacy symbol resolution interface&period;
| xref:llvm/LegalityQuery.adoc[`LegalityQuery`] 
| Bundle the information needed to decide whether an operation is legal&period;
| xref:llvm/LegalizationArtifactCombiner.adoc[`LegalizationArtifactCombiner`] 
| Helper that combines away legalization artifacts such as truncs and extends&period;
| xref:llvm/LegalizeActionStep.adoc[`LegalizeActionStep`] 
| The result of a query&period; It either indicates a final answer of Legal or Unsupported or describes an action that must be taken to make an operation more legal&period;
| xref:llvm/LegalizeRule.adoc[`LegalizeRule`] 
| A single rule in a legalizer info ruleset&period;
| xref:llvm/LegalizeRuleSet.adoc[`LegalizeRuleSet`] 
| Builder for the ordered legalization rules of one opcode (or alias group)&period;
| xref:llvm/LegalizerHelper.adoc[`LegalizerHelper`] 
| Helper that rewrites illegal Generic MIR into legal sequences&period;
| xref:llvm/LegalizerInfo.adoc[`LegalizerInfo`] 
| Describe which GlobalISel operations are legal and how to legalize others&period;
| xref:llvm/LegalizerLegacy.adoc[`LegalizerLegacy`] 
| Legacy pass that legalizes generic machine instructions for GlobalISel&period;
| xref:llvm/LegalizerMFResult.adoc[`LegalizerMFResult`] 
| Result of running GlobalISel legalization on a machine function&period;
| xref:llvm/LegalizerPass.adoc[`LegalizerPass`] 
| New PM pass that legalizes generic machine instructions for GlobalISel&period;
| xref:llvm/LessRecord.adoc[`LessRecord`] 
| Sort record pointers by name&period;
| xref:llvm/LessRecordByID.adoc[`LessRecordByID`] 
| Sort record pointers by unique identifier&period;
| xref:llvm/LessRecordFieldName.adoc[`LessRecordFieldName`] 
| Sorting predicate to sort record pointers by their Name field&period;
| xref:llvm/LessRecordRegister.adoc[`LessRecordRegister`] 
| Sort register records by position order and register&hyphen;name components&period;
| xref:llvm/LexicalScope.adoc[`LexicalScope`] 
| This class is used to track scope information&period;
| xref:llvm/LexicalScopes.adoc[`LexicalScopes`] 
| This class provides interface to collect and use lexical scoping information from machine instruction&period;
| xref:llvm/LibCallSimplifier.adoc[`LibCallSimplifier`] 
| Optimizes well&hyphen;formed library calls into a more efficient form&period;
| xref:llvm/LibCallsShrinkWrapPass.adoc[`LibCallsShrinkWrapPass`] 
| Pass that shrink&hyphen;wraps unused library calls that may set errno&period;
| xref:llvm/LibcallLoweringInfo.adoc[`LibcallLoweringInfo`] 
| Tracks which library functions to use for a particular subtarget or function&period;
| xref:llvm/LibcallLoweringInfoWrapper.adoc[`LibcallLoweringInfoWrapper`] 
| Legacy&hyphen;pass&hyphen;manager wrapper around ModuleLibcallLoweringInfo&period;
| xref:llvm/LibcallLoweringModuleAnalysis.adoc[`LibcallLoweringModuleAnalysis`] 
| Analysis that provides `ModuleLibcallLoweringInfo` for a module&period;
| xref:llvm/LifetimeIntrinsic.adoc[`LifetimeIntrinsic`] 
| This is the common base class for lifetime intrinsics&period;
| xref:llvm/LifetimeSDNode.adoc[`LifetimeSDNode`] 
| This SDNode is used for LIFETIME&lowbar;START&sol;LIFETIME&lowbar;END values&period;
| xref:llvm/LineEditor.adoc[`LineEditor`] 
| Interactive line editor with history and tab completion&period;
| xref:llvm/LinearExpression.adoc[`LinearExpression`] 
| Linear expression of the form BasePtr &plus; Index &ast; Scale &plus; Offset&period;
| xref:llvm/Linker.adoc[`Linker`] 
| Provides the core functionality of linking LLVM modules&period;
| xref:llvm/LintPass.adoc[`LintPass`] 
| Function pass that lints IR for undefined or unintended behavior&period;
| xref:llvm/ListInit.adoc[`ListInit`] 
| Represents an initializer containing a list of values&period;
| xref:llvm/ListRecTy.adoc[`ListRecTy`] 
| &apos;list&lt;Ty&gt;&apos; &hyphen; Represent a list of element values, all of which must be of the specified type&period; The type is stored in ElementTy&period;
| xref:llvm/ListScope.adoc[`ListScope`] 
| RAII helper that opens and closes an array scope on a printer&period;
| xref:llvm/ListSeparator.adoc[`ListSeparator`] 
| Helper that emits a delimiter only after the first use&period;
| xref:llvm/ListeningSocket.adoc[`ListeningSocket`] 
| Manages a passive (i&period;e&period;, listening) UNIX domain socket
| xref:llvm/LiveDebugValuesPass.adoc[`LiveDebugValuesPass`] 
| New PM pass that extends variable debug locations across basic blocks&period;
| xref:llvm/LiveDebugVariables.adoc[`LiveDebugVariables`] 
| Analysis that tracks user variables across register allocation&period;
| xref:llvm/LiveDebugVariablesAnalysis.adoc[`LiveDebugVariablesAnalysis`] 
| Analysis pass that computes `LiveDebugVariables` for a machine function&period;
| xref:llvm/LiveDebugVariablesPrinterPass.adoc[`LiveDebugVariablesPrinterPass`] 
| Printer pass for the `LiveDebugVariablesAnalysis` results&period;
| xref:llvm/LiveDebugVariablesWrapperLegacy.adoc[`LiveDebugVariablesWrapperLegacy`] 
| Legacy pass wrapper for LiveDebugVariables&period;
| xref:llvm/LiveInterval.adoc[`LiveInterval`] 
| LiveInterval &hyphen; This class represents the liveness of a register, or stack slot&period;
| xref:llvm/LiveIntervalCalc.adoc[`LiveIntervalCalc`] 
| Extension of LiveRangeCalc for computing and modifying LiveIntervals&period;
| xref:llvm/LiveIntervalUnion.adoc[`LiveIntervalUnion`] 
| Union of live intervals that are strong candidates for coalescing&period;
| xref:llvm/LiveIntervals.adoc[`LiveIntervals`] 
| Analysis that computes and maintains live intervals for virtual registers&period;
| xref:llvm/LiveIntervalsAnalysis.adoc[`LiveIntervalsAnalysis`] 
| Analysis pass that computes LiveIntervals for a MachineFunction&period;
| xref:llvm/LiveIntervalsPrinterPass.adoc[`LiveIntervalsPrinterPass`] 
| Printer pass for the `LiveIntervalsAnalysis` results&period;
| xref:llvm/LiveIntervalsWrapperPass.adoc[`LiveIntervalsWrapperPass`] 
| Legacy MachineFunctionPass wrapper around LiveIntervals&period;
| xref:llvm/LivePhysRegs.adoc[`LivePhysRegs`] 
| A set of physical registers with utility functions to track liveness when walking backward&sol;forward through a basic block&period;
| xref:llvm/LiveQueryResult.adoc[`LiveQueryResult`] 
| Result of querying a LiveRange around a single instruction&period;
| xref:llvm/LiveRange.adoc[`LiveRange`] 
| Represents the liveness of a register, stack slot, or similar entity&period;
| xref:llvm/LiveRangeCalc.adoc[`LiveRangeCalc`] 
| Calculator for live ranges over machine IR&period;
| xref:llvm/LiveRangeEdit.adoc[`LiveRangeEdit`] 
| Represents changes to a virtual register when it is spilled or split&period;
| xref:llvm/LiveRangeUpdater.adoc[`LiveRangeUpdater`] 
| Helper class for performant LiveRange bulk updates&period;
| xref:llvm/LiveRegMatrix.adoc[`LiveRegMatrix`] 
| Tracks virtual register interference across slot indexes and register units&period;
| xref:llvm/LiveRegMatrixAnalysis.adoc[`LiveRegMatrixAnalysis`] 
| Analysis pass that computes `LiveRegMatrix` for a machine function&period;
| xref:llvm/LiveRegMatrixWrapperLegacy.adoc[`LiveRegMatrixWrapperLegacy`] 
| Legacy MachineFunctionPass wrapper that computes and owns `LiveRegMatrix&period;`
| xref:llvm/LiveRegSet.adoc[`LiveRegSet`] 
| A set of live virtual registers and physical register units&period;
| xref:llvm/LiveRegUnit.adoc[`LiveRegUnit`] 
| Live physical register unit with its defining or reading operand&period;
| xref:llvm/LiveRegUnits.adoc[`LiveRegUnits`] 
| A set of register units used to track register liveness&period;
| xref:llvm/LiveStacks.adoc[`LiveStacks`] 
| Analysis that tracks live intervals for stack slots&period;
| xref:llvm/LiveStacksAnalysis.adoc[`LiveStacksAnalysis`] 
| Analysis pass that computes `LiveStacks` for a machine function&period;
| xref:llvm/LiveStacksPrinterPass.adoc[`LiveStacksPrinterPass`] 
| Printer pass for the `LiveStacksAnalysis` results&period;
| xref:llvm/LiveStacksWrapperLegacy.adoc[`LiveStacksWrapperLegacy`] 
| Legacy pass wrapper for LiveStacks&period;
| xref:llvm/LiveVariables.adoc[`LiveVariables`] 
| Sparse live&hyphen;variable analysis for virtual and allocatable physical registers&period;
| xref:llvm/LiveVariablesAnalysis.adoc[`LiveVariablesAnalysis`] 
| Analysis pass that computes `LiveVariables` for a machine function&period;
| xref:llvm/LiveVariablesPrinterPass.adoc[`LiveVariablesPrinterPass`] 
| Printer pass for the `LiveVariablesAnalysis` results&period;
| xref:llvm/LiveVariablesWrapperPass.adoc[`LiveVariablesWrapperPass`] 
| Legacy pass wrapper for LiveVariables&period;
| xref:llvm/LoadAndStorePromoter.adoc[`LoadAndStorePromoter`] 
| Helper class for promoting a collection of loads and stores into SSA Form using the SSAUpdater&period;
| xref:llvm/LoadInst.adoc[`LoadInst`] 
| An instruction for reading from memory&period; This uses the SubclassData field in Value to store whether or not the load is volatile&period;
| xref:llvm/LoadSDNode.adoc[`LoadSDNode`] 
| This class is used to represent ISD&colon;&colon;LOAD nodes&period;
| xref:llvm/LoadStoreInstProperties.adoc[`LoadStoreInstProperties`] 
| A structure representing the properties of a load or store instruction&period;
| xref:llvm/LoadStoreOptLegacy.adoc[`LoadStoreOptLegacy`] 
| Legacy pass that merges consecutive GlobalISel loads and stores&period;
| xref:llvm/LoadStoreOptPass.adoc[`LoadStoreOptPass`] 
| New PM pass that merges consecutive GlobalISel loads and stores&period;
| xref:llvm/LoadStoreVectorizerPass.adoc[`LoadStoreVectorizerPass`] 
| Merges consecutive loads and stores into vector loads and stores&period;
| xref:llvm/LoadedObjectInfo.adoc[`LoadedObjectInfo`] 
| An inferface for inquiring the load address of a loaded object file to be used by the DIContext implementations when applying relocations on the fly&period;
| xref:llvm/LoadedObjectInfoHelper.adoc[`LoadedObjectInfoHelper`] 
| CRTP helper that implements LoadedObjectInfo&colon;&colon;clone for Derived&period;
| xref:llvm/LocalAsMetadata.adoc[`LocalAsMetadata`] 
| Metadata wrapping a function&hyphen;local (non&hyphen;constant) IR value&period;
| xref:llvm/LocalStackSlotAllocationPass.adoc[`LocalStackSlotAllocationPass`] 
| New PM pass that pre&hyphen;allocates local frame indices to stack slots&period;
| xref:llvm/LocalizerLegacy.adoc[`LocalizerLegacy`] 
| Legacy pass that localizes constant&hyphen;like instructions near their uses&period;
| xref:llvm/LocalizerPass.adoc[`LocalizerPass`] 
| New PM pass that localizes constant&hyphen;like instructions near their uses&period;
| xref:llvm/LocationSize.adoc[`LocationSize`] 
| Represents the size of a MemoryLocation&period;
| xref:llvm/LockFileManager.adoc[`LockFileManager`] 
| Class that manages the creation of a lock file to aid implicit coordination between different processes&period;
| xref:llvm/LockstepReverseIterator.adoc[`LockstepReverseIterator`] 
| Iterates instructions across blocks in reverse from the first non&hyphen;terminator&period;
| xref:llvm/Logger.adoc[`Logger`] 
| Utility for logging MLGO feature values and scalar rewards&period;
| xref:llvm/LogicalResult.adoc[`LogicalResult`] 
| Efficient success&hyphen;or&hyphen;failure status, preferred over ambiguous bool results&period;
| xref:llvm/LogicalSROAPass.adoc[`LogicalSROAPass`] 
| Logical Scalar Replacement of Aggregates pass&period;
| xref:llvm/Loop.adoc[`Loop`] 
| Represents a single loop in the control flow graph&period; Note that not all SCCs in the CFG are necessarily loops&period;
| xref:llvm/LoopAccessAnalysis.adoc[`LoopAccessAnalysis`] 
| This analysis provides dependence information for the memory accesses of a loop&period;
| xref:llvm/LoopAccessInfo.adoc[`LoopAccessInfo`] 
| Drive the analysis of memory accesses in the loop
| xref:llvm/LoopAccessInfoManager.adoc[`LoopAccessInfoManager`] 
| Manages and caches LoopAccessInfo results for loops in a function&period;
| xref:llvm/LoopAccessInfoPrinterPass.adoc[`LoopAccessInfoPrinterPass`] 
| Printer pass for the `LoopAccessInfo` results&period;
| xref:llvm/LoopAnalysis.adoc[`LoopAnalysis`] 
| Analysis pass that exposes the `LoopInfo` for a function&period;
| xref:llvm/LoopBase-0fa.adoc[`LoopBase`] 
| Instances of this class are used to represent loops that are detected in the flow graph&period;
| xref:llvm/LoopBlocksDFS.adoc[`LoopBlocksDFS`] 
| Store the result of a depth first search within basic blocks contained by a single loop&period;
| xref:llvm/LoopBlocksRPO.adoc[`LoopBlocksRPO`] 
| Wrapper class to LoopBlocksDFS that provides a standard begin()&sol;end() interface for the DFS reverse post&hyphen;order traversal of blocks in a loop body&period;
| xref:llvm/LoopBlocksTraversal.adoc[`LoopBlocksTraversal`] 
| Traverse the blocks in a loop using a depth&hyphen;first search&period;
| xref:llvm/LoopBodyTraits.adoc[`LoopBodyTraits`] 
| Graph traits for traversing basic blocks in a loop body&period;
| xref:llvm/LoopBoundSplitPass.adoc[`LoopBoundSplitPass`] 
| This pass transforms loops that contain a conditional branch with induction variable&period; For example, it transforms left code to right code&colon;
| xref:llvm/LoopCachePrinterPass.adoc[`LoopCachePrinterPass`] 
| Printer pass for the `CacheCost` results&period;
| xref:llvm/LoopCarriedEdges.adoc[`LoopCarriedEdges`] 
| Loop&hyphen;carried dependencies tracked separately from the acyclic SUnit DAG&period;
| xref:llvm/LoopConstrainer.adoc[`LoopConstrainer`] 
| Constrain a loop to run within a given iteration range&period;
| xref:llvm/LoopDataPrefetchPass.adoc[`LoopDataPrefetchPass`] 
| An optimization pass inserting data prefetches in loops&period;
| xref:llvm/LoopDeletionPass.adoc[`LoopDeletionPass`] 
| Pass that deletes loops that are provably dead&period;
| xref:llvm/LoopDistributePass.adoc[`LoopDistributePass`] 
| Pass that distributes loops to enable vectorization&period;
| xref:llvm/LoopFlattenPass.adoc[`LoopFlattenPass`] 
| Pass that flattens nested loops into a single loop&period;
| xref:llvm/LoopFullUnrollPass.adoc[`LoopFullUnrollPass`] 
| Loop unroll pass that only does full loop unrolling and peeling&period;
| xref:llvm/LoopFusePass.adoc[`LoopFusePass`] 
| Pass that fuses adjacent loops to improve locality and reduce overhead&period;
| xref:llvm/LoopIdiomRecognizePass.adoc[`LoopIdiomRecognizePass`] 
| Performs Loop Idiom Recognize Pass&period;
| xref:llvm/LoopIdiomVectorizePass.adoc[`LoopIdiomVectorizePass`] 
| Pass that recognizes specific loop idioms and rewrites them with vector code&period;
| xref:llvm/LoopInfo.adoc[`LoopInfo`] 
| Analysis that identifies natural loops in a function&apos;s CFG&period;
| xref:llvm/LoopInfoBase-00.adoc[`LoopInfoBase`] 
| Analysis that builds and owns the loop forest for a function&period;
| xref:llvm/LoopInfoWrapperPass.adoc[`LoopInfoWrapperPass`] 
| The legacy pass manager&apos;s analysis pass to compute loop information&period;
| xref:llvm/LoopInstSimplifyPass.adoc[`LoopInstSimplifyPass`] 
| Performs Loop Inst Simplify Pass&period;
| xref:llvm/LoopInterchangePass.adoc[`LoopInterchangePass`] 
| Pass that interchanges nested loops to improve locality and performance&period;
| xref:llvm/LoopLoadEliminationPass.adoc[`LoopLoadEliminationPass`] 
| Pass to forward loads in a loop around the backedge to subsequent iterations&period;
| xref:llvm/LoopNest.adoc[`LoopNest`] 
| This class represents a loop nest and can be used to query its properties&period;
| xref:llvm/LoopNestAnalysis.adoc[`LoopNestAnalysis`] 
| This analysis provides information for a loop nest&period; The analysis runs on demand and can be initiated via AM&period;getResult&lt;LoopNestAnalysis&gt;&period;
| xref:llvm/LoopNestPrinterPass.adoc[`LoopNestPrinterPass`] 
| Printer pass for the `LoopNest` results&period;
| xref:llvm/LoopPass.adoc[`LoopPass`] 
| Base class for loop optimization and transformation passes&period;
| xref:llvm/LoopPredicationPass.adoc[`LoopPredicationPass`] 
| Performs Loop Predication Pass&period;
| xref:llvm/LoopPrinterPass.adoc[`LoopPrinterPass`] 
| Printer pass for the `LoopAnalysis` results&period;
| xref:llvm/LoopRotatePass.adoc[`LoopRotatePass`] 
| A simple loop rotation transformation&period;
| xref:llvm/LoopSafetyInfo.adoc[`LoopSafetyInfo`] 
| Captures information about whether loop blocks may throw or exit abnormally&period;
| xref:llvm/LoopSimplifyCFGPass.adoc[`LoopSimplifyCFGPass`] 
| Performs basic CFG simplifications to assist other loop passes&period;
| xref:llvm/LoopSimplifyPass.adoc[`LoopSimplifyPass`] 
| This pass is responsible for loop canonicalization&period;
| xref:llvm/LoopSinkPass.adoc[`LoopSinkPass`] 
| A pass that does profile&hyphen;guided sinking of instructions into loops&period;
| xref:llvm/LoopStandardAnalysisResults.adoc[`LoopStandardAnalysisResults`] 
| Analyses provided to loop passes by the function&hyphen;to&hyphen;loop adaptor&period;
| xref:llvm/LoopStrengthReducePass.adoc[`LoopStrengthReducePass`] 
| Performs Loop Strength Reduce Pass&period;
| xref:llvm/LoopStructure.adoc[`LoopStructure`] 
| Lightweight description of a loop with a single exiting latch and IV&period;
| xref:llvm/LoopTermFoldPass.adoc[`LoopTermFoldPass`] 
| Pass that folds loop terminating conditions to eliminate induction&hyphen;variable uses&period;
| xref:llvm/LoopTraversal.adoc[`LoopTraversal`] 
| Computes an efficient basic&hyphen;block traversal order for loop&hyphen;aware passes&period;
| xref:llvm/LoopUnrollAndJamPass.adoc[`LoopUnrollAndJamPass`] 
| A simple loop rotation transformation&period;
| xref:llvm/LoopUnrollOptions.adoc[`LoopUnrollOptions`] 
| Parameters controlling transforms performed by the LoopUnroll pass&period;
| xref:llvm/LoopUnrollPass.adoc[`LoopUnrollPass`] 
| Loop unroll pass that supports both full and partial unrolling&period;
| xref:llvm/LoopVectorizationLegality.adoc[`LoopVectorizationLegality`] 
| Checks whether a loop is legal to vectorize and at what factor&period;
| xref:llvm/LoopVectorizationRequirements.adoc[`LoopVectorizationRequirements`] 
| Late&hyphen;checked requirements that must hold once vectorization is chosen&period;
| xref:llvm/LoopVectorizeHints.adoc[`LoopVectorizeHints`] 
| Utility class for getting and setting loop vectorizer hints&period;
| xref:llvm/LoopVectorizeOptions.adoc[`LoopVectorizeOptions`] 
| Options that control when loop interleaving and vectorization may run&period;
| xref:llvm/LoopVectorizePass.adoc[`LoopVectorizePass`] 
| The LoopVectorize Pass&period;
| xref:llvm/LoopVectorizeResult.adoc[`LoopVectorizeResult`] 
| Storage for information about made changes&period;
| xref:llvm/LoopVerifierPass.adoc[`LoopVerifierPass`] 
| Verifier pass for the `LoopAnalysis` results&period;
| xref:llvm/LoopVersioning.adoc[`LoopVersioning`] 
| This class emits a version of the loop where run&hyphen;time checks ensure that may&hyphen;alias pointers can&apos;t overlap&period;
| xref:llvm/LoopVersioningLICMPass.adoc[`LoopVersioningLICMPass`] 
| Pass that versions loops to enable LICM when alias analysis is uncertain&period;
| xref:llvm/LoopVersioningPass.adoc[`LoopVersioningPass`] 
| Expose LoopVersioning as a pass&period;
| xref:llvm/LostDebugLocObserver.adoc[`LostDebugLocObserver`] 
| Tracks DebugLocs between checkpoints and verifies that they are transferred&period;
| xref:llvm/LowerAllowCheckPass.adoc[`LowerAllowCheckPass`] 
| Pass that lowers allow&hyphen;check intrinsics to remove optional traps from hot code&period;
| xref:llvm/LowerAtomicPass.adoc[`LowerAtomicPass`] 
| A pass that lowers atomic intrinsic into non&hyphen;atomic intrinsics&period;
| xref:llvm/LowerCommentStringPass.adoc[`LowerCommentStringPass`] 
| Pass that lowers loadtime comment string metadata for supported targets&period;
| xref:llvm/LowerConstantIntrinsicsPass.adoc[`LowerConstantIntrinsicsPass`] 
| Pass that lowers remaining objectsize and is&period;constant intrinsics&period;
| xref:llvm/LowerEmuTLSPass.adoc[`LowerEmuTLSPass`] 
| New PM pass that adds `&lowbar;&lowbar;emutls&lowbar;&lsqb;vt&rsqb;&period;&ast;` variables for emulated TLS&period;
| xref:llvm/LowerExpectIntrinsicPass.adoc[`LowerExpectIntrinsicPass`] 
| A pass that lowers llvm&period;expect intrinsics into branch weight metadata&period;
| xref:llvm/LowerGlobalDtorsPass.adoc[`LowerGlobalDtorsPass`] 
| Pass that lowers llvm&period;global&lowbar;dtors via wrappers registered in llvm&period;global&lowbar;ctors&period;
| xref:llvm/LowerGuardIntrinsicPass.adoc[`LowerGuardIntrinsicPass`] 
| Pass that lowers llvm&period;experimental&period;guard to a conditional deoptimize call&period;
| xref:llvm/LowerIFuncPass.adoc[`LowerIFuncPass`] 
| Pass to replace calls to ifuncs with indirect calls&period;
| xref:llvm/LowerInvokePass.adoc[`LowerInvokePass`] 
| Pass that converts invoke instructions to call instructions&period;
| xref:llvm/LowerMatrixIntrinsicsPass.adoc[`LowerMatrixIntrinsicsPass`] 
| Pass that lowers matrix intrinsics to vector operations&period;
| xref:llvm/LowerSwitchPass.adoc[`LowerSwitchPass`] 
| Pass that rewrites switch instructions as a sequence of branches&period;
| xref:llvm/LowerTypeTestsPass.adoc[`LowerTypeTestsPass`] 
| Pass that lowers type metadata and type&hyphen;test intrinsics&period;
| xref:llvm/LowerWidenableConditionPass.adoc[`LowerWidenableConditionPass`] 
| Pass that lowers llvm&period;widenable&period;condition to the default value i1 true&period;
| xref:llvm/LshrOfTruncOfLshr.adoc[`LshrOfTruncOfLshr`] 
| Match info for folding lshr(trunc(lshr x, C1), C2)&period;
| xref:llvm/MBB2NumberFunctor.adoc[`MBB2NumberFunctor`] 
| Map a MachineBasicBlock pointer to its dense block number for IndexedMap&period;
| xref:llvm/MBBReachingDefsInfo.adoc[`MBBReachingDefsInfo`] 
| Storage for all reaching definitions across basic blocks and reg units&period;
| xref:llvm/MBBSectionID.adoc[`MBBSectionID`] 
| Uniquely identifies a basic block section within a function&period;
| xref:llvm/MBFIWrapper.adoc[`MBFIWrapper`] 
| Tracks block frequencies for newly created and tail&hyphen;merged blocks&period;
| xref:llvm/MCAsmBackend.adoc[`MCAsmBackend`] 
| Generic interface to target specific assembler backends&period;
| xref:llvm/MCAsmBaseStreamer.adoc[`MCAsmBaseStreamer`] 
| Base class for streamers that emit assembly text&period;
| xref:llvm/MCAsmInfo.adoc[`MCAsmInfo`] 
| This class is intended to be used as a base class for asm properties and features specific to the target&period;
| xref:llvm/MCAsmInfoCOFF.adoc[`MCAsmInfoCOFF`] 
| Base class for asm properties and features on COFF&hyphen;based targets&period;
| xref:llvm/MCAsmInfoDarwin.adoc[`MCAsmInfoDarwin`] 
| Target asm properties for Darwin&hyphen;based targets&period;
| xref:llvm/MCAsmInfoELF.adoc[`MCAsmInfoELF`] 
| Target asm properties for ELF&hyphen;based targets&period;
| xref:llvm/MCAsmInfoGNUCOFF.adoc[`MCAsmInfoGNUCOFF`] 
| Asm info for GNU COFF targets (MinGW and Cygwin)&period;
| xref:llvm/MCAsmInfoGOFF.adoc[`MCAsmInfoGOFF`] 
| Target&hyphen;specific assembly properties for GOFF (z&sol;OS) based targets&period;
| xref:llvm/MCAsmInfoMicrosoft.adoc[`MCAsmInfoMicrosoft`] 
| Asm info for Microsoft COFF targets (MSVC&hyphen;style assembly)&period;
| xref:llvm/MCAsmInfoWasm.adoc[`MCAsmInfoWasm`] 
| Target asm properties for Wasm&hyphen;based targets&period;
| xref:llvm/MCAsmInfoXCOFF.adoc[`MCAsmInfoXCOFF`] 
| Target asm properties for XCOFF&hyphen;based targets&period;
| xref:llvm/MCAsmMacro.adoc[`MCAsmMacro`] 
| Definition of an assembler macro or macro&hyphen;like function&period;
| xref:llvm/MCAsmMacroParameter.adoc[`MCAsmMacroParameter`] 
| A single formal parameter of an assembler macro&period;
| xref:llvm/MCAsmParser.adoc[`MCAsmParser`] 
| Generic assembler parser interface, for use by target specific assembly parsers&period;
| xref:llvm/MCAsmParserExtension.adoc[`MCAsmParserExtension`] 
| Generic interface for extending the MCAsmParser, which is implemented by target and object file assembly parser implementations&period;
| xref:llvm/MCAsmParserSemaCallback.adoc[`MCAsmParserSemaCallback`] 
| Generic Sema callback for assembly parser&period;
| xref:llvm/MCAssembler.adoc[`MCAssembler`] 
| Assembles machine&hyphen;code sections, lays them out, and writes object files&period;
| xref:llvm/MCBinaryExpr.adoc[`MCBinaryExpr`] 
| Binary assembler expressions&period;
| xref:llvm/MCBoundaryAlignFragment.adoc[`MCBoundaryAlignFragment`] 
| Padding fragment that keeps a following fragment set within one alignment boundary&period;
| xref:llvm/MCCFIInstruction.adoc[`MCCFIInstruction`] 
| One Call Frame Information instruction for DWARF unwind data&period;
| xref:llvm/MCCVDefRangeFragment.adoc[`MCCVDefRangeFragment`] 
| Fragment representing the &period;cv&lowbar;def&lowbar;range directive&period;
| xref:llvm/MCCVFunctionInfo.adoc[`MCCVFunctionInfo`] 
| Information describing a function or inlined call site&period;
| xref:llvm/MCCVInlineLineTableFragment.adoc[`MCCVInlineLineTableFragment`] 
| Fragment representing the binary annotations produced by the &period;cv&lowbar;inline&lowbar;linetable directive&period;
| xref:llvm/MCCVLoc.adoc[`MCCVLoc`] 
| Instances of this class represent the information from a &period;cv&lowbar;loc directive&period;
| xref:llvm/MCCodeEmitter.adoc[`MCCodeEmitter`] 
| MCCodeEmitter &hyphen; Generic instruction encoding interface&period;
| xref:llvm/MCConstantExpr.adoc[`MCConstantExpr`] 
| &sol; Represent a constant integer expression&period;
| xref:llvm/MCContext.adoc[`MCContext`] 
| Context object for machine code objects&period; This class owns all of the sections that it creates&period;
| xref:llvm/MCDXContainerBaseWriter.adoc[`MCDXContainerBaseWriter`] 
| Base writer that emits DXContainer files from a sequence of named parts&period;
| xref:llvm/MCDXContainerPart.adoc[`MCDXContainerPart`] 
| A named payload to emit as one part of a DXContainer file&period;
| xref:llvm/MCDXContainerStreamer.adoc[`MCDXContainerStreamer`] 
| Streaming DXContainer object file generation interface&period;
| xref:llvm/MCDXContainerTargetWriter.adoc[`MCDXContainerTargetWriter`] 
| Target&hyphen;specific DXContainer object&hyphen;file writer hooks&period;
| xref:llvm/MCDecodedPseudoProbe.adoc[`MCDecodedPseudoProbe`] 
| A pseudo probe decoded from a `&period;pseudoprobe` section&period;
| xref:llvm/MCDecodedPseudoProbeInlineTree.adoc[`MCDecodedPseudoProbeInlineTree`] 
| Inline&hyphen;tree node for a decoded pseudo probe&period;
| xref:llvm/MCDisassembler.adoc[`MCDisassembler`] 
| Superclass for all disassemblers&period; Consumes a memory region and provides an array of assembly instructions&period;
| xref:llvm/MCDwarfDwoLineTable.adoc[`MCDwarfDwoLineTable`] 
| Split DWARF (DWO) line table for type units and skeleton CUs&period;
| xref:llvm/MCDwarfFile.adoc[`MCDwarfFile`] 
| Represents a DWARF &period;file directive name and its file number&period;
| xref:llvm/MCDwarfFrameEmitter.adoc[`MCDwarfFrameEmitter`] 
| Emits DWARF call&hyphen;frame and compact&hyphen;unwind information&period;
| xref:llvm/MCDwarfFrameInfo.adoc[`MCDwarfFrameInfo`] 
| Frame metadata and CFI instructions for one function or EH frame&period;
| xref:llvm/MCDwarfLineAddr.adoc[`MCDwarfLineAddr`] 
| Helpers for encoding DWARF line&sol;address advance pairs&period;
| xref:llvm/MCDwarfLineEntry.adoc[`MCDwarfLineEntry`] 
| Represents one DWARF line&hyphen;table entry for an assembled instruction&period;
| xref:llvm/MCDwarfLineStr.adoc[`MCDwarfLineStr`] 
| Manage the &period;debug&lowbar;line&lowbar;str section contents, if we use it&period;
| xref:llvm/MCDwarfLineTable.adoc[`MCDwarfLineTable`] 
| DWARF line table for a compile unit, including header and per&hyphen;section entries&period;
| xref:llvm/MCDwarfLineTableHeader.adoc[`MCDwarfLineTableHeader`] 
| Header metadata for a DWARF line table (directories, files, and root file)&period;
| xref:llvm/MCDwarfLineTableParams.adoc[`MCDwarfLineTableParams`] 
| Parameters controlling special opcodes in the DWARF line table&period;
| xref:llvm/MCDwarfLoc.adoc[`MCDwarfLoc`] 
| Instances of this class represent the information from a dwarf &period;loc directive&period;
| xref:llvm/MCELFObjectTargetWriter.adoc[`MCELFObjectTargetWriter`] 
| Target&hyphen;specific ELF object&hyphen;file writer hooks&period;
| xref:llvm/MCELFStreamer.adoc[`MCELFStreamer`] 
| Streaming ELF object file generation interface&period;
| xref:llvm/MCExpr.adoc[`MCExpr`] 
| Base class for the full range of assembler expressions which are needed for parsing&period;
| xref:llvm/MCExternalSymbolizer.adoc[`MCExternalSymbolizer`] 
| Symbolize using user&hyphen;provided, C API, callbacks&period;
| xref:llvm/MCExtraProcessorInfo.adoc[`MCExtraProcessorInfo`] 
| Provide extra details about the machine processor&period;
| xref:llvm/MCFillFragment.adoc[`MCFillFragment`] 
| Fragment that fills a region with a repeated value (`&period;fill` &sol; `&period;space)&period;`
| xref:llvm/MCFixup.adoc[`MCFixup`] 
| Encode information on a single operation to perform on a byte sequence (e&period;g&period;, an encoded instruction) which requires assemble&hyphen; or run&hyphen; time patching&period;
| xref:llvm/MCFixupKindInfo.adoc[`MCFixupKindInfo`] 
| Target independent information on a fixup kind&period;
| xref:llvm/MCFragment.adoc[`MCFragment`] 
| Contiguous piece of code or data within a section&period;
| xref:llvm/MCGOFFObjectTargetWriter.adoc[`MCGOFFObjectTargetWriter`] 
| Target&hyphen;specific GOFF object&hyphen;file writer hooks&period;
| xref:llvm/MCGOFFStreamer.adoc[`MCGOFFStreamer`] 
| Streaming GOFF object file generation interface&period;
| xref:llvm/MCGenDwarfInfo.adoc[`MCGenDwarfInfo`] 
| Emitter for DWARF generated from assembly source files&period;
| xref:llvm/MCGenDwarfLabelEntry.adoc[`MCGenDwarfLabelEntry`] 
| Per&hyphen;symbol info gathered when generating DWARF labels for assembly sources&period;
| xref:llvm/MCInst.adoc[`MCInst`] 
| Instances of this class represent a single low&hyphen;level machine instruction&period;
| xref:llvm/MCInstBuilder.adoc[`MCInstBuilder`] 
| Convenience builder for constructing MCInst objects&period;
| xref:llvm/MCInstPrinter.adoc[`MCInstPrinter`] 
| This is an instance of a target assembly language printer that converts an MCInst to valid target assembly syntax&period;
| xref:llvm/MCInstrAnalysis.adoc[`MCInstrAnalysis`] 
| Target hooks that analyse machine instructions for MC clients&period;
| xref:llvm/MCInstrDesc.adoc[`MCInstrDesc`] 
| Describe properties of one target instruction class&period;
| xref:llvm/MCInstrInfo.adoc[`MCInstrInfo`] 
| Interface to description of machine instruction set&period;
| xref:llvm/MCJITMemoryManager.adoc[`MCJITMemoryManager`] 
| Memory manager interface for MCJIT with ExecutionEngine&hyphen;aware callbacks&period;
| xref:llvm/MCLFIRewriter.adoc[`MCLFIRewriter`] 
| Abstract base class that rewrites MCInsts for LFI sandboxing&period;
| xref:llvm/MCLOHContainer.adoc[`MCLOHContainer`] 
| Container that accumulates and emits Linker Optimization Hint directives&period;
| xref:llvm/MCLOHDirective.adoc[`MCLOHDirective`] 
| Store Linker Optimization Hint information (LOH)&period;
| xref:llvm/MCLabel.adoc[`MCLabel`] 
| Represents a label name in the MC file&period;
| xref:llvm/MCLineSection.adoc[`MCLineSection`] 
| Holds per&hyphen;section DWARF line entries for a compile unit&period;
| xref:llvm/MCMachObjectTargetWriter.adoc[`MCMachObjectTargetWriter`] 
| Target&hyphen;specific Mach&hyphen;O object&hyphen;file writer hooks&period;
| xref:llvm/MCNopsFragment.adoc[`MCNopsFragment`] 
| Fragment representing NOP bytes inserted by a &period;nops directive&period;
| xref:llvm/MCObjectFileInfo.adoc[`MCObjectFileInfo`] 
| Holds section handles and related object&hyphen;file metadata for MC emission&period;
| xref:llvm/MCObjectStreamer.adoc[`MCObjectStreamer`] 
| Streaming object file generation interface&period;
| xref:llvm/MCObjectTargetWriter.adoc[`MCObjectTargetWriter`] 
| Base class for classes that define behaviour that is specific to both the target and the object format&period;
| xref:llvm/MCObjectWriter.adoc[`MCObjectWriter`] 
| Defines the object file and target independent interfaces used by the assembler backend to write native file format object files&period;
| xref:llvm/MCOperand.adoc[`MCOperand`] 
| Instances of this class represent operands of the MCInst class&period; This is a simple discriminated union&period;
| xref:llvm/MCOperandInfo.adoc[`MCOperandInfo`] 
| This holds information about one operand of a machine instruction, indicating the register class for register operands, etc&period;
| xref:llvm/MCOrgFragment.adoc[`MCOrgFragment`] 
| Fragment representing a `&period;org` directive that advances to an absolute offset&period;
| xref:llvm/MCParsedAsmOperand.adoc[`MCParsedAsmOperand`] 
| Abstract representation of a source&hyphen;level assembly instruction operand&period;
| xref:llvm/MCProcResourceDesc.adoc[`MCProcResourceDesc`] 
| Define a kind of processor resource that will be modeled by the scheduler&period;
| xref:llvm/MCPseudoProbe.adoc[`MCPseudoProbe`] 
| A pseudo probe instance for one table entry&period;
| xref:llvm/MCPseudoProbeBase.adoc[`MCPseudoProbeBase`] 
| Shared state for an encoded or decoded pseudo probe&period;
| xref:llvm/MCPseudoProbeDecoder.adoc[`MCPseudoProbeDecoder`] 
| Decoder for `&period;pseudo&lowbar;probe&lowbar;desc` and `&period;pseudoprobe` section contents&period;
| xref:llvm/MCPseudoProbeFuncDesc.adoc[`MCPseudoProbeFuncDesc`] 
| Function descriptor decoded from a `&period;pseudo&lowbar;probe&lowbar;desc` section&period;
| xref:llvm/MCPseudoProbeInlineTree.adoc[`MCPseudoProbeInlineTree`] 
| Trie that groups probes by inline stack for one `&period;text` section&period;
| xref:llvm/MCPseudoProbeInlineTreeBase-0a.adoc[`MCPseudoProbeInlineTreeBase`] 
| CRTP base for a trie that groups probes by inline stack&period;
| xref:llvm/MCPseudoProbeSections.adoc[`MCPseudoProbeSections`] 
| Pseudo probes collected for one compile unit, grouped by function&period;
| xref:llvm/MCPseudoProbeTable.adoc[`MCPseudoProbeTable`] 
| Module&hyphen;level holder for pseudo probes to emit into `&period;pseudoprobe` sections&period;
| xref:llvm/MCReadAdvanceEntry.adoc[`MCReadAdvanceEntry`] 
| Specify how many cycles after issue a use may read its registers early&period;
| xref:llvm/MCRegAliasIterator.adoc[`MCRegAliasIterator`] 
| MCRegAliasIterator enumerates all registers aliasing Reg&period;
| xref:llvm/MCRegUnitIterator.adoc[`MCRegUnitIterator`] 
| MCRegUnitIterator enumerates a list of register units for Reg&period;
| xref:llvm/MCRegUnitMaskIterator.adoc[`MCRegUnitMaskIterator`] 
| MCRegUnitMaskIterator enumerates a list of register units and their associated lane masks for Reg&period; The register units are in ascending numerical order&period;
| xref:llvm/MCRegUnitRootIterator.adoc[`MCRegUnitRootIterator`] 
| MCRegUnitRootIterator enumerates the root registers of a register unit&period;
| xref:llvm/MCRegUnitToIndex.adoc[`MCRegUnitToIndex`] 
| Functor that maps an `MCRegUnit` to an unsigned index&period;
| xref:llvm/MCRegister.adoc[`MCRegister`] 
| Wrapper class representing physical registers&period; Should be passed by value&period;
| xref:llvm/MCRegisterClass.adoc[`MCRegisterClass`] 
| MCRegisterClass &hyphen; Base class of TargetRegisterClass&period;
| xref:llvm/MCRegisterClassStorage.adoc[`MCRegisterClassStorage`] 
| Contiguous storage layout for TableGen&hyphen;emitted register class data&period;
| xref:llvm/MCRegisterCostEntry.adoc[`MCRegisterCostEntry`] 
| Specify the rename&hyphen;stage cost of a register definition&period;
| xref:llvm/MCRegisterDesc.adoc[`MCRegisterDesc`] 
| Description of a single physical register&period;
| xref:llvm/MCRegisterFileDesc.adoc[`MCRegisterFileDesc`] 
| A register file descriptor&period;
| xref:llvm/MCRegisterInfo.adoc[`MCRegisterInfo`] 
| Interface to TableGen&hyphen;generated physical register data for a target&period;
| xref:llvm/MCRelocationInfo.adoc[`MCRelocationInfo`] 
| Create MCExprs from relocations found in an object file&period;
| xref:llvm/MCSFrameEmitter.adoc[`MCSFrameEmitter`] 
| Emits sframe unwinding information from CFI directives&period;
| xref:llvm/MCSPIRVObjectTargetWriter.adoc[`MCSPIRVObjectTargetWriter`] 
| Target&hyphen;specific SPIR&hyphen;V object&hyphen;file writer hooks&period;
| xref:llvm/MCSPIRVStreamer.adoc[`MCSPIRVStreamer`] 
| Streaming SPIR&hyphen;V object file generation interface&period;
| xref:llvm/MCSchedClassDesc.adoc[`MCSchedClassDesc`] 
| Summarize the scheduling resources required for an instruction of a particular scheduling class&period;
| xref:llvm/MCSchedModel.adoc[`MCSchedModel`] 
| Machine model for scheduling, bundling, and heuristics&period;
| xref:llvm/MCSection.adoc[`MCSection`] 
| Instances of this class represent a uniqued identifier for a section in the current translation unit&period; The MCContext class uniques and creates these&period;
| xref:llvm/MCSectionCOFF.adoc[`MCSectionCOFF`] 
| This represents a section on Windows
| xref:llvm/MCSectionDXContainer.adoc[`MCSectionDXContainer`] 
| This represents a section in a DXContainer (DXBC) object file&period;
| xref:llvm/MCSectionELF.adoc[`MCSectionELF`] 
| This represents a section on linux, lots of unix variants and some bare metal systems&period;
| xref:llvm/MCSectionGOFF.adoc[`MCSectionGOFF`] 
| A machine code section for the GOFF (z&sol;OS) object file format&period;
| xref:llvm/MCSectionMachO.adoc[`MCSectionMachO`] 
| This represents a section on a Mach&hyphen;O system (used by Mac OS X)&period; On a Mac system, these are also described in &sol;usr&sol;include&sol;mach&hyphen;o&sol;loader&period;h&period;
| xref:llvm/MCSectionSPIRV.adoc[`MCSectionSPIRV`] 
| This represents a section in a SPIR&hyphen;V object file&period;
| xref:llvm/MCSectionWasm.adoc[`MCSectionWasm`] 
| This represents a section on wasm&period;
| xref:llvm/MCSectionXCOFF.adoc[`MCSectionXCOFF`] 
| Represents an XCOFF control section (csect) or DWARF section&period;
| xref:llvm/MCSpecifierExpr.adoc[`MCSpecifierExpr`] 
| Expression that applies a relocation specifier to a subexpression&period;
| xref:llvm/MCStreamer.adoc[`MCStreamer`] 
| Streaming machine code generation interface&period;
| xref:llvm/MCSubRegIndexIterator.adoc[`MCSubRegIndexIterator`] 
| Iterator that enumerates the sub&hyphen;registers of a Reg and the associated sub&hyphen;register indices&period;
| xref:llvm/MCSubRegIterator.adoc[`MCSubRegIterator`] 
| MCSubRegIterator enumerates all sub&hyphen;registers of Reg&period; If IncludeSelf is set, Reg itself is included in the list&period;
| xref:llvm/MCSubtargetInfo.adoc[`MCSubtargetInfo`] 
| Generic base class for all target subtargets&period;
| xref:llvm/MCSuperRegIterator.adoc[`MCSuperRegIterator`] 
| MCSuperRegIterator enumerates all super&hyphen;registers of Reg&period; If IncludeSelf is set, Reg itself is included in the list&period;
| xref:llvm/MCSymbol.adoc[`MCSymbol`] 
| Represents a symbol name in the MC file&period;
| xref:llvm/MCSymbolCOFF.adoc[`MCSymbolCOFF`] 
| MCSymbol specialization for COFF object files&period;
| xref:llvm/MCSymbolELF.adoc[`MCSymbolELF`] 
| Represents an ELF machine code symbol&period;
| xref:llvm/MCSymbolGOFF.adoc[`MCSymbolGOFF`] 
| A machine code symbol for the GOFF (z&sol;OS) object file format&period;
| xref:llvm/MCSymbolIdFragment.adoc[`MCSymbolIdFragment`] 
| Represents a symbol table index fragment&period;
| xref:llvm/MCSymbolMachO.adoc[`MCSymbolMachO`] 
| Mach&hyphen;O MC symbol that stores nlist desc flags in the symbol flags field&period;
| xref:llvm/MCSymbolRefExpr.adoc[`MCSymbolRefExpr`] 
| Represent a reference to a symbol from inside an expression&period;
| xref:llvm/MCSymbolSDNode.adoc[`MCSymbolSDNode`] 
| SDNode wrapping an MCSymbol&period;
| xref:llvm/MCSymbolTableValue.adoc[`MCSymbolTableValue`] 
| The value for an entry in the symbol table of an MCContext&period;
| xref:llvm/MCSymbolWasm.adoc[`MCSymbolWasm`] 
| MCSymbol specialization for WebAssembly object files&period;
| xref:llvm/MCSymbolXCOFF.adoc[`MCSymbolXCOFF`] 
| An MCSymbol for XCOFF, with storage class, csect, and rename state&period;
| xref:llvm/MCSymbolizer.adoc[`MCSymbolizer`] 
| Symbolize and annotate disassembled instructions&period;
| xref:llvm/MCTargetAsmParser.adoc[`MCTargetAsmParser`] 
| MCTargetAsmParser &hyphen; Generic interface to target specific assembly parsers&period;
| xref:llvm/MCTargetExpr.adoc[`MCTargetExpr`] 
| Base class for target&hyphen;specific assembler expressions&period;
| xref:llvm/MCTargetOptions.adoc[`MCTargetOptions`] 
| Options that configure machine&hyphen;code emission and the integrated assembler&period;
| xref:llvm/MCTargetStreamer.adoc[`MCTargetStreamer`] 
| Target specific streamer interface&period; This is used so that targets can implement support for target specific assembly directives&period;
| xref:llvm/MCUnaryExpr.adoc[`MCUnaryExpr`] 
| Unary assembler expressions&period;
| xref:llvm/MCValue.adoc[`MCValue`] 
| Represents a relocatable expression in its most general form&colon; `Specifier(SymA` &hyphen; SymB &plus; Imm)&period;
| xref:llvm/MCWasmObjectTargetWriter.adoc[`MCWasmObjectTargetWriter`] 
| Target&hyphen;specific Wasm object&hyphen;file writer hooks&period;
| xref:llvm/MCWasmStreamer.adoc[`MCWasmStreamer`] 
| Streaming Wasm object file generation interface&period;
| xref:llvm/MCWinCOFFObjectTargetWriter.adoc[`MCWinCOFFObjectTargetWriter`] 
| Target&hyphen;specific Win COFF object&hyphen;file writer hooks&period;
| xref:llvm/MCWinCOFFStreamer.adoc[`MCWinCOFFStreamer`] 
| Streaming Windows COFF object file generation interface&period;
| xref:llvm/MCWriteLatencyEntry.adoc[`MCWriteLatencyEntry`] 
| Specify the latency in cpu cycles for a particular scheduling class and def&period;
| xref:llvm/MCWriteProcResEntry.adoc[`MCWriteProcResEntry`] 
| Identify one of the processor resource kinds consumed by a particular scheduling class for the specified number of cycles&period;
| xref:llvm/MCXCOFFObjectTargetWriter.adoc[`MCXCOFFObjectTargetWriter`] 
| Target&hyphen;specific XCOFF object&hyphen;file writer hooks&period;
| xref:llvm/MCXCOFFStreamer.adoc[`MCXCOFFStreamer`] 
| Streaming XCOFF object file generation interface&period;
| xref:llvm/MD5.adoc[`MD5`] 
| Incremental MD5 message&hyphen;digest computation&period;
| xref:llvm/MDBuilder.adoc[`MDBuilder`] 
| Builder for creating LLVM metadata with a consistent interface&period;
| xref:llvm/MDNode.adoc[`MDNode`] 
| Metadata node&period;
| xref:llvm/MDNodeSDNode.adoc[`MDNodeSDNode`] 
| SDNode wrapping an LLVM metadata node&period;
| xref:llvm/MDOperand.adoc[`MDOperand`] 
| Tracking metadata reference owned by Metadata&period;
| xref:llvm/MDProfLabels.adoc[`MDProfLabels`] 
| Names of profiling metadata labels stored in `!prof` nodes&period;
| xref:llvm/MDString.adoc[`MDString`] 
| A single uniqued string&period;
| xref:llvm/MDTuple.adoc[`MDTuple`] 
| Tuple of metadata&period;
| xref:llvm/MDTupleTypedArrayWrapper.adoc[`MDTupleTypedArrayWrapper`] 
| Typed, array&hyphen;like tuple of metadata&period;
| xref:llvm/MFPropsModifier-08f.adoc[`MFPropsModifier`] 
| RAII helper that updates MachineFunctionProperties around a pass run&period;
| xref:llvm/MIBInfo.adoc[`MIBInfo`] 
| Summary of a single MIB in a memprof metadata on allocations&period;
| xref:llvm/MIBundleBuilder.adoc[`MIBundleBuilder`] 
| Helper class for constructing bundles of MachineInstrs&period;
| xref:llvm/MIBundleOperandIteratorBase-0f.adoc[`MIBundleOperandIteratorBase`] 
| Iterator that visits all operands in a bundle of MachineInstrs&period;
| xref:llvm/MIBundleOperands.adoc[`MIBundleOperands`] 
| MIBundleOperands &hyphen; Iterate over all operands in a bundle of machine instructions&period;
| xref:llvm/MIMetadata.adoc[`MIMetadata`] 
| Set of metadata that should be preserved when using BuildMI()&period; This provides a more convenient way of preserving certain data from the original instruction&period;
| xref:llvm/MIR2VecPrinterLegacyPass.adoc[`MIR2VecPrinterLegacyPass`] 
| This pass prints the MIR2Vec embeddings for machine functions, basic blocks, and instructions
| xref:llvm/MIR2VecVocabLegacyAnalysis.adoc[`MIR2VecVocabLegacyAnalysis`] 
| Pass to analyze and populate MIR2Vec vocabulary from a module
| xref:llvm/MIR2VecVocabPrinterLegacyPass.adoc[`MIR2VecVocabPrinterLegacyPass`] 
| This pass prints the embeddings in the MIR2Vec vocabulary
| xref:llvm/MIR2VecVocabProvider.adoc[`MIR2VecVocabProvider`] 
| Vocabulary provider used by pass managers and standalone tools&period;
| xref:llvm/MIRAddFSDiscriminators.adoc[`MIRAddFSDiscriminators`] 
| MIR pass that adds flow&hyphen;sensitive discriminators to instruction debug info&period;
| xref:llvm/MIRFormatter.adoc[`MIRFormatter`] 
| Target&hyphen;specific formatter for MIR operands and pseudo source values&period;
| xref:llvm/MIRParser.adoc[`MIRParser`] 
| This class initializes machine functions by applying the state loaded from a MIR file&period;
| xref:llvm/MIRParserImpl.adoc[`MIRParserImpl`] 
| Private implementation details of `MIRParser&period;`
| xref:llvm/MIRProfileLoader.adoc[`MIRProfileLoader`] 
| Opaque implementation of the MIR sample profile loader&period;
| xref:llvm/MIRProfileLoaderPass.adoc[`MIRProfileLoaderPass`] 
| Machine function pass that loads SampleFDO profile data into MIR&period;
| xref:llvm/MLInlineAdvice.adoc[`MLInlineAdvice`] 
| InlineAdvice that tracks changes post inlining&period; For that reason, it only overrides the &quot;successful inlining&quot; extension points&period;
| xref:llvm/MLInlineAdvisor.adoc[`MLInlineAdvisor`] 
| InlineAdvisor that uses an ML model runner to decide whether to inline&period;
| xref:llvm/MLModelRunner.adoc[`MLModelRunner`] 
| Interface for evaluating an ML model given tensors as arguments&period;
| xref:llvm/MMOMetadata.adoc[`MMOMetadata`] 
| LLVM IR metadata carried by a MachineMemOperand&period;
| xref:llvm/MMRAMetadata.adoc[`MMRAMetadata`] 
| Helper class to manipulate `!mmra` metadata nodes&period;
| xref:llvm/MSP430AttributeParser.adoc[`MSP430AttributeParser`] 
| Parser for MSP430 ELF build attributes&period;
| xref:llvm/MSVCPError.adoc[`MSVCPError`] 
| A default&hyphen;constructible Error suitable for use with MSVC&apos;s std&colon;&colon;future&period;
| xref:llvm/MSVCPExpected.adoc[`MSVCPExpected`] 
| A default&hyphen;constructible Expected suitable for use with MSVC&apos;s std&colon;&colon;future&period;
| xref:llvm/MVT.adoc[`MVT`] 
| Machine value type for types natively supported by some LLVM target&period;
| xref:llvm/MachORelocation.adoc[`MachORelocation`] 
| MachORelocation &hyphen; This struct contains information about each relocation that needs to be emitted to the file&period; see &lt;mach&hyphen;o&sol;reloc&period;h&gt;
| xref:llvm/MachObjectWriter.adoc[`MachObjectWriter`] 
| Mach&hyphen;O object writer that emits Mach&hyphen;O object files from an MCAssembler&period;
| xref:llvm/MachineBasicBlock.adoc[`MachineBasicBlock`] 
| A sequence of machine instructions forming one basic block&period;
| xref:llvm/MachineBlockFrequencyAnalysis.adoc[`MachineBlockFrequencyAnalysis`] 
| Analysis pass which computes `MachineBlockFrequencyInfo&period;`
| xref:llvm/MachineBlockFrequencyInfo.adoc[`MachineBlockFrequencyInfo`] 
| MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic block frequencies&period;
| xref:llvm/MachineBlockFrequencyInfoWrapperPass.adoc[`MachineBlockFrequencyInfoWrapperPass`] 
| Legacy analysis pass which computes `MachineBlockFrequencyInfo&period;`
| xref:llvm/MachineBlockFrequencyPrinterPass.adoc[`MachineBlockFrequencyPrinterPass`] 
| Printer pass for the `MachineBlockFrequencyInfo` results&period;
| xref:llvm/MachineBlockHashInfo.adoc[`MachineBlockHashInfo`] 
| Legacy MachineFunctionPass for MachineBlockHashInfo&period;
| xref:llvm/MachineBlockHashInfoAnalysis.adoc[`MachineBlockHashInfoAnalysis`] 
| Analysis pass that computes blended hashes for machine basic blocks&period;
| xref:llvm/MachineBlockHashInfoPrinterPass.adoc[`MachineBlockHashInfoPrinterPass`] 
| Printer pass for the `MachineBlockHashInfoAnalysis` results&period;
| xref:llvm/MachineBlockHashInfoResult.adoc[`MachineBlockHashInfoResult`] 
| Result object for MachineBlockHashInfo&period;
| xref:llvm/MachineBlockPlacementPass.adoc[`MachineBlockPlacementPass`] 
| New PM pass that places basic blocks based on branch probabilities&period;
| xref:llvm/MachineBlockPlacementStatsPass.adoc[`MachineBlockPlacementStatsPass`] 
| New PM pass that collects statistics about basic block placement&period;
| xref:llvm/MachineBranchProbabilityAnalysis.adoc[`MachineBranchProbabilityAnalysis`] 
| Analysis pass which computes `MachineBranchProbabilityInfo&period;`
| xref:llvm/MachineBranchProbabilityInfo.adoc[`MachineBranchProbabilityInfo`] 
| Analysis that provides relative branch probabilities for CFG edges between machine basic blocks&period;
| xref:llvm/MachineBranchProbabilityInfoWrapperPass.adoc[`MachineBranchProbabilityInfoWrapperPass`] 
| Legacy immutable pass wrapping `MachineBranchProbabilityInfo&period;`
| xref:llvm/MachineBranchProbabilityPrinterPass.adoc[`MachineBranchProbabilityPrinterPass`] 
| Printer pass for the `MachineBranchProbabilityAnalysis` results&period;
| xref:llvm/MachineCFGPrinterPass.adoc[`MachineCFGPrinterPass`] 
| Pass that writes a machine function CFG to a DOT file&period;
| xref:llvm/MachineCSEPass.adoc[`MachineCSEPass`] 
| New PM pass that performs global CSE on machine instructions&period;
| xref:llvm/MachineCombinerPass.adoc[`MachineCombinerPass`] 
| New PM pass that combines machine instructions to shorten critical paths&period;
| xref:llvm/MachineConstantPool.adoc[`MachineConstantPool`] 
| Tracks constants that must be spilled to a function&apos;s constant pool&period;
| xref:llvm/MachineConstantPoolEntry.adoc[`MachineConstantPoolEntry`] 
| One entry in a MachineConstantPool&period;
| xref:llvm/MachineConstantPoolValue.adoc[`MachineConstantPoolValue`] 
| Abstract base for target&hyphen;specific constant pool values&period;
| xref:llvm/MachineCopyPropagationPass.adoc[`MachineCopyPropagationPass`] 
| New PM pass that performs copy propagation on machine instructions&period;
| xref:llvm/MachineCycleAnalysis.adoc[`MachineCycleAnalysis`] 
| Analysis pass that computes `MachineCycleInfo` for a machine function&period;
| xref:llvm/MachineCycleInfo.adoc[`MachineCycleInfo`] 
| Cycle information specialized for Machine IR&period;
| xref:llvm/MachineCycleInfoPrinterPass.adoc[`MachineCycleInfoPrinterPass`] 
| Printer pass for the `MachineCycleAnalysis` results&period;
| xref:llvm/MachineCycleInfoWrapperPass.adoc[`MachineCycleInfoWrapperPass`] 
| Legacy analysis pass which computes a xref:llvm/MachineCycleInfo.adoc[`MachineCycleInfo`]&period;
| xref:llvm/MachineDomTreeGraphTraitsBase-04.adoc[`MachineDomTreeGraphTraitsBase`] 
| GraphTraits helpers for walking machine dominator&hyphen;tree nodes depth&hyphen;first&period;
| xref:llvm/MachineDomTreeUpdater.adoc[`MachineDomTreeUpdater`] 
| Updates MachineDominatorTree and MachinePostDominatorTree&period;
| xref:llvm/MachineDominanceFrontier.adoc[`MachineDominanceFrontier`] 
| Dominance frontier analysis result for a MachineFunction&apos;s MachineBasicBlocks&period;
| xref:llvm/MachineDominanceFrontierAnalysis.adoc[`MachineDominanceFrontierAnalysis`] 
| Analysis pass which computes a `MachineDominanceFrontier&period;`
| xref:llvm/MachineDominanceFrontierWrapperPass.adoc[`MachineDominanceFrontierWrapperPass`] 
| Legacy analysis pass which computes a `MachineDominanceFrontier&period;`
| xref:llvm/MachineDominatorTree.adoc[`MachineDominatorTree`] 
| DominatorTree Class &hyphen; Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree&period;
| xref:llvm/MachineDominatorTreeAnalysis.adoc[`MachineDominatorTreeAnalysis`] 
| Analysis pass which computes a `MachineDominatorTree&period;`
| xref:llvm/MachineDominatorTreePrinterPass.adoc[`MachineDominatorTreePrinterPass`] 
| Machine function pass which print `MachineDominatorTree&period;`
| xref:llvm/MachineDominatorTreeWrapperPass.adoc[`MachineDominatorTreeWrapperPass`] 
| Analysis pass which computes a `MachineDominatorTree&period;`
| xref:llvm/MachineFrameInfo.adoc[`MachineFrameInfo`] 
| Represents an abstract stack frame until prolog&sol;epilog code is inserted&period;
| xref:llvm/MachineFunction.adoc[`MachineFunction`] 
| Representation of machine code for a single LLVM IR function&period;
| xref:llvm/MachineFunctionAnalysis.adoc[`MachineFunctionAnalysis`] 
| This analysis create MachineFunction for given Function&period; To release the MachineFunction, users should invalidate it explicitly&period;
| xref:llvm/MachineFunctionInfo.adoc[`MachineFunctionInfo`] 
| Target&hyphen;specific per&hyphen;function information attached to a MachineFunction&period;
| xref:llvm/MachineFunctionPass.adoc[`MachineFunctionPass`] 
| FunctionPass adapter for passes that operate on a MachineFunction&period;
| xref:llvm/MachineFunctionProperties.adoc[`MachineFunctionProperties`] 
| Bitset of MachineFunction invariants checked by the MachineVerifier&period;
| xref:llvm/MachineIDFSSAUpdater.adoc[`MachineIDFSSAUpdater`] 
| Efficient SSA form updater for machine IR using iterated dominance frontiers&period;
| xref:llvm/MachineIRBuilder.adoc[`MachineIRBuilder`] 
| Helper for constructing MachineInstrs with a shared insertion point&period;
| xref:llvm/MachineIRBuilderState.adoc[`MachineIRBuilderState`] 
| Holds insertion and metadata state for a MachineIRBuilder&period;
| xref:llvm/MachineInstr.adoc[`MachineInstr`] 
| Representation of each machine instruction&period;
| xref:llvm/MachineInstrBuilder.adoc[`MachineInstrBuilder`] 
| Helper class for constructing and mutating MachineInstrs&period;
| xref:llvm/MachineInstrBundleIterator.adoc[`MachineInstrBundleIterator`] 
| MachineBasicBlock iterator that automatically skips over MIs that are inside bundles (i&period;e&period; walk top level MIs only)&period;
| xref:llvm/MachineInstrBundleIteratorHelper-07.adoc[`MachineInstrBundleIteratorHelper`] 
| Helper selecting bundle walk direction for forward or reverse iterators&period;
| xref:llvm/MachineInstrBundleIteratorTraits-010.adoc[`MachineInstrBundleIteratorTraits`] 
| Iterator traits for bundle&hyphen;aware machine instruction iterators&period;
| xref:llvm/MachineInstrExpressionTrait.adoc[`MachineInstrExpressionTrait`] 
| DenseMapInfo traits that compare MachineInstr&ast; by instruction value&period;
| xref:llvm/MachineInstrSpan.adoc[`MachineInstrSpan`] 
| Iteration range covering an instruction and later insertions around it&period;
| xref:llvm/MachineJumpTableEntry.adoc[`MachineJumpTableEntry`] 
| MachineJumpTableEntry &hyphen; One jump table in the jump table info&period;
| xref:llvm/MachineJumpTableInfo.adoc[`MachineJumpTableInfo`] 
| Keeps track of jump tables referenced by lowered switch instructions&period;
| xref:llvm/MachineKCFIPass.adoc[`MachineKCFIPass`] 
| New PM pass that implements kernel control&hyphen;flow integrity&period;
| xref:llvm/MachineLICMBasePass-0d.adoc[`MachineLICMBasePass`] 
| CRTP base for new&hyphen;PM machine loop&hyphen;invariant code motion passes&period;
| xref:llvm/MachineLICMPass.adoc[`MachineLICMPass`] 
| New PM pass that performs machine LICM after register allocation&period;
| xref:llvm/MachineLateInstrsCleanupPass.adoc[`MachineLateInstrsCleanupPass`] 
| New PM pass that removes redundant identical instructions after register allocation and rematerialization&period;
| xref:llvm/MachineLocation.adoc[`MachineLocation`] 
| Represents a simple location in a machine frame&period;
| xref:llvm/MachineLoop.adoc[`MachineLoop`] 
| Represents a single natural loop in a machine&hyphen;function CFG&period;
| xref:llvm/MachineLoopAnalysis.adoc[`MachineLoopAnalysis`] 
| Analysis pass that exposes the `MachineLoopInfo` for a machine function&period;
| xref:llvm/MachineLoopInfo.adoc[`MachineLoopInfo`] 
| Analysis that identifies natural loops in a machine function&apos;s CFG&period;
| xref:llvm/MachineLoopInfoWrapperPass.adoc[`MachineLoopInfoWrapperPass`] 
| The legacy pass manager&apos;s analysis pass to compute machine loop information&period;
| xref:llvm/MachineLoopPrinterPass.adoc[`MachineLoopPrinterPass`] 
| Printer pass for the `LoopAnalysis` results&period;
| xref:llvm/MachineMemOperand.adoc[`MachineMemOperand`] 
| Description of a memory reference used in the backend&period;
| xref:llvm/MachineModuleAnalysis.adoc[`MachineModuleAnalysis`] 
| Analysis that produces MachineModuleInfo for a module&period;
| xref:llvm/MachineModuleInfo.adoc[`MachineModuleInfo`] 
| Holds module&hyphen;level metadata for code generation&period;
| xref:llvm/MachineModuleInfoCOFF.adoc[`MachineModuleInfoCOFF`] 
| MachineModuleInfoCOFF &hyphen; This is a MachineModuleInfoImpl implementation for COFF targets&period;
| xref:llvm/MachineModuleInfoELF.adoc[`MachineModuleInfoELF`] 
| MachineModuleInfoELF &hyphen; This is a MachineModuleInfoImpl implementation for ELF targets&period;
| xref:llvm/MachineModuleInfoImpl.adoc[`MachineModuleInfoImpl`] 
| Base class for target&hyphen;specific per&hyphen;module object&hyphen;file information&period;
| xref:llvm/MachineModuleInfoMachO.adoc[`MachineModuleInfoMachO`] 
| MachineModuleInfoMachO &hyphen; This is a MachineModuleInfoImpl implementation for MachO targets&period;
| xref:llvm/MachineModuleInfoWasm.adoc[`MachineModuleInfoWasm`] 
| MachineModuleInfoWasm &hyphen; This is a MachineModuleInfoImpl implementation for Wasm targets&period;
| xref:llvm/MachineModuleInfoWrapperPass.adoc[`MachineModuleInfoWrapperPass`] 
| ImmutablePass wrapper that owns a MachineModuleInfo&period;
| xref:llvm/MachineModuleSlotTracker.adoc[`MachineModuleSlotTracker`] 
| Module slot tracker that also numbers MachineFunction metadata&period;
| xref:llvm/MachineOperand.adoc[`MachineOperand`] 
| MachineOperand class &hyphen; Representation of each machine instruction operand&period;
| xref:llvm/MachineOptimizationRemark.adoc[`MachineOptimizationRemark`] 
| Diagnostic information for applied optimization remarks&period;
| xref:llvm/MachineOptimizationRemarkAnalysis.adoc[`MachineOptimizationRemarkAnalysis`] 
| Diagnostic information for optimization analysis remarks&period;
| xref:llvm/MachineOptimizationRemarkEmitter.adoc[`MachineOptimizationRemarkEmitter`] 
| The optimization diagnostic interface&period;
| xref:llvm/MachineOptimizationRemarkEmitterAnalysis.adoc[`MachineOptimizationRemarkEmitterAnalysis`] 
| The analysis pass
| xref:llvm/MachineOptimizationRemarkEmitterPass.adoc[`MachineOptimizationRemarkEmitterPass`] 
| The analysis pass
| xref:llvm/MachineOptimizationRemarkMissed.adoc[`MachineOptimizationRemarkMissed`] 
| Diagnostic information for missed&hyphen;optimization remarks&period;
| xref:llvm/MachinePassRegistry.adoc[`MachinePassRegistry`] 
| MachinePassRegistry &hyphen; Track the registration of machine passes&period;
| xref:llvm/MachinePassRegistryListener.adoc[`MachinePassRegistryListener`] 
| MachinePassRegistryListener &hyphen; Listener to adds and removals of nodes in registration list&period;
| xref:llvm/MachinePassRegistryNode-0fb.adoc[`MachinePassRegistryNode`] 
| MachinePassRegistryNode &hyphen; Machine pass node stored in registration list&period;
| xref:llvm/MachinePipeliner.adoc[`MachinePipeliner`] 
| The main class in the implementation of the target independent software pipeliner pass&period;
| xref:llvm/MachinePipelinerPolicy.adoc[`MachinePipelinerPolicy`] 
| Software pipelining policy for a loop, which a target can customize by implementing TargetSubtargetInfo&colon;&colon;overridePipelinerPolicy&period;
| xref:llvm/MachinePointerInfo.adoc[`MachinePointerInfo`] 
| Discriminated union of pointer information for memory operands&period;
| xref:llvm/MachinePostDominatorTree.adoc[`MachinePostDominatorTree`] 
| MachinePostDominatorTree &hyphen; an analysis pass wrapper for DominatorTree used to compute the post&hyphen;dominator tree for MachineFunctions&period;
| xref:llvm/MachinePostDominatorTreeAnalysis.adoc[`MachinePostDominatorTreeAnalysis`] 
| Analysis pass which computes a `MachinePostDominatorTree&period;`
| xref:llvm/MachinePostDominatorTreePrinterPass.adoc[`MachinePostDominatorTreePrinterPass`] 
| Machine function pass which prints `MachinePostDominatorTree&period;`
| xref:llvm/MachinePostDominatorTreeWrapperPass.adoc[`MachinePostDominatorTreeWrapperPass`] 
| Analysis pass which computes a `MachinePostDominatorTree&period;`
| xref:llvm/MachineRegion.adoc[`MachineRegion`] 
| Single&hyphen;entry single&hyphen;exit region in a MachineFunction CFG&period;
| xref:llvm/MachineRegionInfo.adoc[`MachineRegionInfo`] 
| Detects single&hyphen;entry single&hyphen;exit regions in a MachineFunction&period;
| xref:llvm/MachineRegionInfoAnalysis.adoc[`MachineRegionInfoAnalysis`] 
| Analysis pass that exposes the `MachineRegionInfo` for a machine function&period;
| xref:llvm/MachineRegionInfoPass.adoc[`MachineRegionInfoPass`] 
| Legacy MachineFunctionPass wrapper that computes MachineRegionInfo&period;
| xref:llvm/MachineRegionInfoPrinterPass.adoc[`MachineRegionInfoPrinterPass`] 
| Printer pass for the `MachineRegionInfo` analysis results&period;
| xref:llvm/MachineRegionNode.adoc[`MachineRegionNode`] 
| Region node that holds either a MachineBasicBlock or a nested MachineRegion&period;
| xref:llvm/MachineRegisterClassAnalysis.adoc[`MachineRegisterClassAnalysis`] 
| Analysis pass that computes RegisterClassInfo for a machine function&period;
| xref:llvm/MachineRegisterClassInfoWrapperPass.adoc[`MachineRegisterClassInfoWrapperPass`] 
| Legacy machine function pass wrapping RegisterClassInfo&period;
| xref:llvm/MachineRegisterInfo.adoc[`MachineRegisterInfo`] 
| MachineRegisterInfo &hyphen; Keep track of information for virtual and physical registers, including vreg register classes, use&sol;def chains for registers, etc&period;
| xref:llvm/MachineSDNode.adoc[`MachineSDNode`] 
| An SDNode that represents everything that will be needed to construct a MachineInstr&period; These nodes are created during the instruction selection proper phase&period;
| xref:llvm/MachineSSAUpdater.adoc[`MachineSSAUpdater`] 
| Helper class for SSA formation on virtual registers defined in multiple blocks&period;
| xref:llvm/MachineSanitizerBinaryMetadataPass.adoc[`MachineSanitizerBinaryMetadataPass`] 
| New PM pass that finalizes sanitizer binary metadata for a machine function&period;
| xref:llvm/MachineSchedContext.adoc[`MachineSchedContext`] 
| Context from the MachineScheduler pass used to instantiate a scheduler&period;
| xref:llvm/MachineSchedPolicy.adoc[`MachineSchedPolicy`] 
| Generic scheduling policy for targets without a custom MachineSchedStrategy&period;
| xref:llvm/MachineSchedRegistry.adoc[`MachineSchedRegistry`] 
| Registry of available machine instruction schedulers&period;
| xref:llvm/MachineSchedStrategy.adoc[`MachineSchedStrategy`] 
| Interface to the scheduling algorithm used by ScheduleDAGMI&period;
| xref:llvm/MachineSchedulerPass.adoc[`MachineSchedulerPass`] 
| New PM pass that runs the pre&hyphen;RA machine instruction scheduler&period;
| xref:llvm/MachineSinkingPass.adoc[`MachineSinkingPass`] 
| New PM pass that sinks machine instructions into successor blocks&period;
| xref:llvm/MachineTraceMetrics.adoc[`MachineTraceMetrics`] 
| Analysis estimating resource use and critical paths through preferred traces&period;
| xref:llvm/MachineTraceMetricsAnalysis.adoc[`MachineTraceMetricsAnalysis`] 
| Analysis pass computing MachineTraceMetrics for a machine function&period;
| xref:llvm/MachineTraceMetricsVerifierPass.adoc[`MachineTraceMetricsVerifierPass`] 
| Verifier pass for `MachineTraceMetrics&period;`
| xref:llvm/MachineTraceMetricsWrapperPass.adoc[`MachineTraceMetricsWrapperPass`] 
| Legacy pass manager wrapper around MachineTraceMetrics&period;
| xref:llvm/MachineUniformityAnalysis.adoc[`MachineUniformityAnalysis`] 
| Analysis pass that computes `MachineUniformityInfo` for a machine function&period;
| xref:llvm/MachineUniformityAnalysisPass.adoc[`MachineUniformityAnalysisPass`] 
| Legacy analysis pass which computes a xref:llvm/MachineUniformityInfo.adoc[`MachineUniformityInfo`]&period;
| xref:llvm/MachineUniformityPrinterPass.adoc[`MachineUniformityPrinterPass`] 
| Printer pass for the `MachineUniformityAnalysis` results&period;
| xref:llvm/MachineVerifierPass.adoc[`MachineVerifierPass`] 
| New PM pass that verifies the integrity of machine code&period;
| xref:llvm/MakeGuardsExplicitPass.adoc[`MakeGuardsExplicitPass`] 
| Pass that lowers llvm&period;experimental&period;guard to widenable explicit branches&period;
| xref:llvm/MallocAllocator.adoc[`MallocAllocator`] 
| Allocator that obtains memory from malloc&sol;free (or aligned variants)&period;
| xref:llvm/ManagedStatic.adoc[`ManagedStatic`] 
| Lazily constructed global destroyed explicitly by llvm&lowbar;shutdown()&period;
| xref:llvm/ManagedStaticBase.adoc[`ManagedStaticBase`] 
| ManagedStaticBase &hyphen; Common base class for ManagedStatic instances&period;
| xref:llvm/Mangler.adoc[`Mangler`] 
| Mangles global names according to the target ABI&period;
| xref:llvm/MapResolver.adoc[`MapResolver`] 
| Resolve arbitrary mappings&period;
| xref:llvm/MapVector-04b.adoc[`MapVector`] 
| This class implements a map that also provides access to all stored values in a deterministic order&period;
| xref:llvm/MaskedGatherSDNode.adoc[`MaskedGatherSDNode`] 
| This class is used to represent an MGATHER node
| xref:llvm/MaskedGatherScatterSDNode.adoc[`MaskedGatherScatterSDNode`] 
| This is a base class used to represent MGATHER and MSCATTER nodes
| xref:llvm/MaskedHistogramSDNode.adoc[`MaskedHistogramSDNode`] 
| SDNode for experimental vector histogram operations&period;
| xref:llvm/MaskedLoadSDNode.adoc[`MaskedLoadSDNode`] 
| This class is used to represent an MLOAD node
| xref:llvm/MaskedLoadStoreSDNode.adoc[`MaskedLoadStoreSDNode`] 
| This base class is used to represent MLOAD and MSTORE nodes
| xref:llvm/MaskedScatterSDNode.adoc[`MaskedScatterSDNode`] 
| This class is used to represent an MSCATTER node
| xref:llvm/MaskedStoreSDNode.adoc[`MaskedStoreSDNode`] 
| This class is used to represent an MSTORE node
| xref:llvm/MatchCustomNoteDiag.adoc[`MatchCustomNoteDiag`] 
| `MatchNoteDiag` with a custom note not described by any other class derived from `MatchNoteDiag&period;`
| xref:llvm/MatchFoundDiag.adoc[`MatchFoundDiag`] 
| `MatchResultDiag` for a pattern that matched the input&period;
| xref:llvm/MatchFuzzyDiag.adoc[`MatchFuzzyDiag`] 
| `MatchNoteDiag` for a fuzzy match that serves as a suggestion for the next intended match for an expected pattern with too few or no good matches&period;
| xref:llvm/MatchNoneDiag.adoc[`MatchNoneDiag`] 
| `MatchResultDiag` for a pattern that did not match the input&period;
| xref:llvm/MatchNoteDiag.adoc[`MatchNoteDiag`] 
| Abstract base class for recording a FileCheck diagnostic that provides an additional note (possibly a new error) about the most recent `MatchResultDiag&period;`
| xref:llvm/MatchResultDiag.adoc[`MatchResultDiag`] 
| Abstract base class for recording a FileCheck diagnostic that reports a match result for a pattern&period;
| xref:llvm/MatrixBuilder.adoc[`MatrixBuilder`] 
| Helper for lowering matrix operations to LLVM IR&period;
| xref:llvm/MaybeAlign.adoc[`MaybeAlign`] 
| This struct is a compact representation of a valid (power of two) or undefined (0) alignment&period;
| xref:llvm/MemCpyInst.adoc[`MemCpyInst`] 
| This class wraps the llvm&period;memcpy intrinsic&period;
| xref:llvm/MemCpyOptPass.adoc[`MemCpyOptPass`] 
| Pass that eliminates memcpy calls and turns store sets into memsets&period;
| xref:llvm/MemDepResult.adoc[`MemDepResult`] 
| A memory dependence query can return one of three different answers&period;
| xref:llvm/MemDerefPrinterPass.adoc[`MemDerefPrinterPass`] 
| Printer pass for whether values are known dereferenceable pointers&period;
| xref:llvm/MemIntrinsic.adoc[`MemIntrinsic`] 
| This is the common base class for memset&sol;memcpy&sol;memmove&period;
| xref:llvm/MemIntrinsicBase-0f.adoc[`MemIntrinsicBase`] 
| CRTP base providing common accessors for memory intrinsics&period;
| xref:llvm/MemIntrinsicCostAttributes.adoc[`MemIntrinsicCostAttributes`] 
| Information for memory intrinsic cost model&period;
| xref:llvm/MemIntrinsicInfo.adoc[`MemIntrinsicInfo`] 
| Information about a load&sol;store intrinsic defined by the target&period;
| xref:llvm/MemIntrinsicSDNode.adoc[`MemIntrinsicSDNode`] 
| Memory&hyphen;touching target intrinsic SDNode with an MMO&period;
| xref:llvm/MemMoveInst.adoc[`MemMoveInst`] 
| This class wraps the llvm&period;memmove intrinsic&period;
| xref:llvm/MemOp.adoc[`MemOp`] 
| Describes a memset, memcpy, or memmove lowering candidate&period;
| xref:llvm/MemProfContextDisambiguation.adoc[`MemProfContextDisambiguation`] 
| Disambiguates memprof allocation contexts for profile&hyphen;guided heap optimization&period;
| xref:llvm/MemProfRemoveInfo.adoc[`MemProfRemoveInfo`] 
| Strips MemProf attributes and metadata&period;
| xref:llvm/MemProfUsePass.adoc[`MemProfUsePass`] 
| Public interface to the MemProf profile&hyphen;use pass that applies memory profiles to the IR&period;
| xref:llvm/MemProfilerPass.adoc[`MemProfilerPass`] 
| Public interface to the memory profiler pass for instrumenting code to profile memory accesses&period;
| xref:llvm/MemSDNode.adoc[`MemSDNode`] 
| This is an abstract virtual class for memory operations&period;
| xref:llvm/MemSetBase-04d.adoc[`MemSetBase`] 
| Common base class for all memset intrinsics&period; Simply provides common methods&period;
| xref:llvm/MemSetInst.adoc[`MemSetInst`] 
| This class wraps the llvm&period;memset and llvm&period;memset&period;inline intrinsics&period;
| xref:llvm/MemSetPatternInst.adoc[`MemSetPatternInst`] 
| Wrapper for the llvm&period;experimental&period;memset&period;pattern intrinsic&period;
| xref:llvm/MemTransferBase-01.adoc[`MemTransferBase`] 
| Common base class for all memory transfer intrinsics&period; Simply provides common methods&period;
| xref:llvm/MemTransferInst.adoc[`MemTransferInst`] 
| This class wraps the llvm&period;memcpy&sol;memmove intrinsics&period;
| xref:llvm/MemoryAccess.adoc[`MemoryAccess`] 
| Base class for MemoryUse, MemoryDef, and MemoryPhi nodes in MemorySSA&period;
| xref:llvm/MemoryBuffer.adoc[`MemoryBuffer`] 
| This interface provides simple read&hyphen;only access to a block of memory, and provides simple methods for reading files and standard input into a memory buffer&period; In addition to basic access to the characters in the file, this interface guarantees you can read one character past the end of the file, and that this character will read as &apos;0&apos;&period;
| xref:llvm/MemoryBufferByteStream.adoc[`MemoryBufferByteStream`] 
| BinaryStream whose data is owned by an llvm MemoryBuffer&period;
| xref:llvm/MemoryBufferRef.adoc[`MemoryBufferRef`] 
| A non&hyphen;owning reference to a memory buffer and its identifier&period;
| xref:llvm/MemoryDef.adoc[`MemoryDef`] 
| Represents a read&hyphen;write access to memory, whether it is a must&hyphen;alias, or a may&hyphen;alias&period;
| xref:llvm/MemoryDepChecker.adoc[`MemoryDepChecker`] 
| Checks memory dependences among accesses to the same underlying object&period;
| xref:llvm/MemoryDependenceAnalysis.adoc[`MemoryDependenceAnalysis`] 
| An analysis that produces `MemoryDependenceResults` for a function&period;
| xref:llvm/MemoryDependenceResults.adoc[`MemoryDependenceResults`] 
| Provides a lazy, caching interface for making common memory aliasing information queries, backed by LLVM&apos;s alias analysis passes&period;
| xref:llvm/MemoryDependenceWrapperPass.adoc[`MemoryDependenceWrapperPass`] 
| A wrapper analysis pass for the legacy pass manager that exposes a `MemoryDepnedenceResults` instance&period;
| xref:llvm/MemoryEffectsBase.adoc[`MemoryEffectsBase`] 
| Bitmask of Mod&sol;Ref effects for each memory location kind in `LocationEnum&period;`
| xref:llvm/MemoryLocation.adoc[`MemoryLocation`] 
| Representation for a specific memory location&period;
| xref:llvm/MemoryOpRemark.adoc[`MemoryOpRemark`] 
| Emit optimization remarks for instructions that copy, move, or initialize memory&period;
| xref:llvm/MemoryPhi.adoc[`MemoryPhi`] 
| Represents phi nodes for memory accesses&period;
| xref:llvm/MemorySSA.adoc[`MemorySSA`] 
| Encapsulates MemorySSA, including all data associated with memory accesses&period;
| xref:llvm/MemorySSAAnalysis.adoc[`MemorySSAAnalysis`] 
| An analysis that produces `MemorySSA` for a function&period;
| xref:llvm/MemorySSAPrinterPass.adoc[`MemorySSAPrinterPass`] 
| Printer pass for `MemorySSA&period;`
| xref:llvm/MemorySSAUpdater.adoc[`MemorySSAUpdater`] 
| Automatic updater that inserts, deletes, and moves MemorySSA accesses&period;
| xref:llvm/MemorySSAUtil.adoc[`MemorySSAUtil`] 
| Internal MemorySSA utilities for MemorySSA classes and walkers&period;
| xref:llvm/MemorySSAVerifierPass.adoc[`MemorySSAVerifierPass`] 
| Verifier pass for `MemorySSA&period;`
| xref:llvm/MemorySSAWalker.adoc[`MemorySSAWalker`] 
| Generic walker interface for further disambiguating MemorySSA def&hyphen;use chains&period;
| xref:llvm/MemorySSAWalkerPrinterPass.adoc[`MemorySSAWalkerPrinterPass`] 
| Printer pass for `MemorySSA` via the walker&period;
| xref:llvm/MemorySSAWrapperPass.adoc[`MemorySSAWrapperPass`] 
| Legacy analysis pass which computes `MemorySSA&period;`
| xref:llvm/MemorySanitizerOptions.adoc[`MemorySanitizerOptions`] 
| Options that control MemorySanitizer instrumentation&period;
| xref:llvm/MemorySanitizerPass.adoc[`MemorySanitizerPass`] 
| A module pass for msan instrumentation&period;
| xref:llvm/MemoryUse.adoc[`MemoryUse`] 
| Represents read&hyphen;only accesses to memory
| xref:llvm/MemoryUseOrDef.adoc[`MemoryUseOrDef`] 
| Common base for MemoryUse and MemoryDef&period;
| xref:llvm/MemoryWriteTracking.adoc[`MemoryWriteTracking`] 
| Tracks instructions that may write to memory within basic blocks&period;
| xref:llvm/MergeFunctionsPass.adoc[`MergeFunctionsPass`] 
| Merge identical functions&period;
| xref:llvm/MergeICmpsPass.adoc[`MergeICmpsPass`] 
| Pass that merges chains of integer comparisons into a memcmp call&period;
| xref:llvm/MergedLoadStoreMotionOptions.adoc[`MergedLoadStoreMotionOptions`] 
| Options controlling merged load&sol;store motion behavior&period;
| xref:llvm/MergedLoadStoreMotionPass.adoc[`MergedLoadStoreMotionPass`] 
| Pass that merges loads and stores across diamond (hammock) control flow&period;
| xref:llvm/MetaRenamerPass.adoc[`MetaRenamerPass`] 
| Pass that renames everything with metasyntactic names&period;
| xref:llvm/Metadata.adoc[`Metadata`] 
| Root of the metadata hierarchy&period;
| xref:llvm/MetadataAsValue.adoc[`MetadataAsValue`] 
| Metadata wrapper in the Value hierarchy&period;
| xref:llvm/MetadataTracking.adoc[`MetadataTracking`] 
| API for tracking metadata references through RAUW and deletion&period;
| xref:llvm/MinMax.adoc[`MinMax`] 
| Inclusive minimum and maximum bounds for a retained knowledge value range&period;
| xref:llvm/MinMaxIntrinsic.adoc[`MinMaxIntrinsic`] 
| This class represents min&sol;max intrinsics&period;
| xref:llvm/ModifiedPostOrder.adoc[`ModifiedPostOrder`] 
| Construct a specially modified post&hyphen;order traversal of cycles&period;
| xref:llvm/Module.adoc[`Module`] 
| Top&hyphen;level container for LLVM IR objects in a translation unit&period;
| xref:llvm/ModuleCopyProfPass.adoc[`ModuleCopyProfPass`] 
| Module&hyphen;level pass that inserts the CopyProf runtime initialization constructor and hooks it into llvm&period;global&lowbar;ctors&period;
| xref:llvm/ModuleDebugInfoPrinterPass.adoc[`ModuleDebugInfoPrinterPass`] 
| Printer pass for module&hyphen;level debug info metadata&period;
| xref:llvm/ModuleInlinerPass.adoc[`ModuleInlinerPass`] 
| The module inliner pass for the new pass manager&period;
| xref:llvm/ModuleInlinerWrapperPass.adoc[`ModuleInlinerWrapperPass`] 
| Module pass wrapping the inliner with a module&hyphen;wide advisor&period;
| xref:llvm/ModuleLibcallLoweringInfo.adoc[`ModuleLibcallLoweringInfo`] 
| Records a mapping from an opaque lowering context to its LibcallLoweringInfo&period;
| xref:llvm/ModuleMemProfilerPass.adoc[`ModuleMemProfilerPass`] 
| Public interface to the memory profiler module pass for instrumenting code to profile memory allocations and accesses&period;
| xref:llvm/ModulePass.adoc[`ModulePass`] 
| Pass that may inspect or transform an entire module freely&period;
| xref:llvm/ModuleSlotTracker.adoc[`ModuleSlotTracker`] 
| Manage lifetime of a slot tracker for printing IR&period;
| xref:llvm/ModuleSummaryIndex.adoc[`ModuleSummaryIndex`] 
| Class to hold module path string table and global value map, and encapsulate methods for operating on them&period;
| xref:llvm/ModuleSummaryIndexAnalysis.adoc[`ModuleSummaryIndexAnalysis`] 
| Analysis pass to provide the ModuleSummaryIndex object&period;
| xref:llvm/ModuleSummaryIndexWrapperPass.adoc[`ModuleSummaryIndexWrapperPass`] 
| Legacy wrapper pass to provide the ModuleSummaryIndex object&period;
| xref:llvm/ModuleSymbolTable.adoc[`ModuleSymbolTable`] 
| Symbol table built from in&hyphen;memory IR modules&period;
| xref:llvm/ModuleThreadSanitizerPass.adoc[`ModuleThreadSanitizerPass`] 
| A module pass for tsan instrumentation&period;
| xref:llvm/ModuleToFunctionPassAdaptor.adoc[`ModuleToFunctionPassAdaptor`] 
| Trivial adaptor that maps from a module to its functions&period;
| xref:llvm/ModuleToPostOrderCGSCCPassAdaptor.adoc[`ModuleToPostOrderCGSCCPassAdaptor`] 
| The core module pass which does a post&hyphen;order walk of the SCCs and runs a CGSCC pass over each one&period;
| xref:llvm/ModuloSchedule.adoc[`ModuloSchedule`] 
| Represents a schedule for a single&hyphen;block loop&period; For every instruction we maintain a Cycle and Stage&period;
| xref:llvm/ModuloScheduleExpander.adoc[`ModuloScheduleExpander`] 
| The ModuloScheduleExpander takes a ModuloSchedule and expands it in&hyphen;place, rewriting the old loop and inserting prologs and epilogs as required&period;
| xref:llvm/ModuloScheduleExpanderMVE.adoc[`ModuloScheduleExpanderMVE`] 
| Expand the kernel using modulo variable expansion algorithm (MVE)&period; It unrolls the kernel enough to avoid overlap of register lifetime&period;
| xref:llvm/ModuloScheduleTestAnnotater.adoc[`ModuloScheduleTestAnnotater`] 
| Expander that simply annotates each scheduled instruction with a post&hyphen;instr symbol that can be consumed by the ModuloScheduleTest pass&period;
| xref:llvm/MoveAutoInitPass.adoc[`MoveAutoInitPass`] 
| Pass that moves auto&hyphen;init instructions closer to their uses when profitable&period;
| xref:llvm/MulOperator.adoc[`MulOperator`] 
| Concrete operator for the Mul instruction opcode&period;
| xref:llvm/MultiHazardRecognizer.adoc[`MultiHazardRecognizer`] 
| Composite hazard recognizer that delegates to a set of recognizers&period;
| xref:llvm/MustBeExecutedContextExplorer.adoc[`MustBeExecutedContextExplorer`] 
| Interface to explore must&hyphen;be&hyphen;executed contexts around program points&period;
| xref:llvm/MustBeExecutedContextPrinterPass.adoc[`MustBeExecutedContextPrinterPass`] 
| Printer pass for must&hyphen;be&hyphen;executed contexts&period;
| xref:llvm/MustBeExecutedIterator.adoc[`MustBeExecutedIterator`] 
| Must be executed iterators visit stretches of instructions that are guaranteed to be executed together, potentially with other instruction executed in&hyphen;between&period;
| xref:llvm/MustExecutePrinterPass.adoc[`MustExecutePrinterPass`] 
| Printer pass for the must&hyphen;execute analysis&period;
| xref:llvm/MutableArrayRef-02.adoc[`MutableArrayRef`] 
| A mutable reference to consecutive elements in memory&period;
| xref:llvm/MutableBinaryByteStream.adoc[`MutableBinaryByteStream`] 
| Writable BinaryStream backed by a single contiguous mutable buffer&period;
| xref:llvm/NameAnonGlobalPass.adoc[`NameAnonGlobalPass`] 
| Simple pass that provides a name to every anonymous globals&period;
| xref:llvm/NamedInstrProfRecord.adoc[`NamedInstrProfRecord`] 
| InstrProfRecord annotated with the function&apos;s PGO name and hash&period;
| xref:llvm/NamedMDNode.adoc[`NamedMDNode`] 
| A tuple of MDNodes&period;
| xref:llvm/NamedRegionTimer.adoc[`NamedRegionTimer`] 
| Combines Timer and TimeRegion to time a named region in one statement&period;
| xref:llvm/NamespaceEmitter.adoc[`NamespaceEmitter`] 
| RAII helper that emits a C&plus;&plus; namespace scope&period;
| xref:llvm/NaryReassociatePass.adoc[`NaryReassociatePass`] 
| Pass that reassociates n&hyphen;ary expressions to reuse existing instructions&period;
| xref:llvm/NearMissInfo.adoc[`NearMissInfo`] 
| Information about one near&hyphen;miss encoding when instruction matching fails&period;
| xref:llvm/NewArchiveMember.adoc[`NewArchiveMember`] 
| A member to include when writing a new archive&period;
| xref:llvm/NewGVNPass.adoc[`NewGVNPass`] 
| A Global Value Numbering pass that eliminates redundant values&period;
| xref:llvm/NfaStatePair.adoc[`NfaStatePair`] 
| Forward define the pair type used by the automata transition info tables&period;
| xref:llvm/NoActiveBlocksOption.adoc[`NoActiveBlocksOption`] 
| Empty base used when `LockstepReverseIterator` does not track active blocks&period;
| xref:llvm/NoAliasScopeDeclInst.adoc[`NoAliasScopeDeclInst`] 
| Wrapper for the llvm&period;experimental&period;noalias&period;scope&period;decl intrinsic&period;
| xref:llvm/NoCFIValue.adoc[`NoCFIValue`] 
| Wrapper for a value that won&apos;t be replaced with a CFI jump table pointer in LowerTypeTestsModule&period;
| xref:llvm/NoFolder.adoc[`NoFolder`] 
| NoFolder &hyphen; Create &quot;constants&quot; (actually, instructions) with no folding&period;
| xref:llvm/NoInferenceModelRunner.adoc[`NoInferenceModelRunner`] 
| A pseudo model runner&period; We use it to store feature values when collecting logs for the default policy, in &apos;development&apos; mode, but never ask it to &apos;run&apos;&period;
| xref:llvm/NoOpCGSCCAnalysis.adoc[`NoOpCGSCCAnalysis`] 
| No&hyphen;op CGSCC analysis&period;
| xref:llvm/NoOpCGSCCPass.adoc[`NoOpCGSCCPass`] 
| No&hyphen;op CGSCC pass which does nothing&period;
| xref:llvm/NoOpFunctionAnalysis.adoc[`NoOpFunctionAnalysis`] 
| No&hyphen;op function analysis&period;
| xref:llvm/NoOpFunctionPass.adoc[`NoOpFunctionPass`] 
| No&hyphen;op function pass which does nothing&period;
| xref:llvm/NoOpLoopAnalysis.adoc[`NoOpLoopAnalysis`] 
| No&hyphen;op loop analysis&period;
| xref:llvm/NoOpLoopNestPass.adoc[`NoOpLoopNestPass`] 
| No&hyphen;op loop nest pass which does nothing&period;
| xref:llvm/NoOpLoopPass.adoc[`NoOpLoopPass`] 
| No&hyphen;op loop pass which does nothing&period;
| xref:llvm/NoOpMachineFunctionPass.adoc[`NoOpMachineFunctionPass`] 
| No&hyphen;op machine function pass which does nothing&period;
| xref:llvm/NoOpModuleAnalysis.adoc[`NoOpModuleAnalysis`] 
| No&hyphen;op module analysis&period;
| xref:llvm/NoOpModulePass.adoc[`NoOpModulePass`] 
| No&hyphen;op module pass which does nothing&period;
| xref:llvm/NoRecurseLTOInferencePass.adoc[`NoRecurseLTOInferencePass`] 
| Additional &apos;norecurse&apos; attribute deduction during postlink LTO phase&period;
| xref:llvm/NodeSet.adoc[`NodeSet`] 
| A NodeSet contains a set of SUnit DAG nodes with additional information that assigns a priority to the set&period;
| xref:llvm/NoinlineNonPrevailing.adoc[`NoinlineNonPrevailing`] 
| Utility pass that blocks inlining for functions that may be overridden by a prevailing copy during linking&period;
| xref:llvm/NonLocalDepEntry.adoc[`NonLocalDepEntry`] 
| This is an entry in the NonLocalDepInfo cache&period;
| xref:llvm/NonLocalDepResult.adoc[`NonLocalDepResult`] 
| This is a result from a NonLocal dependence query&period;
| xref:llvm/NonRelocatableStringpool.adoc[`NonRelocatableStringpool`] 
| A string table that doesn&apos;t need relocations&period;
| xref:llvm/NoopSavedModelImpl.adoc[`NoopSavedModelImpl`] 
| Mock TGen stub for ReleaseModeModelRunner when no AOT model is available&period;
| xref:llvm/NoopStatistic.adoc[`NoopStatistic`] 
| No&hyphen;op statistic used when LLVM&lowbar;ENABLE&lowbar;STATS is off&period;
| xref:llvm/NullableValueCastFailed.adoc[`NullableValueCastFailed`] 
| Provides a declarative `castFailed` that constructs a null `To&period;`
| xref:llvm/NumberedValues.adoc[`NumberedValues`] 
| Mapping from value ID to value, which also remembers what the next unused ID is&period;
| xref:llvm/NumericalStabilitySanitizerPass.adoc[`NumericalStabilitySanitizerPass`] 
| A function pass for nsan instrumentation&period;
| xref:llvm/OProfileWrapper.adoc[`OProfileWrapper`] 
| Wrapper around the OProfile JIT agent API used for testing and reporting&period;
| xref:llvm/ObjCARCContractPass.adoc[`ObjCARCContractPass`] 
| Contract low&hyphen;level ObjC ARC operations into higher&hyphen;level forms late in the pipeline&period;
| xref:llvm/ObjCARCExpandPass.adoc[`ObjCARCExpandPass`] 
| Expand ObjC ARC operations early for later ARC optimizations&period;
| xref:llvm/ObjCARCOptPass.adoc[`ObjCARCOptPass`] 
| Optimize ObjC Automatic Reference Counting retain&sol;release operations&period;
| xref:llvm/ObjCSelectorNames.adoc[`ObjCSelectorNames`] 
| Components of an Objective&hyphen;C method selector name&period;
| xref:llvm/ObjectCache.adoc[`ObjectCache`] 
| Base object&hyphen;file cache for an ExecutionEngine&period;
| xref:llvm/ObjectSizeOffsetEvaluator.adoc[`ObjectSizeOffsetEvaluator`] 
| Evaluate the size and offset of an object pointed to by a Value&ast;&period; May create code to compute the result at run&hyphen;time&period;
| xref:llvm/ObjectSizeOffsetVisitor.adoc[`ObjectSizeOffsetVisitor`] 
| Evaluate the size and offset of an object pointed to by a Value&ast; statically&period; Fails if size or offset are not known at compile time&period;
| xref:llvm/ObjectSizeOpts.adoc[`ObjectSizeOpts`] 
| Various options to control the behavior of getObjectSize&period;
| xref:llvm/OffloadEntriesInfoManager.adoc[`OffloadEntriesInfoManager`] 
| Manager for offload target&hyphen;region and declare&hyphen;target entry metadata&period;
| xref:llvm/OffsetAndUnitID.adoc[`OffsetAndUnitID`] 
| Helper class to identify an entry in DWARF5AccelTable based on their DIE offset and UnitID&period;
| xref:llvm/OffsetSpan.adoc[`OffsetSpan`] 
| OffsetSpan &hyphen; Used internally by `ObjectSizeOffsetVisitor&period;` Represents a point in memory as a pair of allocated bytes before and after it&period;
| xref:llvm/OffsetsTag.adoc[`OffsetsTag`] 
| Tag type that distinguishes offset&hyphen;based string pools from uniquing pools&period;
| xref:llvm/OnDiskChainedHashTable.adoc[`OnDiskChainedHashTable`] 
| Provides lookup on an on disk hash table&period;
| xref:llvm/OnDiskChainedHashTableGenerator.adoc[`OnDiskChainedHashTableGenerator`] 
| Generates an on disk hash table&period;
| xref:llvm/OnDiskIterableChainedHashTable.adoc[`OnDiskIterableChainedHashTable`] 
| Provides lookup and iteration over an on disk hash table&period;
| xref:llvm/OpInit.adoc[`OpInit`] 
| Base class for initializer operators&period;
| xref:llvm/OpenMPIRBuilder.adoc[`OpenMPIRBuilder`] 
| An interface to create LLVM&hyphen;IR for OpenMP directives&period;
| xref:llvm/OpenMPIRBuilderConfig.adoc[`OpenMPIRBuilderConfig`] 
| Configuration affecting OpenMP LLVM&hyphen;IR generation&period;
| xref:llvm/OpenMPOptCGSCCPass.adoc[`OpenMPOptCGSCCPass`] 
| OpenMP optimizations pass operating on a call&hyphen;graph SCC&period;
| xref:llvm/OpenMPOptPass.adoc[`OpenMPOptPass`] 
| OpenMP optimizations pass&period;
| xref:llvm/OperandBundleDefT.adoc[`OperandBundleDefT`] 
| Owned operand bundle definition built from values rather than uses&period;
| xref:llvm/OperandBundleUse.adoc[`OperandBundleUse`] 
| Lightweight view of an operand bundle passed by value&period;
| xref:llvm/OperandTraits-0f9.adoc[`OperandTraits`] 
| Compile&hyphen;time customization of User operands&period;
| xref:llvm/Operator.adoc[`Operator`] 
| This is a utility class that provides an abstraction for the common functionality between Instructions and ConstantExprs&period;
| xref:llvm/OptBisect.adoc[`OptBisect`] 
| Disable passes and optimizations at compile time for bisecting and debugging&period;
| xref:llvm/OptNoneInstrumentation.adoc[`OptNoneInstrumentation`] 
| Instrumentation that skips passes on functions marked `optnone`&period;
| xref:llvm/OptPassGate.adoc[`OptPassGate`] 
| Extensions to this class implement mechanisms to disable passes and individual optimizations at compile time&period;
| xref:llvm/OptPassGateInstrumentation.adoc[`OptPassGateInstrumentation`] 
| Instrumentation that respects `&hyphen;opt&hyphen;bisect&hyphen;limit` and related pass gates&period;
| xref:llvm/OptimizationRemark.adoc[`OptimizationRemark`] 
| Diagnostic information for applied optimization remarks&period;
| xref:llvm/OptimizationRemarkAnalysis.adoc[`OptimizationRemarkAnalysis`] 
| Diagnostic information for optimization analysis remarks&period;
| xref:llvm/OptimizationRemarkAnalysisAliasing.adoc[`OptimizationRemarkAnalysisAliasing`] 
| Diagnostic information for optimization analysis remarks related to pointer aliasing&period;
| xref:llvm/OptimizationRemarkAnalysisFPCommute.adoc[`OptimizationRemarkAnalysisFPCommute`] 
| Diagnostic information for optimization analysis remarks related to floating&hyphen;point non&hyphen;commutativity&period;
| xref:llvm/OptimizationRemarkEmitter.adoc[`OptimizationRemarkEmitter`] 
| The optimization diagnostic interface&period;
| xref:llvm/OptimizationRemarkEmitterAnalysis.adoc[`OptimizationRemarkEmitterAnalysis`] 
| Analysis pass that provides an OptimizationRemarkEmitter&period;
| xref:llvm/OptimizationRemarkEmitterWrapperPass.adoc[`OptimizationRemarkEmitterWrapperPass`] 
| OptimizationRemarkEmitter legacy analysis pass
| xref:llvm/OptimizationRemarkMissed.adoc[`OptimizationRemarkMissed`] 
| Diagnostic information for missed&hyphen;optimization remarks&period;
| xref:llvm/OptimizePHIsPass.adoc[`OptimizePHIsPass`] 
| New PM pass that optimizes machine instruction PHIs&period;
| xref:llvm/OptimizedStructLayoutField.adoc[`OptimizedStructLayoutField`] 
| A field in a structure&period;
| xref:llvm/OptionalOperandTraits-05.adoc[`OptionalOperandTraits`] 
| OptionalOperandTraits &hyphen; when the number of operands may change at runtime&period; Naturally it may only decrease, because the allocations may not change&period;
| xref:llvm/OptionalPassInfoMixin-0246.adoc[`OptionalPassInfoMixin`] 
| A CRTP mix&hyphen;in for passes that can be skipped&period;
| xref:llvm/OptionalValueCast.adoc[`OptionalValueCast`] 
| Cast trait that wraps value casts in `std&colon;&colon;optional&period;`
| xref:llvm/OrderedChangedData.adoc[`OrderedChangedData`] 
| Ordered map of named items used when comparing before&sol;after IR&period;
| xref:llvm/OuterAnalysisManagerProxy.adoc[`OuterAnalysisManagerProxy`] 
| An analysis over an &quot;inner&quot; IR unit that provides access to an outer analysis manager&period;
| xref:llvm/OutlinedHashTree.adoc[`OutlinedHashTree`] 
| A trie of stable hash sequences for outlined instruction sequences&period;
| xref:llvm/OutlinedHashTreeRecord.adoc[`OutlinedHashTreeRecord`] 
| Holds an outlined hash tree for serialization and deserialization&period;
| xref:llvm/OutputCategoryAggregator.adoc[`OutputCategoryAggregator`] 
| Aggregates verification errors and warnings by category for reporting&period;
| xref:llvm/OverflowTracking.adoc[`OverflowTracking`] 
| Accumulates no&hyphen;wrap and related flags across merged instructions&period;
| xref:llvm/OverflowingBinaryOperator.adoc[`OverflowingBinaryOperator`] 
| Binary operator that can signal signed or unsigned overflow&period;
| xref:llvm/OverlapFuncFilters.adoc[`OverlapFuncFilters`] 
| Filters controlling which functions emit overlap information&period;
| xref:llvm/OverlapStats.adoc[`OverlapStats`] 
| Function&hyphen;level or program&hyphen;level profile overlap statistics&period;
| xref:llvm/PAEvalPass.adoc[`PAEvalPass`] 
| Evaluate ObjC ARC provenance analysis results for debugging&period;
| xref:llvm/PBQPRAConstraint.adoc[`PBQPRAConstraint`] 
| Abstract base for classes implementing PBQP register allocation constraints (e&period;g&period; Spill&hyphen;costs, interference, coalescing)&period;
| xref:llvm/PBQPRAConstraintList.adoc[`PBQPRAConstraintList`] 
| PBQP register allocation constraint composer&period;
| xref:llvm/PGOContextualProfile.adoc[`PGOContextualProfile`] 
| The instrumented contextual profile, produced by the CtxProfAnalysis&period;
| xref:llvm/PGOCtxProfContext.adoc[`PGOCtxProfContext`] 
| A mutable node in a loaded contextual profile&period;
| xref:llvm/PGOCtxProfFlatteningPass.adoc[`PGOCtxProfFlatteningPass`] 
| Pass that flattens contextual profiles into MD&lowbar;prof metadata&period;
| xref:llvm/PGOCtxProfLoweringPass.adoc[`PGOCtxProfLoweringPass`] 
| Pass that lowers contextual PGO instrumentation into runtime calls&period;
| xref:llvm/PGOCtxProfile.adoc[`PGOCtxProfile`] 
| Loaded contextual profile&colon; rooted contexts plus flat profiles&period;
| xref:llvm/PGOCtxProfileReader.adoc[`PGOCtxProfileReader`] 
| Reader for contextual PGO profiles stored in bitstream format&period;
| xref:llvm/PGOCtxProfileWriter.adoc[`PGOCtxProfileWriter`] 
| Writer that serializes contextual PGO profiles to a bitstream&period;
| xref:llvm/PGOForceFunctionAttrsPass.adoc[`PGOForceFunctionAttrsPass`] 
| Pass that applies size or optnone attributes to cold functions based on PGO&period;
| xref:llvm/PGOIndirectCallPromotion.adoc[`PGOIndirectCallPromotion`] 
| The indirect function call promotion pass&period;
| xref:llvm/PGOIndirectCallVisitor.adoc[`PGOIndirectCallVisitor`] 
| InstVisitor that collects indirect calls or vtable address instructions&period;
| xref:llvm/PGOInstrumentationGen.adoc[`PGOInstrumentationGen`] 
| The instrumentation (profile&hyphen;instr&hyphen;gen) pass for IR based PGO&period;
| xref:llvm/PGOInstrumentationGenCreateVar.adoc[`PGOInstrumentationGenCreateVar`] 
| The instrumentation (profile&hyphen;instr&hyphen;gen) pass for IR based PGO&period;
| xref:llvm/PGOInstrumentationUse.adoc[`PGOInstrumentationUse`] 
| The profile annotation (profile&hyphen;instr&hyphen;use) pass for IR based PGO&period;
| xref:llvm/PGOMemOPSizeOpt.adoc[`PGOMemOPSizeOpt`] 
| The profile size based optimization pass for memory intrinsics&period;
| xref:llvm/PGOOptions.adoc[`PGOOptions`] 
| A struct capturing PGO tunables&period;
| xref:llvm/PHIEliminationPass.adoc[`PHIEliminationPass`] 
| New PM pass that eliminates machine instruction PHI nodes by inserting copies&period;
| xref:llvm/PHINode.adoc[`PHINode`] 
| PHI node merging values from multiple predecessor blocks&period;
| xref:llvm/PHITransAddr.adoc[`PHITransAddr`] 
| An address value that tracks and handles PHI translation&period;
| xref:llvm/PMDataManager.adoc[`PMDataManager`] 
| PMDataManager provides the common place to manage the analysis data used by pass managers&period;
| xref:llvm/PMStack.adoc[`PMStack`] 
| PMStack &hyphen; This class implements a stack data structure of PMDataManager pointers&period;
| xref:llvm/PMTopLevelManager.adoc[`PMTopLevelManager`] 
| PMTopLevelManager manages LastUser info and collects common APIs used by top level pass managers&period;
| xref:llvm/PSetIterator.adoc[`PSetIterator`] 
| Iterate over the pressure sets affected by a physical or virtual register&period;
| xref:llvm/PackedVector.adoc[`PackedVector`] 
| Store a vector of values using a specific number of bits for each value&period; Both signed and unsigned types can be used, e&period;g
| xref:llvm/PagedVector.adoc[`PagedVector`] 
| A vector that allocates memory in pages&period;
| xref:llvm/ParseInstructionInfo.adoc[`ParseInstructionInfo`] 
| Contextual information passed while parsing a single instruction&period;
| xref:llvm/ParseResult.adoc[`ParseResult`] 
| Success&sol;failure status for parsing&hyphen;style chains using `&verbar;&verbar;&period;`
| xref:llvm/ParseStatus.adoc[`ParseStatus`] 
| Ternary parse status returned by various parse&ast; methods&period;
| xref:llvm/ParsedModuleAndIndex.adoc[`ParsedModuleAndIndex`] 
| Holds the Module and ModuleSummaryIndex returned by the interfaces that parse both&period;
| xref:llvm/ParserCallbacks.adoc[`ParserCallbacks`] 
| Optional callbacks that customize bitcode parsing behavior&period;
| xref:llvm/PartialInlinerPass.adoc[`PartialInlinerPass`] 
| Pass to remove unused function declarations&period;
| xref:llvm/PartiallyInlineLibCallsPass.adoc[`PartiallyInlineLibCallsPass`] 
| Pass that partially inlines the fast path of well&hyphen;known library functions&period;
| xref:llvm/Pass.adoc[`Pass`] 
| Base interface implemented by every LLVM pass&period;
| xref:llvm/PassBuilder.adoc[`PassBuilder`] 
| This class provides access to building LLVM&apos;s passes&period;
| xref:llvm/PassConfigImpl.adoc[`PassConfigImpl`] 
| Opaque implementation details for `TargetPassConfig&period;`
| xref:llvm/PassInfo.adoc[`PassInfo`] 
| Metadata describing a single pass known to the pass registry&period;
| xref:llvm/PassInstrumentation.adoc[`PassInstrumentation`] 
| This class provides instrumentation entry points for the Pass Manager, doing calls to callbacks registered in PassInstrumentationCallbacks&period;
| xref:llvm/PassInstrumentationAnalysis.adoc[`PassInstrumentationAnalysis`] 
| Pseudo&hyphen;analysis pass that exposes the `PassInstrumentation` to pass managers&period;
| xref:llvm/PassInstrumentationCallbacks.adoc[`PassInstrumentationCallbacks`] 
| This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass control to the registered callbacks&period;
| xref:llvm/PassManager-04.adoc[`PassManager`] 
| Manages and runs a sequence of passes over a particular unit of IR&period;
| xref:llvm/PassManagerPrettyStackEntry.adoc[`PassManagerPrettyStackEntry`] 
| PassManagerPrettyStackEntry &hyphen; This is used to print informative information about what pass is running when&sol;if a stack trace is generated&period;
| xref:llvm/PassManagerWrapper.adoc[`PassManagerWrapper`] 
| Wrapper holding module, function, and machine&hyphen;function pass managers&period;
| xref:llvm/PassNameParser.adoc[`PassNameParser`] 
| Command&hyphen;line parser that adds a selectable option for each registered pass&period;
| xref:llvm/PassPlugin.adoc[`PassPlugin`] 
| A loaded pass plugin&period;
| xref:llvm/PassPluginLibraryInfo.adoc[`PassPluginLibraryInfo`] 
| Information about the plugin required to load its passes
| xref:llvm/PassRegistrationListener.adoc[`PassRegistrationListener`] 
| Callback interface notified when passes are registered or enumerated&period;
| xref:llvm/PassRegistry.adoc[`PassRegistry`] 
| Manages registration and initialization of the pass subsystem&period;
| xref:llvm/PatchItem.adoc[`PatchItem`] 
| Describes a deferred patch of uint64&lowbar;t values in an indexed profile stream&period;
| xref:llvm/PatchPointOpers.adoc[`PatchPointOpers`] 
| MI&hyphen;level patchpoint operands&period;
| xref:llvm/PatchableFunctionPass.adoc[`PatchableFunctionPass`] 
| New PM pass that inserts patchable prologue markers for the &quot;patchable&hyphen;function&quot; and &quot;patchable&hyphen;function&hyphen;entry&quot; attributes&period;
| xref:llvm/PatternsForOpcode.adoc[`PatternsForOpcode`] 
| Map from opcode to pattern list by binary search&period;
| xref:llvm/PeelingModuloScheduleExpander.adoc[`PeelingModuloScheduleExpander`] 
| A reimplementation of ModuloScheduleExpander&period; It works by generating a standalone kernel loop and peeling out the prologs and epilogs&period;
| xref:llvm/PeepholeOptimizerPass.adoc[`PeepholeOptimizerPass`] 
| New PM pass that peep&hyphen;hole optimizes machine instructions&period;
| xref:llvm/PerFunctionMIParsingState.adoc[`PerFunctionMIParsingState`] 
| Per&hyphen;function MIR parsing state, including slots and virtual registers&period;
| xref:llvm/PerTargetMIParsingState.adoc[`PerTargetMIParsingState`] 
| Target&hyphen;specific name tables used while parsing MIR machine instructions&period;
| xref:llvm/PhiValues.adoc[`PhiValues`] 
| Class for calculating and caching the underlying values of phis in a function&period;
| xref:llvm/PhiValuesAnalysis.adoc[`PhiValuesAnalysis`] 
| The analysis pass which yields a PhiValues
| xref:llvm/PhiValuesPrinterPass.adoc[`PhiValuesPrinterPass`] 
| A pass for printing the PhiValues for a function&period;
| xref:llvm/PhiValuesWrapperPass.adoc[`PhiValuesWrapperPass`] 
| Wrapper pass for the legacy pass manager
| xref:llvm/PhysRegInfo.adoc[`PhysRegInfo`] 
| Information about how a physical register Reg is used by a set of operands&period;
| xref:llvm/PhysRegSUOper.adoc[`PhysRegSUOper`] 
| Record a physical register access&period; For non&hyphen;data&hyphen;dependent uses, OpIdx &equals;&equals; &hyphen;1&period;
| xref:llvm/PhysicalRegisterUsageAnalysis.adoc[`PhysicalRegisterUsageAnalysis`] 
| Analysis that provides PhysicalRegisterUsageInfo for a module&period;
| xref:llvm/PhysicalRegisterUsageInfo.adoc[`PhysicalRegisterUsageInfo`] 
| Stores physical register usage masks for functions in a module&period;
| xref:llvm/PhysicalRegisterUsageInfoPrinterPass.adoc[`PhysicalRegisterUsageInfoPrinterPass`] 
| Printer pass for the PhysicalRegisterUsageAnalysis results&period;
| xref:llvm/PhysicalRegisterUsageInfoWrapperLegacy.adoc[`PhysicalRegisterUsageInfoWrapperLegacy`] 
| Legacy immutable pass wrapping PhysicalRegisterUsageInfo&period;
| xref:llvm/PiBlockDDGNode.adoc[`PiBlockDDGNode`] 
| DDG node that abstracts a strongly&hyphen;connected component as a pi&hyphen;block&period;
| xref:llvm/PipelineTuningOptions.adoc[`PipelineTuningOptions`] 
| Tunable parameters for passes in the default pipelines&period;
| xref:llvm/PlaceSafepointsPass.adoc[`PlaceSafepointsPass`] 
| Pass that inserts GC safepoints into IR at call sites, entries, and loops&period;
| xref:llvm/PluginInlineAdvisorAnalysis.adoc[`PluginInlineAdvisorAnalysis`] 
| Used for dynamically registering InlineAdvisors as plugins
| xref:llvm/PluginInlineOrderAnalysis.adoc[`PluginInlineOrderAnalysis`] 
| Used for dynamically loading instances of InlineOrder as plugins
| xref:llvm/PluginLoader.adoc[`PluginLoader`] 
| Loads shared&hyphen;object plugins into a tool via the `&hyphen;load` option&period;
| xref:llvm/PointerDiffInfo.adoc[`PointerDiffInfo`] 
| Diff&hyphen;check operands for proving independence via pointer differences&period;
| xref:llvm/PointerEmbeddedInt.adoc[`PointerEmbeddedInt`] 
| Utility to embed an integer into a pointer&hyphen;like type&period;
| xref:llvm/PointerIntPair-03.adoc[`PointerIntPair`] 
| A pointer and a small integer packed into the space of one pointer&period;
| xref:llvm/PointerIntPairInfo.adoc[`PointerIntPairInfo`] 
| Helpers that pack and unpack pointer&sol;integer bits for PointerIntPair&period;
| xref:llvm/PointerLikeTypeTraits-09.adoc[`PointerLikeTypeTraits`] 
| A traits type that is used to handle pointer types and things that are just wrappers for pointers as a uniform entity&period;
| xref:llvm/PointerSumType.adoc[`PointerSumType`] 
| A sum type over pointer&hyphen;like types&period;
| xref:llvm/PointerSumTypeMember.adoc[`PointerSumTypeMember`] 
| A tagged pointer&hyphen;like type bound to a discriminant within a sum type&period;
| xref:llvm/PointerType.adoc[`PointerType`] 
| Class to represent pointers&period;
| xref:llvm/PointerUnion.adoc[`PointerUnion`] 
| A discriminated union of two or more pointer types, with the discriminator in the low bits of the pointer&period;
| xref:llvm/PoisonFlags.adoc[`PoisonFlags`] 
| Captures poison&hyphen;generating flags from an instruction so they can be restored&period;
| xref:llvm/PoisonValue.adoc[`PoisonValue`] 
| Constant representing a poison value used for deferred undefined behavior&period;
| xref:llvm/PoisoningVH.adoc[`PoisoningVH`] 
| Value handle that poisons itself if the Value is deleted&period;
| xref:llvm/PolynomialInfo.adoc[`PolynomialInfo`] 
| Result returned when a polynomial algorithm is recognized by the analysis&period;
| xref:llvm/PossiblyDisjointInst.adoc[`PossiblyDisjointInst`] 
| Binary OR instruction that may be marked disjoint&period;
| xref:llvm/PossiblyExactOperator.adoc[`PossiblyExactOperator`] 
| A udiv, sdiv, lshr, or ashr instruction, which can be marked as &quot;exact&quot;, indicating that no bits are destroyed&period;
| xref:llvm/PossiblyNonNegInst.adoc[`PossiblyNonNegInst`] 
| Cast instruction that may carry a non&hyphen;negative flag&period;
| xref:llvm/PostDomOnlyPrinter.adoc[`PostDomOnlyPrinter`] 
| Pass that writes a function post&hyphen;dominator tree without block bodies&period;
| xref:llvm/PostDomOnlyViewer.adoc[`PostDomOnlyViewer`] 
| Pass that displays a function post&hyphen;dominator tree without block bodies&period;
| xref:llvm/PostDomPrinter.adoc[`PostDomPrinter`] 
| Pass that writes a function post&hyphen;dominator tree to a DOT file&period;
| xref:llvm/PostDomViewer.adoc[`PostDomViewer`] 
| Pass that displays a function post&hyphen;dominator tree in a Graphviz viewer&period;
| xref:llvm/PostDominatorTree.adoc[`PostDominatorTree`] 
| PostDominatorTree Class &hyphen; Concrete subclass of DominatorTree that is used to compute the post&hyphen;dominator tree&period;
| xref:llvm/PostDominatorTreeAnalysis.adoc[`PostDominatorTreeAnalysis`] 
| Analysis pass which computes a `PostDominatorTree&period;`
| xref:llvm/PostDominatorTreePrinterPass.adoc[`PostDominatorTreePrinterPass`] 
| Printer pass for the `PostDominatorTree&period;`
| xref:llvm/PostDominatorTreeWrapperPass.adoc[`PostDominatorTreeWrapperPass`] 
| Legacy analysis pass which computes a `PostDominatorTree&period;`
| xref:llvm/PostGenericScheduler.adoc[`PostGenericScheduler`] 
| Post&hyphen;RA generic scheduler driven by ScheduleDAGMI callbacks&period;
| xref:llvm/PostMachineSchedulerPass.adoc[`PostMachineSchedulerPass`] 
| New PM pass that runs the post&hyphen;RA machine instruction scheduler&period;
| xref:llvm/PostOrderExtTraversal.adoc[`PostOrderExtTraversal`] 
| Post&hyphen;order traversal using an external visited set&period;
| xref:llvm/PostOrderFunctionAttrsPass.adoc[`PostOrderFunctionAttrsPass`] 
| Computes function attributes in post&hyphen;order over the call graph&period;
| xref:llvm/PostOrderTraversal.adoc[`PostOrderTraversal`] 
| Post&hyphen;order traversal of a graph&period;
| xref:llvm/PostOrderTraversalBase-0b.adoc[`PostOrderTraversalBase`] 
| CRTP base for a single post&hyphen;order graph walk&period;
| xref:llvm/PostRAHazardRecognizerPass.adoc[`PostRAHazardRecognizerPass`] 
| New PM pass that runs the post&hyphen;RA hazard recognizer and emits noops&period;
| xref:llvm/PostRAMachineSinkingPass.adoc[`PostRAMachineSinkingPass`] 
| New PM pass that sinks copy instructions after register allocation&period;
| xref:llvm/PostRASchedulerPass.adoc[`PostRASchedulerPass`] 
| New PM pass that performs post&hyphen;register&hyphen;allocation instruction scheduling&period;
| xref:llvm/PotentialValuesState-06.adoc[`PotentialValuesState`] 
| Set&hyphen;based abstract state for potential values&period;
| xref:llvm/PreISelIntrinsicLoweringPass.adoc[`PreISelIntrinsicLoweringPass`] 
| Pass that lowers selected intrinsics before instruction selection&period;
| xref:llvm/PredIterator.adoc[`PredIterator`] 
| Forward iterator over the predecessor basic blocks of a block, discovered by walking users of the block that are terminator instructions&period;
| xref:llvm/PredIteratorCache.adoc[`PredIteratorCache`] 
| Extremely trivial cache for predecessor iterator queries&period;
| xref:llvm/PredicateAssume.adoc[`PredicateAssume`] 
| Predicate information for llvm&period;assume intrinsics&period;
| xref:llvm/PredicateBase.adoc[`PredicateBase`] 
| Base class for all predicate information we provide&period;
| xref:llvm/PredicateBranch.adoc[`PredicateBranch`] 
| Predicate information for conditional branches&period;
| xref:llvm/PredicateBundleAssume.adoc[`PredicateBundleAssume`] 
| Predicate information from an llvm&period;assume operand&hyphen;bundle attribute&period;
| xref:llvm/PredicateConditionAssume.adoc[`PredicateConditionAssume`] 
| Predicate information from the boolean condition of an llvm&period;assume&period;
| xref:llvm/PredicateConstraint.adoc[`PredicateConstraint`] 
| Constraint for a predicate of the form &quot;cmp Pred Op, OtherOp&quot;, where Op is the value the constraint applies to (the bitcast result)&period;
| xref:llvm/PredicateInfo.adoc[`PredicateInfo`] 
| Encapsulates PredicateInfo, including all data associated with memory accesses&period;
| xref:llvm/PredicateInfoAnnotatedWriter.adoc[`PredicateInfoAnnotatedWriter`] 
| Annotated writer that attaches PredicateInfo to IR assembly dumps&period;
| xref:llvm/PredicateInfoBuilder.adoc[`PredicateInfoBuilder`] 
| Builds PredicateInfo by analyzing branches, switches, and assumes&period;
| xref:llvm/PredicateInfoPrinterPass.adoc[`PredicateInfoPrinterPass`] 
| Printer pass for `PredicateInfo&period;`
| xref:llvm/PredicateInfoVerifierPass.adoc[`PredicateInfoVerifierPass`] 
| Verifier pass for `PredicateInfo&period;`
| xref:llvm/PredicateSwitch.adoc[`PredicateSwitch`] 
| Predicate information for a switch case edge&period;
| xref:llvm/PredicateWithEdge.adoc[`PredicateWithEdge`] 
| Mixin for predicates that hold along a CFG edge&period;
| xref:llvm/PredicatedScalarEvolution.adoc[`PredicatedScalarEvolution`] 
| Interface that views SCEV expressions under a growing set of predicates&period;
| xref:llvm/PreferredTuple.adoc[`PreferredTuple`] 
| Preferred candidate for an extending&hyphen;load combine&period;
| xref:llvm/PrefetchHint.adoc[`PrefetchHint`] 
| Prefetch hint targeting a callsite in a named function&period;
| xref:llvm/PreservedAnalyses.adoc[`PreservedAnalyses`] 
| A set of analyses that are preserved following a run of a transformation pass&period;
| xref:llvm/PreservedCFGCheckerInstrumentation.adoc[`PreservedCFGCheckerInstrumentation`] 
| Instrumentation that verifies CFG structure is preserved across passes&period;
| xref:llvm/PreservedCastFlags.adoc[`PreservedCastFlags`] 
| Cast flags that can be preserved by a lossless inverse cast&period;
| xref:llvm/PressureChange.adoc[`PressureChange`] 
| Change in pressure for a single pressure set&period;
| xref:llvm/PressureDiff.adoc[`PressureDiff`] 
| List of PressureChanges in order of increasing, unique PSetID&period;
| xref:llvm/PressureDiffs.adoc[`PressureDiffs`] 
| Array of PressureDiffs&period;
| xref:llvm/PrettyStackTraceEntry.adoc[`PrettyStackTraceEntry`] 
| A frame of the &quot;pretty&quot; stack trace dumped when a program crashes&period;
| xref:llvm/PrettyStackTraceFormat.adoc[`PrettyStackTraceFormat`] 
| Pretty stack&hyphen;trace entry that prints a printf&hyphen;style formatted string&period;
| xref:llvm/PrettyStackTraceProgram.adoc[`PrettyStackTraceProgram`] 
| PrettyStackTraceProgram &hyphen; This object prints a specified program arguments to the stream as the stack trace when a crash occurs&period;
| xref:llvm/PrettyStackTraceString.adoc[`PrettyStackTraceString`] 
| PrettyStackTraceString &hyphen; This object prints a specified string (which should not contain newlines) to the stream as the stack trace when a crash occurs&period;
| xref:llvm/PrintCrashIRInstrumentation.adoc[`PrintCrashIRInstrumentation`] 
| Instrumentation that dumps the last IR seen when the process crashes&period;
| xref:llvm/PrintFunctionPass.adoc[`PrintFunctionPass`] 
| Pass (for the new pass manager) for printing a Function as LLVM&apos;s text IR assembly&period;
| xref:llvm/PrintIRInstrumentation.adoc[`PrintIRInstrumentation`] 
| Instrumentation to print IR before&sol;after passes&period;
| xref:llvm/PrintLoopPass.adoc[`PrintLoopPass`] 
| Pass for printing a loop&apos;s contents as textual IR&period;
| xref:llvm/PrintMIRPass.adoc[`PrintMIRPass`] 
| Pass that prints a machine function in the MIR serialization format&period;
| xref:llvm/PrintMIRPreparePass.adoc[`PrintMIRPreparePass`] 
| Pass that prints LLVM IR of a module in the MIR serialization format&period;
| xref:llvm/PrintModulePass.adoc[`PrintModulePass`] 
| Pass (for the new pass manager) for printing a Module as LLVM&apos;s text IR assembly&period;
| xref:llvm/PrintPassInstrumentation.adoc[`PrintPassInstrumentation`] 
| Debug logging for transformation and analysis passes&period;
| xref:llvm/PrintPassOptions.adoc[`PrintPassOptions`] 
| Options controlling what PrintPassInstrumentation prints&period;
| xref:llvm/PrintPipelinePassesFormatParser.adoc[`PrintPipelinePassesFormatParser`] 
| Command&hyphen;line parser for `PrintPipelinePassesFormat` option values&period;
| xref:llvm/Printable.adoc[`Printable`] 
| Simple wrapper around std&colon;&colon;function&lt;void(raw&lowbar;ostream&amp;)&gt;&period; This class is useful to construct print helpers for raw&lowbar;ostream&period;
| xref:llvm/PriorityQueue.adoc[`PriorityQueue`] 
| PriorityQueue &hyphen; This class behaves like std&colon;&colon;priority&lowbar;queue and provides a few additional convenience functions&period;
| xref:llvm/PriorityWorklist.adoc[`PriorityWorklist`] 
| A FILO worklist that prioritizes on re&hyphen;insertion without duplication&period;
| xref:llvm/ProcessImplicitDefsPass.adoc[`ProcessImplicitDefsPass`] 
| New PM pass that processes IMPLICIT&lowbar;DEF instructions&period;
| xref:llvm/ProfOStream.adoc[`ProfOStream`] 
| Profile writer stream that supports deferred byte&hyphen;level back&hyphen;patching&period;
| xref:llvm/ProfiParams.adoc[`ProfiParams`] 
| Thresholds and options for the profile inference algorithm&period;
| xref:llvm/ProfileAnnotator.adoc[`ProfileAnnotator`] 
| Propagates contextual profile counters onto basic blocks and CFG edges&period;
| xref:llvm/ProfileAnnotatorImpl.adoc[`ProfileAnnotatorImpl`] 
| Implementation details for `ProfileAnnotator&period;`
| xref:llvm/ProfileInjectorPass.adoc[`ProfileInjectorPass`] 
| Inject MD&lowbar;prof metadata where it&apos;s missing&period; Used for testing that passes don&apos;t accidentally drop this metadata&period;
| xref:llvm/ProfileSummary.adoc[`ProfileSummary`] 
| Aggregated profile summary statistics for a module or compilation unit&period;
| xref:llvm/ProfileSummaryAnalysis.adoc[`ProfileSummaryAnalysis`] 
| An analysis pass based on the new PM to deliver ProfileSummaryInfo&period;
| xref:llvm/ProfileSummaryBuilder.adoc[`ProfileSummaryBuilder`] 
| Base builder that accumulates profile counts and computes a ProfileSummary&period;
| xref:llvm/ProfileSummaryEntry.adoc[`ProfileSummaryEntry`] 
| One percentile cut&hyphen;point entry in a profile summary&period;
| xref:llvm/ProfileSummaryInfo.adoc[`ProfileSummaryInfo`] 
| Analysis providing profile information&period;
| xref:llvm/ProfileSummaryInfoWrapperPass.adoc[`ProfileSummaryInfoWrapperPass`] 
| An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo&period;
| xref:llvm/ProfileSummaryPrinterPass.adoc[`ProfileSummaryPrinterPass`] 
| Printer pass that uses `ProfileSummaryAnalysis&period;`
| xref:llvm/ProfileVerifierPass.adoc[`ProfileVerifierPass`] 
| Pass that verifies MD&lowbar;prof is present on every instruction that supports it&period;
| xref:llvm/PrologEpilogInserterPass.adoc[`PrologEpilogInserterPass`] 
| New PM pass that inserts function prologs and epilogs&period;
| xref:llvm/PromotePass.adoc[`PromotePass`] 
| Pass that promotes memory allocas to SSA registers via PromoteMemToReg&period;
| xref:llvm/PseudoProbe.adoc[`PseudoProbe`] 
| Decoded pseudo probe attached to an instruction&period;
| xref:llvm/PseudoProbeDescriptor.adoc[`PseudoProbeDescriptor`] 
| Descriptor pairing a function GUID with its structural hash for pseudo probes&period;
| xref:llvm/PseudoProbeDwarfDiscriminator.adoc[`PseudoProbeDwarfDiscriminator`] 
| Helpers that pack and unpack pseudo probe fields in a DWARF discriminator&period;
| xref:llvm/PseudoProbeHandler.adoc[`PseudoProbeHandler`] 
| Emits pseudo&hyphen;probe records with embedded inline context for an AsmPrinter&period;
| xref:llvm/PseudoProbeInst.adoc[`PseudoProbeInst`] 
| Wrapper for the llvm&period;pseudoprobe intrinsic&period;
| xref:llvm/PseudoProbeManager.adoc[`PseudoProbeManager`] 
| Correlates sample counts with pseudo probes for SampleProfileLoader&period;
| xref:llvm/PseudoProbeSDNode.adoc[`PseudoProbeSDNode`] 
| Pseudo&hyphen;probe SDNode holding function guid and block index&period;
| xref:llvm/PseudoProbeUpdatePass.adoc[`PseudoProbeUpdatePass`] 
| Pseudo probe distribution factor updater&period;
| xref:llvm/PseudoProbeVerifier.adoc[`PseudoProbeVerifier`] 
| Pseudo probe verifier&period;
| xref:llvm/PseudoSourceValue.adoc[`PseudoSourceValue`] 
| Special value supplied for machine level alias analysis&period;
| xref:llvm/PseudoSourceValueManager.adoc[`PseudoSourceValueManager`] 
| Manages creation of pseudo source values&period;
| xref:llvm/PtrAddChain.adoc[`PtrAddChain`] 
| Folded immediate G&lowbar;PTR&lowbar;ADD chain match info&period;
| xref:llvm/PtrToAddr.adoc[`PtrToAddr`] 
| Incomplete type befriended for ptrtoaddr constant&hyphen;expression access&period;
| xref:llvm/PtrToAddrInst.adoc[`PtrToAddrInst`] 
| Instruction that casts a pointer to a non&hyphen;capturing address integer&period;
| xref:llvm/PtrToAddrOperator.adoc[`PtrToAddrOperator`] 
| Concrete operator for the PtrToAddr instruction opcode&period;
| xref:llvm/PtrToInt.adoc[`PtrToInt`] 
| Incomplete type befriended for ptrtoint constant&hyphen;expression access&period;
| xref:llvm/PtrToIntInst.adoc[`PtrToIntInst`] 
| Instruction that casts a pointer to an integer&period;
| xref:llvm/PtrToIntOperator.adoc[`PtrToIntOperator`] 
| Concrete operator for the PtrToInt instruction opcode&period;
| xref:llvm/PtrUseVisitor.adoc[`PtrUseVisitor`] 
| A base class for visitors over the uses of a pointer value&period;
| xref:llvm/RAGreedy.adoc[`RAGreedy`] 
| Greedy register allocator that provides analysis state to advisors&period;
| xref:llvm/RAIIDelegateInstaller.adoc[`RAIIDelegateInstaller`] 
| A simple RAII based Delegate installer&period; Use this in a scope to install a delegate to the MachineFunction and reset it at the end of the scope&period;
| xref:llvm/RAIIMFObsDelInstaller.adoc[`RAIIMFObsDelInstaller`] 
| Class to install both of the above&period;
| xref:llvm/RAIIMFObserverInstaller.adoc[`RAIIMFObserverInstaller`] 
| A simple RAII based Observer installer&period; Use this in a scope to install the Observer to the MachineFunction and reset it at the end of the scope&period;
| xref:llvm/RAIITemporaryObserverInstaller.adoc[`RAIITemporaryObserverInstaller`] 
| A simple RAII based Observer installer&period; Use this in a scope to install the Observer to the MachineFunction and reset it at the end of the scope&period;
| xref:llvm/RCToken.adoc[`RCToken`] 
| A single token from a Windows resource (&period;rc) script&period;
| xref:llvm/RGPassManager.adoc[`RGPassManager`] 
| The pass manager to schedule RegionPasses&period;
| xref:llvm/RISCVAttributeParser.adoc[`RISCVAttributeParser`] 
| Parser for RISCV ELF build attributes&period;
| xref:llvm/RISCVISAInfo.adoc[`RISCVISAInfo`] 
| Parsed RISC&hyphen;V ISA extension set and derived length properties&period;
| xref:llvm/RNSuccIterator-05.adoc[`RNSuccIterator`] 
| Hierarchical RegionNode successor iterator&period;
| xref:llvm/RTDyldMemoryManager.adoc[`RTDyldMemoryManager`] 
| Memory manager and symbol resolver for RuntimeDyld and MCJIT clients&period;
| xref:llvm/RTTIExtends-063.adoc[`RTTIExtends`] 
| Inheritance utility for extensible RTTI&period;
| xref:llvm/RTTIRoot.adoc[`RTTIRoot`] 
| Base class for the extensible RTTI hierarchy&period;
| xref:llvm/RVYCapabilityFormat.adoc[`RVYCapabilityFormat`] 
| RISC&hyphen;V Y (CHERI) compressed capability format&period;
| xref:llvm/RadixTree.adoc[`RadixTree`] 
| A Radix Tree implementation&period;
| xref:llvm/RandomIRBuilder.adoc[`RandomIRBuilder`] 
| Helper for selecting and creating IR values while fuzzing&period;
| xref:llvm/RandomNumberGenerator.adoc[`RandomNumberGenerator`] 
| A random number generator&period;
| xref:llvm/RangeListEntry.adoc[`RangeListEntry`] 
| A class representing a single range list entry&period;
| xref:llvm/RawInstrProfReader.adoc[`RawInstrProfReader`] 
| Reader for the raw instrprof binary format from runtime&period;
| xref:llvm/RawLocationWrapper.adoc[`RawLocationWrapper`] 
| Lightweight class that wraps the location operand metadata of a debug intrinsic&period; The raw location may be a ValueAsMetadata, an empty MDTuple, or a DIArgList&period;
| xref:llvm/ReachingDef.adoc[`ReachingDef`] 
| Thin wrapper around an int encoding a reaching definition&period;
| xref:llvm/ReachingDefAnalysis.adoc[`ReachingDefAnalysis`] 
| Analysis pass that computes `ReachingDefInfo` for a machine function&period;
| xref:llvm/ReachingDefInfo.adoc[`ReachingDefInfo`] 
| This class provides the reaching def analysis&period;
| xref:llvm/ReachingDefInfoWrapperPass.adoc[`ReachingDefInfoWrapperPass`] 
| Legacy pass wrapper for ReachingDefInfo&period;
| xref:llvm/ReachingDefPrinterPass.adoc[`ReachingDefPrinterPass`] 
| Printer pass for the `ReachingDefInfo` results&period;
| xref:llvm/ReadyQueue.adoc[`ReadyQueue`] 
| Vector of ready SUnits with helpers for push and remove&period;
| xref:llvm/RealtimeSanitizerPass.adoc[`RealtimeSanitizerPass`] 
| Create ctor and init functions&period;
| xref:llvm/ReassociatePass.adoc[`ReassociatePass`] 
| Reassociate commutative expressions&period;
| xref:llvm/RecTy.adoc[`RecTy`] 
| Represents a TableGen type&period;
| xref:llvm/RecomputeGlobalsAAPass.adoc[`RecomputeGlobalsAAPass`] 
| Pass that clears and recomputes a cached GlobalsAA result&period;
| xref:llvm/Record.adoc[`Record`] 
| Represents a TableGen class or definition&period;
| xref:llvm/RecordAccessor.adoc[`RecordAccessor`] 
| Accessor for stackmap records&period;
| xref:llvm/RecordKeeper.adoc[`RecordKeeper`] 
| Owns and indexes the records parsed from a TableGen input&period;
| xref:llvm/RecordRecTy.adoc[`RecordRecTy`] 
| &apos;&lsqb;classname&rsqb;&apos; &hyphen; Type of record values that have zero or more superclasses&period;
| xref:llvm/RecordResolver.adoc[`RecordResolver`] 
| Resolve all variables from a record except for unset variables&period;
| xref:llvm/RecordVal.adoc[`RecordVal`] 
| This class represents a field in a record, including its name, type, value, and source location&period;
| xref:llvm/RecurrenceDescriptor.adoc[`RecurrenceDescriptor`] 
| This struct holds information about recurrence variables&period;
| xref:llvm/Recycler.adoc[`Recycler`] 
| Recycler &hyphen; This class manages a linked&hyphen;list of deallocated nodes and facilitates reusing deallocated memory in place of allocating new memory&period;
| xref:llvm/RecyclingAllocator.adoc[`RecyclingAllocator`] 
| RecyclingAllocator &hyphen; This class wraps an Allocator, adding the functionality of recycling deleted objects&period;
| xref:llvm/RedundantDbgInstEliminationPass.adoc[`RedundantDbgInstEliminationPass`] 
| Pass that removes redundant debug instructions from a function&period;
| xref:llvm/RefCountedBase-0d.adoc[`RefCountedBase`] 
| A CRTP mixin class that adds reference counting to a type&period;
| xref:llvm/RegAllocEvictionAdvisor.adoc[`RegAllocEvictionAdvisor`] 
| Interface to the eviction advisor for choosing live ranges to evict&period;
| xref:llvm/RegAllocEvictionAdvisorAnalysis.adoc[`RegAllocEvictionAdvisorAnalysis`] 
| MachineFunction analysis that lazily provides the eviction advisor&period;
| xref:llvm/RegAllocEvictionAdvisorAnalysisLegacy.adoc[`RegAllocEvictionAdvisorAnalysisLegacy`] 
| Immutable analysis that provides the eviction advisor&period;
| xref:llvm/RegAllocEvictionAdvisorProvider.adoc[`RegAllocEvictionAdvisorProvider`] 
| Common provider for legacy and new pass managers&period;
| xref:llvm/RegAllocFastPass.adoc[`RegAllocFastPass`] 
| New PM pass that performs fast (local) register allocation&period;
| xref:llvm/RegAllocPriorityAdvisor.adoc[`RegAllocPriorityAdvisor`] 
| Interface to the priority advisor, which is responsible for prioritizing live ranges&period;
| xref:llvm/RegAllocPriorityAdvisorAnalysis.adoc[`RegAllocPriorityAdvisorAnalysis`] 
| MachineFunction analysis that lazily provides the priority advisor&period;
| xref:llvm/RegAllocPriorityAdvisorAnalysisLegacy.adoc[`RegAllocPriorityAdvisorAnalysisLegacy`] 
| Immutable analysis that provides the priority advisor&period;
| xref:llvm/RegAllocPriorityAdvisorProvider.adoc[`RegAllocPriorityAdvisorProvider`] 
| Common provider for getting the priority advisor and logging rewards&period;
| xref:llvm/RegAllocTypeParser.adoc[`RegAllocTypeParser`] 
| Command&hyphen;line parser mapping allocator names to `RegAllocType&period;`
| xref:llvm/RegBankSelectLegacy.adoc[`RegBankSelectLegacy`] 
| Legacy pass that assigns register banks to generic virtual registers&period;
| xref:llvm/RegBankSelectPass.adoc[`RegBankSelectPass`] 
| New PM pass that assigns register banks to generic virtual registers&period;
| xref:llvm/RegClassWeight.adoc[`RegClassWeight`] 
| Each TargetRegisterClass has a per register weight, and weight limit which must be less than the limits of its pressure sets&period;
| xref:llvm/RegImmPair.adoc[`RegImmPair`] 
| Pair of a register and an immediate offset&period;
| xref:llvm/RegOrConstant.adoc[`RegOrConstant`] 
| Represents a value which can be a Register or a constant&period;
| xref:llvm/RegPressureDelta.adoc[`RegPressureDelta`] 
| Store the effects of a change in pressure on things that MI scheduler cares about&period;
| xref:llvm/RegPressureTracker.adoc[`RegPressureTracker`] 
| Tracker for register pressure at a position in the instruction stream&period;
| xref:llvm/RegScavenger.adoc[`RegScavenger`] 
| Tracks register liveness and scavenges free registers by spilling&period;
| xref:llvm/RegToMemPass.adoc[`RegToMemPass`] 
| Pass that demotes registers to memory allocas&period;
| xref:llvm/RegUsageInfoCollectorPass.adoc[`RegUsageInfoCollectorPass`] 
| New PM pass that collects physical register usage for IPRA&period;
| xref:llvm/RegUsageInfoPropagationPass.adoc[`RegUsageInfoPropagationPass`] 
| New PM pass that propagates callee register usage masks onto call sites&period;
| xref:llvm/Regex.adoc[`Regex`] 
| POSIX regular expression matcher&period;
| xref:llvm/Region.adoc[`Region`] 
| A single entry single exit Region in an LLVM IR Function&period;
| xref:llvm/RegionBase-0e.adoc[`RegionBase`] 
| A single&hyphen;entry single&hyphen;exit region in a control&hyphen;flow graph&period;
| xref:llvm/RegionInfo.adoc[`RegionInfo`] 
| Analysis result that detects all canonical Regions in a Function&period;
| xref:llvm/RegionInfoAnalysis.adoc[`RegionInfoAnalysis`] 
| Analysis pass that exposes the `RegionInfo` for a function&period;
| xref:llvm/RegionInfoBase-09.adoc[`RegionInfoBase`] 
| Analysis that detects all canonical regions in a function&period;
| xref:llvm/RegionInfoPass.adoc[`RegionInfoPass`] 
| Legacy analysis pass which computes a `RegionInfo&period;`
| xref:llvm/RegionInfoPrinterPass.adoc[`RegionInfoPrinterPass`] 
| Printer pass for the `RegionInfo&period;`
| xref:llvm/RegionInfoVerifierPass.adoc[`RegionInfoVerifierPass`] 
| Verifier pass for the `RegionInfo&period;`
| xref:llvm/RegionNode.adoc[`RegionNode`] 
| A RegionNode that holds a BasicBlock or subregion in an LLVM IR Function&period;
| xref:llvm/RegionNodeBase-00.adoc[`RegionNodeBase`] 
| A region node that holds a basic block or a nested subregion&period;
| xref:llvm/RegionPass.adoc[`RegionPass`] 
| A pass that runs on each Region in a function&period;
| xref:llvm/RegionPressure.adoc[`RegionPressure`] 
| Register pressure computed over an iterator&hyphen;delimited instruction region&period;
| xref:llvm/RegionTraits-02.adoc[`RegionTraits`] 
| Traits used to specialize RegionInfo for different IR kinds&period;
| xref:llvm/Register.adoc[`Register`] 
| Wrapper class representing virtual and physical registers&period; Should be passed by value&period;
| xref:llvm/RegisterAsmPrinter.adoc[`RegisterAsmPrinter`] 
| RegisterAsmPrinter &hyphen; Helper template for registering a target specific assembly printer, for use in the target machine initialization function&period; Usage&colon;
| xref:llvm/RegisterBank.adoc[`RegisterBank`] 
| This class implements the register bank concept&period; Two instances of RegisterBank must have different ID&period; This property is enforced by the RegisterBankInfo class&period;
| xref:llvm/RegisterBankInfo.adoc[`RegisterBankInfo`] 
| Only the RegisterBankInfo can initialize RegisterBank properly&period;
| xref:llvm/RegisterClassInfo.adoc[`RegisterClassInfo`] 
| Provides dynamic information about target register classes for a function&period;
| xref:llvm/RegisterCoalescerPass.adoc[`RegisterCoalescerPass`] 
| New PM pass that coalesces copy&hyphen;related virtual registers&period;
| xref:llvm/RegisterImmPair.adoc[`RegisterImmPair`] 
| Pair of a register and an immediate used by shift&sol;ptradd combines&period;
| xref:llvm/RegisterMCAsmBackend.adoc[`RegisterMCAsmBackend`] 
| RegisterMCAsmBackend &hyphen; Helper template for registering a target specific assembler backend&period; Usage&colon;
| xref:llvm/RegisterMCAsmInfo.adoc[`RegisterMCAsmInfo`] 
| Helper template for registering a target assembly info implementation&period;
| xref:llvm/RegisterMCAsmInfoFn.adoc[`RegisterMCAsmInfoFn`] 
| RegisterMCAsmInfoFn &hyphen; Helper template for registering a target assembly info implementation&period; This invokes the specified function to do the construction&period; Usage&colon;
| xref:llvm/RegisterMCAsmParser.adoc[`RegisterMCAsmParser`] 
| RegisterMCAsmParser &hyphen; Helper template for registering a target specific assembly parser, for use in the target machine initialization function&period; Usage&colon;
| xref:llvm/RegisterMCCodeEmitter.adoc[`RegisterMCCodeEmitter`] 
| RegisterMCCodeEmitter &hyphen; Helper template for registering a target specific machine code emitter, for use in the target initialization function&period; Usage&colon;
| xref:llvm/RegisterMCInstrAnalysis.adoc[`RegisterMCInstrAnalysis`] 
| Helper template for registering a target instruction analyzer implementation&period;
| xref:llvm/RegisterMCInstrAnalysisFn.adoc[`RegisterMCInstrAnalysisFn`] 
| Helper template for registering a target instruction analyzer implementation&period;
| xref:llvm/RegisterMCInstrInfo.adoc[`RegisterMCInstrInfo`] 
| Helper template for registering a target instruction info implementation&period;
| xref:llvm/RegisterMCInstrInfoFn.adoc[`RegisterMCInstrInfoFn`] 
| Helper template for registering a target instruction info implementation&period;
| xref:llvm/RegisterMCObjectFileInfo.adoc[`RegisterMCObjectFileInfo`] 
| Helper template for registering a target object file info implementation&period;
| xref:llvm/RegisterMCObjectFileInfoFn.adoc[`RegisterMCObjectFileInfoFn`] 
| Helper template for registering a target object file info implementation&period; This invokes the specified function to do the construction&period; Usage&colon;
| xref:llvm/RegisterMCRegInfo.adoc[`RegisterMCRegInfo`] 
| Helper template for registering a target register info implementation&period;
| xref:llvm/RegisterMCRegInfoFn.adoc[`RegisterMCRegInfoFn`] 
| RegisterMCRegInfoFn &hyphen; Helper template for registering a target register info implementation&period; This invokes the specified function to do the construction&period; Usage&colon;
| xref:llvm/RegisterMCSubtargetInfo.adoc[`RegisterMCSubtargetInfo`] 
| Helper template for registering a target subtarget info implementation&period;
| xref:llvm/RegisterMCSubtargetInfoFn.adoc[`RegisterMCSubtargetInfoFn`] 
| Helper template for registering a target subtarget info implementation&period;
| xref:llvm/RegisterMaskSDNode.adoc[`RegisterMaskSDNode`] 
| SDNode holding a register mask bitvector&period;
| xref:llvm/RegisterOperands.adoc[`RegisterOperands`] 
| List of registers defined and used by a machine instruction&period;
| xref:llvm/RegisterPassParser.adoc[`RegisterPassParser`] 
| RegisterPassParser class &hyphen; Handle the addition of new machine passes&period;
| xref:llvm/RegisterPressure.adoc[`RegisterPressure`] 
| Base class for register pressure results&period;
| xref:llvm/RegisterRegAlloc.adoc[`RegisterRegAlloc`] 
| Registry node that tracks registration of register allocator passes&period;
| xref:llvm/RegisterRegAllocBase-04.adoc[`RegisterRegAllocBase`] 
| RegisterRegAllocBase class &hyphen; Track the registration of register allocators&period;
| xref:llvm/RegisterSDNode.adoc[`RegisterSDNode`] 
| SDNode representing a virtual or physical register&period;
| xref:llvm/RegisterScheduler.adoc[`RegisterScheduler`] 
| Registry node that tracks registration of SelectionDAG instruction schedulers&period;
| xref:llvm/RegisterTarget.adoc[`RegisterTarget`] 
| RegisterTarget &hyphen; Helper template for registering a target, for use in the target&apos;s initialization function&period; Usage&colon;
| xref:llvm/RegisterTargetMachine.adoc[`RegisterTargetMachine`] 
| RegisterTargetMachine &hyphen; Helper template for registering a target machine implementation, for use in the target machine initialization function&period; Usage&colon;
| xref:llvm/RegisterTargetPassConfigCallback.adoc[`RegisterTargetPassConfigCallback`] 
| RAII helper that registers a `PassConfigCallback` in the global registry&period;
| xref:llvm/Registry.adoc[`Registry`] 
| A linker&hyphen;supported registry of pluggable component factories&period;
| xref:llvm/RelLookupTableConverterPass.adoc[`RelLookupTableConverterPass`] 
| Pass that converts lookup tables to relative lookup tables&period;
| xref:llvm/ReleaseModeModelRunner.adoc[`ReleaseModeModelRunner`] 
| Production MLModelRunner that evaluates an AOT&hyphen;compiled SavedModel&period;
| xref:llvm/RelocAddrEntry.adoc[`RelocAddrEntry`] 
| RelocAddrEntry contains relocated value and section index&period; Section index is &hyphen;1LL if relocation points to absolute symbol&period;
| xref:llvm/Rematerializer.adoc[`Rematerializer`] 
| MIR&hyphen;level target&hyphen;independent rematerializer&period; Provides an API to identify and rematerialize registers within a machine function&period;
| xref:llvm/RemoveLoadsIntoFakeUsesPass.adoc[`RemoveLoadsIntoFakeUsesPass`] 
| New PM pass that removes loads that are only used by FAKE&lowbar;USE instructions&period;
| xref:llvm/RemoveRedundantDebugValuesPass.adoc[`RemoveRedundantDebugValuesPass`] 
| New PM pass that removes redundant DBG&lowbar;VALUE instructions&period;
| xref:llvm/RenameIndependentSubregsPass.adoc[`RenameIndependentSubregsPass`] 
| New PM pass that renames independently used subregisters&period;
| xref:llvm/Repeated-08.adoc[`Repeated`] 
| A memory&hyphen;efficient immutable range with a single value repeated N times&period; The value is owned by the range&period;
| xref:llvm/RepeatedIterator.adoc[`RepeatedIterator`] 
| A random&hyphen;access iterator that always dereferences to the same value&period;
| xref:llvm/ReplaceWithVeclib.adoc[`ReplaceWithVeclib`] 
| New PM pass that replaces vector intrinsics with vector&hyphen;library calls&period;
| xref:llvm/ReplaceWithVeclibLegacy.adoc[`ReplaceWithVeclibLegacy`] 
| Legacy FunctionPass that replaces vector intrinsics with vector&hyphen;library calls&period;
| xref:llvm/ReplaceableMetadataImpl.adoc[`ReplaceableMetadataImpl`] 
| Shared implementation of use&hyphen;lists for replaceable metadata&period;
| xref:llvm/ReplacementItem.adoc[`ReplacementItem`] 
| A parsed segment of a formatv format string&period;
| xref:llvm/ReplayInlineAdvisor.adoc[`ReplayInlineAdvisor`] 
| Replay inline advisor that uses optimization remarks from inlining of previous build to guide current inlining&period; This is useful for inliner tuning&period;
| xref:llvm/ReplayInlinerSettings.adoc[`ReplayInlinerSettings`] 
| Replay Inliner Setup
| xref:llvm/RequireAnalysisPass-01.adoc[`RequireAnalysisPass`] 
| A utility pass template to force an analysis result to be available&period;
| xref:llvm/RequiredPassInfoMixin-099.adoc[`RequiredPassInfoMixin`] 
| A CRTP mix&hyphen;in for passes that should not be skipped&period;
| xref:llvm/RequiredPassInfoMixin-0f27.adoc[`RequiredPassInfoMixin`] 
| A CRTP mix&hyphen;in for passes that should not be skipped&period;
| xref:llvm/RequiredPassInfoMixin-047.adoc[`RequiredPassInfoMixin`] 
| A CRTP mix&hyphen;in for passes that should not be skipped&period;
| xref:llvm/ReservoirSampler.adoc[`ReservoirSampler`] 
| Randomly selects an item by sampling into a set with an unknown number of elements, which may each be weighted to be more likely choices&period;
| xref:llvm/Resolver.adoc[`Resolver`] 
| Interface for looking up the initializer for a variable name, used by Init&colon;&colon;resolveReferences&period;
| xref:llvm/ResolverError.adoc[`ResolverError`] 
| Error reporting failure to resolve an indirect address in a location list&period;
| xref:llvm/ResourceManager.adoc[`ResourceManager`] 
| Tracks processor resources consumed while building an SMS schedule&period;
| xref:llvm/ResourcePriorityQueue.adoc[`ResourcePriorityQueue`] 
| Priority queue that schedules nodes using DFA resource state to shorten the critical path on VLIW&hyphen;like targets&period;
| xref:llvm/ResourceSegments.adoc[`ResourceSegments`] 
| ResourceSegments are a collection of intervals closed on the left and opened on the right&colon;
| xref:llvm/ResumeInst.adoc[`ResumeInst`] 
| Resume the propagation of an exception&period;
| xref:llvm/RetainedKnowledge.adoc[`RetainedKnowledge`] 
| One piece of knowledge from an llvm&period;assume operand bundle&period;
| xref:llvm/ReturnInst.adoc[`ReturnInst`] 
| Return from the current function, optionally with a value&period;
| xref:llvm/ReversePostOrderFunctionAttrsPass.adoc[`ReversePostOrderFunctionAttrsPass`] 
| A pass to do RPO deduction and propagation of function attributes&period;
| xref:llvm/ReversePostOrderTraversal.adoc[`ReversePostOrderTraversal`] 
| Precomputed reverse&hyphen;post&hyphen;order walk of a graph&period;
| xref:llvm/RewriteBuffer.adoc[`RewriteBuffer`] 
| Buffer holding rewritten source text and original&hyphen;to&hyphen;rewritten offset maps&period;
| xref:llvm/RewriteRope.adoc[`RewriteRope`] 
| Rope that supports efficient mid&hyphen;string insert and erase&period;
| xref:llvm/RewriteStatepointsForGC.adoc[`RewriteStatepointsForGC`] 
| Pass that rewrites calls and invokes to make GC relocations explicit in IR&period;
| xref:llvm/RewriteSymbolPass.adoc[`RewriteSymbolPass`] 
| Pass that rewrites module&hyphen;level symbol names per configured descriptors&period;
| xref:llvm/Rollbacker.adoc[`Rollbacker`] 
| Rematerializer listener that can recreate registers and roll back remats&period;
| xref:llvm/RootDDGNode.adoc[`RootDDGNode`] 
| Subclass of DDGNode representing the root node of the graph&period; There should only be one such node in a given graph&period;
| xref:llvm/RopePiece.adoc[`RopePiece`] 
| View into a shared RopeRefCountString slice&period;
| xref:llvm/RopePieceBTree.adoc[`RopePieceBTree`] 
| B&plus; tree of RopePiece chunks that stores a rope as ordered byte ranges&period;
| xref:llvm/RopePieceBTreeIterator.adoc[`RopePieceBTreeIterator`] 
| Forward iterator over bytes stored in a RopePieceBTree&period;
| xref:llvm/RopeRefCountString.adoc[`RopeRefCountString`] 
| Reference&hyphen;counted character buffer for rope pieces&period;
| xref:llvm/RuntimeCheckingPtrGroup.adoc[`RuntimeCheckingPtrGroup`] 
| A grouping of pointers&period; A single memcheck is required between two groups&period;
| xref:llvm/RuntimeDyld.adoc[`RuntimeDyld`] 
| Runtime dynamic linker used by MCJIT and related ORC layers&period;
| xref:llvm/RuntimeDyldChecker.adoc[`RuntimeDyldChecker`] 
| RuntimeDyld invariant checker for verifying that RuntimeDyld has correctly applied relocations&period;
| xref:llvm/RuntimeDyldCheckerImpl.adoc[`RuntimeDyldCheckerImpl`] 
| Internal implementation class behind RuntimeDyldChecker&period;
| xref:llvm/RuntimeDyldError.adoc[`RuntimeDyldError`] 
| Base class for errors originating in RuntimeDyld, e&period;g&period; missing relocation support&period;
| xref:llvm/RuntimeDyldImpl.adoc[`RuntimeDyldImpl`] 
| Internal implementation class behind RuntimeDyld&period;
| xref:llvm/RuntimeLibraryAnalysis.adoc[`RuntimeLibraryAnalysis`] 
| Analysis pass providing the `RTLIB&colon;&colon;RuntimeLibcallsInfo` for a module&period;
| xref:llvm/RuntimeLibraryInfoWrapper.adoc[`RuntimeLibraryInfoWrapper`] 
| Legacy immutable pass wrapping `RuntimeLibraryAnalysis` for the old PM&period;
| xref:llvm/RuntimePointerChecking.adoc[`RuntimePointerChecking`] 
| Holds information about the memory runtime legality checks to verify that a group of pointers do not overlap&period;
| xref:llvm/SCCPInstVisitor.adoc[`SCCPInstVisitor`] 
| Instruction visitor that drives Sparse Conditional Constant Propagation&period;
| xref:llvm/SCCPPass.adoc[`SCCPPass`] 
| This pass performs function&hyphen;level constant propagation and merging&period;
| xref:llvm/SCCPSolver.adoc[`SCCPSolver`] 
| SCCPSolver &hyphen; This interface class is a general purpose solver for Sparse Conditional Constant Propagation (SCCP)&period;
| xref:llvm/SCEV.adoc[`SCEV`] 
| This class represents an analyzed expression in the program&period; These are opaque objects that the client is not allowed to do much with directly&period;
| xref:llvm/SCEVAA.adoc[`SCEVAA`] 
| Analysis pass providing a never&hyphen;invalidated alias analysis result&period;
| xref:llvm/SCEVAAResult.adoc[`SCEVAAResult`] 
| A simple alias analysis implementation that uses ScalarEvolution to answer queries&period;
| xref:llvm/SCEVAAWrapperPass.adoc[`SCEVAAWrapperPass`] 
| Legacy wrapper pass to provide the SCEVAAResult object&period;
| xref:llvm/SCEVAddExpr.adoc[`SCEVAddExpr`] 
| This node represents an addition of some number of SCEVs&period;
| xref:llvm/SCEVAddRecExpr.adoc[`SCEVAddRecExpr`] 
| SCEV add&hyphen;recurrence expression representing a loop induction formula&period;
| xref:llvm/SCEVCastExpr.adoc[`SCEVCastExpr`] 
| This is the base class for unary cast operator classes&period;
| xref:llvm/SCEVCommutativeExpr.adoc[`SCEVCommutativeExpr`] 
| This node is the base class for n&apos;ary commutative operators&period;
| xref:llvm/SCEVComparePredicate.adoc[`SCEVComparePredicate`] 
| This class represents an assumption that the expression LHS Pred RHS evaluates to true, and this can be checked at run&hyphen;time&period;
| xref:llvm/SCEVConstant.adoc[`SCEVConstant`] 
| SCEV expression wrapping a constant integer value&period;
| xref:llvm/SCEVCouldNotCompute.adoc[`SCEVCouldNotCompute`] 
| Sentinel SCEV returned when a query cannot be answered&period;
| xref:llvm/SCEVDivision.adoc[`SCEVDivision`] 
| SCEV visitor that divides a numerator expression by a fixed denominator&period;
| xref:llvm/SCEVDivisionPrinterPass.adoc[`SCEVDivisionPrinterPass`] 
| Printer pass that shows SCEVDivision results for signed divides in a function&period;
| xref:llvm/SCEVExpander.adoc[`SCEVExpander`] 
| This class uses information about analyze scalars to rewrite expressions in canonical form&period;
| xref:llvm/SCEVExpanderCleaner.adoc[`SCEVExpanderCleaner`] 
| Helper to remove instructions inserted during SCEV expansion, unless they are marked as used&period;
| xref:llvm/SCEVIntegralCastExpr.adoc[`SCEVIntegralCastExpr`] 
| This is the base class for unary integral cast operator classes&period;
| xref:llvm/SCEVLoopAddRecRewriter.adoc[`SCEVLoopAddRecRewriter`] 
| The SCEVLoopAddRecRewriter takes a scalar evolution expression and applies the Map (Loop &hyphen;&gt; SCEV) to all AddRecExprs&period;
| xref:llvm/SCEVMinMaxExpr.adoc[`SCEVMinMaxExpr`] 
| This node is the base class min&sol;max selections&period;
| xref:llvm/SCEVMulExpr.adoc[`SCEVMulExpr`] 
| This node represents multiplication of some number of SCEVs&period;
| xref:llvm/SCEVNAryExpr.adoc[`SCEVNAryExpr`] 
| This node is a base class providing common functionality for n&apos;ary operators&period;
| xref:llvm/SCEVOperand.adoc[`SCEVOperand`] 
| struct for holding enough information to help calculate the cost of the given SCEV when expanded into IR&period;
| xref:llvm/SCEVParameterRewriter.adoc[`SCEVParameterRewriter`] 
| The SCEVParameterRewriter takes a scalar evolution expression and updates the SCEVUnknown components following the Map (Value &hyphen;&gt; SCEV)&period;
| xref:llvm/SCEVPredicate.adoc[`SCEVPredicate`] 
| This class represents an assumption made using SCEV expressions which can be checked at run&hyphen;time&period;
| xref:llvm/SCEVPtrToAddrExpr.adoc[`SCEVPtrToAddrExpr`] 
| This class represents a cast from a pointer to a pointer&hyphen;sized integer value, without capturing the provenance of the pointer&period;
| xref:llvm/SCEVRewriteVisitor-09.adoc[`SCEVRewriteVisitor`] 
| This visitor recursively visits a SCEV expression and re&hyphen;writes it&period; The result from each visit is cached, so it will return the same SCEV for the same input&period;
| xref:llvm/SCEVSMaxExpr.adoc[`SCEVSMaxExpr`] 
| This class represents a signed maximum selection&period;
| xref:llvm/SCEVSMinExpr.adoc[`SCEVSMinExpr`] 
| This class represents a signed minimum selection&period;
| xref:llvm/SCEVSequentialMinMaxExpr.adoc[`SCEVSequentialMinMaxExpr`] 
| Base class for sequential&sol;in&hyphen;order min&sol;max selections&period;
| xref:llvm/SCEVSequentialUMinExpr.adoc[`SCEVSequentialUMinExpr`] 
| This class represents a sequential&sol;in&hyphen;order unsigned minimum selection&period;
| xref:llvm/SCEVSignExtendExpr.adoc[`SCEVSignExtendExpr`] 
| This class represents a sign extension of a small integer value to a larger integer value&period;
| xref:llvm/SCEVTraversal.adoc[`SCEVTraversal`] 
| Visit all nodes in the expression tree using worklist traversal&period;
| xref:llvm/SCEVTruncateExpr.adoc[`SCEVTruncateExpr`] 
| This class represents a truncation of an integer value to a smaller integer value&period;
| xref:llvm/SCEVUDivExpr.adoc[`SCEVUDivExpr`] 
| This class represents a binary unsigned division operation&period;
| xref:llvm/SCEVUMaxExpr.adoc[`SCEVUMaxExpr`] 
| This class represents an unsigned maximum selection&period;
| xref:llvm/SCEVUMinExpr.adoc[`SCEVUMinExpr`] 
| This class represents an unsigned minimum selection&period;
| xref:llvm/SCEVUnionPredicate.adoc[`SCEVUnionPredicate`] 
| Logical AND of a set of SCEV predicates&period;
| xref:llvm/SCEVUnknown.adoc[`SCEVUnknown`] 
| SCEV expression for a value that ScalarEvolution cannot analyze further&period;
| xref:llvm/SCEVUseT-0f.adoc[`SCEVUseT`] 
| SCEV pointer plus optional use&hyphen;specific NUW&sol;NSW flags&period;
| xref:llvm/SCEVUseVisitor-00.adoc[`SCEVUseVisitor`] 
| A visitor class for SCEVUse&period;
| xref:llvm/SCEVVScale.adoc[`SCEVVScale`] 
| This class represents the value of vscale, as used when defining the length of a scalable vector or returned by the llvm&period;vscale() intrinsic&period;
| xref:llvm/SCEVVisitor-00.adoc[`SCEVVisitor`] 
| This class defines a simple visitor class that may be used for various SCEV analysis purposes&period;
| xref:llvm/SCEVWrapPredicate.adoc[`SCEVWrapPredicate`] 
| Wrap assumption on an affine add recurrence for its first X iterations&period;
| xref:llvm/SCEVZeroExtendExpr.adoc[`SCEVZeroExtendExpr`] 
| This class represents a zero extension of a small integer value to a larger integer value&period;
| xref:llvm/SDDbgInfo.adoc[`SDDbgInfo`] 
| Side table of dbg&lowbar;value and dbg&lowbar;label info for SelectionDAG ISel&period;
| xref:llvm/SDDbgLabel.adoc[`SDDbgLabel`] 
| Debug&hyphen;label descriptor kept off to the side of the DAG&period;
| xref:llvm/SDDbgOperand.adoc[`SDDbgOperand`] 
| One location operand of an SDDbgValue&period;
| xref:llvm/SDDbgValue.adoc[`SDDbgValue`] 
| Debug&hyphen;value descriptor kept off to the side of the DAG&period;
| xref:llvm/SDLoc.adoc[`SDLoc`] 
| IR ordering and DebugLoc wrapper passed into SDNode creation&period;
| xref:llvm/SDNode.adoc[`SDNode`] 
| Represents one node in the SelectionDAG&period;
| xref:llvm/SDNodeDesc.adoc[`SDNodeDesc`] 
| Generated description of a target&hyphen;specific SelectionDAG node&period;
| xref:llvm/SDNodeFlags.adoc[`SDNodeFlags`] 
| IR&hyphen;level optimization flags that may be propagated to SDNodes&period;
| xref:llvm/SDNodeInfo.adoc[`SDNodeInfo`] 
| Generated descriptions and helpers for target&hyphen;specific SelectionDAG nodes&period;
| xref:llvm/SDNodeIterator.adoc[`SDNodeIterator`] 
| Forward iterator over the operand SDNodes of an SDNode&period;
| xref:llvm/SDTypeConstraint.adoc[`SDTypeConstraint`] 
| Generated type constraint for a SelectionDAG node result or operand&period;
| xref:llvm/SDUse.adoc[`SDUse`] 
| Represents a use of an SDNode value in another node&apos;s operand list&period;
| xref:llvm/SDVTList.adoc[`SDVTList`] 
| Interned list of value types returned by SelectionDAG&colon;&colon;getVTList&period;
| xref:llvm/SDVTListNode.adoc[`SDVTListNode`] 
| Interned list of EVTs used as a SelectionDAG node&apos;s result types&period;
| xref:llvm/SDValue.adoc[`SDValue`] 
| Pair of an SDNode and a result number selecting one of its values&period;
| xref:llvm/SDep.adoc[`SDep`] 
| Scheduling dependency&period; This represents one direction of an edge in the scheduling DAG&period;
| xref:llvm/SEHHandler.adoc[`SEHHandler`] 
| Windows SEH handler metadata recorded for a landing pad&period;
| xref:llvm/SEHUnwindMapEntry.adoc[`SEHUnwindMapEntry`] 
| Similar to CxxUnwindMapEntry, but supports SEH filters&period;
| xref:llvm/SExtInst.adoc[`SExtInst`] 
| Instruction that sign&hyphen;extends an integer value to a wider integer type&period;
| xref:llvm/SHA1.adoc[`SHA1`] 
| A class that wrap the SHA1 algorithm&period;
| xref:llvm/SHA256.adoc[`SHA256`] 
| Incremental SHA&hyphen;256 message&hyphen;digest computation&period;
| xref:llvm/SIToFPInst.adoc[`SIToFPInst`] 
| Instruction that converts a signed integer to floating point&period;
| xref:llvm/SLPVectorizerPass.adoc[`SLPVectorizerPass`] 
| Function pass that vectorizes straight&hyphen;line code via bottom&hyphen;up SLP&period;
| xref:llvm/SMDiagnostic.adoc[`SMDiagnostic`] 
| Instances of this class encapsulate one diagnostic report, allowing printing to a raw&lowbar;ostream as a caret diagnostic&period;
| xref:llvm/SMFixIt.adoc[`SMFixIt`] 
| Represents a single fixit, a replacement of one range of text with another&period;
| xref:llvm/SMLoc.adoc[`SMLoc`] 
| Represents a location in source code&period;
| xref:llvm/SMRange.adoc[`SMRange`] 
| Represents a range in source code&period;
| xref:llvm/SMSchedule.adoc[`SMSchedule`] 
| Scheduled code for a software&hyphen;pipelined loop&period;
| xref:llvm/SMTExpr.adoc[`SMTExpr`] 
| Generic base class for SMT exprs
| xref:llvm/SMTSolver.adoc[`SMTSolver`] 
| Generic base class for SMT Solvers
| xref:llvm/SMTSolverStatistics.adoc[`SMTSolverStatistics`] 
| Statistics collected from an SMT solver run&period;
| xref:llvm/SMTSort.adoc[`SMTSort`] 
| Generic base class for SMT sorts
| xref:llvm/SPIRVObjectWriter.adoc[`SPIRVObjectWriter`] 
| SPIR&hyphen;V object writer that emits SPIR&hyphen;V object files from an MCAssembler&period;
| xref:llvm/SROAOptions.adoc[`SROAOptions`] 
| Configuration options for the SROA pass&period;
| xref:llvm/SROAPass.adoc[`SROAPass`] 
| Scalar Replacement of Aggregates pass&period;
| xref:llvm/SSAUpdater.adoc[`SSAUpdater`] 
| Helper class for SSA formation on a set of values defined in multiple blocks&period;
| xref:llvm/SSAUpdaterBulk.adoc[`SSAUpdaterBulk`] 
| Helper class for SSA formation on a set of values defined in multiple blocks&period;
| xref:llvm/SSAUpdaterImpl.adoc[`SSAUpdaterImpl`] 
| Core algorithm template for SSAUpdater and MachineSSAUpdater&period;
| xref:llvm/SSAUpdaterTraits.adoc[`SSAUpdaterTraits`] 
| Traits used by SSAUpdaterImpl to adapt an SSA updater implementation&period;
| xref:llvm/SSAValueNameMap.adoc[`SSAValueNameMap`] 
| Utility class used to store the names of SSA values after their owning modules have been destroyed&period;
| xref:llvm/SSPLayoutAnalysis.adoc[`SSPLayoutAnalysis`] 
| Analysis that computes stack&hyphen;protector layout information for a function&period;
| xref:llvm/SSPLayoutInfo.adoc[`SSPLayoutInfo`] 
| Per&hyphen;function layout information used when deciding and applying stack protectors&period;
| xref:llvm/SUnit.adoc[`SUnit`] 
| Scheduling unit&period; This is a node in the scheduling DAG&period;
| xref:llvm/SUnitIterator.adoc[`SUnitIterator`] 
| Forward iterator over the predecessor SUnits of an SUnit&period;
| xref:llvm/SafeStackPass.adoc[`SafeStackPass`] 
| New PM pass that splits the stack into a safe stack and an unsafe stack&period;
| xref:llvm/SafepointIRVerifierPass.adoc[`SafepointIRVerifierPass`] 
| Create an instance of the safepoint verifier pass which can be added to a pass pipeline to check for relocation bugs&period;
| xref:llvm/SameType.adoc[`SameType`] 
| SFINAE helper that is only defined when both template arguments match&period;
| xref:llvm/SampleContextTracker.adoc[`SampleContextTracker`] 
| Tracker that manages context&hyphen;sensitive profiles for CSSPGO&period;
| xref:llvm/SampleProfileInference.adoc[`SampleProfileInference`] 
| Sample profile inference pass&period;
| xref:llvm/SampleProfileLoaderBaseImpl.adoc[`SampleProfileLoaderBaseImpl`] 
| Base implementation for loading and applying sample profiles to IR&period;
| xref:llvm/SampleProfileLoaderPass.adoc[`SampleProfileLoaderPass`] 
| The sample profiler data loader pass&period;
| xref:llvm/SampleProfileMatcher.adoc[`SampleProfileMatcher`] 
| Fuzzy&hyphen;matches a sample profile to IR when locations or names have drifted&period;
| xref:llvm/SampleProfileProbePass.adoc[`SampleProfileProbePass`] 
| Pass that inserts sample&hyphen;profile pseudo probes into a module&period;
| xref:llvm/SampleProfileProber.adoc[`SampleProfileProber`] 
| Sample profile pseudo prober&period;
| xref:llvm/SampleProfileSummaryBuilder.adoc[`SampleProfileSummaryBuilder`] 
| Builder that constructs a ProfileSummary from sample profile data&period;
| xref:llvm/SandboxVectorizerPass.adoc[`SandboxVectorizerPass`] 
| Vectorizes IR using a configurable SandboxIR function&hyphen;pass pipeline&period;
| xref:llvm/SanitizerBinaryMetadataOptions.adoc[`SanitizerBinaryMetadataOptions`] 
| Options that control which sanitizer binary metadata is emitted&period;
| xref:llvm/SanitizerBinaryMetadataPass.adoc[`SanitizerBinaryMetadataPass`] 
| The pass should be inserted after optimizations&period;
| xref:llvm/SanitizerCoverageOptions.adoc[`SanitizerCoverageOptions`] 
| Options for SanitizerCoverage instrumentation&period;
| xref:llvm/SanitizerCoveragePass.adoc[`SanitizerCoveragePass`] 
| Module pass that instruments functions for SanitizerCoverage&period;
| xref:llvm/SanitizerStatReport.adoc[`SanitizerStatReport`] 
| Emits and finalizes per&hyphen;module sanitizer statistic counters&period;
| xref:llvm/SaturatingInst.adoc[`SaturatingInst`] 
| Represents a saturating add&sol;sub intrinsic&period;
| xref:llvm/SaveAndRestore-07.adoc[`SaveAndRestore`] 
| A utility class that uses RAII to save and restore the value of a variable&period;
| xref:llvm/ScalableVectorType.adoc[`ScalableVectorType`] 
| Class to represent scalable SIMD vectors
| xref:llvm/ScalarEvolution.adoc[`ScalarEvolution`] 
| The main scalar evolution driver&period; Because client code (intentionally) can&apos;t do much with the SCEV objects directly, they must ask this class for services&period;
| xref:llvm/ScalarEvolutionAnalysis.adoc[`ScalarEvolutionAnalysis`] 
| Analysis pass that exposes the `ScalarEvolution` for a function&period;
| xref:llvm/ScalarEvolutionPrinterPass.adoc[`ScalarEvolutionPrinterPass`] 
| Printer pass for the `ScalarEvolutionAnalysis` results&period;
| xref:llvm/ScalarEvolutionVerifierPass.adoc[`ScalarEvolutionVerifierPass`] 
| Verifier pass for the `ScalarEvolutionAnalysis` results&period;
| xref:llvm/ScalarEvolutionWrapperPass.adoc[`ScalarEvolutionWrapperPass`] 
| Legacy FunctionPass wrapper around ScalarEvolution&period;
| xref:llvm/ScalarEvolutionsTest.adoc[`ScalarEvolutionsTest`] 
| Test helper that needs access to ScalarEvolution internals&period;
| xref:llvm/ScalarizeMaskedMemIntrinPass.adoc[`ScalarizeMaskedMemIntrinPass`] 
| Pass that scalarizes masked memory intrinsics unsupported by the target&period;
| xref:llvm/ScalarizerPass.adoc[`ScalarizerPass`] 
| Pass that converts vector operations into scalar or smaller&hyphen;vector forms&period;
| xref:llvm/ScalarizerPassOptions.adoc[`ScalarizerPassOptions`] 
| Options controlling how the Scalarizer pass splits vector operations&period;
| xref:llvm/ScaledNumber.adoc[`ScaledNumber`] 
| Simple representation of a scaled number&period;
| xref:llvm/ScaledNumberBase.adoc[`ScaledNumberBase`] 
| Shared helpers for printing and converting scaled numbers&period;
| xref:llvm/ScanInfo.adoc[`ScanInfo`] 
| Holds information used while lowering an OpenMP scan reduction&period;
| xref:llvm/SchedBoundary.adoc[`SchedBoundary`] 
| Scheduling boundary that tracks ready queues and hazard state&period;
| xref:llvm/SchedDFSImpl.adoc[`SchedDFSImpl`] 
| Internal DFS state used to compute SchedDFSResult metrics&period;
| xref:llvm/SchedDFSResult.adoc[`SchedDFSResult`] 
| Compute the values of each DAG node for various metrics during DFS&period;
| xref:llvm/SchedRegion.adoc[`SchedRegion`] 
| A region of an MBB for scheduling&period;
| xref:llvm/SchedRemainder.adoc[`SchedRemainder`] 
| Summarize the unscheduled region&period;
| xref:llvm/ScheduleDAG.adoc[`ScheduleDAG`] 
| Base class for instruction scheduling DAGs&period;
| xref:llvm/ScheduleDAGInstrs.adoc[`ScheduleDAGInstrs`] 
| A ScheduleDAG for scheduling lists of MachineInstr&period;
| xref:llvm/ScheduleDAGMI.adoc[`ScheduleDAGMI`] 
| ScheduleDAG that schedules according to a MachineSchedStrategy&period;
| xref:llvm/ScheduleDAGMILive.adoc[`ScheduleDAGMILive`] 
| ScheduleDAG that tracks live intervals and register pressure&period;
| xref:llvm/ScheduleDAGMutation.adoc[`ScheduleDAGMutation`] 
| Mutate the DAG as a postpass after normal DAG building&period;
| xref:llvm/ScheduleDAGSDNodes.adoc[`ScheduleDAGSDNodes`] 
| RegisterScheduler class &hyphen; Track the registration of instruction schedulers&period;
| xref:llvm/ScheduleDAGTopologicalSort.adoc[`ScheduleDAGTopologicalSort`] 
| This class can compute a topological ordering for SUnits and provides methods for dynamically updating the ordering as new edges are added&period;
| xref:llvm/ScheduleHazardRecognizer.adoc[`ScheduleHazardRecognizer`] 
| HazardRecognizer &hyphen; This determines whether or not an instruction can be issued this cycle, and whether or not a noop needs to be inserted to handle the hazard&period;
| xref:llvm/SchedulingPriorityQueue.adoc[`SchedulingPriorityQueue`] 
| Priority queue interface for plugging heuristics into the list scheduler&period;
| xref:llvm/ScopedFatalErrorHandler.adoc[`ScopedFatalErrorHandler`] 
| Installs and removes a fatal error handler for a scope&period;
| xref:llvm/ScopedHashTable.adoc[`ScopedHashTable`] 
| Hash table whose mappings are nested in RAII scopes and restored when those scopes end&period;
| xref:llvm/ScopedHashTableIterator.adoc[`ScopedHashTableIterator`] 
| Iterator over successive shadowed values for a single key&period;
| xref:llvm/ScopedHashTableScope.adoc[`ScopedHashTableScope`] 
| RAII scope that shadows an outer ScopedHashTable and pops its bindings on destruction&period;
| xref:llvm/ScopedHashTableVal.adoc[`ScopedHashTableVal`] 
| One key&sol;value binding stored in a ScopedHashTable scope&period;
| xref:llvm/ScopedNoAliasAA.adoc[`ScopedNoAliasAA`] 
| Analysis pass providing a never&hyphen;invalidated alias analysis result&period;
| xref:llvm/ScopedNoAliasAAResult.adoc[`ScopedNoAliasAAResult`] 
| A simple AA result which uses scoped&hyphen;noalias metadata to answer queries&period;
| xref:llvm/ScopedNoAliasAAWrapperPass.adoc[`ScopedNoAliasAAWrapperPass`] 
| Legacy wrapper pass to provide the ScopedNoAliasAAResult object&period;
| xref:llvm/ScopedPrinter.adoc[`ScopedPrinter`] 
| Pretty&hyphen;printer that emits indented, labeled text with nested scopes&period;
| xref:llvm/ScoreboardHazardRecognizer.adoc[`ScoreboardHazardRecognizer`] 
| Hazard recognizer that tracks function&hyphen;unit usage with a scoreboard&period;
| xref:llvm/SectionKind.adoc[`SectionKind`] 
| POD value that classifies the properties of a section&period;
| xref:llvm/SectionMemoryManager.adoc[`SectionMemoryManager`] 
| Simple section&hyphen;based memory manager for RuntimeDyld and MCJIT&period;
| xref:llvm/SectionName.adoc[`SectionName`] 
| Object&hyphen;file section name and whether that name is unique in the object&period;
| xref:llvm/SelectAddr.adoc[`SelectAddr`] 
| Holds a normal address or a select&hyphen;dependent address pair&period;
| xref:llvm/SelectInst.adoc[`SelectInst`] 
| This class represents the LLVM &apos;select&apos; instruction&period;
| xref:llvm/SelectOptimizePass.adoc[`SelectOptimizePass`] 
| New PM pass that converts select instructions to branches when profitable&period;
| xref:llvm/SelectPatternResult.adoc[`SelectPatternResult`] 
| Result of matching a select as a min&sol;max&sol;abs idiom&period;
| xref:llvm/SelectionDAG.adoc[`SelectionDAG`] 
| This is used to represent a portion of an LLVM function as a DAG&period;
| xref:llvm/SelectionDAGBuilder.adoc[`SelectionDAGBuilder`] 
| Builds a SelectionDAG from LLVM IR for instruction selection&period;
| xref:llvm/SelectionDAGGenTargetInfo.adoc[`SelectionDAGGenTargetInfo`] 
| Proxy class that targets should inherit from if they wish to use the generated node descriptions&period;
| xref:llvm/SelectionDAGISel.adoc[`SelectionDAGISel`] 
| SelectionDAGISel &hyphen; This is the common base class used for SelectionDAG&hyphen;based pattern&hyphen;matching instruction selectors&period;
| xref:llvm/SelectionDAGISelLegacy.adoc[`SelectionDAGISelLegacy`] 
| Legacy pass&hyphen;manager wrapper that owns a SelectionDAGISel and runs it&period;
| xref:llvm/SelectionDAGISelPass.adoc[`SelectionDAGISelPass`] 
| New pass&hyphen;manager wrapper that runs SelectionDAG instruction selection&period;
| xref:llvm/SelectionDAGTargetInfo.adoc[`SelectionDAGTargetInfo`] 
| Targets can subclass this to parameterize the SelectionDAG lowering and instruction selection process&period;
| xref:llvm/SeparateConstOffsetFromGEPPass.adoc[`SeparateConstOffsetFromGEPPass`] 
| Pass that splits GEPs into a variadic base and a constant offset&period;
| xref:llvm/SetState-0b.adoc[`SetState`] 
| Simple state for a set&period;
| xref:llvm/SetTheory.adoc[`SetTheory`] 
| Computes ordered sets of Records from DAG expressions&period;
| xref:llvm/SetVector-023.adoc[`SetVector`] 
| A vector that has set insertion semantics&period;
| xref:llvm/ShadowResolver.adoc[`ShadowResolver`] 
| Delegate resolving to a sub&hyphen;resolver, but shadow some variable names&period;
| xref:llvm/ShadowStackGCLoweringPass.adoc[`ShadowStackGCLoweringPass`] 
| New PM pass that implements the custom lowering used by the shadow stack GC&period;
| xref:llvm/ShapeT.adoc[`ShapeT`] 
| 2D tile shape (row and column) for AMX tile configuration&period;
| xref:llvm/ShiftOfShiftedLogic.adoc[`ShiftOfShiftedLogic`] 
| Match info for folding a shift of a shifted bitwise logic operation&period;
| xref:llvm/ShlOperator.adoc[`ShlOperator`] 
| Concrete operator for the Shl instruction opcode&period;
| xref:llvm/ShouldNotRunFunctionPassesAnalysis.adoc[`ShouldNotRunFunctionPassesAnalysis`] 
| Analysis marking that function passes should be skipped for a function&period;
| xref:llvm/ShouldRunExtraPasses-009.adoc[`ShouldRunExtraPasses`] 
| A marker analysis to determine if extra passes should be run on demand&period;
| xref:llvm/ShouldRunExtraSimpleLoopUnswitch.adoc[`ShouldRunExtraSimpleLoopUnswitch`] 
| A marker analysis to determine if SimpleLoopUnswitch should run again on a given loop&period;
| xref:llvm/ShouldRunExtraVectorPasses.adoc[`ShouldRunExtraVectorPasses`] 
| A marker analysis to determine if extra passes should be run after loop vectorization&period;
| xref:llvm/ShrinkWrapPass.adoc[`ShrinkWrapPass`] 
| New PM pass that finds better places for prologue&sol;epilogue save and restore&period;
| xref:llvm/ShuffleBlockStrategy.adoc[`ShuffleBlockStrategy`] 
| Strategy to randomly select a block and shuffle the operations without affecting data dependency&period;
| xref:llvm/ShuffleVectorInst.adoc[`ShuffleVectorInst`] 
| This instruction constructs a fixed permutation of two input vectors&period;
| xref:llvm/ShuffleVectorSDNode.adoc[`ShuffleVectorSDNode`] 
| SDNode for the shufflevector code&hyphen;generator representation&period;
| xref:llvm/SignedDivisionByConstantInfo.adoc[`SignedDivisionByConstantInfo`] 
| Magic data for optimising signed division by a constant&period;
| xref:llvm/SignpostEmitter.adoc[`SignpostEmitter`] 
| Manages the emission of signposts into the recording method supported by the OS&period;
| xref:llvm/SignpostEmitterImpl.adoc[`SignpostEmitterImpl`] 
| Private implementation of SignpostEmitter&period;
| xref:llvm/SimpleAAQueryInfo.adoc[`SimpleAAQueryInfo`] 
| AAQueryInfo that uses SimpleCaptureAnalysis&period;
| xref:llvm/SimpleBitstreamCursor.adoc[`SimpleBitstreamCursor`] 
| This represents a position within a bitstream&period; There may be multiple independent cursors reading within one bitstream, each maintaining their own local state&period;
| xref:llvm/SimpleCaptureAnalysis.adoc[`SimpleCaptureAnalysis`] 
| Context&hyphen;free CaptureAnalysis provider&period;
| xref:llvm/SimpleDDGNode.adoc[`SimpleDDGNode`] 
| Subclass of DDGNode representing single or multi&hyphen;instruction nodes&period;
| xref:llvm/SimpleLoopSafetyInfo.adoc[`SimpleLoopSafetyInfo`] 
| Simple and conservative implementation of LoopSafetyInfo that can give false&hyphen;positive answers to its queries in order to avoid complicated analysis&period;
| xref:llvm/SimpleLoopUnswitchPass.adoc[`SimpleLoopUnswitchPass`] 
| Pass that unswitches loops with loop&hyphen;invariant branch or switch conditions&period;
| xref:llvm/SimpleRegistryEntry.adoc[`SimpleRegistryEntry`] 
| A simple registry entry which provides only a name, description, and an `CtorParamTypes&amp;&amp;` variadic parameterized constructor&period;
| xref:llvm/SimplifyCFGOptions.adoc[`SimplifyCFGOptions`] 
| Options that control transforms performed by the SimplifyCFG pass&period;
| xref:llvm/SimplifyCFGPass.adoc[`SimplifyCFGPass`] 
| A pass to simplify and canonicalize the CFG of a function&period;
| xref:llvm/SimplifyQuery.adoc[`SimplifyQuery`] 
| Analyses and flags used as context for instruction simplification&period;
| xref:llvm/SimplifyTypeTestsPass.adoc[`SimplifyTypeTestsPass`] 
| Pass that simplifies type&hyphen;test intrinsics where possible&period;
| xref:llvm/SingleThreadExecutor.adoc[`SingleThreadExecutor`] 
| A non&hyphen;threaded implementation&period;
| xref:llvm/SinkAndHoistLICMFlags.adoc[`SinkAndHoistLICMFlags`] 
| Flags controlling how much is checked when sinking or hoisting instructions&period;
| xref:llvm/SinkInstructionStrategy.adoc[`SinkInstructionStrategy`] 
| Strategy to select a random instruction and add a new sink (user) to it to increate data dependency&period;
| xref:llvm/SinkingPass.adoc[`SinkingPass`] 
| Move instructions into successor blocks when possible&period;
| xref:llvm/SizeOffsetAPInt.adoc[`SizeOffsetAPInt`] 
| SizeOffsetAPInt &hyphen; Used by `ObjectSizeOffsetVisitor,` which works with `APInts&period;`
| xref:llvm/SizeOffsetType-00.adoc[`SizeOffsetType`] 
| SizeOffsetType &hyphen; A base template class for the object size visitors&period; Used here as a self&hyphen;documenting way to handle the values rather than using a `std&colon;&colon;pair&period;`
| xref:llvm/SizeOffsetValue.adoc[`SizeOffsetValue`] 
| Size and offset pair represented as IR Values&period;
| xref:llvm/SizeOffsetWeakTrackingVH.adoc[`SizeOffsetWeakTrackingVH`] 
| SizeOffsetWeakTrackingVH &hyphen; Used by `ObjectSizeOffsetEvaluator` in a `DenseMap&period;`
| xref:llvm/SjLjEHPreparePass.adoc[`SjLjEHPreparePass`] 
| New PM pass that prepares setjmp&sol;longjmp exception handling for code generation&period;
| xref:llvm/SlotIndex.adoc[`SlotIndex`] 
| SlotIndex &hyphen; An opaque wrapper around machine indexes&period;
| xref:llvm/SlotIndexes.adoc[`SlotIndexes`] 
| SlotIndexes pass&period;
| xref:llvm/SlotIndexesAnalysis.adoc[`SlotIndexesAnalysis`] 
| Analysis pass that computes SlotIndexes for a MachineFunction&period;
| xref:llvm/SlotIndexesPrinterPass.adoc[`SlotIndexesPrinterPass`] 
| Printer pass for the SlotIndexes analysis&period;
| xref:llvm/SlotIndexesWrapperPass.adoc[`SlotIndexesWrapperPass`] 
| Legacy MachineFunctionPass wrapper around SlotIndexes&period;
| xref:llvm/SlotMapping.adoc[`SlotMapping`] 
| Slot&hyphen;number mappings for unnamed metadata, global values, and types&period;
| xref:llvm/SlotTracker.adoc[`SlotTracker`] 
| Slot numbering table used when printing LLVM IR as assembly&period;
| xref:llvm/SmallBitVector.adoc[`SmallBitVector`] 
| Variable&hyphen;sized bit array optimized for small bit counts&period;
| xref:llvm/SmallDenseMap.adoc[`SmallDenseMap`] 
| DenseMap with a small inline bucket buffer to avoid heap allocation&period;
| xref:llvm/SmallDenseSet.adoc[`SmallDenseSet`] 
| Implements a dense probed hash&hyphen;table based set with some number of buckets stored inline&period;
| xref:llvm/SmallMapVector.adoc[`SmallMapVector`] 
| A MapVector that performs no allocations if smaller than a certain size&period;
| xref:llvm/SmallPriorityWorklist.adoc[`SmallPriorityWorklist`] 
| A version of `PriorityWorklist` that selects small size optimized data structures for the vector and map&period;
| xref:llvm/SmallPtrSet.adoc[`SmallPtrSet`] 
| A set of pointers optimized for holding SmallSize or fewer elements&period;
| xref:llvm/SmallPtrSetImpl-05.adoc[`SmallPtrSetImpl`] 
| A templated base class for `SmallPtrSet` which provides the typesafe interface that is common across all small sizes&period;
| xref:llvm/SmallPtrSetImplBase.adoc[`SmallPtrSetImplBase`] 
| Common base implementation shared by all `SmallPtrSet` specializations&period;
| xref:llvm/SmallPtrSetIterator.adoc[`SmallPtrSetIterator`] 
| SmallPtrSetIterator &hyphen; This implements a const&lowbar;iterator for SmallPtrSet&period;
| xref:llvm/SmallPtrSetIteratorImpl.adoc[`SmallPtrSetIteratorImpl`] 
| SmallPtrSetIteratorImpl &hyphen; This is the common base class shared between all instances of SmallPtrSetIterator&period;
| xref:llvm/SmallSet-0d.adoc[`SmallSet`] 
| A set of unique values optimized for the case when the set is small&period;
| xref:llvm/SmallSetIterator.adoc[`SmallSetIterator`] 
| SmallSetIterator &hyphen; This class implements a const&lowbar;iterator for SmallSet by delegating to the underlying SmallVector or Set iterators&period;
| xref:llvm/SmallSetVector.adoc[`SmallSetVector`] 
| A SetVector that performs no allocations if smaller than a certain size&period;
| xref:llvm/SmallString.adoc[`SmallString`] 
| SmallString &hyphen; A SmallString is just a SmallVector with methods and accessors that make it work better as a string (e&period;g&period; operator&plus; etc)&period;
| xref:llvm/SmallVector-06.adoc[`SmallVector`] 
| Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference `sizeof(SmallVector&lt;T, 0&gt;)`&period;
| xref:llvm/SmallVectorAlignmentAndSize.adoc[`SmallVectorAlignmentAndSize`] 
| Figure out the offset of the first element&period;
| xref:llvm/SmallVectorBase-02.adoc[`SmallVectorBase`] 
| This is all the stuff common to all SmallVectors&period;
| xref:llvm/SmallVectorImpl-06c.adoc[`SmallVectorImpl`] 
| Shared SmallVector API and growth logic independent of inline capacity&period;
| xref:llvm/SmallVectorMemoryBuffer.adoc[`SmallVectorMemoryBuffer`] 
| SmallVector&hyphen;backed MemoryBuffer instance&period;
| xref:llvm/SmallVectorStorage-05.adoc[`SmallVectorStorage`] 
| Storage for the SmallVector elements&period; This is specialized for the N&equals;0 case to avoid allocating unnecessary storage&period;
| xref:llvm/SmallVectorTemplateBase-0ec.adoc[`SmallVectorTemplateBase`] 
| SmallVectorTemplateBase&lt;TriviallyCopyable &equals; false&gt; &hyphen; This is where we put method implementations that are designed to work with non&hyphen;trivial T&apos;s&period;
| xref:llvm/SmallVectorTemplateCommon-064.adoc[`SmallVectorTemplateCommon`] 
| Common SmallVector functionality independent of whether `T` is POD&period;
| xref:llvm/SortedVectorMap.adoc[`SortedVectorMap`] 
| A map implementation backed by a sorted SmallVector&period; Key&hyphen;value pairs are stored in contiguous memory ordered by `KeyCompare&period;`
| xref:llvm/SourceMgr.adoc[`SourceMgr`] 
| This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling&period;
| xref:llvm/SparseBitVector.adoc[`SparseBitVector`] 
| Sparse bit vector that stores only elements containing set bits&period;
| xref:llvm/SparseBitVectorElement.adoc[`SparseBitVectorElement`] 
| Fixed&hyphen;size block of bits stored as a contiguous array of BitWords&period;
| xref:llvm/SparseMultiSet.adoc[`SparseMultiSet`] 
| Fast multiset implementation for objects that can be identified by small unsigned keys&period;
| xref:llvm/SparseSet-09.adoc[`SparseSet`] 
| SparseSet &hyphen; Fast set implementation for objects that can be identified by small unsigned keys&period;
| xref:llvm/SparseSetValFunctor.adoc[`SparseSetValFunctor`] 
| SparseSetValFunctor &hyphen; Helper class for getting a value&apos;s index&period;
| xref:llvm/SparseSetValTraits.adoc[`SparseSetValTraits`] 
| SparseSetValTraits &hyphen; Traits for deriving a sparse&hyphen;set index from a value&period;
| xref:llvm/SparseSolver.adoc[`SparseSolver`] 
| General&hyphen;purpose sparse conditional propagation solver&period;
| xref:llvm/Spec.adoc[`Spec`] 
| A candidate specialization of a function for a given signature&period;
| xref:llvm/SpecSig.adoc[`SpecSig`] 
| Specialization signature uniquely designating a specialization of a function&period;
| xref:llvm/SpecialCaseList.adoc[`SpecialCaseList`] 
| This is a utility class used to parse user&hyphen;provided text files with &quot;special case lists&quot; for code sanitizers&period;
| xref:llvm/SpecificBumpPtrAllocator.adoc[`SpecificBumpPtrAllocator`] 
| A BumpPtrAllocator that allows only elements of a specific type to be allocated&period;
| xref:llvm/SpeculativeExecutionPass.adoc[`SpeculativeExecutionPass`] 
| Pass that hoists instructions to enable speculative execution&period;
| xref:llvm/Spelling.adoc[`Spelling`] 
| Wrapper for a spelling record with an associated version range&period;
| xref:llvm/SpillPlacement.adoc[`SpillPlacement`] 
| Computes optimal spill&hyphen;code placement between basic blocks for a live range&period;
| xref:llvm/SpillPlacementAnalysis.adoc[`SpillPlacementAnalysis`] 
| Analysis pass that computes `SpillPlacement` for a machine function&period;
| xref:llvm/SpillPlacementWrapperLegacy.adoc[`SpillPlacementWrapperLegacy`] 
| Legacy machine function pass wrapping SpillPlacement&period;
| xref:llvm/Spiller.adoc[`Spiller`] 
| Spiller interface&period;
| xref:llvm/SplittingIterator.adoc[`SplittingIterator`] 
| A forward iterator over partitions of string over a separator&period;
| xref:llvm/SrcOp.adoc[`SrcOp`] 
| Source operand accepted by MachineIRBuilder helpers&period;
| xref:llvm/SrcValueSDNode.adoc[`SrcValueSDNode`] 
| SDNode holding an arbitrary LLVM IR Value reference&period;
| xref:llvm/StableFunction.adoc[`StableFunction`] 
| A stable function is a function with a stable hash while tracking the locations of ignored operands and their hashes&period;
| xref:llvm/StableFunctionMap.adoc[`StableFunctionMap`] 
| Maps stable function hashes to their corresponding metadata entries&period;
| xref:llvm/StableFunctionMapRecord.adoc[`StableFunctionMapRecord`] 
| Holds a stable function map for serialization and deserialization&period;
| xref:llvm/StackColoringPass.adoc[`StackColoringPass`] 
| New PM pass that merges disjoint stack slots to reduce frame size&period;
| xref:llvm/StackFrameLayoutAnalysisPass.adoc[`StackFrameLayoutAnalysisPass`] 
| New PM pass that dumps the stack frame layout via remarks&period;
| xref:llvm/StackLifetime.adoc[`StackLifetime`] 
| Compute live ranges of allocas&period;
| xref:llvm/StackLifetimePrinterPass.adoc[`StackLifetimePrinterPass`] 
| Printer pass for testing&period;
| xref:llvm/StackMapOpers.adoc[`StackMapOpers`] 
| MI&hyphen;level stackmap operands&period;
| xref:llvm/StackMapParser.adoc[`StackMapParser`] 
| A parser for the latest stackmap format&period; At the moment, latest&equals;V3&period;
| xref:llvm/StackMaps.adoc[`StackMaps`] 
| Collects stackmap, patchpoint, and statepoint records and serializes them into the object file&apos;s stack map section via AsmPrinter&period;
| xref:llvm/StackOffset.adoc[`StackOffset`] 
| StackOffset holds a fixed and a scalable offset in bytes&period;
| xref:llvm/StackProtector.adoc[`StackProtector`] 
| Legacy FunctionPass that inserts stack protectors into functions that need them&period;
| xref:llvm/StackProtectorDescriptor.adoc[`StackProtectorDescriptor`] 
| Encapsulates all of the information needed to generate a stack protector check, and signals to isel when initialized that one needs to be generated&period;
| xref:llvm/StackProtectorPass.adoc[`StackProtectorPass`] 
| New PM pass that inserts stack protectors into functions that need them&period;
| xref:llvm/StackSafetyAnalysis.adoc[`StackSafetyAnalysis`] 
| StackSafetyInfo wrapper for the new pass manager&period;
| xref:llvm/StackSafetyGlobalAnalysis.adoc[`StackSafetyGlobalAnalysis`] 
| This pass performs the global (interprocedural) stack safety analysis (new pass manager)&period;
| xref:llvm/StackSafetyGlobalInfo.adoc[`StackSafetyGlobalInfo`] 
| Interprocedural stack safety analysis results for a module&period;
| xref:llvm/StackSafetyGlobalInfoWrapperPass.adoc[`StackSafetyGlobalInfoWrapperPass`] 
| This pass performs the global (interprocedural) stack safety analysis (legacy pass manager)&period;
| xref:llvm/StackSafetyGlobalPrinterPass.adoc[`StackSafetyGlobalPrinterPass`] 
| Printer pass for the `StackSafetyGlobalAnalysis` results&period;
| xref:llvm/StackSafetyInfo.adoc[`StackSafetyInfo`] 
| Interface to access stack safety analysis results for single function&period;
| xref:llvm/StackSafetyInfoWrapperPass.adoc[`StackSafetyInfoWrapperPass`] 
| StackSafetyInfo wrapper for the legacy pass manager
| xref:llvm/StackSafetyPrinterPass.adoc[`StackSafetyPrinterPass`] 
| Printer pass for the `StackSafetyAnalysis` results&period;
| xref:llvm/StackSlotColoringPass.adoc[`StackSlotColoringPass`] 
| New PM pass that colors stack slots to share non&hyphen;overlapping spill slots&period;
| xref:llvm/StandardInstrumentations.adoc[`StandardInstrumentations`] 
| This class provides an interface to register all the standard pass instrumentations and manages their state (if any)&period;
| xref:llvm/StateWrapper-09.adoc[`StateWrapper`] 
| Helper to tie a abstract state implementation to an abstract attribute&period;
| xref:llvm/StatepointDirectives.adoc[`StatepointDirectives`] 
| Directives describing properties of a future gc&period;statepoint wrapper&period;
| xref:llvm/StatepointOpers.adoc[`StatepointOpers`] 
| MI&hyphen;level Statepoint operands
| xref:llvm/StaticDataAnnoatorPass.adoc[`StaticDataAnnoatorPass`] 
| New PM pass that annotates static data section prefixes from profiles&period;
| xref:llvm/StaticDataProfileInfo.adoc[`StaticDataProfileInfo`] 
| A class that holds the constants that represent static data and their profile information and provides methods to operate on them&period;
| xref:llvm/StaticDataProfileInfoAnalysis.adoc[`StaticDataProfileInfoAnalysis`] 
| NewPM analysis that computes and caches `StaticDataProfileInfo` for a module&period;
| xref:llvm/StaticDataProfileInfoWrapperPass.adoc[`StaticDataProfileInfoWrapperPass`] 
| This wraps the StaticDataProfileInfo object as an immutable pass, for a backend pass to operate on&period;
| xref:llvm/StaticDataSplitterPass.adoc[`StaticDataSplitterPass`] 
| New PM pass that categorizes static data hotness using profile information&period;
| xref:llvm/StdThreadPool.adoc[`StdThreadPool`] 
| A ThreadPool implementation using std&colon;&colon;threads&period;
| xref:llvm/StoreInst.adoc[`StoreInst`] 
| An instruction for storing to memory&period;
| xref:llvm/StoreSDNode.adoc[`StoreSDNode`] 
| This class is used to represent ISD&colon;&colon;STORE nodes&period;
| xref:llvm/StrOffsetsContributionDescriptor.adoc[`StrOffsetsContributionDescriptor`] 
| Represents base address of the CU&period; Represents a unit&apos;s contribution to the string offsets table&period;
| xref:llvm/StraightLineStrengthReducePass.adoc[`StraightLineStrengthReducePass`] 
| Performs straight&hyphen;line strength reduction on arithmetic expressions&period;
| xref:llvm/StreamedHTTPResponseHandler.adoc[`StreamedHTTPResponseHandler`] 
| A handler which streams the returned data to a CachedFileStream&period; The cache file is only created if a 200 OK status is observed&period;
| xref:llvm/StreamingHTTPResponse.adoc[`StreamingHTTPResponse`] 
| Wraps the content provider with HTTP Status code and headers&period;
| xref:llvm/StringError.adoc[`StringError`] 
| This class wraps a string in an Error&period;
| xref:llvm/StringInit.adoc[`StringInit`] 
| Represents an initializer containing a string value&period;
| xref:llvm/StringLiteral.adoc[`StringLiteral`] 
| A compile&hyphen;time StringRef wrapper over a string literal&period;
| xref:llvm/StringMap-044.adoc[`StringMap`] 
| Map specialized for string keys with efficient allocation and hashing&period;
| xref:llvm/StringMapEntry.adoc[`StringMapEntry`] 
| StringMapEntry &hyphen; This is used to represent one value that is inserted into a StringMap&period; It contains the Value itself and the key&colon; the string length and data&period;
| xref:llvm/StringMapEntryBase.adoc[`StringMapEntryBase`] 
| StringMapEntryBase &hyphen; Shared base class of StringMapEntry instances&period;
| xref:llvm/StringMapEntryStorage-01.adoc[`StringMapEntryStorage`] 
| StringMapEntryStorage &hyphen; Holds the value in a StringMapEntry&period;
| xref:llvm/StringMapImpl.adoc[`StringMapImpl`] 
| StringMapImpl &hyphen; This is the base class of StringMap that is shared among all of its instantiations&period;
| xref:llvm/StringMapIterBase.adoc[`StringMapIterBase`] 
| Forward iterator over StringMap entries&period;
| xref:llvm/StringMapKeyIterator.adoc[`StringMapKeyIterator`] 
| Adapter that yields StringRef keys from a StringMap iterator&period;
| xref:llvm/StringMatcher.adoc[`StringMatcher`] 
| Given a list of strings and code to execute when they match, output a simple switch tree to classify the input string&period;
| xref:llvm/StringRecTy.adoc[`StringRecTy`] 
| &apos;string&apos; &hyphen; Represent an string value
| xref:llvm/StringRef.adoc[`StringRef`] 
| Represent a constant reference to a string, i&period;e&period; a character array and a length, which need not be null terminated&period;
| xref:llvm/StringSaver.adoc[`StringSaver`] 
| Saves strings in the provided stable storage and returns a StringRef with a stable character pointer&period;
| xref:llvm/StringSet.adoc[`StringSet`] 
| StringSet &hyphen; A wrapper for StringMap that provides set&hyphen;like functionality&period;
| xref:llvm/StringSwitch.adoc[`StringSwitch`] 
| A switch()&hyphen;like statement whose cases are string literals&period;
| xref:llvm/StringTable.adoc[`StringTable`] 
| A table of densely packed, null&hyphen;terminated strings indexed by offset&period;
| xref:llvm/StringTableBuilder.adoc[`StringTableBuilder`] 
| Utility for building string tables with deduplicated suffixes&period;
| xref:llvm/StringToOffsetTable.adoc[`StringToOffsetTable`] 
| Uniques nul&hyphen;terminated strings and tracks their offsets in a contiguous allocation&period;
| xref:llvm/StripConvergenceIntrinsicsPass.adoc[`StripConvergenceIntrinsicsPass`] 
| Pass that strips convergence intrinsics and operand bundles&period;
| xref:llvm/StripDeadCGProfilePass.adoc[`StripDeadCGProfilePass`] 
| Pass that removes dead edges from the CG Profile module flag&period;
| xref:llvm/StripDeadDebugInfoPass.adoc[`StripDeadDebugInfoPass`] 
| Pass that removes debug info for deleted functions and globals&period;
| xref:llvm/StripDeadPrototypesPass.adoc[`StripDeadPrototypesPass`] 
| Pass to remove unused function declarations&period;
| xref:llvm/StripDebugDeclarePass.adoc[`StripDebugDeclarePass`] 
| Pass that removes llvm&period;dbg&period;declare intrinsics from a module&period;
| xref:llvm/StripDebugMachineModulePass.adoc[`StripDebugMachineModulePass`] 
| New PM pass that strips debug info from Machine IR in a module&period;
| xref:llvm/StripGCRelocates.adoc[`StripGCRelocates`] 
| Pass that removes gc&period;relocates inserted by RewriteStatepointsForGC&period;
| xref:llvm/StripNonDebugSymbolsPass.adoc[`StripNonDebugSymbolsPass`] 
| Pass that strips non&hyphen;debug symbol names while preserving debug info&period;
| xref:llvm/StripNonLineTableDebugInfoPass.adoc[`StripNonLineTableDebugInfoPass`] 
| Pass that strips debug info down to line&hyphen;table information only&period;
| xref:llvm/StripSymbolsPass.adoc[`StripSymbolsPass`] 
| Pass that strips symbol names and debug info from a module&period;
| xref:llvm/StrongType.adoc[`StrongType`] 
| Helper for making strong types&period;
| xref:llvm/StructLayout.adoc[`StructLayout`] 
| Used to lazily calculate structure layout information for a target machine, based on the DataLayout structure&period;
| xref:llvm/StructType.adoc[`StructType`] 
| Class to represent struct types&period; There are two different kinds of struct types&colon; Literal structs and Identified structs&period;
| xref:llvm/StructuralHashPrinterPass.adoc[`StructuralHashPrinterPass`] 
| Printer pass for StructuralHashes
| xref:llvm/StructuredAllocaInst.adoc[`StructuredAllocaInst`] 
| Wrapper for the llvm&period;structured&period;alloca intrinsic&period;
| xref:llvm/StructuredGEPInst.adoc[`StructuredGEPInst`] 
| Wrapper for the llvm&period;structured&period;gep intrinsic&period;
| xref:llvm/StructurizeCFGPass.adoc[`StructurizeCFGPass`] 
| Pass that transforms regions into structured control flow&period;
| xref:llvm/SubOperator.adoc[`SubOperator`] 
| Concrete operator for the Sub instruction opcode&period;
| xref:llvm/SubsectionAndTagToTagName.adoc[`SubsectionAndTagToTagName`] 
| Mapping from a subsection name and tag to a display name for extended build attributes&period;
| xref:llvm/SubsumingPositionIterator.adoc[`SubsumingPositionIterator`] 
| A visitor class for IR positions&period;
| xref:llvm/SubtargetFeatureKV.adoc[`SubtargetFeatureKV`] 
| Used to provide key value pairs for feature and CPU bit flags&period;
| xref:llvm/SubtargetFeatureKVStorage.adoc[`SubtargetFeatureKVStorage`] 
| Storage for a table of SubtargetFeatureKV entries and their string table&period;
| xref:llvm/SubtargetFeatures.adoc[`SubtargetFeatures`] 
| Describes CPU&sol;feature bits selected for a target (defined in TargetParser)&period;
| xref:llvm/SubtargetSubTypeAliasKV.adoc[`SubtargetSubTypeAliasKV`] 
| Maps a CPU alias name to the index of the processor it resolves to&period;
| xref:llvm/SubtargetSubTypeKV.adoc[`SubtargetSubTypeKV`] 
| Used to provide key value pairs for feature and CPU bit flags&period;
| xref:llvm/SubtargetSubTypeKVStorage.adoc[`SubtargetSubTypeKVStorage`] 
| Storage for CPU&sol;subtype entries, aliases, and their string table&period;
| xref:llvm/SuffixTree.adoc[`SuffixTree`] 
| A suffix tree for fast repeated&hyphen;substring queries over unsigned integers&period;
| xref:llvm/SuffixTreeInternalNode.adoc[`SuffixTreeInternalNode`] 
| A node with two or more children, or the root&period;
| xref:llvm/SuffixTreeLeafNode.adoc[`SuffixTreeLeafNode`] 
| A node representing a suffix&period;
| xref:llvm/SuffixTreeNode.adoc[`SuffixTreeNode`] 
| A node in a suffix tree which represents a substring or suffix&period;
| xref:llvm/SuperRegClassIterator.adoc[`SuperRegClassIterator`] 
| Iterate over possible super&hyphen;register classes for a register class&period;
| xref:llvm/SuspendCrossingInfo.adoc[`SuspendCrossingInfo`] 
| Answers whether a path between two basic blocks crosses a suspend point&period;
| xref:llvm/SwiftErrorValueTracking.adoc[`SwiftErrorValueTracking`] 
| Tracks swifterror values as virtual registers during code generation&period;
| xref:llvm/SwingSchedulerDAG.adoc[`SwingSchedulerDAG`] 
| This class builds the dependence graph for the instructions in a loop, and attempts to schedule the instructions using the SMS algorithm&period;
| xref:llvm/SwingSchedulerDDG.adoc[`SwingSchedulerDDG`] 
| Wrapper around SUnit that exposes loop&hyphen;carried dependence edges&period;
| xref:llvm/SwingSchedulerDDGEdge.adoc[`SwingSchedulerDDGEdge`] 
| Represents a dependence between two instruction&period;
| xref:llvm/SwitchInst.adoc[`SwitchInst`] 
| Switch on an integer value with a default and case destinations&period;
| xref:llvm/SwitchInstProfUpdateWrapper.adoc[`SwitchInstProfUpdateWrapper`] 
| Keep SwitchInst branch&hyphen;weight metadata in sync when editing cases&period;
| xref:llvm/SymbolInfoTy.adoc[`SymbolInfoTy`] 
| Symbol description used while disassembling an object section&period;
| xref:llvm/SymbolRemappingParseError.adoc[`SymbolRemappingParseError`] 
| ErrorInfo specialization for symbol remapping parse failures&period;
| xref:llvm/SymbolRemappingReader.adoc[`SymbolRemappingReader`] 
| Reader for symbol remapping files&period;
| xref:llvm/SymbolTableList.adoc[`SymbolTableList`] 
| List that automatically updates parent links and symbol tables&period;
| xref:llvm/SymbolTableListParentType-05.adoc[`SymbolTableListParentType`] 
| Template metafunction to get the parent type for a symbol table list&period;
| xref:llvm/SymbolTableListTraits-0d.adoc[`SymbolTableListTraits`] 
| Traits that keep parent links and symbol tables in sync with list changes&period;
| xref:llvm/SymbolsMapKey.adoc[`SymbolsMapKey`] 
| Key used to look up symbols by encode kind and name&period;
| xref:llvm/SyntheticCountsUtils.adoc[`SyntheticCountsUtils`] 
| Class with methods to propagate synthetic entry counts&period;
| xref:llvm/TBAAVerifier.adoc[`TBAAVerifier`] 
| Verify that the TBAA Metadatas are valid&period;
| xref:llvm/TGTimer.adoc[`TGTimer`] 
| Thin wrapper around Timer support for TableGen backends&period;
| xref:llvm/TableGenOutputFiles.adoc[`TableGenOutputFiles`] 
| Holds the primary and any additional files produced by a TableGen backend&period;
| xref:llvm/TagNameItem.adoc[`TagNameItem`] 
| Mapping from an ELF compact build&hyphen;attribute tag to its display name&period;
| xref:llvm/TailCallElimPass.adoc[`TailCallElimPass`] 
| A pass that eliminates tail recursion by converting it into a loop&period;
| xref:llvm/TailDuplicatePass.adoc[`TailDuplicatePass`] 
| New PM pass that performs late (post&hyphen;regalloc) tail duplication&period;
| xref:llvm/TailDuplicatePassBase-03.adoc[`TailDuplicatePassBase`] 
| CRTP base for new&hyphen;PM machine&hyphen;function tail&hyphen;duplication passes&period;
| xref:llvm/TailDuplicator.adoc[`TailDuplicator`] 
| Utility class to perform tail duplication&period;
| xref:llvm/TailFoldingInfo.adoc[`TailFoldingInfo`] 
| Context used when choosing a preferred tail&hyphen;folding style&period;
| xref:llvm/TarWriter.adoc[`TarWriter`] 
| Creates Unix tar archive files&period;
| xref:llvm/Target.adoc[`Target`] 
| Target &hyphen; Wrapper for Target specific information&period;
| xref:llvm/TargetExtType.adoc[`TargetExtType`] 
| Class to represent target extensions types, which are generally unintrospectable from target&hyphen;independent optimizations&period;
| xref:llvm/TargetFolder.adoc[`TargetFolder`] 
| TargetFolder &hyphen; Create constants with target dependent folding&period;
| xref:llvm/TargetFrameLowering.adoc[`TargetFrameLowering`] 
| Information about stack frame layout on the target&period;
| xref:llvm/TargetIRAnalysis.adoc[`TargetIRAnalysis`] 
| Analysis pass providing the `TargetTransformInfo&period;`
| xref:llvm/TargetIndexSDNode.adoc[`TargetIndexSDNode`] 
| Completely target&hyphen;dependent object reference&period;
| xref:llvm/TargetInstrInfo.adoc[`TargetInstrInfo`] 
| TargetInstrInfo &hyphen; Interface to description of machine instruction set
| xref:llvm/TargetLibraryAnalysis.adoc[`TargetLibraryAnalysis`] 
| Analysis pass providing the `TargetLibraryInfo&period;`
| xref:llvm/TargetLibraryInfo.adoc[`TargetLibraryInfo`] 
| Provides information about what library functions are available for the current target&period;
| xref:llvm/TargetLibraryInfoImpl.adoc[`TargetLibraryInfoImpl`] 
| Implementation of the target library information&period;
| xref:llvm/TargetLibraryInfoWrapperPass.adoc[`TargetLibraryInfoWrapperPass`] 
| Legacy immutable wrapper pass around TargetLibraryAnalysis&period;
| xref:llvm/TargetLowering.adoc[`TargetLowering`] 
| This class defines information used to lower LLVM code to legal SelectionDAG operators that the target instruction selector can accept natively&period;
| xref:llvm/TargetLoweringBase.adoc[`TargetLoweringBase`] 
| This base class for TargetLowering contains the SelectionDAG&hyphen;independent parts that can be used from the rest of CodeGen&period;
| xref:llvm/TargetLoweringObjectFile.adoc[`TargetLoweringObjectFile`] 
| Target&hyphen;specific lowering of globals and constants into object&hyphen;file sections&period;
| xref:llvm/TargetLoweringObjectFileCOFF.adoc[`TargetLoweringObjectFileCOFF`] 
| Object&hyphen;file lowering for COFF targets&period;
| xref:llvm/TargetLoweringObjectFileELF.adoc[`TargetLoweringObjectFileELF`] 
| Object&hyphen;file lowering for ELF targets&period;
| xref:llvm/TargetLoweringObjectFileGOFF.adoc[`TargetLoweringObjectFileGOFF`] 
| Object&hyphen;file lowering for GOFF targets&period;
| xref:llvm/TargetLoweringObjectFileMachO.adoc[`TargetLoweringObjectFileMachO`] 
| Object&hyphen;file lowering for Mach&hyphen;O targets&period;
| xref:llvm/TargetLoweringObjectFileWasm.adoc[`TargetLoweringObjectFileWasm`] 
| Object&hyphen;file lowering for WebAssembly targets&period;
| xref:llvm/TargetLoweringObjectFileXCOFF.adoc[`TargetLoweringObjectFileXCOFF`] 
| Object&hyphen;file lowering for XCOFF targets&period;
| xref:llvm/TargetMachine.adoc[`TargetMachine`] 
| Primary interface to the complete machine description for the target machine&period; All target&hyphen;specific information should be accessible through this interface&period;
| xref:llvm/TargetOptions.adoc[`TargetOptions`] 
| Shared command&hyphen;line option flags used across LLVM code generation targets&period;
| xref:llvm/TargetPassConfig.adoc[`TargetPassConfig`] 
| Target&hyphen;Independent Code Generator Pass Configuration Options&period;
| xref:llvm/TargetRegionEntryInfo.adoc[`TargetRegionEntryInfo`] 
| Unique identification tuple for an OpenMP target region entry&period;
| xref:llvm/TargetRegisterInfo.adoc[`TargetRegisterInfo`] 
| Target register information for a machine&apos;s register file&period;
| xref:llvm/TargetRegisterInfoDesc.adoc[`TargetRegisterInfoDesc`] 
| Extra information, not in MCRegisterDesc, about registers&period; These are used by codegen, not by MC&period;
| xref:llvm/TargetRegistry.adoc[`TargetRegistry`] 
| TargetRegistry &hyphen; Generic interface to target specific features&period;
| xref:llvm/TargetSchedModel.adoc[`TargetSchedModel`] 
| Provide an instruction scheduling machine model to CodeGen passes&period;
| xref:llvm/TargetSubtargetInfo.adoc[`TargetSubtargetInfo`] 
| Generic base class for all target&hyphen;specific subtarget information&period;
| xref:llvm/TargetTransformInfo.adoc[`TargetTransformInfo`] 
| This pass provides access to the codegen interfaces that are needed for IR&hyphen;level transformations&period;
| xref:llvm/TargetTransformInfoImplBase.adoc[`TargetTransformInfoImplBase`] 
| Base class for use as a mix&hyphen;in that aids implementing a TargetTransformInfo&hyphen;compatible class&period;
| xref:llvm/TargetTransformInfoImplCRTPBase-08.adoc[`TargetTransformInfoImplCRTPBase`] 
| CRTP base class for use as a mix&hyphen;in that aids implementing a TargetTransformInfo&hyphen;compatible class&period;
| xref:llvm/TargetTransformInfoWrapperPass.adoc[`TargetTransformInfoWrapperPass`] 
| Wrapper pass for TargetTransformInfo&period;
| xref:llvm/TempMDNodeDeleter.adoc[`TempMDNodeDeleter`] 
| Deleter for temporary MDNodes used with `std&colon;&colon;unique&lowbar;ptr&period;`
| xref:llvm/TemporalProfTraceTy.adoc[`TemporalProfTraceTy`] 
| Ordered temporal profile trace of functions identified by NameRef&period;
| xref:llvm/TensorSpec.adoc[`TensorSpec`] 
| Specification of a named tensor&colon; shape, element type, name, and port&period;
| xref:llvm/TernOpInit.adoc[`TernOpInit`] 
| Represents a ternary initializer operator&period;
| xref:llvm/TextChangeReporter-07.adoc[`TextChangeReporter`] 
| Textual change reporter that prints banners and no&hyphen;change&sol;filter messages&period;
| xref:llvm/TextCodeGenDataReader.adoc[`TextCodeGenDataReader`] 
| Reader for text codegen data suitable for test inputs&period;
| xref:llvm/TextEncodingConverter.adoc[`TextEncodingConverter`] 
| Utility class to convert between different character encodings&period;
| xref:llvm/TextInstrProfReader.adoc[`TextInstrProfReader`] 
| Reader for the simple text based instrprof format&period;
| xref:llvm/ThinLTOBitcodeWriterPass.adoc[`ThinLTOBitcodeWriterPass`] 
| Pass that prepares a module for ThinLTO and writes bitcode&period;
| xref:llvm/ThinLTOCodeGenerator.adoc[`ThinLTOCodeGenerator`] 
| Interface similar to LTOCodeGenerator, adapted for ThinLTO processing&period;
| xref:llvm/ThreadPoolInterface.adoc[`ThreadPoolInterface`] 
| This defines the abstract base interface for a ThreadPool allowing asynchronous parallel execution on a defined number of threads&period;
| xref:llvm/ThreadPoolStrategy.adoc[`ThreadPoolStrategy`] 
| This tells how a thread pool will be used
| xref:llvm/ThreadPoolTaskGroup.adoc[`ThreadPoolTaskGroup`] 
| A group of tasks that can be waited for separately on a shared thread pool&period;
| xref:llvm/ThreadSafeAllocator.adoc[`ThreadSafeAllocator`] 
| Thread&hyphen;safe allocator adaptor&period; Uses a spin lock on the assumption that contention here is extremely rare&period;
| xref:llvm/ThreadSafeRefCountedBase-04.adoc[`ThreadSafeRefCountedBase`] 
| A thread&hyphen;safe version of `RefCountedBase&period;`
| xref:llvm/ThreadSafeTrieRawHashMap.adoc[`ThreadSafeTrieRawHashMap`] 
| Lock&hyphen;free thread&hyphen;safe hash&hyphen;mapped trie&period;
| xref:llvm/ThreadSafeTrieRawHashMapBase.adoc[`ThreadSafeTrieRawHashMapBase`] 
| Base class for a lock&hyphen;free thread&hyphen;safe hash&hyphen;mapped trie&period;
| xref:llvm/ThreadSanitizerPass.adoc[`ThreadSanitizerPass`] 
| A function pass for tsan instrumentation&period;
| xref:llvm/ThunkInserter.adoc[`ThunkInserter`] 
| This class assists in inserting MI thunk functions into the module and rewriting the existing machine functions to call these thunks&period;
| xref:llvm/ThunkInserterPass.adoc[`ThunkInserterPass`] 
| Basic implementation of MachineFunctionPass wrapping one or more `ThunkInserter`s passed as type parameters&period;
| xref:llvm/TileInfo.adoc[`TileInfo`] 
| Helper to create tiled IR loop nests for matrix operations&period;
| xref:llvm/TimePassesHandler.adoc[`TimePassesHandler`] 
| Implements &hyphen;time&hyphen;passes timing for the new pass manager&period;
| xref:llvm/TimeProfilingPassesHandler.adoc[`TimeProfilingPassesHandler`] 
| Pass instrumentation for `&hyphen;&hyphen;time&hyphen;trace` under the new pass manager&period;
| xref:llvm/TimeRecord.adoc[`TimeRecord`] 
| A snapshot of wall, user, and system time plus memory and instruction counts&period;
| xref:llvm/TimeRegion.adoc[`TimeRegion`] 
| RAII helper that starts a timer on construction and stops it on destruction&period;
| xref:llvm/TimeTraceMetadata.adoc[`TimeTraceMetadata`] 
| Optional detail, file, and line attached to a time&hyphen;trace event&period;
| xref:llvm/TimeTraceProfiler.adoc[`TimeTraceProfiler`] 
| Per&hyphen;thread time&hyphen;trace profiler that records events for later export&period;
| xref:llvm/TimeTraceProfilerEntry.adoc[`TimeTraceProfilerEntry`] 
| An open or completed time section recorded by the profiler&period;
| xref:llvm/TimeTraceScope.adoc[`TimeTraceScope`] 
| RAII helper that begins a time&hyphen;trace section and ends it on destruction&period;
| xref:llvm/Timer.adoc[`Timer`] 
| Tracks elapsed time between paired startTimer() and stopTimer() calls&period;
| xref:llvm/TimerGlobals.adoc[`TimerGlobals`] 
| Owns process&hyphen;wide timer state, options, and the default timer group&period;
| xref:llvm/TimerGroup.adoc[`TimerGroup`] 
| Groups related timers into a single report printed on destruction&period;
| xref:llvm/TinyPtrVector.adoc[`TinyPtrVector`] 
| TinyPtrVector &hyphen; This class is specialized for cases where there are normally 0 or 1 element in a vector, but is general enough to go beyond that when required&period;
| xref:llvm/ToolContext.adoc[`ToolContext`] 
| Context describing how an llvm&hyphen;driver tool was invoked&period;
| xref:llvm/ToolOutputFile.adoc[`ToolOutputFile`] 
| RAII wrapper around a raw&lowbar;fd&lowbar;ostream for compiler&hyphen;like tool output files&period;
| xref:llvm/Trace.adoc[`Trace`] 
| A single&hyphen;entry, multiple&hyphen;exit sequence of basic blocks on a hot path&period;
| xref:llvm/TrackUnresolvedResolver.adoc[`TrackUnresolvedResolver`] 
| (Optionally) delegate resolving to a sub&hyphen;resolver, and keep track whether there were unresolved references&period;
| xref:llvm/TrackingMDRef.adoc[`TrackingMDRef`] 
| Tracking metadata reference&period;
| xref:llvm/TrackingStatistic.adoc[`TrackingStatistic`] 
| Atomic counter used when statistics collection is enabled&period;
| xref:llvm/TrackingVH.adoc[`TrackingVH`] 
| Value handle that tracks a Value across RAUW&period;
| xref:llvm/TrailingObjects.adoc[`TrailingObjects`] 
| See the file comment for details on the usage of the TrailingObjects type&period;
| xref:llvm/TrieHashIndexGenerator.adoc[`TrieHashIndexGenerator`] 
| Utility that computes trie child indexes from successive hash bit slices&period;
| xref:llvm/TrieRawHashMapTestHelper.adoc[`TrieRawHashMapTestHelper`] 
| Helper used by unit tests to inspect ThreadSafeTrieRawHashMapBase internals&period;
| xref:llvm/TriggerCrashFunctionPass.adoc[`TriggerCrashFunctionPass`] 
| Pass that aborts when run over a function, for testing crash handling&period;
| xref:llvm/TriggerCrashModulePass.adoc[`TriggerCrashModulePass`] 
| Pass that aborts when run over a module, for testing crash handling&period;
| xref:llvm/Triple.adoc[`Triple`] 
| Helper class for working with autoconf&hyphen;style target configuration names&period;
| xref:llvm/TruncInst.adoc[`TruncInst`] 
| Instruction that truncates an integer value to a smaller integer type&period;
| xref:llvm/TruncatedBLAKE3.adoc[`TruncatedBLAKE3`] 
| Like `BLAKE3` but using a class&hyphen;level template parameter for specifying the hash size of the `final()` and `result()` functions&period;
| xref:llvm/Twine.adoc[`Twine`] 
| Twine &hyphen; A lightweight data structure for efficiently representing the concatenation of temporary values as strings&period;
| xref:llvm/TwoAddressInstructionPass.adoc[`TwoAddressInstructionPass`] 
| New PM pass that rewrites two&hyphen;address instructions to use tied operands&period;
| xref:llvm/Type.adoc[`Type`] 
| The root of the LLVM type system hierarchy&period;
| xref:llvm/TypeBasedAA.adoc[`TypeBasedAA`] 
| Analysis pass providing a never&hyphen;invalidated alias analysis result&period;
| xref:llvm/TypeBasedAAResult.adoc[`TypeBasedAAResult`] 
| A simple AA result that uses TBAA metadata to answer queries&period;
| xref:llvm/TypeBasedAAWrapperPass.adoc[`TypeBasedAAWrapperPass`] 
| Legacy wrapper pass to provide the TypeBasedAAResult object&period;
| xref:llvm/TypeConversionCostTblEntryT.adoc[`TypeConversionCostTblEntryT`] 
| Type Conversion Cost Table
| xref:llvm/TypeFinder.adoc[`TypeFinder`] 
| TypeFinder &hyphen; Walk over a module, identifying all of the types that are used by the module&period;
| xref:llvm/TypeIdOffsetVtableInfo.adoc[`TypeIdOffsetVtableInfo`] 
| Holds a vtable ValueInfo and its address&hyphen;point offset for a type id&period;
| xref:llvm/TypeIdSummary.adoc[`TypeIdSummary`] 
| Combined type&hyphen;test and whole&hyphen;program&hyphen;devirt summary for one type id&period;
| xref:llvm/TypePromotionPass.adoc[`TypePromotionPass`] 
| New PM pass that promotes small integer types that would otherwise be promoted during legalization&period;
| xref:llvm/TypeSanitizerPass.adoc[`TypeSanitizerPass`] 
| A module pass for tysan instrumentation&period;
| xref:llvm/TypeSize.adoc[`TypeSize`] 
| Represents the size of a type as an exact size or a known minimum&period;
| xref:llvm/TypeSwitch-0e.adoc[`TypeSwitch`] 
| A switch()&hyphen;like dispatch on a value of type `T` using dyn&lowbar;cast&period;
| xref:llvm/TypeTestResolution.adoc[`TypeTestResolution`] 
| Summary of type identifier metadata used for CFI and whole&hyphen;program devirtualization&period;
| xref:llvm/TypeUnitMetaInfo.adoc[`TypeUnitMetaInfo`] 
| Metadata describing a type unit referenced by a DWARF v5 accelerator table&period;
| xref:llvm/TypedInit.adoc[`TypedInit`] 
| This is the common superclass of types that have a specific, explicit type, stored in ValueTy&period;
| xref:llvm/TypedMDOperandIterator.adoc[`TypedMDOperandIterator`] 
| Typed iterator through MDNode operands&period;
| xref:llvm/TypedPointerType.adoc[`TypedPointerType`] 
| A typed pointer type used by some GPU targets&period;
| xref:llvm/TypedTrackingMDRef.adoc[`TypedTrackingMDRef`] 
| Typed tracking ref&period;
| xref:llvm/TypesAreDistinct-03.adoc[`TypesAreDistinct`] 
| Determine if all types in Ts are distinct&period;
| xref:llvm/UIToFPInst.adoc[`UIToFPInst`] 
| Instruction that converts an unsigned integer to floating point&period;
| xref:llvm/Uint24.adoc[`Uint24`] 
| An auxiliary type to facilitate extraction of 3&hyphen;byte entities&period;
| xref:llvm/UnOpInit.adoc[`UnOpInit`] 
| Represents a unary initializer operator&period;
| xref:llvm/UnaryInstruction.adoc[`UnaryInstruction`] 
| Base class for instructions with exactly one operand&period;
| xref:llvm/UnaryOperator.adoc[`UnaryOperator`] 
| Instruction representing a standard unary operator&period;
| xref:llvm/UncondBrInst.adoc[`UncondBrInst`] 
| Unconditional Branch instruction&period;
| xref:llvm/UndefValue.adoc[`UndefValue`] 
| Constant representing an undefined value of a first&hyphen;class type&period;
| xref:llvm/UnderlyingObject.adoc[`UnderlyingObject`] 
| An underlying memory object paired with whether it may alias others&period;
| xref:llvm/UniformityInfoAnalysis.adoc[`UniformityInfoAnalysis`] 
| Analysis pass which computes xref:llvm/UniformityInfo.adoc[`UniformityInfo`]&period;
| xref:llvm/UniformityInfoPrinterPass.adoc[`UniformityInfoPrinterPass`] 
| Printer pass for the `UniformityInfo&period;`
| xref:llvm/UniformityInfoWrapperPass.adoc[`UniformityInfoWrapperPass`] 
| Legacy analysis pass which computes a xref:llvm/CycleInfo.adoc[`CycleInfo`]&period;
| xref:llvm/UnifyLoopExitsPass.adoc[`UnifyLoopExitsPass`] 
| Pass that redirects each natural loop&apos;s exiting edges through one block&period;
| xref:llvm/UniqueBBID.adoc[`UniqueBBID`] 
| Unique identifier for a basic block within a function&period;
| xref:llvm/UniqueMachineInstr.adoc[`UniqueMachineInstr`] 
| Wrap a MachineInstr for uniquing in a CSE FoldingSet&period;
| xref:llvm/UniquePtrCast.adoc[`UniquePtrCast`] 
| Cast trait that moves a `unique&lowbar;ptr` during a successful cast&period;
| xref:llvm/UniqueStringSaver.adoc[`UniqueStringSaver`] 
| Saves strings in the provided stable storage and returns a StringRef with a stable character pointer&period; Saving the same string yields the same StringRef&period;
| xref:llvm/UniqueTag.adoc[`UniqueTag`] 
| It&apos;s very easy to introduce bugs by passing the wrong string pool&period; By using strong types the interface enforces that the right kind of pool is used&period;
| xref:llvm/UniqueVector.adoc[`UniqueVector`] 
| Vector that assigns a sequential base&hyphen;1 ID to each unique entry&period;
| xref:llvm/UnitIndexEntry.adoc[`UnitIndexEntry`] 
| Per&hyphen;unit contribution offsets and identifying names for a DWP index entry&period;
| xref:llvm/UnpackMachineBundlesPass.adoc[`UnpackMachineBundlesPass`] 
| New PM pass that unpacks machine instruction bundles&period;
| xref:llvm/UnreachableBlockElimPass.adoc[`UnreachableBlockElimPass`] 
| New PM pass that deletes IR basic blocks unreachable from the entry node&period;
| xref:llvm/UnreachableInst.adoc[`UnreachableInst`] 
| Mark a basic block as unreachable (undefined behavior if executed)&period;
| xref:llvm/UnreachableMachineBlockElimPass.adoc[`UnreachableMachineBlockElimPass`] 
| New PM pass that deletes machine basic blocks unreachable from the entry&period;
| xref:llvm/UnrollCostEstimator.adoc[`UnrollCostEstimator`] 
| Produce an estimate of the unrolled cost of the specified loop&period;
| xref:llvm/UnrollLoopOptions.adoc[`UnrollLoopOptions`] 
| Options controlling how `UnrollLoop` transforms a loop&period;
| xref:llvm/UnrollPragmaInfo.adoc[`UnrollPragmaInfo`] 
| Unroll pragma, metadata, and command&hyphen;line overrides for a loop&period;
| xref:llvm/UnrolledInstAnalyzer.adoc[`UnrolledInstAnalyzer`] 
| Estimates optimization effects from complete loop unrolling&period;
| xref:llvm/UnsetInit.adoc[`UnsetInit`] 
| &apos;?&apos; &hyphen; Represents an uninitialized value&period;
| xref:llvm/UnsignedDivisionByConstantInfo.adoc[`UnsignedDivisionByConstantInfo`] 
| Magic data for optimising unsigned division by a constant&period;
| xref:llvm/UpwardDefsElem.adoc[`UpwardDefsElem`] 
| Pair of a memory access and the location being queried while walking up&period;
| xref:llvm/Use.adoc[`Use`] 
| A Use represents the edge between a Value definition and its users&period;
| xref:llvm/UseCaptureInfo.adoc[`UseCaptureInfo`] 
| Capture information for a specific Use&period;
| xref:llvm/UseListOrder.adoc[`UseListOrder`] 
| Structure to hold a use&hyphen;list order&period;
| xref:llvm/User.adoc[`User`] 
| A Value that uses other Values as operands&period;
| xref:llvm/VAArgInst.adoc[`VAArgInst`] 
| Represent the va&lowbar;arg instruction&period;
| xref:llvm/VACopyInst.adoc[`VACopyInst`] 
| This represents the llvm&period;va&lowbar;copy intrinsic&period;
| xref:llvm/VAEndInst.adoc[`VAEndInst`] 
| This represents the llvm&period;va&lowbar;end intrinsic&period;
| xref:llvm/VAStartInst.adoc[`VAStartInst`] 
| This represents the llvm&period;va&lowbar;start intrinsic&period;
| xref:llvm/VFDatabase.adoc[`VFDatabase`] 
| The Vector Function Database&period;
| xref:llvm/VFInfo.adoc[`VFInfo`] 
| Holds the VFShape for a specific scalar to vector function mapping&period;
| xref:llvm/VFParameter.adoc[`VFParameter`] 
| Encapsulates information needed to describe a parameter&period;
| xref:llvm/VFShape.adoc[`VFShape`] 
| Contains the information about the kind of vectorization available&period;
| xref:llvm/VLIWMachineScheduler.adoc[`VLIWMachineScheduler`] 
| Extend the standard ScheduleDAGMILive to provide more context and override the top&hyphen;level schedule() driver&period;
| xref:llvm/VLIWPacketizerList.adoc[`VLIWPacketizerList`] 
| Simple VLIW packetizer that groups instructions using a DFA resource model&period;
| xref:llvm/VLIWResourceModel.adoc[`VLIWResourceModel`] 
| Model of VLIW packet resources used while scheduling SUnits&period;
| xref:llvm/VNInfo.adoc[`VNInfo`] 
| Value Number Information for a live range definition&period;
| xref:llvm/VPBaseLoadStoreSDNode.adoc[`VPBaseLoadStoreSDNode`] 
| This base class is used to represent VP&lowbar;LOAD, VP&lowbar;STORE, EXPERIMENTAL&lowbar;VP&lowbar;STRIDED&lowbar;LOAD and EXPERIMENTAL&lowbar;VP&lowbar;STRIDED&lowbar;STORE nodes
| xref:llvm/VPGatherSDNode.adoc[`VPGatherSDNode`] 
| This class is used to represent an VP&lowbar;GATHER node
| xref:llvm/VPGatherScatterSDNode.adoc[`VPGatherScatterSDNode`] 
| This is a base class used to represent VP&lowbar;GATHER and VP&lowbar;SCATTER nodes
| xref:llvm/VPIntrinsic.adoc[`VPIntrinsic`] 
| This is the common base class for vector predication intrinsics&period;
| xref:llvm/VPLoadFFSDNode.adoc[`VPLoadFFSDNode`] 
| SDNode for VP&lowbar;LOAD&lowbar;FF (vector&hyphen;predicated fault&hyphen;only&hyphen;first load)&period;
| xref:llvm/VPLoadSDNode.adoc[`VPLoadSDNode`] 
| This class is used to represent a VP&lowbar;LOAD node&period;
| xref:llvm/VPReductionIntrinsic.adoc[`VPReductionIntrinsic`] 
| This represents vector predication reduction intrinsics&period;
| xref:llvm/VPSCEVExpander.adoc[`VPSCEVExpander`] 
| Vector predication SCEV expander (defined in SCEVExpander&period;h)&period;
| xref:llvm/VPScatterSDNode.adoc[`VPScatterSDNode`] 
| This class is used to represent an VP&lowbar;SCATTER node
| xref:llvm/VPStoreSDNode.adoc[`VPStoreSDNode`] 
| This class is used to represent a VP&lowbar;STORE node
| xref:llvm/VPStridedLoadSDNode.adoc[`VPStridedLoadSDNode`] 
| This class is used to represent an EXPERIMENTAL&lowbar;VP&lowbar;STRIDED&lowbar;LOAD node&period;
| xref:llvm/VPStridedStoreSDNode.adoc[`VPStridedStoreSDNode`] 
| This class is used to represent an EXPERIMENTAL&lowbar;VP&lowbar;STRIDED&lowbar;STORE node&period;
| xref:llvm/VReg2SUnit.adoc[`VReg2SUnit`] 
| An individual mapping from virtual register number to SUnit&period;
| xref:llvm/VReg2SUnitOperIdx.adoc[`VReg2SUnitOperIdx`] 
| Mapping from virtual register to SUnit including an operand index&period;
| xref:llvm/VRegInfo.adoc[`VRegInfo`] 
| Parsing state for a virtual register referenced in MIR&period;
| xref:llvm/VRegMaskOrUnit.adoc[`VRegMaskOrUnit`] 
| Virtual register or register unit paired with a lane mask&period;
| xref:llvm/VTByHwModePair.adoc[`VTByHwModePair`] 
| Hardware&hyphen;mode and value&hyphen;type pair in a generated VT&hyphen;by&hyphen;HwMode table&period;
| xref:llvm/VTSDNode.adoc[`VTSDNode`] 
| This class is used to represent EVT&apos;s, which are used to parameterize some operations&period;
| xref:llvm/VTableSlotSummary.adoc[`VTableSlotSummary`] 
| Summary of a vtable slot identified by type ID and byte offset&period;
| xref:llvm/ValID.adoc[`ValID`] 
| Untyped reference to a value whose type depends on later context&period;
| xref:llvm/Value.adoc[`Value`] 
| LLVM Value Representation
| xref:llvm/ValueAndVReg.adoc[`ValueAndVReg`] 
| Simple struct used to hold a constant integer value and a virtual register&period;
| xref:llvm/ValueAsMetadata.adoc[`ValueAsMetadata`] 
| Value wrapper in the Metadata hierarchy&period;
| xref:llvm/ValueDeleter.adoc[`ValueDeleter`] 
| Deleter for `unique&lowbar;value` that calls `Value&colon;&colon;deleteValue()&period;`
| xref:llvm/ValueFromPointerCast.adoc[`ValueFromPointerCast`] 
| Cast trait for constructing a value&hyphen;typed `To` from a `From` pointer&period;
| xref:llvm/ValueHandleBase.adoc[`ValueHandleBase`] 
| Befriended by DenseMapBase so it can use bucket&hyphen;relocation erase callbacks&period; ValueHandleBase is the only caller that caches pointers into bucket arrays&period;
| xref:llvm/ValueInfo.adoc[`ValueInfo`] 
| Struct that holds a reference to a particular GUID in a global value summary&period;
| xref:llvm/ValueIsPresent-09.adoc[`ValueIsPresent`] 
| Trait that tests whether a value is present and can unwrap it&period;
| xref:llvm/ValueIterator.adoc[`ValueIterator`] 
| An iterator for Entries all having the same string as key&period;
| xref:llvm/ValueLatticeElement.adoc[`ValueLatticeElement`] 
| This class represents lattice values for constants&period;
| xref:llvm/ValueMap.adoc[`ValueMap`] 
| See the file comment&period;
| xref:llvm/ValueMapCallbackVH.adoc[`ValueMapCallbackVH`] 
| CallbackVH that updates its ValueMap when the contained Value changes&period;
| xref:llvm/ValueMapConfig.adoc[`ValueMapConfig`] 
| Default configuration for configurable aspects of ValueMap&period;
| xref:llvm/ValueMapIteratorImpl.adoc[`ValueMapIteratorImpl`] 
| Forward iterator that unwraps ValueMapCallbackVH keys to `KeyT&period;`
| xref:llvm/ValueMapTypeRemapper.adoc[`ValueMapTypeRemapper`] 
| This is a class that can be implemented by clients to remap types when cloning constants and instructions&period;
| xref:llvm/ValueMapper.adoc[`ValueMapper`] 
| Context for (re&hyphen;)mapping values (and metadata)&period;
| xref:llvm/ValueMaterializer.adoc[`ValueMaterializer`] 
| This is a class that can be implemented by clients to materialize Values on demand&period;
| xref:llvm/ValueSimplifyStateType.adoc[`ValueSimplifyStateType`] 
| State representing an assumed simplified IR value&period;
| xref:llvm/ValueSymbolTable.adoc[`ValueSymbolTable`] 
| A symbol table of name&sol;Value pairs&period;
| xref:llvm/VarBitInit.adoc[`VarBitInit`] 
| Opcode&lcub;0&rcub; &hyphen; Represent access to one bit of a variable or field&period;
| xref:llvm/VarDefInit.adoc[`VarDefInit`] 
| classname&lt;targs&period;&period;&period;&gt; &hyphen; Represent an uninstantiated anonymous class instantiation&period;
| xref:llvm/VarInit.adoc[`VarInit`] 
| &apos;Opcode&apos; &hyphen; Represent a reference to an entire variable object&period;
| xref:llvm/VarLocInfo.adoc[`VarLocInfo`] 
| Variable location definition used by FunctionVarLocs&period;
| xref:llvm/VarStreamArray-03.adoc[`VarStreamArray`] 
| Array of variable&hyphen;length records backed by a BinaryStream&period;
| xref:llvm/VarStreamArrayExtractor-071.adoc[`VarStreamArrayExtractor`] 
| Trait specialized to extract one variable&hyphen;length record from a stream&period;
| xref:llvm/VarStreamArrayIterator.adoc[`VarStreamArrayIterator`] 
| Forward iterator over the records of a VarStreamArray&period;
| xref:llvm/VariadicOperandTraits-04.adoc[`VariadicOperandTraits`] 
| Traits for a prefix Use array sized at allocation time&period;
| xref:llvm/VecDesc.adoc[`VecDesc`] 
| Describes a scalar&hyphen;to&hyphen;vector function mapping for vectorization&period;
| xref:llvm/VectorCombinePass.adoc[`VectorCombinePass`] 
| Optimize scalar&sol;vector interactions in IR using target cost models&period;
| xref:llvm/VectorType.adoc[`VectorType`] 
| Base class of all SIMD vector types
| xref:llvm/VectorizerParams.adoc[`VectorizerParams`] 
| Collection of parameters shared beetween the Loop Vectorizer and the Loop Access Analysis&period;
| xref:llvm/VerifierAnalysis.adoc[`VerifierAnalysis`] 
| Check a module for errors, and report separate error states for IR and debug info errors&period;
| xref:llvm/VerifierPass.adoc[`VerifierPass`] 
| New pass manager pass that verifies IR and optionally aborts on failure&period;
| xref:llvm/VerifierSupport.adoc[`VerifierSupport`] 
| Shared diagnostic and module state used by the IR verifier&period;
| xref:llvm/VerifyInstrumentation.adoc[`VerifyInstrumentation`] 
| Instrumentation that runs the IR verifier after passes&period;
| xref:llvm/VersionTuple.adoc[`VersionTuple`] 
| Represents a version number in the form major&lsqb;&period;minor&lsqb;&period;subminor&lsqb;&period;build&rsqb;&rsqb;&rsqb;&period;
| xref:llvm/Versioned.adoc[`Versioned`] 
| Helpers for reading min&sol;max version fields from a TableGen record&period;
| xref:llvm/VersionedClause.adoc[`VersionedClause`] 
| Accessors for a VersionedClause record defined in DirectiveBase&period;td&period;
| xref:llvm/VirtFuncOffset.adoc[`VirtFuncOffset`] 
| The ValueInfo and offset for a function within a vtable definition initializer array&period;
| xref:llvm/VirtReg2IndexFunctor.adoc[`VirtReg2IndexFunctor`] 
| Functor that maps a virtual register to its dense index&period;
| xref:llvm/VirtRegAuxInfo.adoc[`VirtRegAuxInfo`] 
| Calculate auxiliary information for a virtual register such as its spill weight and allocation hint&period;
| xref:llvm/VirtRegInfo.adoc[`VirtRegInfo`] 
| VirtRegInfo &hyphen; Information about a virtual register used by a set of operands&period;
| xref:llvm/VirtRegMap.adoc[`VirtRegMap`] 
| Maps virtual registers to physical registers and stack slots&period;
| xref:llvm/VirtRegMapAnalysis.adoc[`VirtRegMapAnalysis`] 
| Analysis pass that computes `VirtRegMap` for a machine function&period;
| xref:llvm/VirtRegMapPrinterPass.adoc[`VirtRegMapPrinterPass`] 
| Printer pass for the `VirtRegMapAnalysis` results&period;
| xref:llvm/VirtRegMapWrapperLegacy.adoc[`VirtRegMapWrapperLegacy`] 
| Legacy MachineFunctionPass wrapper that owns a `VirtRegMap&period;`
| xref:llvm/VirtRegOrUnit.adoc[`VirtRegOrUnit`] 
| Wrapper class representing a virtual register or register unit&period;
| xref:llvm/VirtRegRewriterPass.adoc[`VirtRegRewriterPass`] 
| Pass that rewrites virtual registers to physical registers via VirtRegMap&period;
| xref:llvm/WarnMissedTransformationsPass.adoc[`WarnMissedTransformationsPass`] 
| Pass that emits warnings when forced transformations were not performed&period;
| xref:llvm/WasmEHPreparePass.adoc[`WasmEHPreparePass`] 
| New PM pass that prepares WebAssembly exception handling for code generation&period;
| xref:llvm/WeakTrackingVH.adoc[`WeakTrackingVH`] 
| Value handle that is nullable, but tries to track the Value&period;
| xref:llvm/WeakVH.adoc[`WeakVH`] 
| A nullable Value handle that is nullable&period;
| xref:llvm/WholeProgramDevirtPass.adoc[`WholeProgramDevirtPass`] 
| Pass that performs whole&hyphen;program virtual call devirtualization&period;
| xref:llvm/WholeProgramDevirtResolution.adoc[`WholeProgramDevirtResolution`] 
| Whole&hyphen;program virtual call resolution for a (typeid, offset) pair&period;
| xref:llvm/WideIVInfo.adoc[`WideIVInfo`] 
| Information about an induction variable used by sign or zero extends&period;
| xref:llvm/WinCOFFObjectWriter.adoc[`WinCOFFObjectWriter`] 
| Win COFF object writer that emits COFF object files from an MCAssembler&period;
| xref:llvm/WinCOFFWriter.adoc[`WinCOFFWriter`] 
| Helper that emits one Win COFF object stream (main or DWO)&period;
| xref:llvm/WinEHFuncInfo.adoc[`WinEHFuncInfo`] 
| Per&hyphen;function Windows EH tables, state maps, and related frame indices&period;
| xref:llvm/WinEHHandlerType.adoc[`WinEHHandlerType`] 
| Catch&hyphen;handler descriptor stored in a try&hyphen;block map entry&period;
| xref:llvm/WinEHPreparePass.adoc[`WinEHPreparePass`] 
| New PM pass that prepares Windows exception handling for code generation&period;
| xref:llvm/WinEHTryBlockMapEntry.adoc[`WinEHTryBlockMapEntry`] 
| Try&hyphen;region descriptor with the catch handlers that cover it&period;
| xref:llvm/WindowScheduler.adoc[`WindowScheduler`] 
| The main class in the implementation of the target independent window scheduler&period;
| xref:llvm/WindowsResourceProcessor.adoc[`WindowsResourceProcessor`] 
| Compiles Windows resource (&period;rc) script input into a &period;res binary stream&period;
| xref:llvm/WithCache.adoc[`WithCache`] 
| Pointer wrapper that lazily caches KnownBits for the pointed&hyphen;to value&period;
| xref:llvm/WithColor.adoc[`WithColor`] 
| An RAII object that temporarily switches an output stream to a specific color&period;
| xref:llvm/WithOverflowInst.adoc[`WithOverflowInst`] 
| Represents an op&period;with&period;overflow intrinsic&period;
| xref:llvm/WritableBinaryStream.adoc[`WritableBinaryStream`] 
| A BinaryStream that supports both reading and writing&period;
| xref:llvm/WritableBinaryStreamRef.adoc[`WritableBinaryStreamRef`] 
| A copyable, writable window into a WritableBinaryStream&period;
| xref:llvm/WritableMemoryBuffer.adoc[`WritableMemoryBuffer`] 
| MemoryBuffer with copy&hyphen;on&hyphen;write access to a writable backing store&period;
| xref:llvm/WriteThroughMemoryBuffer.adoc[`WriteThroughMemoryBuffer`] 
| MemoryBuffer that maps a file writable and can commit changes back&period;
| xref:llvm/XCOFFObjectWriter.adoc[`XCOFFObjectWriter`] 
| XCOFF object writer that emits XCOFF object files from an MCAssembler&period;
| xref:llvm/XCOFFSymbolInfoTy.adoc[`XCOFFSymbolInfoTy`] 
| XCOFF&hyphen;specific symbol metadata used when ranking or describing symbols&period;
| xref:llvm/XRayInstrumentationPass.adoc[`XRayInstrumentationPass`] 
| New PM pass that inserts XRay instrumentation into machine functions&period;
| xref:llvm/XXH128_hash_t.adoc[`XXH128&lowbar;hash&lowbar;t`] 
| The return value from 128&hyphen;bit hashes&period;
| xref:llvm/ZExtInst.adoc[`ZExtInst`] 
| Instruction that zero&hyphen;extends an integer value to a wider integer type&period;
| xref:llvm/add_const_past_pointer.adoc[`add&lowbar;const&lowbar;past&lowbar;pointer`] 
| If T is a pointer to X, return a pointer to const X&period; If it is not, return const T&period;
| xref:llvm/add_lvalue_reference_if_not_pointer.adoc[`add&lowbar;lvalue&lowbar;reference&lowbar;if&lowbar;not&lowbar;pointer`] 
| If T is a pointer, just return it&period; If it is not, return T&amp;&period;
| xref:llvm/bf_iterator.adoc[`bf&lowbar;iterator`] 
| Generic breadth&hyphen;first search iterator over a graph&period;
| xref:llvm/bf_iterator_storage.adoc[`bf&lowbar;iterator&lowbar;storage`] 
| Storage for the visited&hyphen;node set used by breadth&hyphen;first iterators&period;
| xref:llvm/buffer_ostream.adoc[`buffer&lowbar;ostream`] 
| raw&lowbar;svector&lowbar;ostream that buffers output and flushes to another stream&period;
| xref:llvm/buffer_unique_ostream.adoc[`buffer&lowbar;unique&lowbar;ostream`] 
| raw&lowbar;svector&lowbar;ostream that owns another stream and buffers until destruction&period;
| xref:llvm/cast_convert_val-04.adoc[`cast&lowbar;convert&lowbar;val`] 
| Performs the actual cast after simplifying non&hyphen;simple source values&period;
| xref:llvm/cast_retty.adoc[`cast&lowbar;retty`] 
| Computes the return type of `cast&sol;dyn&lowbar;cast` for `To` and `From&period;`
| xref:llvm/cast_retty_impl-0b.adoc[`cast&lowbar;retty&lowbar;impl`] 
| Implementation detail that computes the return type of cast for `To&sol;From&period;`
| xref:llvm/cast_retty_wrap-07.adoc[`cast&lowbar;retty&lowbar;wrap`] 
| Selects cast return type after optionally simplifying `From&period;`
| xref:llvm/circular_raw_ostream.adoc[`circular&lowbar;raw&lowbar;ostream`] 
| A raw&lowbar;ostream that can save output in a circular buffer&period;
| xref:llvm/concat_iterator.adoc[`concat&lowbar;iterator`] 
| Iterator wrapper that concatenates sequences together&period;
| xref:llvm/const_pointer_or_const_ref.adoc[`const&lowbar;pointer&lowbar;or&lowbar;const&lowbar;ref`] 
| Choose const pointer or const reference based on whether `T` is a pointer&period; Choose const pointer or const reference based on whether `T` is a pointer&period;
| xref:llvm/const_set_bits_iterator_impl.adoc[`const&lowbar;set&lowbar;bits&lowbar;iterator&lowbar;impl`] 
| ForwardIterator for the bits that are set&period; Iterators get invalidated when resize &sol; reserve is called&period;
| xref:llvm/def_chain_iterator.adoc[`def&lowbar;chain&lowbar;iterator`] 
| Forward iterator over the defining&hyphen;access chain of a MemoryDef or MemoryUse&period;
| xref:llvm/deref.adoc[`deref`] 
| Binary functor that adapts to any other binary functor after dereferencing operands&period;
| xref:llvm/df_ext_iterator.adoc[`df&lowbar;ext&lowbar;iterator`] 
| Depth&hyphen;first iterator that stores its visited set externally&period;
| xref:llvm/df_iterator.adoc[`df&lowbar;iterator`] 
| Generic depth&hyphen;first search iterator over a graph&period;
| xref:llvm/df_iterator_default_set.adoc[`df&lowbar;iterator&lowbar;default&lowbar;set`] 
| Default visited&hyphen;node set for depth&hyphen;first iteration&period;
| xref:llvm/df_iterator_storage-0e.adoc[`df&lowbar;iterator&lowbar;storage`] 
| Storage for the visited&hyphen;node set used by depth&hyphen;first iterators&period;
| xref:llvm/early_inc_iterator_impl.adoc[`early&lowbar;inc&lowbar;iterator&lowbar;impl`] 
| A pseudo&hyphen;iterator adaptor that is designed to implement &quot;early increment&quot; style loops&period;
| xref:llvm/enum_iteration_traits-0a.adoc[`enum&lowbar;iteration&lowbar;traits`] 
| Traits marking whether `EnumT` is safe to iterate with enum&lowbar;seq helpers&period;
| xref:llvm/fallible_iterator.adoc[`fallible&lowbar;iterator`] 
| A wrapper class for fallible iterators&period;
| xref:llvm/file_magic.adoc[`file&lowbar;magic`] 
| file&lowbar;magic &hyphen; An &quot;enum class&quot; enumeration of file types based on magic (the first N bytes of the file)&period;
| xref:llvm/filter_iterator_base.adoc[`filter&lowbar;iterator&lowbar;base`] 
| An iterator adaptor that filters the elements of given inner iterators&period;
| xref:llvm/filter_iterator_impl-00.adoc[`filter&lowbar;iterator&lowbar;impl`] 
| Specialization of filter&lowbar;iterator&lowbar;base for forward iteration only&period;
| xref:llvm/fltSemantics.adoc[`fltSemantics`] 
| Describes the parameters of a floating&hyphen;point format used by APFloat&period;
| xref:llvm/force_iteration_on_noniterable_enum_t.adoc[`force&lowbar;iteration&lowbar;on&lowbar;noniterable&lowbar;enum&lowbar;t`] 
| Tag type that opts into iterating enums without enum&lowbar;iteration&lowbar;traits&period;
| xref:llvm/format_object.adoc[`format&lowbar;object`] 
| Captures a printf&hyphen;style format string and values for deferred formatting&period;
| xref:llvm/format_provider-03.adoc[`format&lowbar;provider`] 
| Trait that formats values of type `T` for formatv&period;
| xref:llvm/formatted_raw_ostream.adoc[`formatted&lowbar;raw&lowbar;ostream`] 
| A raw&lowbar;ostream that wraps another and tracks line and column position&period;
| xref:llvm/formatv_object.adoc[`formatv&lowbar;object`] 
| Owning formatv result that stores parameters and type&hyphen;erased adapters&period;
| xref:llvm/formatv_object_base.adoc[`formatv&lowbar;object&lowbar;base`] 
| Base class for formatv objects used by Twine&period;
| xref:llvm/from_range_t.adoc[`from&lowbar;range&lowbar;t`] 
| Tag type indicating that a constructor should initialize from a range&period;
| xref:llvm/function_ref-03.adoc[`function&lowbar;ref`] 
| An efficient, type&hyphen;erasing, non&hyphen;owning reference to a callable&period;
| xref:llvm/function_traits-0b.adoc[`function&lowbar;traits`] 
| Trait information about a callable object&apos;s arguments and result type&period;
| xref:llvm/generic_gep_type_iterator.adoc[`generic&lowbar;gep&lowbar;type&lowbar;iterator`] 
| Iterator over the types indexed by a getelementptr instruction or operator&period;
| xref:llvm/hash_code.adoc[`hash&lowbar;code`] 
| An opaque object representing a hash code&period;
| xref:llvm/identity.adoc[`identity`] 
| Function object that returns its argument unchanged&period;
| xref:llvm/idf_ext_iterator.adoc[`idf&lowbar;ext&lowbar;iterator`] 
| Inverse depth&hyphen;first iterator that stores its visited set externally&period;
| xref:llvm/idf_iterator.adoc[`idf&lowbar;iterator`] 
| Depth&hyphen;first iterator over the inverse of graph `T&period;`
| xref:llvm/ilist_alloc_traits-0b7.adoc[`ilist&lowbar;alloc&lowbar;traits`] 
| Use delete by default for iplist and ilist&period;
| xref:llvm/ilist_base.adoc[`ilist&lowbar;base`] 
| Implementations of list algorithms using ilist&lowbar;node&lowbar;base&period;
| xref:llvm/ilist_callback_traits-09.adoc[`ilist&lowbar;callback&lowbar;traits`] 
| Callbacks do nothing by default in iplist and ilist&period;
| xref:llvm/ilist_iterator.adoc[`ilist&lowbar;iterator`] 
| Iterator for intrusive lists based on ilist&lowbar;node&period;
| xref:llvm/ilist_iterator_bits.adoc[`ilist&lowbar;iterator&lowbar;bits`] 
| Option to add extra bits to the ilist&lowbar;iterator&period;
| xref:llvm/ilist_iterator_w_bits.adoc[`ilist&lowbar;iterator&lowbar;w&lowbar;bits`] 
| Iterator for ilist&lowbar;node lists that records half&hyphen;open range bits&period;
| xref:llvm/ilist_noalloc_traits.adoc[`ilist&lowbar;noalloc&lowbar;traits`] 
| Custom traits to do nothing on deletion&period;
| xref:llvm/ilist_node-0c.adoc[`ilist&lowbar;node`] 
| An intrusive list node&period;
| xref:llvm/ilist_node_base.adoc[`ilist&lowbar;node&lowbar;base`] 
| Base class for ilist nodes&period;
| xref:llvm/ilist_node_impl-0748.adoc[`ilist&lowbar;node&lowbar;impl`] 
| Implementation for an ilist node&period;
| xref:llvm/ilist_node_traits-0993.adoc[`ilist&lowbar;node&lowbar;traits`] 
| A fragment for template traits for intrusive list that provides default node related operations&period;
| xref:llvm/ilist_node_with_parent-02.adoc[`ilist&lowbar;node&lowbar;with&lowbar;parent`] 
| An ilist node that can access its parent list&period;
| xref:llvm/ilist_parent.adoc[`ilist&lowbar;parent`] 
| Option to add a pointer to this list&apos;s owner in every node&period;
| xref:llvm/ilist_sentinel.adoc[`ilist&lowbar;sentinel`] 
| Sentinel node that marks the end of an intrusive list&period;
| xref:llvm/ilist_sentinel_tracking.adoc[`ilist&lowbar;sentinel&lowbar;tracking`] 
| Option to choose whether to track sentinels&period;
| xref:llvm/ilist_tag.adoc[`ilist&lowbar;tag`] 
| Option to specify a tag for the node type&period;
| xref:llvm/ilist_traits-05.adoc[`ilist&lowbar;traits`] 
| Template traits for intrusive list&period;
| xref:llvm/indent.adoc[`indent`] 
| Value that inserts spaces when streamed into a raw&lowbar;ostream&period;
| xref:llvm/index_range.adoc[`index&lowbar;range`] 
| Increasing range of `size&lowbar;t` indices&period;
| xref:llvm/indexed_accessor_iterator.adoc[`indexed&lowbar;accessor&lowbar;iterator`] 
| A utility class used to implement an iterator that contains some base object and an index&period; The iterator moves the index but keeps the base constant&period;
| xref:llvm/indexed_accessor_range.adoc[`indexed&lowbar;accessor&lowbar;range`] 
| Range of indexed accessor iterators over a non&hyphen;indexable base&period;
| xref:llvm/iota_range.adoc[`iota&lowbar;range`] 
| Half&hyphen;open or closed integer&sol;enum range yielding successive values of type `T&period;`
| xref:llvm/iplist.adoc[`iplist`] 
| An intrusive list with ownership and callbacks specified&sol;controlled by ilist&lowbar;traits, only with API safe for polymorphic types&period;
| xref:llvm/iplist_impl-04.adoc[`iplist&lowbar;impl`] 
| A wrapper around an intrusive list with callbacks and non&hyphen;intrusive ownership&period;
| xref:llvm/is_bitmask_enum-03.adoc[`is&lowbar;bitmask&lowbar;enum`] 
| Mark `FPClassTest` as a bitmask enumeration for bitwise operators&period;
| xref:llvm/is_bitmask_enum-04e.adoc[`is&lowbar;bitmask&lowbar;enum`] 
| Trait specialization marking SDNodeFlags bitmask enumerators as a bitmask enum&period;
| xref:llvm/is_bitmask_enum-046.adoc[`is&lowbar;bitmask&lowbar;enum`] 
| Partial specialization that is true when `E` is a bitmask enum&period;
| xref:llvm/is_integral_or_enum.adoc[`is&lowbar;integral&lowbar;or&lowbar;enum`] 
| Metafunction that determines whether the given type is either an integral type or an enumeration type, including enum classes&period;
| xref:llvm/is_simple_type.adoc[`is&lowbar;simple&lowbar;type`] 
| Trait that is true when `X` is already a simplified type&period;
| xref:llvm/isa_impl-09.adoc[`isa&lowbar;impl`] 
| Core implementation of `isa` that invokes `To&colon;&colon;classof&period;`
| xref:llvm/isa_impl_cl-0c6.adoc[`isa&lowbar;impl&lowbar;cl`] 
| Const&hyphen;aware wrapper that forwards `isa` checks to `isa&lowbar;impl&period;`
| xref:llvm/isa_impl_wrap-01.adoc[`isa&lowbar;impl&lowbar;wrap`] 
| Recursively simplifies `From` via `simplify&lowbar;type` before the `isa` check&period;
| xref:llvm/iterator_adaptor_base-081.adoc[`iterator&lowbar;adaptor&lowbar;base`] 
| CRTP base class for adapting an iterator to a different type&period;
| xref:llvm/iterator_facade_base-08c.adoc[`iterator&lowbar;facade&lowbar;base`] 
| CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of the interface&period;
| xref:llvm/iterator_range-0b.adoc[`iterator&lowbar;range`] 
| A range adaptor for a pair of iterators&period;
| xref:llvm/largest_bitmask_enum_bit-02.adoc[`largest&lowbar;bitmask&lowbar;enum&lowbar;bit`] 
| Largest individual bit value used by `FPClassTest` bitmask operations&period;
| xref:llvm/largest_bitmask_enum_bit-0a.adoc[`largest&lowbar;bitmask&lowbar;enum&lowbar;bit`] 
| Trait specialization giving the largest SDNodeFlags bitmask enumerator value&period;
| xref:llvm/largest_bitmask_enum_bit-0d.adoc[`largest&lowbar;bitmask&lowbar;enum&lowbar;bit`] 
| Partial specialization providing the largest bit value of bitmask enum `E&period;`
| xref:llvm/latency_sort.adoc[`latency&lowbar;sort`] 
| Sorting functions for the Available queue&period;
| xref:llvm/less_first.adoc[`less&lowbar;first`] 
| Compare first components of pair&hyphen;like values with std&colon;&colon;less&period;
| xref:llvm/less_second.adoc[`less&lowbar;second`] 
| Compare second components of pair&hyphen;like values with std&colon;&colon;less&period;
| xref:llvm/line_iterator.adoc[`line&lowbar;iterator`] 
| A forward iterator which reads text lines from a buffer&period;
| xref:llvm/llvm_shutdown_obj.adoc[`llvm&lowbar;shutdown&lowbar;obj`] 
| llvm&lowbar;shutdown&lowbar;obj &hyphen; This is a simple helper class that calls llvm&lowbar;shutdown() when it is destroyed&period;
| xref:llvm/location_op_iterator.adoc[`location&lowbar;op&lowbar;iterator`] 
| Bidirectional iterator over debug&hyphen;info location operands&period;
| xref:llvm/make_const_ptr.adoc[`make&lowbar;const&lowbar;ptr`] 
| Trait that yields a pointer to const `T&period;`
| xref:llvm/make_const_ref.adoc[`make&lowbar;const&lowbar;ref`] 
| Trait that yields a const lvalue reference to `T&period;`
| xref:llvm/mapped_iterator.adoc[`mapped&lowbar;iterator`] 
| Iterator adapter that applies a function when dereferenced&period;
| xref:llvm/mapped_iterator_base.adoc[`mapped&lowbar;iterator&lowbar;base`] 
| Base class for mapped iterators without stored function objects&period;
| xref:llvm/memoryaccess_def_iterator_base.adoc[`memoryaccess&lowbar;def&lowbar;iterator&lowbar;base`] 
| Iterator over the defining accesses of a MemoryAccess&period;
| xref:llvm/object_creator.adoc[`object&lowbar;creator`] 
| object&lowbar;creator &hyphen; Helper method for ManagedStatic&period;
| xref:llvm/object_deleter-02.adoc[`object&lowbar;deleter`] 
| object&lowbar;deleter &hyphen; Helper method for ManagedStatic&period;
| xref:llvm/on_first.adoc[`on&lowbar;first`] 
| Function object to apply a binary function to the first component of a std&colon;&colon;pair&period;
| xref:llvm/pair_hash.adoc[`pair&lowbar;hash`] 
| Hash functor for `std&colon;&colon;pair` values&period;
| xref:llvm/pointee_iterator.adoc[`pointee&lowbar;iterator`] 
| An iterator type that allows iterating over the pointees via some other iterator&period;
| xref:llvm/pointer_iterator.adoc[`pointer&lowbar;iterator`] 
| An iterator adaptor that yields pointers to the wrapped iterator&apos;s elements&period;
| xref:llvm/rank-06.adoc[`rank`] 
| Inheritance&hyphen;chain tag used to rank overload candidates&period;
| xref:llvm/raw_fd_ostream.adoc[`raw&lowbar;fd&lowbar;ostream`] 
| A raw&lowbar;ostream that writes to a file descriptor&period;
| xref:llvm/raw_fd_stream.adoc[`raw&lowbar;fd&lowbar;stream`] 
| A raw&lowbar;ostream of a file for reading&sol;writing&sol;seeking&period;
| xref:llvm/raw_null_ostream.adoc[`raw&lowbar;null&lowbar;ostream`] 
| A raw&lowbar;ostream that discards all output&period;
| xref:llvm/raw_os_ostream.adoc[`raw&lowbar;os&lowbar;ostream`] 
| A raw&lowbar;ostream that writes to an std&colon;&colon;ostream&period;
| xref:llvm/raw_ostream.adoc[`raw&lowbar;ostream`] 
| Extremely fast bulk output stream that only supports sequential writing&period;
| xref:llvm/raw_ostream_proxy.adoc[`raw&lowbar;ostream&lowbar;proxy`] 
| Non&hyphen;owning proxy for a _raw&lowbar;ostream&period;_ Enables passing a stream into an API that takes ownership&period;
| xref:llvm/raw_ostream_proxy_adaptor-0f.adoc[`raw&lowbar;ostream&lowbar;proxy&lowbar;adaptor`] 
| Adaptor to create a stream class that proxies another _raw&lowbar;ostream&period;_
| xref:llvm/raw_pwrite_stream.adoc[`raw&lowbar;pwrite&lowbar;stream`] 
| Abstract base for streams that also support a pwrite operation&period;
| xref:llvm/raw_pwrite_stream_proxy.adoc[`raw&lowbar;pwrite&lowbar;stream&lowbar;proxy`] 
| Non&hyphen;owning proxy for a _raw&lowbar;pwrite&lowbar;stream&period;_ Enables passing a stream into an API that takes ownership&period;
| xref:llvm/raw_pwrite_stream_proxy_adaptor-02.adoc[`raw&lowbar;pwrite&lowbar;stream&lowbar;proxy&lowbar;adaptor`] 
| Adaptor for creating a stream that proxies a _raw&lowbar;pwrite&lowbar;stream&period;_
| xref:llvm/raw_sha1_ostream.adoc[`raw&lowbar;sha1&lowbar;ostream`] 
| A raw&lowbar;ostream that hash the content using the sha1 algorithm&period;
| xref:llvm/raw_socket_stream.adoc[`raw&lowbar;socket&lowbar;stream`] 
| A raw&lowbar;fd&lowbar;stream that communicates over a UNIX domain socket&period;
| xref:llvm/raw_string_ostream.adoc[`raw&lowbar;string&lowbar;ostream`] 
| A raw&lowbar;ostream that writes to an std&colon;&colon;string&period;
| xref:llvm/raw_svector_ostream.adoc[`raw&lowbar;svector&lowbar;ostream`] 
| A raw&lowbar;ostream that writes to a SmallVector or SmallString&period;
| xref:llvm/remove_cvref.adoc[`remove&lowbar;cvref`] 
| Remove cv&hyphen;qualifiers and references from `T&period;`
| xref:llvm/resource_sort.adoc[`resource&lowbar;sort`] 
| Sorting functions for the Available queue&period;
| xref:llvm/scc_iterator.adoc[`scc&lowbar;iterator`] 
| Enumerate the SCCs of a directed graph in reverse topological order of the SCC DAG&period;
| xref:llvm/scc_member_iterator.adoc[`scc&lowbar;member&lowbar;iterator`] 
| Reorder nodes of a directed SCC by decreasing edge weight&period;
| xref:llvm/scope_exit-07.adoc[`scope&lowbar;exit`] 
| RAII guard that invokes a callable when leaving the current scope&period;
| xref:llvm/simple_ilist-01.adoc[`simple&lowbar;ilist`] 
| A simple intrusive list implementation&period;
| xref:llvm/simplify_type-0af8.adoc[`simplify&lowbar;type`] 
| Trait that maps a possibly wrapped type to the type used for casting&period;
| xref:llvm/thread.adoc[`thread`] 
| LLVM thread following std&colon;&colon;thread interface with added constructor to specify stack size&period;
| xref:llvm/type_identity.adoc[`type&lowbar;identity`] 
| Backport of C&plus;&plus;20 `std&colon;&colon;type&lowbar;identity&period;`
| xref:llvm/unique_function-09.adoc[`unique&lowbar;function`] 
| unique&lowbar;function is a type&hyphen;erasing functor similar to std&colon;&colon;function&period;
| xref:llvm/upward_defs_iterator.adoc[`upward&lowbar;defs&lowbar;iterator`] 
| Iterator that walks defs with a phi&hyphen;translated memory location&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:llvm/AAAlignmentStateType.adoc[`AAAlignmentStateType`] 
| Integer state type used by AAAlign&period;
| xref:llvm/AddBufferFn.adoc[`AddBufferFn`] 
| This type defines the callback to add a pre&hyphen;existing file (e&period;g&period; in a cache)&period;
| xref:llvm/AddStreamFn.adoc[`AddStreamFn`] 
| This type defines the callback to add a file that is generated on the fly&period;
| xref:llvm/AliasAnalysis.adoc[`AliasAnalysis`] 
| Temporary typedef for legacy code that uses a generic `AliasAnalysis` pointer or reference&period;
| xref:llvm/AnalysisID.adoc[`AnalysisID`] 
| Opaque identity key for a pass, typically the address of its static ID&period;
| xref:llvm/AnchorList.adoc[`AnchorList`] 
| Ordered sequence of (location, callee) pairs used as matching anchors&period;
| xref:llvm/AnchorMap.adoc[`AnchorMap`] 
| Location&hyphen;to&hyphen;callee map of matching anchors extracted from IR or a profile&period;
| xref:llvm/ArgAuxType.adoc[`ArgAuxType`] 
| Stores either a positional argument index or a named argument key&period;
| xref:llvm/Assume2KnowledgeMap.adoc[`Assume2KnowledgeMap`] 
| Map from llvm&period;assume intrinsics to encoded knowledge value ranges&period;
| xref:llvm/BLAKE3Result.adoc[`BLAKE3Result`] 
| The constant `LLVM&lowbar;BLAKE3&lowbar;OUT&lowbar;LEN` provides the default output length, 32 bytes, which is recommended for most callers&period;
| xref:llvm/BlockIdMap.adoc[`BlockIdMap`] 
| Map from a basic block to its pseudo&hyphen;probe ID&period;
| xref:llvm/BlockSequence.adoc[`BlockSequence`] 
| A sequence of basic blocks&period;
| xref:llvm/Boolean.adoc[`Boolean`] 
| Boolean type used by the ConvertUTF routines&semi; 0 or 1&period;
| xref:llvm/BuildFnTy.adoc[`BuildFnTy`] 
| Callback that builds replacement MIR using a MachineIRBuilder&period;
| xref:llvm/BumpPtrAllocator.adoc[`BumpPtrAllocator`] 
| The standard BumpPtrAllocator which just uses the default template parameters&period;
| xref:llvm/BumpPtrList.adoc[`BumpPtrList`] 
| AllocatorList specialized to allocate nodes from a bump&hyphen;pointer allocator&period;
| xref:llvm/CCAssignFn.adoc[`CCAssignFn`] 
| CCAssignFn &hyphen; This function assigns a location for Val, updating State to reflect the change&period; It returns &apos;true&apos; if it failed to handle Val&period;
| xref:llvm/CCCustomFn.adoc[`CCCustomFn`] 
| Callback that assigns a custom location for a calling&hyphen;convention value&period;
| xref:llvm/CFGUpdate.adoc[`CFGUpdate`] 
| CFG edge update used when applying MemorySSA updates&period;
| xref:llvm/CGSCCAnalysisManager.adoc[`CGSCCAnalysisManager`] 
| The CGSCC analysis manager&period;
| xref:llvm/CGSCCAnalysisManagerFunctionProxy.adoc[`CGSCCAnalysisManagerFunctionProxy`] 
| A proxy from a `CGSCCAnalysisManager` to a `Function&period;`
| xref:llvm/CGSCCAnalysisManagerModuleProxy.adoc[`CGSCCAnalysisManagerModuleProxy`] 
| A proxy from a `CGSCCAnalysisManager` to a `Module&period;`
| xref:llvm/CGSCCPassManager.adoc[`CGSCCPassManager`] 
| The CGSCC pass manager&period;
| xref:llvm/CacheCostTy.adoc[`CacheCostTy`] 
| Estimated cache cost in cache&hyphen;line units, as an InstructionCost&period;
| xref:llvm/ClusterInfo.adoc[`ClusterInfo`] 
| Keep record of which SUnit are in the same cluster group&period;
| xref:llvm/ColorVector.adoc[`ColorVector`] 
| Vector of basic blocks sharing an EH &quot;color&quot; (funclet membership)&period;
| xref:llvm/ConstMap.adoc[`ConstMap`] 
| Map of known constants found during specialization bonus estimation&period;
| xref:llvm/ConstOperandBundleDef.adoc[`ConstOperandBundleDef`] 
| Operand bundle definition with const `Value&ast;` inputs&period;
| xref:llvm/ContextualFoldingSet.adoc[`ContextualFoldingSet`] 
| FoldingSet that passes a fixed context to each node&apos;s Profile&period;
| xref:llvm/ConvergenceVerifier.adoc[`ConvergenceVerifier`] 
| Verifier for static convergence&hyphen;control token rules in LLVM IR&period;
| xref:llvm/Cost.adoc[`Cost`] 
| Instruction cost type used by specialization profitability estimates&period;
| xref:llvm/CostTblEntry.adoc[`CostTblEntry`] 
| Cost table entry whose cost is a 16&hyphen;bit integer&period;
| xref:llvm/CtxProfContextualProfiles.adoc[`CtxProfContextualProfiles`] 
| Map from root GUID to its contextual profile tree&period;
| xref:llvm/CtxProfFlatIndirectCallProfile.adoc[`CtxProfFlatIndirectCallProfile`] 
| Flat contextual profile of indirect&hyphen;call targets keyed by caller and site&period;
| xref:llvm/CtxProfFlatProfile.adoc[`CtxProfFlatProfile`] 
| Flat profile&colon; per&hyphen;GUID counter vectors without contextual nesting&period;
| xref:llvm/DDGBase.adoc[`DDGBase`] 
| Directed&hyphen;graph base type for a data dependence graph&period;
| xref:llvm/DDGDotGraphTraits.adoc[`DDGDotGraphTraits`] 
| Convenience alias for DOTGraphTraits specialized on a const DDG&period;
| xref:llvm/DDGEdgeBase.adoc[`DDGEdgeBase`] 
| Directed&hyphen;graph edge base type used by DDG edges&period;
| xref:llvm/DDGInfo.adoc[`DDGInfo`] 
| Dependence&hyphen;graph info specialized for DDG nodes&period;
| xref:llvm/DDGNodeBase.adoc[`DDGNodeBase`] 
| Directed&hyphen;graph node base type used by DDG nodes&period;
| xref:llvm/DILineInfoTable.adoc[`DILineInfoTable`] 
| Table of absolute addresses paired with their DILineInfo&period;
| xref:llvm/DWARFAddressRangesVector.adoc[`DWARFAddressRangesVector`] 
| DWARFAddressRangesVector &hyphen; represents a set of absolute address ranges&period;
| xref:llvm/DWARFLocationExpressionsVector.adoc[`DWARFLocationExpressionsVector`] 
| Represents a set of absolute location expressions&period;
| xref:llvm/DWARFRegNum.adoc[`DWARFRegNum`] 
| DWARF register number used by CFI unwinding rules&period;
| xref:llvm/DataLayoutCallbackFuncTy.adoc[`DataLayoutCallbackFuncTy`] 
| Callback that may override the data layout of an imported bitcode module&period;
| xref:llvm/DataLayoutCallbackTy-0c.adoc[`DataLayoutCallbackTy`] 
| Callback that may override the data layout string found in LLVM assembly&period;
| xref:llvm/DataLayoutCallbackTy-04.adoc[`DataLayoutCallbackTy`] 
| Callback that may override the data layout of a parsed MIR module&period;
| xref:llvm/DbgRecordIterator.adoc[`DbgRecordIterator`] 
| Iterator over debug records in a simple intrusive list&period;
| xref:llvm/DebugLocRef.adoc[`DebugLocRef`] 
| Alias for the stored debug&hyphen;location representation (a `DILocation` &ast; when coverage tracking is disabled)&period;
| xref:llvm/DefaultThreadPool.adoc[`DefaultThreadPool`] 
| Preferred thread&hyphen;pool type when LLVM is built with thread support&period;
| xref:llvm/DiagnosticHandlerFunction.adoc[`DiagnosticHandlerFunction`] 
| Callback type that receives a diagnostic for handling&period;
| xref:llvm/DomTreeBase.adoc[`DomTreeBase`] 
| Dominator tree specialization (not post&hyphen;dominator)&period;
| xref:llvm/DomTreeNode.adoc[`DomTreeNode`] 
| Dominator tree node for a BasicBlock&period;
| xref:llvm/EnableIfConvertibleToInputIterator.adoc[`EnableIfConvertibleToInputIterator`] 
| SFINAE helper that is valid when `Iterator` models an input iterator&period;
| xref:llvm/ExceptionSymbolProvider.adoc[`ExceptionSymbolProvider`] 
| Callback that returns an exception symbol for a basic block&period;
| xref:llvm/FileCacheFunction.adoc[`FileCacheFunction`] 
| This is a callable that manages file caching operations&period;
| xref:llvm/FlatIndirectTargets.adoc[`FlatIndirectTargets`] 
| Flat map from callee GUID to an indirect&hyphen;call target count&period;
| xref:llvm/FloatingPointPredicateUtils.adoc[`FloatingPointPredicateUtils`] 
| Floating&hyphen;point predicate utilities specialized for LLVM IR&period;
| xref:llvm/FoldingSet.adoc[`FoldingSet`] 
| Specialized FoldingSet for node class `T&period;`
| xref:llvm/FoldingSetNode.adoc[`FoldingSetNode`] 
| Convenience alias for the base node type stored in a folding set&period;
| xref:llvm/ForwardIDFCalculator.adoc[`ForwardIDFCalculator`] 
| Forward iterated dominance frontier calculator over BasicBlocks&period;
| xref:llvm/FuncProbeFactorMap.adoc[`FuncProbeFactorMap`] 
| Map from a function name to that function&apos;s probe distribution factors&period;
| xref:llvm/FunctionAnalysisManager.adoc[`FunctionAnalysisManager`] 
| Convenience typedef for the Function analysis manager&period;
| xref:llvm/FunctionAnalysisManagerLoopProxy.adoc[`FunctionAnalysisManagerLoopProxy`] 
| A proxy from a `FunctionAnalysisManager` to a `Loop&period;`
| xref:llvm/FunctionAnalysisManagerModuleProxy.adoc[`FunctionAnalysisManagerModuleProxy`] 
| Provide the `FunctionAnalysisManager` to `Module` proxy&period;
| xref:llvm/FunctionCreator.adoc[`FunctionCreator`] 
| Callback that materializes an unknown function by name for the JIT&period;
| xref:llvm/FunctionModRefBehavior.adoc[`FunctionModRefBehavior`] 
| Legacy alias for `MemoryEffects&period;`
| xref:llvm/FunctionPassManager.adoc[`FunctionPassManager`] 
| Convenience typedef for a pass manager over functions&period;
| xref:llvm/FuzzerInitFun.adoc[`FuzzerInitFun`] 
| Callback type for initializing a fuzzer before running inputs&period;
| xref:llvm/FuzzerTestFun.adoc[`FuzzerTestFun`] 
| Callback type for testing a single fuzzer input&period;
| xref:llvm/GCMetadataPrinterRegistry.adoc[`GCMetadataPrinterRegistry`] 
| GCMetadataPrinterRegistry &hyphen; The GC assembly printer registry uses all the defaults from Registry&period;
| xref:llvm/GCRegistry.adoc[`GCRegistry`] 
| Registry of GCStrategy subclasses available during compilation&period;
| xref:llvm/GVSummaryMapTy.adoc[`GVSummaryMapTy`] 
| Map of global value GUID to its summary, used to identify values defined in a particular module, and provide efficient access to their summary&period;
| xref:llvm/GVSummaryPtrSet.adoc[`GVSummaryPtrSet`] 
| A set of global value summary pointers&period;
| xref:llvm/GetContainedTypeIDTy.adoc[`GetContainedTypeIDTy`] 
| Function that returns the type ID of a contained type by index&period;
| xref:llvm/GetTypeByIDTy.adoc[`GetTypeByIDTy`] 
| Function that looks up a Type by its bitcode type ID&period;
| xref:llvm/GetterTy.adoc[`GetterTy`] 
| Function type that returns an analysis of type `T` for a Function&period;
| xref:llvm/GlobalCtorTransformFn.adoc[`GlobalCtorTransformFn`] 
| Callback that transforms a single global constructor record&period;
| xref:llvm/GlobalValueSummaryList.adoc[`GlobalValueSummaryList`] 
| List of owned global value summary instances for one GUID&period;
| xref:llvm/GlobalValueSummaryMapTy.adoc[`GlobalValueSummaryMapTy`] 
| Type alias for the GUID&hyphen;to&hyphen;summary map used throughout the index&period;
| xref:llvm/HTTPContentProvider.adoc[`HTTPContentProvider`] 
| Callback that supplies a chunk of a streaming HTTP response body&period;
| xref:llvm/HTTPRequestHandler.adoc[`HTTPRequestHandler`] 
| Callable that handles an inbound HTTPServerRequest&period;
| xref:llvm/HasIteratorTag.adoc[`HasIteratorTag`] 
| True if `Iterator&apos;s` category is convertible to `Tag&period;`
| xref:llvm/HasRunOnLoopT.adoc[`HasRunOnLoopT`] 
| Detects whether `PassT` provides a loop `run` method (not loop&hyphen;nest)&period;
| xref:llvm/HashNodeIdMapTy.adoc[`HashNodeIdMapTy`] 
| Map from HashNode pointers to their stable node IDs&period;
| xref:llvm/IdHashNodeMapTy.adoc[`IdHashNodeMapTy`] 
| Map from node IDs to mutable HashNode pointers&period;
| xref:llvm/IdHashNodeStableMapTy.adoc[`IdHashNodeStableMapTy`] 
| Map from stable node IDs to their serialized HashNodeStable records&period;
| xref:llvm/IdxMBBPair.adoc[`IdxMBBPair`] 
| Pair of a SlotIndex and the MachineBasicBlock that starts there&period;
| xref:llvm/IgnoreOperandFunc.adoc[`IgnoreOperandFunc`] 
| A function that takes an instruction and an operand index and returns true if the operand should be ignored in the function hash computation&period;
| xref:llvm/IndexInstrMap.adoc[`IndexInstrMap`] 
| A map from an instruction index to an instruction pointer&period;
| xref:llvm/IndexOperandHashMapType.adoc[`IndexOperandHashMapType`] 
| A map from an IndexPair to a stable hash&period;
| xref:llvm/IndexOperandHashVecType.adoc[`IndexOperandHashVecType`] 
| A vector of skipped operand IndexPair&sol;hash pairs&period;
| xref:llvm/IndexPair.adoc[`IndexPair`] 
| The pair of an instruction index and a operand index&period;
| xref:llvm/IndexPairHash.adoc[`IndexPairHash`] 
| A pair of an IndexPair and the stable hash of the skipped operand&period;
| xref:llvm/InlineCostFeatures.adoc[`InlineCostFeatures`] 
| Array of per&hyphen;call&hyphen;site heuristic inline cost feature values&period;
| xref:llvm/InlineFeatures.adoc[`InlineFeatures`] 
| Vector of ML inliner feature values for a call site&period;
| xref:llvm/InlineSite.adoc[`InlineSite`] 
| An inline frame as the pair `&lt;CalleeGuid, ProbeID&gt;`&period;
| xref:llvm/InsnRange.adoc[`InsnRange`] 
| This is used to track range of instructions with identical lexical scope&period;
| xref:llvm/InstructionIdMap.adoc[`InstructionIdMap`] 
| Map from an instruction to its pseudo&hyphen;probe ID&period;
| xref:llvm/JITTargetAddress.adoc[`JITTargetAddress`] 
| Represents an address in the target process&apos;s address space&period;
| xref:llvm/LargestSDNode.adoc[`LargestSDNode`] 
| A representation of the largest SDNode, for use in sizeof()&period;
| xref:llvm/LegalityPredicate.adoc[`LegalityPredicate`] 
| Predicate that decides whether a legality query matches a rule&period;
| xref:llvm/LegalizeMutation.adoc[`LegalizeMutation`] 
| Mutation that selects a type index and replacement LLT for an action&period;
| xref:llvm/LiveRegUnitSet.adoc[`LiveRegUnitSet`] 
| Sparse set of live register units keyed by regunit index&period;
| xref:llvm/LiveVirtRegBitSet.adoc[`LiveVirtRegBitSet`] 
| Bit set of live virtual registers used when verifying unions&period;
| xref:llvm/LoopAnalysisManager.adoc[`LoopAnalysisManager`] 
| The loop analysis manager&period;
| xref:llvm/LoopAnalysisManagerFunctionProxy.adoc[`LoopAnalysisManagerFunctionProxy`] 
| A proxy from a `LoopAnalysisManager` to a `Function&period;`
| xref:llvm/LoopPassManager.adoc[`LoopPassManager`] 
| The Loop pass manager&period;
| xref:llvm/LoopToScevMapT.adoc[`LoopToScevMapT`] 
| Map from loops to SCEVs used to evaluate add&hyphen;recurrences&period;
| xref:llvm/LoopVectorTy.adoc[`LoopVectorTy`] 
| A vector of loops, typically the loops of a nest in breadth&hyphen;first order&period;
| xref:llvm/MBBOrBasicBlock.adoc[`MBBOrBasicBlock`] 
| Pointer to either an IR basic block or a machine basic block&period;
| xref:llvm/MCAsmMacroParameters.adoc[`MCAsmMacroParameters`] 
| List of formal parameters for an assembler macro&period;
| xref:llvm/MCFixupKind.adoc[`MCFixupKind`] 
| Extensible enumeration to represent the type of a fixup&period;
| xref:llvm/MCLOHArgs.adoc[`MCLOHArgs`] 
| Alias for the argument list type used by LOH directives&period;
| xref:llvm/MCLOHDirectives.adoc[`MCLOHDirectives`] 
| Alias for the directive list type used by LOH containers&period;
| xref:llvm/MCPhysReg.adoc[`MCPhysReg`] 
| An unsigned integer type large enough to represent all physical registers, but not necessarily virtual registers&period;
| xref:llvm/MCPseudoProbeFrameLocation.adoc[`MCPseudoProbeFrameLocation`] 
| A callsite identified by caller function name and probe id&period;
| xref:llvm/MCPseudoProbeInlineStack.adoc[`MCPseudoProbeInlineStack`] 
| Stack of inline sites from outermost caller to innermost callee&period;
| xref:llvm/MCSectionSubPair.adoc[`MCSectionSubPair`] 
| Pair of a section and a subsection index&period;
| xref:llvm/MCSymbolTableEntry.adoc[`MCSymbolTableEntry`] 
| String map entry holding an MCSymbolTableValue in an MCContext&period;
| xref:llvm/MDTypeCallbackTy.adoc[`MDTypeCallbackTy`] 
| Callback invoked for each Metadata value with its type ID and helpers&period;
| xref:llvm/MFGetterFnT.adoc[`MFGetterFnT`] 
| Callback that returns the MachineFunction for a given IR Function&period;
| xref:llvm/MachineBasicBlockComparator.adoc[`MachineBasicBlockComparator`] 
| Comparator used to order machine basic blocks for section layout&period;
| xref:llvm/MachineConvergenceVerifier.adoc[`MachineConvergenceVerifier`] 
| Convergence verifier specialized for Machine IR&period;
| xref:llvm/MachineDomTreeNode.adoc[`MachineDomTreeNode`] 
| Dominator tree node for a MachineBasicBlock&period;
| xref:llvm/MachineFloatingPointPredicateUtils.adoc[`MachineFloatingPointPredicateUtils`] 
| Floating&hyphen;point predicate utilities specialized for Machine IR&period;
| xref:llvm/MachineFunctionAnalysisManager.adoc[`MachineFunctionAnalysisManager`] 
| Convenience typedef for the MachineFunction analysis manager&period;
| xref:llvm/MachineFunctionAnalysisManagerFunctionProxy.adoc[`MachineFunctionAnalysisManagerFunctionProxy`] 
| Provide the `MachineFunctionAnalysisManager` to `Function` proxy&period;
| xref:llvm/MachineFunctionAnalysisManagerModuleProxy.adoc[`MachineFunctionAnalysisManagerModuleProxy`] 
| Provide the `MachineFunctionAnalysisManager` to `Module` proxy&period;
| xref:llvm/MachineFunctionPassManager.adoc[`MachineFunctionPassManager`] 
| Convenience typedef for a pass manager over functions&period;
| xref:llvm/MachineSSAContext.adoc[`MachineSSAContext`] 
| SSA context specialized for Machine IR functions&period;
| xref:llvm/MachineUniformityInfo.adoc[`MachineUniformityInfo`] 
| Uniformity information specialized for Machine IR&period;
| xref:llvm/MacroFusionPredTy.adoc[`MacroFusionPredTy`] 
| Predicate type that decides whether two instructions should be fused&period;
| xref:llvm/MemCpyFamilyLoweringInfo.adoc[`MemCpyFamilyLoweringInfo`] 
| Lowering info for a memcpy&hyphen;family intrinsic&colon; dst, src, length, align, and whether dst alignment can change, plus per&hyphen;chunk load&sol;store types&period;
| xref:llvm/MemProfCallStackHashTable.adoc[`MemProfCallStackHashTable`] 
| On&hyphen;disk hash table of MemProf call stacks keyed by call stack id&period;
| xref:llvm/MemProfFrameHashTable.adoc[`MemProfFrameHashTable`] 
| On&hyphen;disk hash table of MemProf frames keyed by frame id&period;
| xref:llvm/MemProfRecordHashTable.adoc[`MemProfRecordHashTable`] 
| On&hyphen;disk hash table of MemProf records keyed by function name hash&period;
| xref:llvm/MemoryEffects.adoc[`MemoryEffects`] 
| Summary of how a function affects memory in the program&period;
| xref:llvm/MetadataPredicate.adoc[`MetadataPredicate`] 
| Predicate that identifies metadata which should map onto itself&period;
| xref:llvm/MetadataSetTy.adoc[`MetadataSetTy`] 
| Small set of metadata pointers used while remapping&period;
| xref:llvm/ModuleAnalysisManager.adoc[`ModuleAnalysisManager`] 
| Convenience typedef for the Module analysis manager&period;
| xref:llvm/ModuleAnalysisManagerCGSCCProxy.adoc[`ModuleAnalysisManagerCGSCCProxy`] 
| A proxy from a `ModuleAnalysisManager` to an `SCC&period;`
| xref:llvm/ModuleAnalysisManagerFunctionProxy.adoc[`ModuleAnalysisManagerFunctionProxy`] 
| Provide the `ModuleAnalysisManager` to `Function` proxy&period;
| xref:llvm/ModuleAnalysisManagerMachineFunctionProxy.adoc[`ModuleAnalysisManagerMachineFunctionProxy`] 
| Provide the `ModuleAnalysisManager` to `MachineFunction` proxy&period;
| xref:llvm/ModuleHash.adoc[`ModuleHash`] 
| 160 bits SHA1
| xref:llvm/ModulePassManager.adoc[`ModulePassManager`] 
| Convenience typedef for a pass manager over modules&period;
| xref:llvm/ModulePathStringTableTy.adoc[`ModulePathStringTableTy`] 
| String table to hold&sol;own module path strings, as well as a hash of the module&period; The StringMap makes a copy of and owns inserted strings&period;
| xref:llvm/ModuleToSummariesForIndexTy.adoc[`ModuleToSummariesForIndexTy`] 
| Map of a module name to the GUIDs and summaries we will import from that module&period;
| xref:llvm/MostAlignedSDNode.adoc[`MostAlignedSDNode`] 
| The SDNode class with the greatest alignment requirement&period;
| xref:llvm/MultiFileTableGenMainFn.adoc[`MultiFileTableGenMainFn`] 
| Perform the action using Records, and store output in OutFiles&period; Returns true on error, false otherwise&period;
| xref:llvm/Name2RegBankMap.adoc[`Name2RegBankMap`] 
| Map from register bank names to register banks&period;
| xref:llvm/Name2RegClassMap.adoc[`Name2RegClassMap`] 
| Map from register class names to register classes&period;
| xref:llvm/NewLoopsMap.adoc[`NewLoopsMap`] 
| Map from an original loop to the corresponding newly created loop clone&period;
| xref:llvm/NfaPath.adoc[`NfaPath`] 
| A sequence of NFA state IDs representing one path through an NFA&period;
| xref:llvm/NormalizePredTy.adoc[`NormalizePredTy`] 
| Predicate selecting add&hyphen;recurrence SCEVs to normalize for post&hyphen;increment use&period;
| xref:llvm/OffsetsStringPool.adoc[`OffsetsStringPool`] 
| Strongly typed non&hyphen;relocatable string pool for offset lookup&period;
| xref:llvm/OnDiskHashTableImplV3.adoc[`OnDiskHashTableImplV3`] 
| On&hyphen;disk iterable hash table used by indexed instrprof format version 3&period;
| xref:llvm/OperandBuildSteps.adoc[`OperandBuildSteps`] 
| Ordered callbacks that append operands to a MachineInstrBuilder&period;
| xref:llvm/OperandBundleDef.adoc[`OperandBundleDef`] 
| Operand bundle definition with mutable `Value&ast;` inputs&period;
| xref:llvm/OperandVector.adoc[`OperandVector`] 
| Vector of owned parsed assembly operands&period;
| xref:llvm/PBQPRAGraph.adoc[`PBQPRAGraph`] 
| Alias for the PBQP register&hyphen;allocation graph type&period;
| xref:llvm/ParamLoadedValue.adoc[`ParamLoadedValue`] 
| Pair of a machine operand and a DIExpression describing a loaded value&period;
| xref:llvm/ParamLocs.adoc[`ParamLocs`] 
| Locations (instruction, operand index pairs) reachable from a parameter&period;
| xref:llvm/ParamLocsVecTy.adoc[`ParamLocsVecTy`] 
| Vector of parameter location lists for a stable function merge&period;
| xref:llvm/PassConfigCallback.adoc[`PassConfigCallback`] 
| Callback that customizes a `TargetPassConfig` during TargetMachine setup&period;
| xref:llvm/PhiToDefMap.adoc[`PhiToDefMap`] 
| Map from MemoryPhi nodes to their defining MemoryAccess&period;
| xref:llvm/PointTypeIsValid.adoc[`PointTypeIsValid`] 
| Trait that is true when `T` is a fundamental type suitable as a point&period;
| xref:llvm/PointerTy.adoc[`PointerTy`] 
| Opaque pointer type used to store pointer values in a GenericValue&period;
| xref:llvm/PostDomTreeBase.adoc[`PostDomTreeBase`] 
| Post&hyphen;dominator tree specialization&period;
| xref:llvm/PostIncLoopSet.adoc[`PostIncLoopSet`] 
| Set of loops for which a SCEV is in post&hyphen;increment mode&period;
| xref:llvm/PotentialConstantIntValuesState.adoc[`PotentialConstantIntValuesState`] 
| Potential&hyphen;values state specialized for constant integers&period;
| xref:llvm/PotentialLLVMValuesState.adoc[`PotentialLLVMValuesState`] 
| Potential&hyphen;values state specialized for LLVM values and scopes&period;
| xref:llvm/ProbeFactorMap.adoc[`ProbeFactorMap`] 
| Map from tuples of Probe id and inline stack hash code to distribution factors&period;
| xref:llvm/RV32YCapabilityFormat.adoc[`RV32YCapabilityFormat`] 
| 32&hyphen;bit RISC&hyphen;V Y capability format (MW&equals;10, MAX&lowbar;E&equals;24)&period;
| xref:llvm/RV64YCapabilityFormat.adoc[`RV64YCapabilityFormat`] 
| 64&hyphen;bit RISC&hyphen;V Y capability format (MW&equals;14, MAX&lowbar;E&equals;52)&period;
| xref:llvm/RandomEngine.adoc[`RandomEngine`] 
| Pseudo&hyphen;random number generator type used by RandomIRBuilder&period;
| xref:llvm/RawInstrProfReader32.adoc[`RawInstrProfReader32`] 
| Raw instrprof reader specialized for 32&hyphen;bit profile pointer values&period;
| xref:llvm/RawInstrProfReader64.adoc[`RawInstrProfReader64`] 
| Raw instrprof reader specialized for 64&hyphen;bit profile pointer values&period;
| xref:llvm/ReferenceGroupTy.adoc[`ReferenceGroupTy`] 
| A set of memory references that exhibit temporal or spatial reuse&period;
| xref:llvm/ReferenceGroupsTy.adoc[`ReferenceGroupsTy`] 
| A collection of reference groups for a loop nest&period;
| xref:llvm/RegAllocFilterFunc.adoc[`RegAllocFilterFunc`] 
| Filter function for register classes during regalloc&period; Default register class filter is nullptr, where all registers should be allocated&period;
| xref:llvm/RegClassOrRegBank.adoc[`RegClassOrRegBank`] 
| Convenient type to represent either a register class or a register bank&period;
| xref:llvm/RegUnit2SUnitsMap.adoc[`RegUnit2SUnitsMap`] 
| Use a SparseMultiSet to track physical registers&period; Storage is only allocated once for the pass&period; It can be cleared in constant time and reused without any frees&period;
| xref:llvm/RelocAddrMap.adoc[`RelocAddrMap`] 
| Side table mapping DWARF section offsets to relocation address entries&period;
| xref:llvm/RequireAnalysisLoopPass.adoc[`RequireAnalysisLoopPass`] 
| An alias template to easily name a require analysis loop pass&period;
| xref:llvm/RetainedKnowledgeKey.adoc[`RetainedKnowledgeKey`] 
| Key pairing a value with an attribute kind for retained knowledge&period;
| xref:llvm/RetainedKnowledgeMap.adoc[`RetainedKnowledgeMap`] 
| Map from retained&hyphen;knowledge keys to assume intrinsics and their ranges&period;
| xref:llvm/ReverseIDFCalculator.adoc[`ReverseIDFCalculator`] 
| Reverse (post&hyphen;dominance) iterated dominance frontier calculator&period;
| xref:llvm/RuntimePointerCheck-03e.adoc[`RuntimePointerCheck`] 
| A memcheck which made up of a pair of grouped pointers&period;
| xref:llvm/RuntimePointerCheck-0b.adoc[`RuntimePointerCheck`] 
| A runtime memcheck made of a pair of grouped pointers&period;
| xref:llvm/RuntimePointerCheck-038.adoc[`RuntimePointerCheck`] 
| A runtime memcheck made of a pair of grouped pointers&period;
| xref:llvm/SCEVUse.adoc[`SCEVUse`] 
| SCEVUse of a const SCEV pointer&period;
| xref:llvm/SDNodeTSFlags.adoc[`SDNodeTSFlags`] 
| Target&hyphen;specific SelectionDAG node flags packed into a 32&hyphen;bit word&period;
| xref:llvm/SMTExprRef.adoc[`SMTExprRef`] 
| Shared pointer for SMTExprs, used by SMTSolver API&period;
| xref:llvm/SMTSolverRef.adoc[`SMTSolverRef`] 
| Shared pointer for SMTSolvers&period;
| xref:llvm/SMTSortRef.adoc[`SMTSortRef`] 
| Shared pointer for SMTSorts, used by SMTSolver API&period;
| xref:llvm/SSAContext.adoc[`SSAContext`] 
| SSA context specialized for LLVM IR functions&period;
| xref:llvm/SaveRestorePoints.adoc[`SaveRestorePoints`] 
| Map from basic blocks to the callee&hyphen;saved registers saved or restored there&period;
| xref:llvm/SectionLengths.adoc[`SectionLengths`] 
| Mapping from DWARF section kind to its contribution length in bytes&period;
| xref:llvm/SectionSymbolsTy.adoc[`SectionSymbolsTy`] 
| Ordered list of symbols belonging to one section&period;
| xref:llvm/SmallInstListTy.adoc[`SmallInstListTy`] 
| Small work list of machine instructions used while erasing dead chains&period;
| xref:llvm/SmallVectorSizeType.adoc[`SmallVectorSizeType`] 
| Unsigned size&sol;capacity type used by SmallVector for element type `T&period;`
| xref:llvm/SmallVirtRegSet.adoc[`SmallVirtRegSet`] 
| Small set of virtual registers used to mark fixed interference&period;
| xref:llvm/SpecMap.adoc[`SpecMap`] 
| Map from functions to ranges of candidate specializations&period;
| xref:llvm/Statistic.adoc[`Statistic`] 
| Statistic type that actually tracks values when stats are enabled&period;
| xref:llvm/SummaryEntryVector.adoc[`SummaryEntryVector`] 
| Vector of profile summary percentile entries&period;
| xref:llvm/TTI.adoc[`TTI`] 
| Convenience alias for TargetTransformInfo&period;
| xref:llvm/TUVectorTy.adoc[`TUVectorTy`] 
| Vector of type&hyphen;unit metadata entries&period;
| xref:llvm/TableGenMainFn.adoc[`TableGenMainFn`] 
| Returns true on error, false otherwise&period;
| xref:llvm/TagNameMap.adoc[`TagNameMap`] 
| Array of `TagNameItem` entries for looking up compact build&hyphen;attribute names&period;
| xref:llvm/TargetFlagsType.adoc[`TargetFlagsType`] 
| Holds target&hyphen;specific properties for a symbol&period;
| xref:llvm/TargetRegisterClass.adoc[`TargetRegisterClass`] 
| Register class type used throughout CodeGen&period;
| xref:llvm/TrackingMDNodeRef.adoc[`TrackingMDNodeRef`] 
| Tracking reference specialized for _MDNode&period;_
| xref:llvm/TrackingValueAsMetadataRef.adoc[`TrackingValueAsMetadataRef`] 
| Tracking reference specialized for _ValueAsMetadata&period;_
| xref:llvm/TypeAtIndex.adoc[`TypeAtIndex`] 
| Find the type at a given index in a list of types&period;
| xref:llvm/TypeConversionCostTblEntry.adoc[`TypeConversionCostTblEntry`] 
| Type&hyphen;conversion cost table entry whose cost is a 16&hyphen;bit integer&period;
| xref:llvm/TypeGetter.adoc[`TypeGetter`] 
| Callback that returns an allowed IR type for a given LLVM context&period;
| xref:llvm/TypeIdCompatibleVtableInfo.adoc[`TypeIdCompatibleVtableInfo`] 
| List of vtable definitions decorated by a particular type identifier&period;
| xref:llvm/TypeIdSummaryMapTy.adoc[`TypeIdSummaryMapTy`] 
| Map of a type GUID to type id string and summary (multimap used in case of GUID conflicts)&period;
| xref:llvm/UTF16.adoc[`UTF16`] 
| Unicode UTF&hyphen;16 code unit type&semi; at least 16 bits&period;
| xref:llvm/UTF32.adoc[`UTF32`] 
| Unicode UTF&hyphen;32 code unit type&semi; at least 32 bits&period;
| xref:llvm/UTF8.adoc[`UTF8`] 
| Unicode UTF&hyphen;8 code unit type&semi; typically 8 bits&period;
| xref:llvm/UnderlyingObjectsVector.adoc[`UnderlyingObjectsVector`] 
| Small vector of underlying memory objects for a memory operand&period;
| xref:llvm/UniformityInfo.adoc[`UniformityInfo`] 
| Uniformity information specialized for LLVM IR&period;
| xref:llvm/UniquingStringPool.adoc[`UniquingStringPool`] 
| Strongly typed non&hyphen;relocatable string pool for uniquing strings&period;
| xref:llvm/UseListOrderStack.adoc[`UseListOrderStack`] 
| Stack of use&hyphen;list orders collected while predicting serialization order&period;
| xref:llvm/VReg2SUnitMultiMap.adoc[`VReg2SUnitMultiMap`] 
| Sparse multi&hyphen;map from virtual registers to their local SUnit uses&period;
| xref:llvm/VReg2SUnitOperIdxMultiMap.adoc[`VReg2SUnitOperIdxMultiMap`] 
| Sparse multi&hyphen;map from virtual registers to SUnits with operand indices&period;
| xref:llvm/VTableFuncList.adoc[`VTableFuncList`] 
| List of functions referenced by a particular vtable definition&period;
| xref:llvm/ValueMapConstIterator.adoc[`ValueMapConstIterator`] 
| Const ValueMap iterator alias&period;
| xref:llvm/ValueMapIterator.adoc[`ValueMapIterator`] 
| Mutable ValueMap iterator alias&period;
| xref:llvm/ValueName.adoc[`ValueName`] 
| Entry in a value symbol table mapping a name to a `Value&period;`
| xref:llvm/ValueToSCEVMapTy.adoc[`ValueToSCEVMapTy`] 
| Map from LLVM values to replacement SCEVs&period;
| xref:llvm/ValueToValueMap.adoc[`ValueToValueMap`] 
| Map from LLVM values to replacement LLVM values&period;
| xref:llvm/ValueToValueMapTy.adoc[`ValueToValueMapTy`] 
| Map from values to weak tracking value handles&period;
| xref:llvm/ValueType.adoc[`ValueType`] 
| Pointer to an IR Value or PseudoSourceValue used as a memory location key&period;
| xref:llvm/ValueTypeCallbackTy.adoc[`ValueTypeCallbackTy`] 
| Callback invoked for each Value with its type ID and type&hyphen;lookup helpers&period;
| xref:llvm/ValueTypeFromRangeType.adoc[`ValueTypeFromRangeType`] 
| Element type of `RangeType` with top&hyphen;level const removed&period;
| xref:llvm/ValueTypeIsValid.adoc[`ValueTypeIsValid`] 
| Trait that is true when `T` is a fundamental or pointer value type&period;
| xref:llvm/VarID.adoc[`VarID`] 
| A unique key that represents a debug variable&period;
| xref:llvm/all_types_equal.adoc[`all&lowbar;types&lowbar;equal`] 
| traits class for checking whether type `T` is same as all other types in `Ts`&period;
| xref:llvm/are_base_of.adoc[`are&lowbar;base&lowbar;of`] 
| traits class for checking whether type T is a base class for all the given types in the variadic list&period;
| xref:llvm/bf_iterator_default_set.adoc[`bf&lowbar;iterator&lowbar;default&lowbar;set`] 
| Default visited&hyphen;node set type for breadth&hyphen;first iteration&period;
| xref:llvm/common_sint.adoc[`common&lowbar;sint`] 
| Common signed type of two integral types&period;
| xref:llvm/common_uint.adoc[`common&lowbar;uint`] 
| Common unsigned type of two integral types&period;
| xref:llvm/const_gvsummary_iterator.adoc[`const&lowbar;gvsummary&lowbar;iterator`] 
| Type used for iterating through the global value summary map&period;
| xref:llvm/const_inst_iterator.adoc[`const&lowbar;inst&lowbar;iterator`] 
| Read&hyphen;only iterator over all instructions in a Function&period;
| xref:llvm/const_inst_range.adoc[`const&lowbar;inst&lowbar;range`] 
| Range of read&hyphen;only instruction iterators&period;
| xref:llvm/const_memoryaccess_def_iterator.adoc[`const&lowbar;memoryaccess&lowbar;def&lowbar;iterator`] 
| Const iterator over the defining accesses of a MemoryAccess&period;
| xref:llvm/const_pred_iterator.adoc[`const&lowbar;pred&lowbar;iterator`] 
| Read&hyphen;only predecessor iterator over a `const` BasicBlock&period;
| xref:llvm/const_pred_range.adoc[`const&lowbar;pred&lowbar;range`] 
| Read&hyphen;only range over the predecessor basic blocks of a `const` BasicBlock&period;
| xref:llvm/const_succ_iterator.adoc[`const&lowbar;succ&lowbar;iterator`] 
| Read&hyphen;only iterator over successor basic blocks of a terminator instruction&period;
| xref:llvm/const_succ_range.adoc[`const&lowbar;succ&lowbar;range`] 
| Read&hyphen;only range over successor basic blocks of a terminator instruction&period;
| xref:llvm/enableif_int.adoc[`enableif&lowbar;int`] 
| Some template parameter helpers to optimize for bitwidth, for functions that take multiple arguments&period;
| xref:llvm/fatal_error_handler_t.adoc[`fatal&lowbar;error&lowbar;handler&lowbar;t`] 
| An error handler callback&period;
| xref:llvm/filter_iterator.adoc[`filter&lowbar;iterator`] 
| Defines filter&lowbar;iterator to a suitable specialization of filter&lowbar;iterator&lowbar;impl, based on the underlying iterator&apos;s category&period;
| xref:llvm/float128.adoc[`float128`] 
| 
| xref:llvm/gep_type_iterator.adoc[`gep&lowbar;type&lowbar;iterator`] 
| Iterator over types indexed by a GetElementPtr instruction or operator&period;
| xref:llvm/gvsummary_iterator.adoc[`gvsummary&lowbar;iterator`] 
| Mutable iterator type for the global value summary map&period;
| xref:llvm/ilist.adoc[`ilist`] 
| Intrusive list alias equivalent to `iplist` with the same options&period;
| xref:llvm/ilist_select_iterator_type.adoc[`ilist&lowbar;select&lowbar;iterator&lowbar;type`] 
| Iterator type for `OptionsT,` selecting _ilist&lowbar;iterator&lowbar;w&lowbar;bits_ when iterator bits are enabled and _ilist&lowbar;iterator_ otherwise&period;
| xref:llvm/inst_iterator.adoc[`inst&lowbar;iterator`] 
| Mutable iterator over all instructions in a Function&period;
| xref:llvm/inst_range.adoc[`inst&lowbar;range`] 
| Range of mutable instruction iterators&period;
| xref:llvm/is_detected.adoc[`is&lowbar;detected`] 
| Detects whether trait `Op` holds for the given `Args&period;`
| xref:llvm/is_one_of.adoc[`is&lowbar;one&lowbar;of`] 
| traits class for checking whether type T is one of any of the given types in the variadic list&period;
| xref:llvm/memoryaccess_def_iterator.adoc[`memoryaccess&lowbar;def&lowbar;iterator`] 
| Mutable iterator over the defining accesses of a MemoryAccess&period;
| xref:llvm/once_flag.adoc[`once&lowbar;flag`] 
| Alias of `std&colon;&colon;once&lowbar;flag` used with `llvm&colon;&colon;call&lowbar;once&period;`
| xref:llvm/pred_iterator.adoc[`pred&lowbar;iterator`] 
| Iterator over the predecessor basic blocks of a `BasicBlock&period;`
| xref:llvm/pred_range.adoc[`pred&lowbar;range`] 
| Range over the predecessor basic blocks of a `BasicBlock&period;`
| xref:llvm/raw_pointer_iterator.adoc[`raw&lowbar;pointer&lowbar;iterator`] 
| Iterator adapter that dereferences twice to obtain a raw pointer&period;
| xref:llvm/remove_cvref_t.adoc[`remove&lowbar;cvref&lowbar;t`] 
| Alias for `remove&lowbar;cvref&lt;T&gt;&colon;&colon;type&period;`
| xref:llvm/stable_hash.adoc[`stable&lowbar;hash`] 
| An opaque object representing a stable hash code&period; It can be serialized, deserialized, and is stable across processes and executions&period;
| xref:llvm/stack_float_t.adoc[`stack&lowbar;float&lowbar;t`] 
| Stack&hyphen;forced float type on non&hyphen;x86 hosts&period;
| xref:llvm/succ_iterator.adoc[`succ&lowbar;iterator`] 
| Iterator over successor basic blocks of a terminator instruction&period;
| xref:llvm/succ_range.adoc[`succ&lowbar;range`] 
| Range over successor basic blocks of a terminator instruction&period;
| xref:llvm/type_identity_t.adoc[`type&lowbar;identity&lowbar;t`] 
| Alias for `type&lowbar;identity&lt;T&gt;&colon;&colon;type&period;`
| xref:llvm/uint24_t.adoc[`uint24&lowbar;t`] 
| Alias for a packed 24&hyphen;bit unsigned integer&period;
| xref:llvm/unique_value.adoc[`unique&lowbar;value`] 
| Unique ownership pointer for `Value` that calls `deleteValue&period;`
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:llvm/_04enum-01b.adoc[`Unnamed enum`] 
| Sentinel IDs used by MemoryAccess&colon;&colon;getID()&period;
| xref:llvm/_04enum-0b7.adoc[`Unnamed enum`] 
| Sentinel IDs for invalid C&plus;&plus; predicates and custom actions&period;
| xref:llvm/_04enum-016.adoc[`Unnamed enum`] 
| The MatchTable is encoded as an array of bytes&period; Thus, opcodes are expected to be &lt;255&period;
| xref:llvm/_04enum-0d.adoc[`Unnamed enum`] 
| This is a llvm local version of &lowbar;&lowbar;cxa&lowbar;demangle&period; Other than the name and being in the llvm namespace it is identical&period;
| xref:llvm/_04enum-04.adoc[`Unnamed enum`] 
| Standard fixup kinds shared by all targets, plus bounds for literal and target&hyphen;specific ranges&period;
| xref:llvm/_04enum-0b0.adoc[`Unnamed enum`] 
| Bitfield flags describing X86 fold&hyphen;table entries for register&sol;memory folding&period;
| xref:llvm/_04enum-0e.adoc[`Unnamed enum`] 
| Number of bits reserved to encode a sanitizer statistic kind&period;
| xref:llvm/AlignStyle.adoc[`AlignStyle`] 
| Horizontal alignment of formatted text within a field&period;
| xref:llvm/AllocFnKind.adoc[`AllocFnKind`] 
| Bitmask describing the role and properties of an allocation function for the `allockind` attribute (alloc, realloc, free, and returned memory state)&period;
| xref:llvm/AllocTokenMode.adoc[`AllocTokenMode`] 
| Modes for generating allocation token IDs&period;
| xref:llvm/AllocationType.adoc[`AllocationType`] 
| Allocation type assigned to an allocation reached by a given context&period;
| xref:llvm/AsanCtorKind.adoc[`AsanCtorKind`] 
| Types of ASan module constructors supported
| xref:llvm/AsanDetectStackUseAfterReturnMode.adoc[`AsanDetectStackUseAfterReturnMode`] 
| Mode of ASan detect stack use after return
| xref:llvm/AsanDtorKind.adoc[`AsanDtorKind`] 
| Types of ASan module destructors supported
| xref:llvm/AsmRewriteKind.adoc[`AsmRewriteKind`] 
| Kind of rewrite applied when converting MS&hyphen;style inline assembly&period;
| xref:llvm/AssumeBundleArg.adoc[`AssumeBundleArg`] 
| Index of elements in the operand bundle&period; If the element exist it is guaranteed to be what is specified in this enum but it may not exist&period;
| xref:llvm/AtomicOrdering.adoc[`AtomicOrdering`] 
| Atomic ordering for LLVM&apos;s memory model&period;
| xref:llvm/AtomicOrderingCABI.adoc[`AtomicOrderingCABI`] 
| Atomic ordering for C11 &sol; C&plus;&plus;11&apos;s memory models&period;
| xref:llvm/AtomicScope.adoc[`AtomicScope`] 
| Target&hyphen;neutral memory synchronization scopes&period;
| xref:llvm/AttributorRunOption.adoc[`AttributorRunOption`] 
| Run options, used by the pass manager&period;
| xref:llvm/BasicBlockSection.adoc[`BasicBlockSection`] 
| Controls whether basic blocks are emitted into separate ELF sections&period;
| xref:llvm/BinaryStreamFlags.adoc[`BinaryStreamFlags`] 
| Properties of a BinaryStream implementation&period;
| xref:llvm/BitcodeError.adoc[`BitcodeError`] 
| Error codes that can be produced while reading bitcode&period;
| xref:llvm/BitstreamWrapperHeader.adoc[`BitstreamWrapperHeader`] 
| Offsets of the 32&hyphen;bit fields of bitstream wrapper header&period;
| xref:llvm/CGDataKind.adoc[`CGDataKind`] 
| Bitmask identifying which kinds of codegen data are present&period;
| xref:llvm/CGDataMode.adoc[`CGDataMode`] 
| Whether codegen data is unused, being read, or being written&period;
| xref:llvm/CGDataSectKind.adoc[`CGDataSectKind`] 
| Object&hyphen;file section kinds that store codegen data&period;
| xref:llvm/CaptureComponents.adoc[`CaptureComponents`] 
| Components of the pointer that may be captured&period;
| xref:llvm/CfiFunctionLinkage.adoc[`CfiFunctionLinkage`] 
| The type of CFI jumptable needed for a function&period;
| xref:llvm/ChangePrinter.adoc[`ChangePrinter`] 
| How `&hyphen;print&hyphen;changed` presents IR that a pass modified&period;
| xref:llvm/ChangeStatus.adoc[`ChangeStatus`] 
| Indicator whether an abstract state or the IR changed&period;
| xref:llvm/CloneFunctionChangeType.adoc[`CloneFunctionChangeType`] 
| Controls how much metadata and module state CloneFunctionInto updates&period;
| xref:llvm/ClrHandlerType.adoc[`ClrHandlerType`] 
| Kind of CoreCLR exception handler represented in ClrEHUnwindMap&period;
| xref:llvm/CodeGenFileType.adoc[`CodeGenFileType`] 
| Output kind requested from or returned by addPassesToEmitFile&period;
| xref:llvm/CodeGenOptLevel.adoc[`CodeGenOptLevel`] 
| Code generation optimization level&period;
| xref:llvm/CodeObjectVersionKind.adoc[`CodeObjectVersionKind`] 
| Enumeration value for AMDGPU code object version, which is the code object version times 100&period;
| xref:llvm/ColorMode.adoc[`ColorMode`] 
| Controls whether WithColor applies ANSI colors to a stream&period;
| xref:llvm/CombineLevel.adoc[`CombineLevel`] 
| Phase of SelectionDAG combining relative to legalization&period;
| xref:llvm/CombinerObjective.adoc[`CombinerObjective`] 
| The combiner&apos;s goal may differ based on which pattern it is attempting to optimize&period;
| xref:llvm/ComplexDeinterleavingOperation.adoc[`ComplexDeinterleavingOperation`] 
| Kind of complex arithmetic or graph node used by complex deinterleaving&period;
| xref:llvm/ComplexDeinterleavingRotation.adoc[`ComplexDeinterleavingRotation`] 
| Rotation applied to a complex value in the complex plane&period;
| xref:llvm/ControlFlowGuardMechanism.adoc[`ControlFlowGuardMechanism`] 
| Control Flow Guard check mechanism&period;
| xref:llvm/ControlFlowGuardMode.adoc[`ControlFlowGuardMode`] 
| Control Flow Guard enablement mode&period;
| xref:llvm/ConvergenceKind.adoc[`ConvergenceKind`] 
| Kind of convergence present in analyzed code&period;
| xref:llvm/ConversionFlags.adoc[`ConversionFlags`] 
| Controls whether conversion is strict or lenient about irregular sequences&period;
| xref:llvm/ConversionResult.adoc[`ConversionResult`] 
| Result of a ConvertUTF&ast; conversion between UTF encodings&period;
| xref:llvm/CurStreamTypeType.adoc[`CurStreamTypeType`] 
| CurStreamTypeType &hyphen; A type for CurStreamType
| xref:llvm/DIDumpType.adoc[`DIDumpType`] 
| Selects which debug sections get dumped&period;
| xref:llvm/DIDumpTypeCounter.adoc[`DIDumpTypeCounter`] 
| This is just a helper to programmatically construct DIDumpType&period;
| xref:llvm/DINameKind.adoc[`DINameKind`] 
| A DINameKind is passed to name search methods to specify a preference regarding the type of name resolution the caller wants&period;
| xref:llvm/DWARFSectionKind.adoc[`DWARFSectionKind`] 
| The enum of section identifiers to be used in internal interfaces&period;
| xref:llvm/DWPSectionId.adoc[`DWPSectionId`] 
| Section identifiers for DWP output&period;
| xref:llvm/DebugCompressionType.adoc[`DebugCompressionType`] 
| Compression scheme used for compressed debug sections in object files&period;
| xref:llvm/DebuggerKind.adoc[`DebuggerKind`] 
| Identify a debugger for &quot;tuning&quot; the debug info&period;
| xref:llvm/DepClassTy.adoc[`DepClassTy`] 
| Dependence class between abstract attributes&period;
| xref:llvm/DiagnosticKind.adoc[`DiagnosticKind`] 
| Defines the different supported kind of a diagnostic&period; This enum should be extended with a new ID for each added concrete subclass&period;
| xref:llvm/DiagnosticSeverity.adoc[`DiagnosticSeverity`] 
| Defines the different supported severity of a diagnostic&period;
| xref:llvm/Dwarf64StrOffsetsPromotion.adoc[`Dwarf64StrOffsetsPromotion`] 
| Policy for promoting &period;debug&lowbar;str&lowbar;offsets tables to DWARF64 form&period;
| xref:llvm/EABI.adoc[`EABI`] 
| Embedded ABI version selection&period;
| xref:llvm/EHPersonality.adoc[`EHPersonality`] 
| Recognized exception&hyphen;handling personality kinds&period;
| xref:llvm/EmitDwarfUnwindType.adoc[`EmitDwarfUnwindType`] 
| Controls when DWARF unwind information is emitted&period;
| xref:llvm/ExceptionHandling.adoc[`ExceptionHandling`] 
| Exception&hyphen;handling model selected for code generation&period;
| xref:llvm/ExpandVariadicsMode.adoc[`ExpandVariadicsMode`] 
| Operating mode for the expand&hyphen;variadics pass&period;
| xref:llvm/ExplorationDirection.adoc[`ExplorationDirection`] 
| Direction in which a must&hyphen;be&hyphen;executed context is explored&period;
| xref:llvm/FPClassTest.adoc[`FPClassTest`] 
| Floating&hyphen;point class tests, supported by &apos;is&lowbar;fpclass&apos; intrinsic&period; Actual test may be an OR combination of basic tests&period;
| xref:llvm/FeatureIndex.adoc[`FeatureIndex`] 
| Indices of ML inliner input features (cost features, context, embeddings)&period;
| xref:llvm/FloatStyle.adoc[`FloatStyle`] 
| Floating&hyphen;point formatting style for native writers&period;
| xref:llvm/FramePointerKind.adoc[`FramePointerKind`] 
| Specify which functions should keep the frame pointer&period;
| xref:llvm/FunctionReturnThunksKind.adoc[`FunctionReturnThunksKind`] 
| Function return thunk generation mode&period;
| xref:llvm/GVDAGType.adoc[`GVDAGType`] 
| How block frequencies are rendered in DOT graph viewers&period;
| xref:llvm/GlobalISelAbortMode.adoc[`GlobalISelAbortMode`] 
| Enable abort calls when global instruction selection fails to lower&sol;select an instruction&period;
| xref:llvm/HTTPMethod.adoc[`HTTPMethod`] 
| HTTP methods supported by HTTPRequest&period;
| xref:llvm/HexPrintStyle.adoc[`HexPrintStyle`] 
| Hexadecimal formatting style for native writers&period;
| xref:llvm/HighlightColor.adoc[`HighlightColor`] 
| Symbolic highlight roles used when coloring diagnostic and dump output&period;
| xref:llvm/IR2VecKind.adoc[`IR2VecKind`] 
| Selects Symbolic or FlowAware IR2Vec embedding generation&period;
| xref:llvm/IRMemLocation.adoc[`IRMemLocation`] 
| The locations at which a function might access memory&period;
| xref:llvm/IRUnitKind.adoc[`IRUnitKind`] 
| The IR units a pass can run on&period;
| xref:llvm/InlineCostFeatureIndex.adoc[`InlineCostFeatureIndex`] 
| Indices of heuristic inline&hyphen;cost feature summands&period;
| xref:llvm/InlinePass.adoc[`InlinePass`] 
| Identifies which inline driver is constructing or using an advisor&period;
| xref:llvm/InlinerFunctionImportStatsOpts.adoc[`InlinerFunctionImportStatsOpts`] 
| Verbosity level for imported&hyphen;function inliner statistics&period;
| xref:llvm/InliningAdvisorMode.adoc[`InliningAdvisorMode`] 
| There are 4 scenarios we can use the InlineAdvisor&colon; &hyphen; Default &hyphen; use manual heuristics&period;
| xref:llvm/InstrProfKind.adoc[`InstrProfKind`] 
| Bitmask describing attributes of an instrumented profile&period;
| xref:llvm/InstrProfSectKind.adoc[`InstrProfSectKind`] 
| Identifiers for instrumented&hyphen;profiling and coverage object&hyphen;file sections&period;
| xref:llvm/InstrProfValueKind.adoc[`InstrProfValueKind`] 
| Kinds of value&hyphen;profile data recorded at instrumented sites&period;
| xref:llvm/IntegerStyle.adoc[`IntegerStyle`] 
| Integer formatting style for native writers&period;
| xref:llvm/KCFIHashAlgorithm.adoc[`KCFIHashAlgorithm`] 
| Hash algorithm used to compute a KCFI type ID&period;
| xref:llvm/LEB128Sign.adoc[`LEB128Sign`] 
| Whether to encode with signed or unsigned LEB128&period;
| xref:llvm/LLVMConstants.adoc[`LLVMConstants`] 
| Named constants used by LLVM IR metadata encodings&period;
| xref:llvm/LibFunc.adoc[`LibFunc`] 
| 
| xref:llvm/LiveRangeStage.adoc[`LiveRangeStage`] 
| Stages a live range passes through during greedy register allocation&period;
| xref:llvm/LongDoubleFormat.adoc[`LongDoubleFormat`] 
| The floating&hyphen;point format used for the target&apos;s &quot;long double&quot; type&period;
| xref:llvm/LoopIdiomVectorizeStyle.adoc[`LoopIdiomVectorizeStyle`] 
| Vectorization style used when rewriting recognized loop idioms&period;
| xref:llvm/LoopPeelDirection.adoc[`LoopPeelDirection`] 
| Direction in which to peel a single&hyphen;block loop&period;
| xref:llvm/LoopUnrollResult.adoc[`LoopUnrollResult`] 
| Represents the result of a `UnrollLoop` invocation&period;
| xref:llvm/MCDataRegionType.adoc[`MCDataRegionType`] 
| Kinds of Mach&hyphen;O `&period;data&lowbar;region` &sol; `&period;end&lowbar;data&lowbar;region` directives&period;
| xref:llvm/MCLOHType.adoc[`MCLOHType`] 
| Linker Optimization Hint Type&period;
| xref:llvm/MCPseudoProbeFlag.adoc[`MCPseudoProbeFlag`] 
| Flags that control how a pseudo probe is encoded&period;
| xref:llvm/MCRegUnit.adoc[`MCRegUnit`] 
| Opaque identifier for a register unit used to compute register aliasing&period;
| xref:llvm/MCSymbolAttr.adoc[`MCSymbolAttr`] 
| Symbol attributes corresponding to target&hyphen;specific assembler directives&period;
| xref:llvm/MCVersionMinType.adoc[`MCVersionMinType`] 
| Kinds of Darwin minimum&hyphen;OS&hyphen;version directives&period;
| xref:llvm/MIR2VecKind.adoc[`MIR2VecKind`] 
| Kind of MIR2Vec embedding algorithm to use&period;
| xref:llvm/MSDemangleFlags.adoc[`MSDemangleFlags`] 
| Flags that control Microsoft demangled name formatting&period;
| xref:llvm/MachineCombinerPattern.adoc[`MachineCombinerPattern`] 
| These are instruction patterns matched by the machine combiner pass&period;
| xref:llvm/MachineFunctionDataHotness.adoc[`MachineFunctionDataHotness`] 
| Hotness of MachineFunction&hyphen;owned static data not represented as a global&period;
| xref:llvm/MachineTraceStrategy.adoc[`MachineTraceStrategy`] 
| Strategies for selecting traces&period;
| xref:llvm/ModRefInfo.adoc[`ModRefInfo`] 
| Flags indicating whether a memory access modifies or references memory&period;
| xref:llvm/NoCommonBitsSetResult.adoc[`NoCommonBitsSetResult`] 
| Strength of the no&hyphen;common&hyphen;bits&hyphen;set relationship between two values&period;
| xref:llvm/OnCuIndexOverflow.adoc[`OnCuIndexOverflow`] 
| Policy for handling CU&sol;TU index section contribution offset overflow&period;
| xref:llvm/OptimizationLevel.adoc[`OptimizationLevel`] 
| LLVM&hyphen;provided high&hyphen;level optimization level&period;
| xref:llvm/OverflowResult.adoc[`OverflowResult`] 
| Result of analyzing whether an arithmetic operation can overflow&period;
| xref:llvm/PGOCtxProfileBlockIDs.adoc[`PGOCtxProfileBlockIDs`] 
| Bitstream block IDs used in contextual PGO profiles&period;
| xref:llvm/PGOCtxProfileRecords.adoc[`PGOCtxProfileRecords`] 
| Bitstream record codes used in contextual PGO profiles&period;
| xref:llvm/PGOInstrumentationType.adoc[`PGOInstrumentationType`] 
| Kind of IR&hyphen;based PGO instrumentation to generate&period;
| xref:llvm/PGOViewCountsType.adoc[`PGOViewCountsType`] 
| How to display block profile counts after PGO annotation&period;
| xref:llvm/PGSOQueryType.adoc[`PGSOQueryType`] 
| Identifies the caller context of a profile&hyphen;guided size optimization query&period;
| xref:llvm/PassDebuggingString.adoc[`PassDebuggingString`] 
| Fragments used to format &hyphen;debug&hyphen;pass status messages&period;
| xref:llvm/PassKind.adoc[`PassKind`] 
| Classifies a pass by the IR unit or manager it operates on&period;
| xref:llvm/PassManagerType.adoc[`PassManagerType`] 
| Identifies which internal pass&hyphen;manager stack level owns a pass&period;
| xref:llvm/PassSummaryAction.adoc[`PassSummaryAction`] 
| What to do with the summary when running passes that operate on it&period;
| xref:llvm/PredicateType.adoc[`PredicateType`] 
| Kind of predicate information attached to a renamed operand copy&period;
| xref:llvm/PrevailingType.adoc[`PrevailingType`] 
| Prevailing status of a symbol for dead&hyphen;symbol analysis callbacks&period;
| xref:llvm/PrintPipelinePassesFormat.adoc[`PrintPipelinePassesFormat`] 
| Output format for printing pass pipelines&period;
| xref:llvm/PseudoProbeAttributes.adoc[`PseudoProbeAttributes`] 
| Bit flags describing optional properties of a pseudo probe&period;
| xref:llvm/PseudoProbeReservedId.adoc[`PseudoProbeReservedId`] 
| Reserved probe identifier values&period;
| xref:llvm/PseudoProbeType.adoc[`PseudoProbeType`] 
| Kind of code location a pseudo probe represents&period;
| xref:llvm/RecurKind.adoc[`RecurKind`] 
| These are the kinds of recurrences that we support&period;
| xref:llvm/RegAllocType.adoc[`RegAllocType`] 
| Identifies which register allocator the codegen pipeline should use&period;
| xref:llvm/RegBankSelectMode.adoc[`RegBankSelectMode`] 
| List of the modes supported by the RegBankSelect pass&period;
| xref:llvm/RegState.adoc[`RegState`] 
| Flags to represent properties of register accesses&period;
| xref:llvm/RelocSectionSymType.adoc[`RelocSectionSymType`] 
| For ELF targets, whether to adjust relocations referencing eligible local symbols to use section symbols&period;
| xref:llvm/RemapFlags.adoc[`RemapFlags`] 
| These are flags that the value mapping APIs allow&period;
| xref:llvm/ReplaceExitVal.adoc[`ReplaceExitVal`] 
| Strategy for replacing loop exit values with SCEV expansions&period;
| xref:llvm/ReplacementType.adoc[`ReplacementType`] 
| Kind of segment produced when parsing a formatv format string&period;
| xref:llvm/RoundingMode.adoc[`RoundingMode`] 
| Rounding mode&period;
| xref:llvm/RunOutliner.adoc[`RunOutliner`] 
| Controls when the machine outliner runs during code generation&period;
| xref:llvm/SCEVNoWrapFlags.adoc[`SCEVNoWrapFlags`] 
| NoWrapFlags are bitfield indices into SCEV&apos;s SubclassData&period;
| xref:llvm/SCEVTypes.adoc[`SCEVTypes`] 
| Kinds of SCEV expression nodes, ordered by increasing complexity&period;
| xref:llvm/SDNF.adoc[`SDNF`] 
| SelectionDAG node flags used by generated SDNode descriptions&period;
| xref:llvm/SDNP.adoc[`SDNP`] 
| SelectionDAG node properties used by generated SDNode descriptions&period;
| xref:llvm/SDTC.adoc[`SDTC`] 
| SelectionDAG type&hyphen;constraint kinds used by generated SDNode descriptions&period;
| xref:llvm/SanitizerStatKind.adoc[`SanitizerStatKind`] 
| Kinds of control&hyphen;flow integrity checks counted by sanitizer stats&period;
| xref:llvm/SelectPatternFlavor.adoc[`SelectPatternFlavor`] 
| Specific patterns of select instructions we can match&period;
| xref:llvm/SelectPatternNaNBehavior.adoc[`SelectPatternNaNBehavior`] 
| Behavior when a floating point min&sol;max is given one NaN and one non&hyphen;NaN as input&period;
| xref:llvm/SetThreadPriorityResult.adoc[`SetThreadPriorityResult`] 
| Outcome of attempting to change the current thread&apos;s priority&period;
| xref:llvm/StatepointFlags.adoc[`StatepointFlags`] 
| The statepoint intrinsic accepts a set of flags as its third argument&period; Valid values come out of this set&period;
| xref:llvm/StructuralHashOptions.adoc[`StructuralHashOptions`] 
| Options that control how structural hashes are computed&period;
| xref:llvm/SwiftAsyncFramePointerMode.adoc[`SwiftAsyncFramePointerMode`] 
| Indicates when and how the Swift async frame pointer bit should be set&period;
| xref:llvm/SymtabWritingMode.adoc[`SymtabWritingMode`] 
| Controls which symbol tables are written into the archive&period;
| xref:llvm/TailFoldingStyle.adoc[`TailFoldingStyle`] 
| Style of tail folding used by the loop vectorizer&period;
| xref:llvm/TensorType.adoc[`TensorType`] 
| Element type of a tensor buffer&period;
| xref:llvm/TextEncoding.adoc[`TextEncoding`] 
| Character set encodings supported by TextEncodingConverter&period;
| xref:llvm/ThinOrFullLTOPhase.adoc[`ThinOrFullLTOPhase`] 
| This enumerates the LLVM full LTO or ThinLTO optimization phases&period;
| xref:llvm/ThreadPriority.adoc[`ThreadPriority`] 
| Scheduling priority hint for `set&lowbar;thread&lowbar;priority&period;`
| xref:llvm/TimeTraceEventType.adoc[`TimeTraceEventType`] 
| Chrome Trace Event phase kinds recorded by the time profiler&period;
| xref:llvm/TransformationMode.adoc[`TransformationMode`] 
| The mode sets how eager a transformation should be applied&period;
| xref:llvm/UWTableKind.adoc[`UWTableKind`] 
| Kind of unwind table to emit for a function&period;
| xref:llvm/UncountableExitTrait.adoc[`UncountableExitTrait`] 
| Characteristics of a loop with an uncountable exit&period;
| xref:llvm/UndefPoisonKind.adoc[`UndefPoisonKind`] 
| Enumeration to track whether we are interested in Undef, Poison, or both&period;
| xref:llvm/VFISAKind.adoc[`VFISAKind`] 
| Describes the type of Instruction Set Architecture
| xref:llvm/VFParamKind.adoc[`VFParamKind`] 
| Describes the type of Parameters
| xref:llvm/VPExpansionDetails.adoc[`VPExpansionDetails`] 
| Represents the details the expansion of a VP intrinsic&period;
| xref:llvm/ValueUniformity.adoc[`ValueUniformity`] 
| How a value behaves with respect to uniformity and divergence&period;
| xref:llvm/VariableID.adoc[`VariableID`] 
| Type wrapper for integer ID for Variables&period; 0 is reserved&period;
| xref:llvm/VectorInstrContext.adoc[`VectorInstrContext`] 
| Represents a hint about the context in which a vector instruction or intrinsic is used&period;
| xref:llvm/VectorLibrary.adoc[`VectorLibrary`] 
| List of known vector&hyphen;functions libraries&period;
| xref:llvm/WaitForUnlockResult.adoc[`WaitForUnlockResult`] 
| Describes the result of waiting for the owner to release the lock&period;
| xref:llvm/WinX64EHUnwindMode.adoc[`WinX64EHUnwindMode`] 
| Windows x64 exception&hyphen;handling unwind info version&period;
| xref:llvm/WindowSchedulingFlag.adoc[`WindowSchedulingFlag`] 
| Controls whether and when the window scheduling algorithm is used&period;
| xref:llvm/cgdata_error.adoc[`cgdata&lowbar;error`] 
| Error codes for codegen data reading and validation&period;
| xref:llvm/endianness.adoc[`endianness`] 
| Byte order of multi&hyphen;byte values&period;
| xref:llvm/errc.adoc[`errc`] 
| Portable error conditions corresponding to the supported subset of `std&colon;&colon;errc&period;`
| xref:llvm/fltNanEncoding.adoc[`fltNanEncoding`] 
| How NaN values are represented&period;
| xref:llvm/fltNonfiniteBehavior.adoc[`fltNonfiniteBehavior`] 
| How the nonfinite values Inf and NaN are represented&period;
| xref:llvm/instrprof_error.adoc[`instrprof&lowbar;error`] 
| Error codes returned while reading or writing instrumented profiles&period;
| xref:llvm/lostFraction.adoc[`lostFraction`] 
| Enum that represents what fraction of the LSB truncated bits of an fp number represent&period;
| xref:llvm/sampleprof_error.adoc[`sampleprof&lowbar;error`] 
| Error codes for sample profile reading and writing&period;
| xref:llvm/stream_error_code.adoc[`stream&lowbar;error&lowbar;code`] 
| Error codes for failures while reading or writing binary streams&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/AbsoluteDifference.adoc[`AbsoluteDifference`] 
| Subtract two unsigned integers, X and Y, of type T and return the absolute value of the result&period;
| xref:llvm/AbsoluteValue.adoc[`AbsoluteValue`] 
| Return the absolute value of a signed integer as unsigned&period;
| xref:llvm/AddOverflow-00.adoc[`AddOverflow`] 
| `AddOverflow` overloads
| xref:llvm/AnalyzePhysRegInBundle.adoc[`AnalyzePhysRegInBundle`] 
| Analyze how the current instruction or bundle uses a physical register&period;
| xref:llvm/AnalyzeVirtRegInBundle.adoc[`AnalyzeVirtRegInBundle`] 
| Analyze how the current instruction or bundle uses a virtual register&period;
| xref:llvm/AnalyzeVirtRegLanesInBundle.adoc[`AnalyzeVirtRegLanesInBundle`] 
| Return a pair of lane masks (reads, writes) indicating which lanes this instruction uses with Reg&period;
| xref:llvm/AnnotateInlinePassName.adoc[`AnnotateInlinePassName`] 
| Annotate `IC` with a human&hyphen;readable inline pass name string&period;
| xref:llvm/AreStatisticsEnabled.adoc[`AreStatisticsEnabled`] 
| Check if statistics are enabled&period;
| xref:llvm/BitcodeErrorCategory.adoc[`BitcodeErrorCategory`] 
| Return the error category for BitcodeError values&period;
| xref:llvm/BuildMI-06f.adoc[`BuildMI`] 
| `BuildMI` overloads
| xref:llvm/BuryPointer-0e.adoc[`BuryPointer`] 
| Intentionally leak a pointer so leak detectors do not report it&period;
| xref:llvm/CanInlineCallSite.adoc[`CanInlineCallSite`] 
| Check if it is legal to perform inlining of the function called by `CB` into the caller at this particular use, and sets fields in `IFI&period;`
| xref:llvm/CheckAssert.adoc[`CheckAssert`] 
| Check TableGen assert condition `Condition` at `Loc&period;`
| xref:llvm/CheckBitcodeOutputToConsole.adoc[`CheckBitcodeOutputToConsole`] 
| Check for bitcode output written to a console&period;
| xref:llvm/CloneAndPruneFunctionInto.adoc[`CloneAndPruneFunctionInto`] 
| Clone OldFunc into NewFunc with on&hyphen;the&hyphen;fly constant prop and DCE&period;
| xref:llvm/CloneAndPruneIntoFromInst.adoc[`CloneAndPruneIntoFromInst`] 
| Clone and prune OldFunc into NewFunc starting at a given instruction&period;
| xref:llvm/CloneBasicBlock.adoc[`CloneBasicBlock`] 
| Return a copy of the specified basic block without embedding it&period;
| xref:llvm/CloneFunction.adoc[`CloneFunction`] 
| Return a copy of the specified function and add it to its module&period;
| xref:llvm/CloneFunctionAttributesInto.adoc[`CloneFunctionAttributesInto`] 
| Clone OldFunc&apos;s attributes into NewFunc, transforming values based on the mappings in VMap&period;
| xref:llvm/CloneFunctionBodyInto.adoc[`CloneFunctionBodyInto`] 
| Clone OldFunc&apos;s body into NewFunc&period;
| xref:llvm/CloneFunctionInto.adoc[`CloneFunctionInto`] 
| Clone OldFunc into NewFunc using the provided value map&period;
| xref:llvm/CloneFunctionMetadataInto.adoc[`CloneFunctionMetadataInto`] 
| Clone OldFunc&apos;s metadata into NewFunc&period;
| xref:llvm/CloneModule-04.adoc[`CloneModule`] 
| `CloneModule` overloads
| xref:llvm/CompleteNodeLabelString.adoc[`CompleteNodeLabelString`] 
| Build a detailed DOT label for a basic block, wrapping and stripping comments&period;
| xref:llvm/ComputeASanStackFrameDescription.adoc[`ComputeASanStackFrameDescription`] 
| Compute a frame description string for AddressSanitizer reports&period;
| xref:llvm/ComputeASanStackFrameLayout.adoc[`ComputeASanStackFrameLayout`] 
| Compute the AddressSanitizer layout of a stack frame&period;
| xref:llvm/ComputeCrossModuleImport.adoc[`ComputeCrossModuleImport`] 
| Compute all the imports and exports for every module in the Index&period;
| xref:llvm/ComputeEditDistance.adoc[`ComputeEditDistance`] 
| Determine the edit distance between two sequences&period;
| xref:llvm/ComputeLinearIndex-06c.adoc[`ComputeLinearIndex`] 
| `ComputeLinearIndex` overloads
| xref:llvm/ComputeMappedEditDistance.adoc[`ComputeMappedEditDistance`] 
| Determine the edit distance between two sequences&period;
| xref:llvm/ComputeMaxSignificantBits.adoc[`ComputeMaxSignificantBits`] 
| Get the upper bound on bit size for this Value `Op` as a signed integer&period;
| xref:llvm/ComputeNumSignBits.adoc[`ComputeNumSignBits`] 
| Return the number of times the sign bit of the register is replicated into the other bits&period;
| xref:llvm/ComputeValueTypes.adoc[`ComputeValueTypes`] 
| Given an LLVM IR type, compute non&hyphen;aggregate subtypes&period; Optionally also compute their offsets&period;
| xref:llvm/ComputeValueVTs-06.adoc[`ComputeValueVTs`] 
| Compute a sequence of EVTs for the non&hyphen;aggregate parts of an LLVM IR type&period;
| xref:llvm/ConstantFoldBinOp.adoc[`ConstantFoldBinOp`] 
| Constant&hyphen;fold a generic integer binary opcode on two register operands&period;
| xref:llvm/ConstantFoldBinaryInstruction.adoc[`ConstantFoldBinaryInstruction`] 
| Attempt to constant fold a binary instruction with the specified operands&period;
| xref:llvm/ConstantFoldBinaryOpOperands.adoc[`ConstantFoldBinaryOpOperands`] 
| Attempt to constant fold a binary operation with the specified operands&period; Returns null or a constant expression of the specified operands on failure&period;
| xref:llvm/ConstantFoldCall.adoc[`ConstantFoldCall`] 
| Attempt to constant fold a call to the specified function with the specified arguments, returning null if unsuccessful&period;
| xref:llvm/ConstantFoldCastInstruction.adoc[`ConstantFoldCastInstruction`] 
| Attempt to constant fold a cast instruction with the specified operand&period;
| xref:llvm/ConstantFoldCastOp.adoc[`ConstantFoldCastOp`] 
| Constant&hyphen;fold a generic cast opcode producing an integer result&period;
| xref:llvm/ConstantFoldCastOperand.adoc[`ConstantFoldCastOperand`] 
| Attempt to constant fold a cast with the specified operand&period; If it fails, it returns a constant expression of the specified operand&period;
| xref:llvm/ConstantFoldCompareInstOperands.adoc[`ConstantFoldCompareInstOperands`] 
| Attempt to constant fold a compare instruction with the specified operands&period;
| xref:llvm/ConstantFoldCompareInstruction.adoc[`ConstantFoldCompareInstruction`] 
| Attempt to constant fold a compare instruction with the specified operands&period;
| xref:llvm/ConstantFoldConstant.adoc[`ConstantFoldConstant`] 
| Fold a constant using the specified DataLayout&period;
| xref:llvm/ConstantFoldExtOp.adoc[`ConstantFoldExtOp`] 
| Constant&hyphen;fold a generic extend opcode with an immediate second operand&period;
| xref:llvm/ConstantFoldExtractElementInstruction.adoc[`ConstantFoldExtractElementInstruction`] 
| Attempt to constant fold an extractelement instruction with the specified operands and indices&period;
| xref:llvm/ConstantFoldExtractValueInstruction.adoc[`ConstantFoldExtractValueInstruction`] 
| Attempt to constant fold an extractvalue instruction with the specified operands and indices&period;
| xref:llvm/ConstantFoldFPBinOp.adoc[`ConstantFoldFPBinOp`] 
| Constant&hyphen;fold a generic floating&hyphen;point binary opcode on two registers&period;
| xref:llvm/ConstantFoldFPInstOperands.adoc[`ConstantFoldFPInstOperands`] 
| Attempt to constant fold a floating&hyphen;point binary operation with denormal handling&period;
| xref:llvm/ConstantFoldGetElementPtr.adoc[`ConstantFoldGetElementPtr`] 
| Attempt to constant fold a getelementptr instruction with the specified operands&period;
| xref:llvm/ConstantFoldICmp.adoc[`ConstantFoldICmp`] 
| Constant&hyphen;fold an integer compare of two register operands&period;
| xref:llvm/ConstantFoldInsertElementInstruction.adoc[`ConstantFoldInsertElementInstruction`] 
| Attempt to constant fold an insertelement instruction with the specified operands and indices&period;
| xref:llvm/ConstantFoldInsertValueInstruction.adoc[`ConstantFoldInsertValueInstruction`] 
| Attempt to constant fold an insertvalue instruction with the specified operands and indices&period;
| xref:llvm/ConstantFoldInstOperands.adoc[`ConstantFoldInstOperands`] 
| Attempt to constant fold an instruction with the specified operands&period;
| xref:llvm/ConstantFoldInstruction.adoc[`ConstantFoldInstruction`] 
| Try to constant fold the specified instruction&period;
| xref:llvm/ConstantFoldIntToFloat.adoc[`ConstantFoldIntToFloat`] 
| Constant&hyphen;fold an integer&hyphen;to&hyphen;float conversion opcode&period;
| xref:llvm/ConstantFoldIntegerCast.adoc[`ConstantFoldIntegerCast`] 
| Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrower than C&period; Returns nullptr on failure&period;
| xref:llvm/ConstantFoldIntrinsic.adoc[`ConstantFoldIntrinsic`] 
| Attempt to constant fold a call to the specified intrinsic&period;
| xref:llvm/ConstantFoldLoadFromConst-0a.adoc[`ConstantFoldLoadFromConst`] 
| `ConstantFoldLoadFromConst` overloads
| xref:llvm/ConstantFoldLoadFromConstPtr-0d.adoc[`ConstantFoldLoadFromConstPtr`] 
| `ConstantFoldLoadFromConstPtr` overloads
| xref:llvm/ConstantFoldLoadFromUniformValue.adoc[`ConstantFoldLoadFromUniformValue`] 
| Return a uniform bit&hyphen;pattern constant reinterpreted as `Ty,` or null&period;
| xref:llvm/ConstantFoldLoadThroughBitcast.adoc[`ConstantFoldLoadThroughBitcast`] 
| Try to cast a constant to a destination type through a bitcast&hyphen;like load&period;
| xref:llvm/ConstantFoldSelectInstruction.adoc[`ConstantFoldSelectInstruction`] 
| Attempt to constant fold a select instruction with the specified operands&period; The constant result is returned if successful&semi; if not, null is returned&period;
| xref:llvm/ConstantFoldShuffleVectorInstruction.adoc[`ConstantFoldShuffleVectorInstruction`] 
| Attempt to constant fold a shufflevector instruction with the specified operands and mask&period;
| xref:llvm/ConstantFoldTerminator.adoc[`ConstantFoldTerminator`] 
| Fold a constant&hyphen;predicated terminator into an unconditional branch&period;
| xref:llvm/ConstantFoldUnaryInstruction.adoc[`ConstantFoldUnaryInstruction`] 
| Attempt to constant fold a unary instruction with the specified operand&period;
| xref:llvm/ConstantFoldUnaryIntOp.adoc[`ConstantFoldUnaryIntOp`] 
| Constant&hyphen;fold a unary integer operation on `Src&period;`
| xref:llvm/ConstantFoldUnaryOpOperand.adoc[`ConstantFoldUnaryOpOperand`] 
| Attempt to constant fold a unary operation with the specified operand&period; Returns null on failure&period;
| xref:llvm/ConstantFoldVectorBinop.adoc[`ConstantFoldVectorBinop`] 
| Tries to constant fold a vector binop with sources `Op1` and `Op2&period;` Returns an empty vector on failure&period;
| xref:llvm/ConstantLog2.adoc[`ConstantLog2`] 
| Compile time Log2&period; Valid only for positive powers of two&period;
| xref:llvm/ConvertCodePointToUTF8.adoc[`ConvertCodePointToUTF8`] 
| Convert an Unicode code point to UTF8 sequence&period;
| xref:llvm/ConvertCostTableLookup-0ae.adoc[`ConvertCostTableLookup`] 
| `ConvertCostTableLookup` overloads
| xref:llvm/ConvertDebugDeclareToDebugValue-0a.adoc[`ConvertDebugDeclareToDebugValue`] 
| `ConvertDebugDeclareToDebugValue` overloads
| xref:llvm/ConvertUTF16toUTF32.adoc[`ConvertUTF16toUTF32`] 
| Convert a UTF&hyphen;16 sequence to UTF&hyphen;32&period;
| xref:llvm/ConvertUTF16toUTF8.adoc[`ConvertUTF16toUTF8`] 
| Convert a UTF&hyphen;16 sequence to UTF&hyphen;8&period;
| xref:llvm/ConvertUTF32toUTF16.adoc[`ConvertUTF32toUTF16`] 
| Convert a UTF&hyphen;32 sequence to UTF&hyphen;16&period;
| xref:llvm/ConvertUTF32toUTF8.adoc[`ConvertUTF32toUTF8`] 
| Convert a UTF&hyphen;32 sequence to UTF&hyphen;8&period;
| xref:llvm/ConvertUTF8toUTF16.adoc[`ConvertUTF8toUTF16`] 
| Convert a UTF&hyphen;8 sequence to UTF&hyphen;16&period;
| xref:llvm/ConvertUTF8toUTF32.adoc[`ConvertUTF8toUTF32`] 
| Convert a partial UTF8 sequence to UTF32&period; If the sequence ends in an incomplete code unit sequence, returns `sourceIllegal&period;`
| xref:llvm/ConvertUTF8toUTF32Partial.adoc[`ConvertUTF8toUTF32Partial`] 
| Convert a partial UTF8 sequence to UTF32&period; If the sequence ends in an incomplete code unit sequence, returns `sourceExhausted&period;`
| xref:llvm/ConvertUTF8toWide-0ca.adoc[`ConvertUTF8toWide`] 
| `ConvertUTF8toWide` overloads
| xref:llvm/CostTableLookup-03.adoc[`CostTableLookup`] 
| `CostTableLookup` overloads
| xref:llvm/CreateInfoOutputFile.adoc[`CreateInfoOutputFile`] 
| Return a stream to print our output on&period;
| xref:llvm/CreateZ3Solver.adoc[`CreateZ3Solver`] 
| Convenience method to create and Z3Solver object
| xref:llvm/DebugStr-07.adoc[`DebugStr`] 
| `DebugStr` overloads
| xref:llvm/DeleteDeadBlock.adoc[`DeleteDeadBlock`] 
| Delete the specified block, which must have no predecessors&period;
| xref:llvm/DeleteDeadBlocks.adoc[`DeleteDeadBlocks`] 
| Delete the specified blocks, which must have no live predecessors&period;
| xref:llvm/DeleteDeadPHIs.adoc[`DeleteDeadPHIs`] 
| Delete dead PHI nodes in a block and recursively dead operands&period;
| xref:llvm/DemotePHIToStack.adoc[`DemotePHIToStack`] 
| Demote a PHI node&apos;s virtual register to a stack slot&period;
| xref:llvm/DemoteRegToStack.adoc[`DemoteRegToStack`] 
| Demote an instruction&apos;s virtual register to a stack slot&period;
| xref:llvm/DetermineUseCaptureKind.adoc[`DetermineUseCaptureKind`] 
| Determine what kind of capture behaviour `U` may exhibit&period;
| xref:llvm/DiffFilesWithTolerance.adoc[`DiffFilesWithTolerance`] 
| Compare two files, allowing absolute and relative floating&hyphen;point tolerance&period;
| xref:llvm/DisplayGraph.adoc[`DisplayGraph`] 
| Display a DOT graph file with the given Graphviz program&period;
| xref:llvm/DuplicateInstructionsInSplitBetween.adoc[`DuplicateInstructionsInSplitBetween`] 
| Split PredBB&hyphen;&gt;BB and duplicate non&hyphen;Phi instructions into the split block&period;
| xref:llvm/EliminateDuplicatePHINodes-0d.adoc[`EliminateDuplicatePHINodes`] 
| `EliminateDuplicatePHINodes` overloads
| xref:llvm/EliminateNewDuplicatePHINodes.adoc[`EliminateNewDuplicatePHINodes`] 
| Eliminate newly inserted PHI nodes in `BB` that duplicate earlier ones&period;
| xref:llvm/EliminateUnreachableBlocks.adoc[`EliminateUnreachableBlocks`] 
| Delete all basic blocks in `F` that are unreachable from its entry&period;
| xref:llvm/EmitDetailedRecords.adoc[`EmitDetailedRecords`] 
| Emit detailed textual representations of all records&period;
| xref:llvm/EmitImportsFiles.adoc[`EmitImportsFiles`] 
| Emit into `OutputFilename` the files module `ModulePath` will import from&period;
| xref:llvm/EmitJSON.adoc[`EmitJSON`] 
| Emit a JSON representation of all records&period;
| xref:llvm/EnablePrettyStackTrace.adoc[`EnablePrettyStackTrace`] 
| Enables dumping a &quot;pretty&quot; stack trace when the program crashes&period;
| xref:llvm/EnablePrettyStackTraceOnSigInfoForThisThread.adoc[`EnablePrettyStackTraceOnSigInfoForThisThread`] 
| Enables (or disables) dumping a &quot;pretty&quot; stack trace when the user sends SIGINFO or SIGUSR1 to the current process&period;
| xref:llvm/EnableStatistics.adoc[`EnableStatistics`] 
| Enable the collection and printing of statistics&period;
| xref:llvm/ExtractTypeInfo.adoc[`ExtractTypeInfo`] 
| ExtractTypeInfo &hyphen; Returns the type info, possibly bitcast, encoded in V&period;
| xref:llvm/FindAvailableLoadedValue-06.adoc[`FindAvailableLoadedValue`] 
| `FindAvailableLoadedValue` overloads
| xref:llvm/FindEarliestCapture.adoc[`FindEarliestCapture`] 
| Find the earliest instruction that captures `V` in `F&period;`
| xref:llvm/FindFunctionBackedges.adoc[`FindFunctionBackedges`] 
| Find all loop backedges in the specified function&period;
| xref:llvm/FindInsertedValue.adoc[`FindInsertedValue`] 
| Given an aggregate and a sequence of indices, see if the scalar value indexed is already around as a register&period;
| xref:llvm/FlattenCFG.adoc[`FlattenCFG`] 
| Flatten a CFG by collapsing related if&hyphen;conditions and regions&period;
| xref:llvm/FlushFPConstant.adoc[`FlushFPConstant`] 
| Flush a floating&hyphen;point constant according to the parent function&apos;s denormal mode&period;
| xref:llvm/FoldReturnIntoUncondBranch.adoc[`FoldReturnIntoUncondBranch`] 
| Fold a return into a predecessor that ends with an unconditional branch&period;
| xref:llvm/FoldSingleEntryPHINodes.adoc[`FoldSingleEntryPHINodes`] 
| Fold away single&hyphen;entry PHI nodes in a block with one predecessor&period;
| xref:llvm/GVTOP.adoc[`GVTOP`] 
| Extract the pointer stored in a GenericValue&period;
| xref:llvm/GetIfCondition.adoc[`GetIfCondition`] 
| Return the branch that selects between predecessors of an if&hyphen;merge block&period;
| xref:llvm/GetPointerBaseWithConstantOffset-08.adoc[`GetPointerBaseWithConstantOffset`] 
| `GetPointerBaseWithConstantOffset` overloads
| xref:llvm/GetReturnInfo.adoc[`GetReturnInfo`] 
| Compute the return value EVTs, flags, and offsets for a given LLVM IR return type&period;
| xref:llvm/GetShadowBytes.adoc[`GetShadowBytes`] 
| Return shadow bytes for a stack frame with all locals in scope&period;
| xref:llvm/GetShadowBytesAfterScope.adoc[`GetShadowBytesAfterScope`] 
| Return shadow bytes after all locals have gone out of scope&period;
| xref:llvm/GetStatistics.adoc[`GetStatistics`] 
| Get the statistics&period; This can be used to look up the value of statistics without needing to parse JSON&period;
| xref:llvm/GetStringLength.adoc[`GetStringLength`] 
| If we can compute the length of the string pointed to by the specified pointer, return &apos;len&plus;1&apos;&period; If we can&apos;t, return 0&period;
| xref:llvm/GetSuccessorNumber.adoc[`GetSuccessorNumber`] 
| Return the successor index of `Succ` in `BB&apos;s` terminator&period;
| xref:llvm/GetUnrollMetadata.adoc[`GetUnrollMetadata`] 
| Return the named unroll hint metadata operand from loop id `LoopID&period;`
| xref:llvm/HasLoopOrEntryConvergenceToken.adoc[`HasLoopOrEntryConvergenceToken`] 
| Check if the given basic block contains any loop or entry convergent intrinsic instructions&period;
| xref:llvm/Hi_32.adoc[`Hi&lowbar;32`] 
| Return the high 32 bits of a 64 bit value&period;
| xref:llvm/InlineFunction-04.adoc[`InlineFunction`] 
| `InlineFunction` overloads
| xref:llvm/InlineFunctionImpl.adoc[`InlineFunctionImpl`] 
| This should generally not be used, use InlineFunction instead&period;
| xref:llvm/InsertDebugValueAtStoreLoc.adoc[`InsertDebugValueAtStoreLoc`] 
| Insert a dbg&period;value before a store with an associated dbg&period;value&period;
| xref:llvm/InsertPreheaderForLoop.adoc[`InsertPreheaderForLoop`] 
| Insert a loop preheader for `L` when one does not already exist&period;
| xref:llvm/InvertBranch.adoc[`InvertBranch`] 
| Invert a conditional branch&apos;s condition and swap its successors&period;
| xref:llvm/IsBlockFollowedByDeoptOrUnreachable.adoc[`IsBlockFollowedByDeoptOrUnreachable`] 
| Check whether all paths from a block reach deopt or unreachable&period;
| xref:llvm/IsConstantOffsetFromGlobal.adoc[`IsConstantOffsetFromGlobal`] 
| Return true if `C` is a constant offset from a global&period;
| xref:llvm/IsSingleCodeUnitUTF16Codepoint.adoc[`IsSingleCodeUnitUTF16Codepoint`] 
| Returns true if `Codepoint` fits in a single UTF&hyphen;16 code unit&period;
| xref:llvm/IsSingleCodeUnitUTF32Codepoint.adoc[`IsSingleCodeUnitUTF32Codepoint`] 
| Returns true if `Codepoint` is a valid UTF&hyphen;32 scalar value&period;
| xref:llvm/IsSingleCodeUnitUTF8Codepoint.adoc[`IsSingleCodeUnitUTF8Codepoint`] 
| Returns true if `Codepoint` fits in a single UTF&hyphen;8 code unit (ASCII)&period;
| xref:llvm/Lo_32.adoc[`Lo&lowbar;32`] 
| Return the low 32 bits of a 64 bit value&period;
| xref:llvm/LoadIntFromMemory.adoc[`LoadIntFromMemory`] 
| Load `LoadBytes` bytes from `Src` into `IntVal&period;`
| xref:llvm/Log2.adoc[`Log2`] 
| Returns the log2 of the alignment&period;
| xref:llvm/Log2_32.adoc[`Log2&lowbar;32`] 
| Return the floor log base 2 of the specified value (32&hyphen;bit)&period;
| xref:llvm/Log2_32_Ceil.adoc[`Log2&lowbar;32&lowbar;Ceil`] 
| Return the ceil log base 2 of the specified value (32&hyphen;bit)&period;
| xref:llvm/Log2_64.adoc[`Log2&lowbar;64`] 
| Return the floor log base 2 of the specified value, &hyphen;1 if the value is zero&period; (64 bit edition&period;)
| xref:llvm/Log2_64_Ceil.adoc[`Log2&lowbar;64&lowbar;Ceil`] 
| Return the ceil log base 2 of the specified value, 64 if the value is zero&period; (64 bit edition&period;)
| xref:llvm/LoopRotation.adoc[`LoopRotation`] 
| Convert a loop into a loop with bottom test&period;
| xref:llvm/LowerDbgDeclare.adoc[`LowerDbgDeclare`] 
| Lower dbg&period;declare records into dbg&period;value records&period;
| xref:llvm/MD5Hash.adoc[`MD5Hash`] 
| Helper to compute and return lower 64 bits of the given string&apos;s MD5 hash&period;
| xref:llvm/Make_64.adoc[`Make&lowbar;64`] 
| Make a 64&hyphen;bit integer from a high &sol; low pair of 32&hyphen;bit integers&period;
| xref:llvm/MapMetadata-07.adoc[`MapMetadata`] 
| `MapMetadata` overloads
| xref:llvm/MapValue-0d.adoc[`MapValue`] 
| `MapValue` overloads
| xref:llvm/MaskedValueIsZero.adoc[`MaskedValueIsZero`] 
| Return true if &apos;V &amp; Mask&apos; is known to be zero&period; We use this predicate to simplify operations downstream&period; Mask is known to be zero for bits that V cannot have&period;
| xref:llvm/MergeBasicBlockIntoOnlyPred.adoc[`MergeBasicBlockIntoOnlyPred`] 
| Merge a block into its unique predecessor when that edge is trivial&period;
| xref:llvm/MergeBlockIntoPredecessor.adoc[`MergeBlockIntoPredecessor`] 
| Attempt to merge a block into its predecessor when possible&period;
| xref:llvm/MergeBlockSuccessorsIntoGivenBlocks.adoc[`MergeBlockSuccessorsIntoGivenBlocks`] 
| Merge successors of the given blocks into them when possible&period;
| xref:llvm/MinAlign-02.adoc[`MinAlign`] 
| `MinAlign` overloads
| xref:llvm/MulOverflow-0d0.adoc[`MulOverflow`] 
| `MulOverflow` overloads
| xref:llvm/NextPowerOf2.adoc[`NextPowerOf2`] 
| Returns the next power of two (in 64&hyphen;bits) that is strictly greater than A&period; Returns zero on overflow&period;
| xref:llvm/NullPointerIsDefined.adoc[`NullPointerIsDefined`] 
| Return whether null pointer dereference is defined for `F` or address space `AS&period;`
| xref:llvm/NumDigitsBase10.adoc[`NumDigitsBase10`] 
| Returns the number of digits in the given integer&period;
| xref:llvm/PTOGV.adoc[`PTOGV`] 
| Convert a pointer to a GenericValue that holds it&period;
| xref:llvm/PeelSingleBlockLoop.adoc[`PeelSingleBlockLoop`] 
| Peels a single block loop&period;
| xref:llvm/PointerMayBeCaptured-021.adoc[`PointerMayBeCaptured`] 
| `PointerMayBeCaptured` overloads
| xref:llvm/PointerMayBeCapturedBefore-0b.adoc[`PointerMayBeCapturedBefore`] 
| `PointerMayBeCapturedBefore` overloads
| xref:llvm/PowerOf2Ceil.adoc[`PowerOf2Ceil`] 
| Returns the power of two which is greater than or equal to the given value&period; Essentially, it is a ceil operation across the domain of powers of two&period;
| xref:llvm/PrepareToSplitEntryBlock.adoc[`PrepareToSplitEntryBlock`] 
| Move entry&hyphen;block&hyphen;only instructions before a planned split point&period;
| xref:llvm/PrintDomTree.adoc[`PrintDomTree`] 
| Recursively print the subtree rooted at `N` indented by level `Lev&period;`
| xref:llvm/PrintError-04a.adoc[`PrintError`] 
| `PrintError` overloads
| xref:llvm/PrintFatalError-0d.adoc[`PrintFatalError`]  [.small]#[noreturn]#
| `PrintFatalError` overloads
| xref:llvm/PrintFatalNote-05.adoc[`PrintFatalNote`]  [.small]#[noreturn]#
| `PrintFatalNote` overloads
| xref:llvm/PrintLaneMask.adoc[`PrintLaneMask`] 
| Create Printable object to print LaneBitmasks on a xref:llvm/raw_ostream.adoc[`raw&lowbar;ostream`]&period;
| xref:llvm/PrintNote-0b.adoc[`PrintNote`] 
| `PrintNote` overloads
| xref:llvm/PrintRecyclerStats.adoc[`PrintRecyclerStats`] 
| PrintRecyclingAllocatorStats &hyphen; Helper for RecyclingAllocator for printing statistics&period;
| xref:llvm/PrintStatistics-07.adoc[`PrintStatistics`] 
| `PrintStatistics` overloads
| xref:llvm/PrintStatisticsJSON.adoc[`PrintStatisticsJSON`] 
| Print statistics in JSON format&period; This does include all global timers (
| xref:llvm/PrintWarning-06.adoc[`PrintWarning`] 
| `PrintWarning` overloads
| xref:llvm/PromoteMemToReg.adoc[`PromoteMemToReg`] 
| Promote the specified list of alloca instructions into scalar registers, inserting PHI nodes as appropriate&period;
| xref:llvm/ReadByteArrayFromGlobal.adoc[`ReadByteArrayFromGlobal`] 
| Read the trailing bytes of a global&apos;s initializer starting at `Offset&period;`
| xref:llvm/RecursivelyDeleteDeadPHINode.adoc[`RecursivelyDeleteDeadPHINode`] 
| Recursively delete an effectively dead PHI and its dead operands&period;
| xref:llvm/RecursivelyDeleteTriviallyDeadInstructions-00.adoc[`RecursivelyDeleteTriviallyDeadInstructions`] 
| `RecursivelyDeleteTriviallyDeadInstructions` overloads
| xref:llvm/RecursivelyDeleteTriviallyDeadInstructionsPermissive.adoc[`RecursivelyDeleteTriviallyDeadInstructionsPermissive`] 
| Recursively delete trivially dead instructions from a permissive worklist&period;
| xref:llvm/RemapDbgRecord.adoc[`RemapDbgRecord`] 
| Remap the Values used in the DbgRecord _DR_ using the value map _VM&period;_
| xref:llvm/RemapDbgRecordRange.adoc[`RemapDbgRecordRange`] 
| Remap the Values used in the DbgRecords _Range_ using the value map _VM&period;_
| xref:llvm/RemapFunction.adoc[`RemapFunction`] 
| Remap the operands, metadata, arguments, and instructions of a function&period;
| xref:llvm/RemapInstruction.adoc[`RemapInstruction`] 
| Convert the instruction operands from referencing the current values into those specified by VM&period;
| xref:llvm/RemapSourceAtom.adoc[`RemapSourceAtom`] 
| Remap the source&hyphen;location atom of instruction `I&period;`
| xref:llvm/RemoveRedundantDbgInstrs.adoc[`RemoveRedundantDbgInstrs`] 
| Try to remove redundant dbg&period;value instructions from a basic block&period;
| xref:llvm/ReplaceInstWithInst-05.adoc[`ReplaceInstWithInst`] 
| `ReplaceInstWithInst` overloads
| xref:llvm/ReplaceInstWithValue.adoc[`ReplaceInstWithValue`] 
| Replace all uses of an instruction with a value, then delete it&period;
| xref:llvm/ResetStatistics.adoc[`ResetStatistics`] 
| Reset the statistics&period; This can be used to zero and de&hyphen;register the statistics in order to measure a compilation&period;
| xref:llvm/RestorePrettyStackState.adoc[`RestorePrettyStackState`] 
| Restore the pretty stack state saved by SavePrettyStackState&period;
| xref:llvm/ReverseStackTrace.adoc[`ReverseStackTrace`] 
| Reverse the singly linked list of pretty stack&hyphen;trace entries&period;
| xref:llvm/SCEVExprContains.adoc[`SCEVExprContains`] 
| Return true if any node in `Root` satisfies the predicate `Pred&period;`
| xref:llvm/SaturatingAdd-0d.adoc[`SaturatingAdd`] 
| `SaturatingAdd` overloads
| xref:llvm/SaturatingMultiply.adoc[`SaturatingMultiply`] 
| Multiply two unsigned integers with saturation on overflow&period;
| xref:llvm/SaturatingMultiplyAdd.adoc[`SaturatingMultiplyAdd`] 
| Multiply `X` by `Y` and add `A` with unsigned saturation&period;
| xref:llvm/SavePrettyStackState.adoc[`SavePrettyStackState`] 
| Returns the topmost element of the &quot;pretty&quot; stack state&period;
| xref:llvm/SignExtend32-0f.adoc[`SignExtend32`] 
| Sign&hyphen;extend the number in the bottom B bits of X to a 32&hyphen;bit integer&period; Requires B &lt;&equals; 32&period;
| xref:llvm/SignExtend64-0d.adoc[`SignExtend64`] 
| Sign&hyphen;extend the number in the bottom B bits of X to a 64&hyphen;bit integer&period; Requires B &lt;&equals; 64&period;
| xref:llvm/SimpleNodeLabelString.adoc[`SimpleNodeLabelString`] 
| Build a simple DOT label for a basic block from its name or operand form&period;
| xref:llvm/SimplifyInstructionsInBlock.adoc[`SimplifyInstructionsInBlock`] 
| Simplify instructions in a block and recursively delete dead ones&period;
| xref:llvm/SkipBitcodeWrapperHeader.adoc[`SkipBitcodeWrapperHeader`] 
| SkipBitcodeWrapperHeader &hyphen; Some systems wrap bc files with a special header for padding or other reasons&period; The format of this header is&colon;
| xref:llvm/SplitAllCriticalEdges.adoc[`SplitAllCriticalEdges`] 
| Split every critical edge in a function&period;
| xref:llvm/SplitBlock-06.adoc[`SplitBlock`] 
| `SplitBlock` overloads
| xref:llvm/SplitBlockAndInsertForEachLane-0b.adoc[`SplitBlockAndInsertForEachLane`] 
| `SplitBlockAndInsertForEachLane` overloads
| xref:llvm/SplitBlockAndInsertIfElse-07.adoc[`SplitBlockAndInsertIfElse`] 
| `SplitBlockAndInsertIfElse` overloads
| xref:llvm/SplitBlockAndInsertIfThen-00.adoc[`SplitBlockAndInsertIfThen`] 
| `SplitBlockAndInsertIfThen` overloads
| xref:llvm/SplitBlockAndInsertIfThenElse-06.adoc[`SplitBlockAndInsertIfThenElse`] 
| `SplitBlockAndInsertIfThenElse` overloads
| xref:llvm/SplitBlockAndInsertSimpleForLoop.adoc[`SplitBlockAndInsertSimpleForLoop`] 
| Insert a simple counted for&hyphen;loop at a split point&period;
| xref:llvm/SplitBlockPredecessors-01.adoc[`SplitBlockPredecessors`] 
| Redirect selected predecessors of a block through a new intermediate block&period;
| xref:llvm/SplitCriticalEdge-0f.adoc[`SplitCriticalEdge`] 
| `SplitCriticalEdge` overloads
| xref:llvm/SplitEdge.adoc[`SplitEdge`] 
| Split the edge connecting two blocks and return the new block&period;
| xref:llvm/SplitIndirectBrCriticalEdges.adoc[`SplitIndirectBrCriticalEdges`] 
| Split critical edges leaving an indirectbr when a simple case applies&period;
| xref:llvm/SplitKnownCriticalEdge.adoc[`SplitKnownCriticalEdge`] 
| Split an edge that is already known to be critical&period;
| xref:llvm/SplitLandingPadPredecessors.adoc[`SplitLandingPadPredecessors`] 
| Split a landing&hyphen;pad block&apos;s predecessors into two new landing&hyphen;pad clones&period;
| xref:llvm/SplitModule.adoc[`SplitModule`] 
| Splits a module into multiple linkable partitions&period;
| xref:llvm/SplitMultiBrEdge.adoc[`SplitMultiBrEdge`] 
| Create a new intermediate target block for a callbr or switch edge&period;
| xref:llvm/SplitString.adoc[`SplitString`] 
| Split `Source` on `Delimiters,` appending fragments to `OutFragments&period;`
| xref:llvm/StoreIntToMemory.adoc[`StoreIntToMemory`] 
| Fill `StoreBytes` bytes of memory starting at `Dst` with `IntVal&period;`
| xref:llvm/StrCmpOptionName.adoc[`StrCmpOptionName`] 
| Compare two option name (or prefix) strings for sorting&period;
| xref:llvm/StrCmpOptionPrefixes.adoc[`StrCmpOptionPrefixes`] 
| Compare two option prefix sequences for sorting&period;
| xref:llvm/StripDebugInfo-03.adoc[`StripDebugInfo`] 
| Strip debug info in the module if it exists&period;
| xref:llvm/StripTemplateParameters.adoc[`StripTemplateParameters`] 
| Strips template parameters from a templated function name&period;
| xref:llvm/StructuralHash-0f.adoc[`StructuralHash`] 
| `StructuralHash` overloads
| xref:llvm/StructuralHashWithDifferences.adoc[`StructuralHashWithDifferences`] 
| Computes a structural hash of a function while selectively ignoring operands&period;
| xref:llvm/SubOverflow-02.adoc[`SubOverflow`] 
| `SubOverflow` overloads
| xref:llvm/TableGenMain-0b.adoc[`TableGenMain`] 
| `TableGenMain` overloads
| xref:llvm/TableGenParseFile.adoc[`TableGenParseFile`] 
| Parse the TableGen file from the main buffer of a SourceMgr&period;
| xref:llvm/TryToSimplifyUncondBranchFromEmptyBlock.adoc[`TryToSimplifyUncondBranchFromEmptyBlock`] 
| Eliminate an empty block that only contains an unconditional branch&period;
| xref:llvm/UnrollAndJamLoop.adoc[`UnrollAndJamLoop`] 
| Unroll the outer loop and jam its iterations with the inner loop&period;
| xref:llvm/UnrollLoop.adoc[`UnrollLoop`] 
| Unroll loop `L` by the factor and policies in `ULO&period;`
| xref:llvm/UnrollRuntimeLoopRemainder.adoc[`UnrollRuntimeLoopRemainder`] 
| Insert a runtime prolog or epilog so `L` can be unrolled by `Count&period;`
| xref:llvm/UpgradeARCRuntime.adoc[`UpgradeARCRuntime`] 
| Convert calls to ARC runtime functions to intrinsic calls and upgrade the old retain release marker to new module flag format&period;
| xref:llvm/UpgradeAttributes.adoc[`UpgradeAttributes`] 
| Upgrade attributes that changed format or kind&period;
| xref:llvm/UpgradeBitCastExpr.adoc[`UpgradeBitCastExpr`] 
| This is an auto&hyphen;upgrade for bitcast constant expression between pointers with different address spaces&colon; the instruction is replaced by a pair ptrtoint&plus;inttoptr&period;
| xref:llvm/UpgradeBitCastInst.adoc[`UpgradeBitCastInst`] 
| This is an auto&hyphen;upgrade for bitcast between pointers with different address spaces&colon; the instruction is replaced by a pair ptrtoint&plus;inttoptr&period;
| xref:llvm/UpgradeCFIFunctionsMetadata.adoc[`UpgradeCFIFunctionsMetadata`] 
| Upgrade the cfi&period;functions metadata node by calculating and inserting the GUID for each function entry if it&apos;s missing&period;
| xref:llvm/UpgradeCallsToIntrinsic.adoc[`UpgradeCallsToIntrinsic`] 
| Upgrade an old intrinsic function and all of its call sites&period;
| xref:llvm/UpgradeDataLayoutString.adoc[`UpgradeDataLayoutString`] 
| Upgrade the datalayout string by adding a section for address space pointers&period;
| xref:llvm/UpgradeDebugInfo.adoc[`UpgradeDebugInfo`] 
| Check the debug info version number, if it is out&hyphen;dated, drop the debug info&period; Return true if module is modified&period;
| xref:llvm/UpgradeFunctionAttributes.adoc[`UpgradeFunctionAttributes`] 
| Correct any IR that is relying on old function attribute behavior&period;
| xref:llvm/UpgradeGlobalVariable.adoc[`UpgradeGlobalVariable`] 
| This checks for global variables which should be upgraded&period; If it requires upgrading, returns a pointer to the upgraded variable&period;
| xref:llvm/UpgradeInlineAsmString.adoc[`UpgradeInlineAsmString`] 
| Upgrade inline&hyphen;asm comments for Objective&hyphen;C retain&sol;release markers&period;
| xref:llvm/UpgradeIntrinsicCall.adoc[`UpgradeIntrinsicCall`] 
| This is the complement to the above, replacing a specific call to an intrinsic function with a call to the specified new function&period;
| xref:llvm/UpgradeIntrinsicFunction.adoc[`UpgradeIntrinsicFunction`] 
| Check whether an intrinsic function needs upgrading&period;
| xref:llvm/UpgradeModuleFlags.adoc[`UpgradeModuleFlags`] 
| This checks for module flags which should be upgraded&period; It returns true if module is modified&period;
| xref:llvm/UpgradeNVVMAnnotations.adoc[`UpgradeNVVMAnnotations`] 
| Convert legacy nvvm&period;annotations metadata to appropriate function attributes&period;
| xref:llvm/UpgradeOperandBundles.adoc[`UpgradeOperandBundles`] 
| Upgrade operand bundles (without knowing about their user instruction)&period;
| xref:llvm/UpgradeSectionAttributes.adoc[`UpgradeSectionAttributes`] 
| Upgrade outdated section attributes on globals in a module&period;
| xref:llvm/UpgradeTBAANode.adoc[`UpgradeTBAANode`] 
| Upgrade a scalar TBAA tag to the struct&hyphen;path aware TBAA format&period;
| xref:llvm/ViewGraph.adoc[`ViewGraph`] 
| Emit a DOT graph and open it with a Graphviz viewer&period;
| xref:llvm/WriteBitcodeToFile.adoc[`WriteBitcodeToFile`] 
| Write the specified module to the specified raw output stream&period;
| xref:llvm/WriteDOTGraphToFile.adoc[`WriteDOTGraphToFile`] 
| Write a function analysis graph to a DOT file with a custom name prefix&period;
| xref:llvm/WriteGraph-063.adoc[`WriteGraph`] 
| `WriteGraph` overloads
| xref:llvm/abs-0e.adoc[`abs`] 
| `abs` overloads
| xref:llvm/accumulate-06.adoc[`accumulate`] 
| `accumulate` overloads
| xref:llvm/adaptNoAliasScopes.adoc[`adaptNoAliasScopes`] 
| Adapt an instruction&apos;s noalias metadata using a scope map&period;
| xref:llvm/addAssumptions-05.adoc[`addAssumptions`] 
| `addAssumptions` overloads
| xref:llvm/addClonedBlockToLoopInfo.adoc[`addClonedBlockToLoopInfo`] 
| Add a cloned basic block to LoopInfo and record any newly created loop&period;
| xref:llvm/addDiffRuntimeChecks.adoc[`addDiffRuntimeChecks`] 
| Add runtime checks that compare pointer differences against a distance&period;
| xref:llvm/addEnumValues.adoc[`addEnumValues`] 
| Add the underlying integer values of two enumeration values&period;
| xref:llvm/addHash.adoc[`addHash`] 
| Feed version components of `VT` into hash builder `HBuilder&period;`
| xref:llvm/addInnerLoopsToHeadersMap.adoc[`addInnerLoopsToHeadersMap`] 
| Map each header in the nest of `L` to its loop in `LoopHeaders&period;`
| xref:llvm/addLiveIns.adoc[`addLiveIns`] 
| Adds registers contained in `LiveRegs` to the block live&hyphen;in list of `MBB&period;` Does not add reserved registers&period;
| xref:llvm/addLocationToRemarks.adoc[`addLocationToRemarks`] 
| Add location info from `DLoc` to ORE message `Remark&period;`
| xref:llvm/addRuntimeChecks.adoc[`addRuntimeChecks`] 
| Add code that checks at runtime if the accessed arrays in `PointerChecks` overlap&period; Returns the final comparator value or NULL if no check is needed&period;
| xref:llvm/addStringMetadataToLoop-00.adoc[`addStringMetadataToLoop`] 
| `addStringMetadataToLoop` overloads
| xref:llvm/adjacent_find-04.adoc[`adjacent&lowbar;find`] 
| `adjacent&lowbar;find` overloads
| xref:llvm/adjustKnownBitsForSelectArm.adoc[`adjustKnownBitsForSelectArm`] 
| Adjust `Known` for the given select `Arm` to include information from the select `Cond&period;`
| xref:llvm/adjustKnownFPClassForSelectArm.adoc[`adjustKnownFPClassForSelectArm`] 
| Adjust `Known` for the given select `Arm` to include information from the select `Cond&period;`
| xref:llvm/adl_begin.adoc[`adl&lowbar;begin`] 
| Returns the begin iterator to `range` using `std&colon;&colon;begin` and function found through Argument&hyphen;Dependent Lookup (ADL)&period;
| xref:llvm/adl_end.adoc[`adl&lowbar;end`] 
| Returns the end iterator to `range` using `std&colon;&colon;end` and functions found through Argument&hyphen;Dependent Lookup (ADL)&period;
| xref:llvm/adl_rbegin.adoc[`adl&lowbar;rbegin`] 
| Returns the reverse&hyphen;begin iterator to `range` using `std&colon;&colon;rbegin` and function found through Argument&hyphen;Dependent Lookup (ADL)&period;
| xref:llvm/adl_rend.adoc[`adl&lowbar;rend`] 
| Returns the reverse&hyphen;end iterator to `range` using `std&colon;&colon;rend` and functions found through Argument&hyphen;Dependent Lookup (ADL)&period;
| xref:llvm/adl_size.adoc[`adl&lowbar;size`] 
| Returns the size of `range` using `std&colon;&colon;size` and functions found through Argument&hyphen;Dependent Lookup (ADL)&period;
| xref:llvm/adl_swap.adoc[`adl&lowbar;swap`] 
| Swaps `lhs` with `rhs` using `std&colon;&colon;swap` and functions found through Argument&hyphen;Dependent Lookup (ADL)&period;
| xref:llvm/alignAddr.adoc[`alignAddr`] 
| Aligns `Addr` to `Alignment` bytes, rounding up&period;
| xref:llvm/alignDown.adoc[`alignDown`] 
| Returns the largest unsigned integer less than or equal to `Value` and is `Skew` mod `Align&period;` `Align` must be non&hyphen;zero&period; Guaranteed to never overflow&period;
| xref:llvm/alignTo-01.adoc[`alignTo`] 
| `alignTo` overloads
| xref:llvm/alignToPowerOf2-0bc.adoc[`alignToPowerOf2`] 
| `alignToPowerOf2` overloads
| xref:llvm/all_equal-03.adoc[`all&lowbar;equal`] 
| `all&lowbar;equal` overloads
| xref:llvm/all_of.adoc[`all&lowbar;of`] 
| Return true if `P` is true for every element of `Range&period;`
| xref:llvm/all_of_zip.adoc[`all&lowbar;of&lowbar;zip`] 
| Return true if the trailing predicate holds for every zipped tuple&period;
| xref:llvm/allocate_buffer.adoc[`allocate&lowbar;buffer`] 
| Allocate a buffer of memory with the given size and alignment&period;
| xref:llvm/analyzeKnownBitsFromAndXorOr.adoc[`analyzeKnownBitsFromAndXorOr`] 
| Using KnownBits LHS&sol;RHS produce the known bits for logic op (and&sol;xor&sol;or)&period;
| xref:llvm/annotateValueSite-08.adoc[`annotateValueSite`] 
| `annotateValueSite` overloads
| xref:llvm/any_cast-0a.adoc[`any&lowbar;cast`] 
| `any&lowbar;cast` overloads
| xref:llvm/any_of.adoc[`any&lowbar;of`] 
| Return true if `P` is true for any element of `Range&period;`
| xref:llvm/appendLEB128.adoc[`appendLEB128`] 
| Append a LEB128&hyphen;encoded value to a byte buffer&period;
| xref:llvm/appendLoopsToWorklist-02.adoc[`appendLoopsToWorklist`] 
| `appendLoopsToWorklist` overloads
| xref:llvm/appendReversedLoopsToWorklist.adoc[`appendReversedLoopsToWorklist`] 
| Append an already&hyphen;reversed range of loops onto a worklist&period;
| xref:llvm/appendToCompilerUsed.adoc[`appendToCompilerUsed`] 
| Adds global values to the llvm&period;compiler&period;used list&period;
| xref:llvm/appendToGlobalCtors.adoc[`appendToGlobalCtors`] 
| Append `F` to the global constructors of module `M&period;`
| xref:llvm/appendToGlobalDtors.adoc[`appendToGlobalDtors`] 
| Append `F` to the global destructors of module `M&period;`
| xref:llvm/appendToUsed.adoc[`appendToUsed`] 
| Adds global values to the llvm&period;used list&period;
| xref:llvm/append_range.adoc[`append&lowbar;range`] 
| Append the elements of range `R` to container `C&period;`
| xref:llvm/append_values.adoc[`append&lowbar;values`] 
| Append each of `Values` to container `C&period;`
| xref:llvm/applyDebugifyMetadata.adoc[`applyDebugifyMetadata`] 
| Add synthesized debug information to a module&period;
| xref:llvm/applyDebugifyMetadataToMachineFunction.adoc[`applyDebugifyMetadataToMachineFunction`] 
| Add synthesized debug information to a MachineFunction&period;
| xref:llvm/applyFlowInference-0c.adoc[`applyFlowInference`] 
| `applyFlowInference` overloads
| xref:llvm/applyProfMetadataIfEnabled.adoc[`applyProfMetadataIfEnabled`] 
| Apply a metadata callback if `V` is an instruction and profiling is enabled&period;
| xref:llvm/arrayRefFromStringRef.adoc[`arrayRefFromStringRef`] 
| Construct an array ref of bytes from a string ref&period;
| xref:llvm/array_pod_sort-09.adoc[`array&lowbar;pod&lowbar;sort`] 
| `array&lowbar;pod&lowbar;sort` overloads
| xref:llvm/array_pod_sort_comparator.adoc[`array&lowbar;pod&lowbar;sort&lowbar;comparator`] 
| Adapt std&colon;&colon;less&lt;T&gt; for array&lowbar;pod&lowbar;sort&period;
| xref:llvm/assumeAligned.adoc[`assumeAligned`] 
| Treats the value 0 as a 1, so Align is always at least 1&period;
| xref:llvm/assumeBundleImpliesNonNull.adoc[`assumeBundleImpliesNonNull`] 
| Return true if the given assume operand bundle implies that `Val` is non&hyphen;null&period;
| xref:llvm/attributesPermitTailCall.adoc[`attributesPermitTailCall`] 
| Check whether caller&sol;callee attribute mismatches inhibit a tail call&period;
| xref:llvm/avoidZeroOffsetLandingPad.adoc[`avoidZeroOffsetLandingPad`] 
| Insert a NOP before a section&hyphen;leading EH pad so its LSDA offset is nonzero&period;
| xref:llvm/bf_begin.adoc[`bf&lowbar;begin`] 
| Return a breadth&hyphen;first iterator at the entry of `G&period;`
| xref:llvm/bf_end.adoc[`bf&lowbar;end`] 
| Return a past&hyphen;the&hyphen;end breadth&hyphen;first iterator for `G&period;`
| xref:llvm/biasPhysReg.adoc[`biasPhysReg`] 
| Return a bias score for scheduling physreg&hyphen;related unit `SU&period;`
| xref:llvm/binary_search-0cb.adoc[`binary&lowbar;search`] 
| `binary&lowbar;search` overloads
| xref:llvm/bind_back-0a.adoc[`bind&lowbar;back`] 
| `bind&lowbar;back` overloads
| xref:llvm/bind_front-0f.adoc[`bind&lowbar;front`] 
| `bind&lowbar;front` overloads
| xref:llvm/bit_cast.adoc[`bit&lowbar;cast`] 
| Reinterpret the object representation of `from` as type `To&period;`
| xref:llvm/bit_ceil.adoc[`bit&lowbar;ceil`] 
| Returns the smallest integral power of two no smaller than Value if Value is nonzero&period; Returns 1 otherwise&period;
| xref:llvm/bit_ceil_constexpr.adoc[`bit&lowbar;ceil&lowbar;constexpr`] 
| Returns the smallest integral power of two no smaller than Value if Value is nonzero&period; Returns 1 otherwise&period;
| xref:llvm/bit_floor.adoc[`bit&lowbar;floor`] 
| Returns the largest integral power of two no greater than Value if Value is nonzero&period; Returns 0 otherwise&period;
| xref:llvm/bit_width.adoc[`bit&lowbar;width`] 
| Returns the number of bits needed to represent Value if Value is nonzero&period; Returns 0 otherwise&period;
| xref:llvm/bit_width_constexpr.adoc[`bit&lowbar;width&lowbar;constexpr`] 
| Returns the number of bits needed to represent Value if Value is nonzero&period; Returns 0 otherwise&period;
| xref:llvm/breadth_first.adoc[`breadth&lowbar;first`] 
| Return a range that visits `G` in breadth&hyphen;first order&period;
| xref:llvm/breakLoopBackedge.adoc[`breakLoopBackedge`] 
| Remove the backedge of a top&hyphen;level single&hyphen;latch loop&period;
| xref:llvm/buildAssumeFromInst.adoc[`buildAssumeFromInst`] 
| Build an llvm&period;assume call preserving information derived from an instruction&period;
| xref:llvm/buildAtomicRMWValue.adoc[`buildAtomicRMWValue`] 
| Emit IR to implement the given atomicrmw operation on values in registers, returning the new value&period;
| xref:llvm/buildCmpXchgValue.adoc[`buildCmpXchgValue`] 
| Emit IR to implement the given cmpxchg operation on values in registers, returning the new value&period;
| xref:llvm/buildDbgValueForSpill-05.adoc[`buildDbgValueForSpill`] 
| `buildDbgValueForSpill` overloads
| xref:llvm/buildModuleSummaryIndex.adoc[`buildModuleSummaryIndex`] 
| Direct function to compute a `ModuleSummaryIndex` from a given module&period;
| xref:llvm/bypassSlowDivision.adoc[`bypassSlowDivision`] 
| This optimization identifies DIV instructions in a BB that can be profitably bypassed and carried out with a shorter, faster divide&period;
| xref:llvm/byteswap.adoc[`byteswap`] 
| Reverses the bytes in the given integer value V&period;
| xref:llvm/calculateCXXStateForAsynchEH.adoc[`calculateCXXStateForAsynchEH`] 
| Propagate C&plus;&plus; EH state numbers through `BB` for asynchronous EH (&hyphen;EHa)&period;
| xref:llvm/calculateClrEHStateNumbers.adoc[`calculateClrEHStateNumbers`] 
| Build WinEHFuncInfo CoreCLR state numbers and unwind&hyphen;map tables&period;
| xref:llvm/calculateCountScale.adoc[`calculateCountScale`] 
| Calculate what to divide by to scale counts&period;
| xref:llvm/calculateDbgEntityHistory.adoc[`calculateDbgEntityHistory`] 
| Compute debug&hyphen;value and debug&hyphen;label histories for `MF&period;`
| xref:llvm/calculateSEHStateForAsynchEH.adoc[`calculateSEHStateForAsynchEH`] 
| Propagate SEH state numbers through `BB` for asynchronous EH (&hyphen;EHa)&period;
| xref:llvm/calculateSEHStateNumbers.adoc[`calculateSEHStateNumbers`] 
| Build WinEHFuncInfo SEH state numbers and unwind&hyphen;map tables&period;
| xref:llvm/calculateWinCXXEHStateNumbers.adoc[`calculateWinCXXEHStateNumbers`] 
| Build WinEHFuncInfo state numbers and tables for &lowbar;&lowbar;CxxFrameHandler3&period;
| xref:llvm/callDefaultCtor-0a.adoc[`callDefaultCtor`] 
| `callDefaultCtor` overloads
| xref:llvm/call_once.adoc[`call&lowbar;once`] 
| Execute the function specified as a parameter once&period;
| xref:llvm/callsGCLeafFunction.adoc[`callsGCLeafFunction`] 
| Return true if this call calls a GC leaf function&period;
| xref:llvm/canConstantFoldCallTo.adoc[`canConstantFoldCallTo`] 
| Return true if it is even possible to fold a call to the specified function&period;
| xref:llvm/canConvertToMinOrMaxIntrinsic.adoc[`canConvertToMinOrMaxIntrinsic`] 
| Check if values in `VL` are selects convertible to a min&sol;max intrinsic&period;
| xref:llvm/canCreatePoison-0a.adoc[`canCreatePoison`] 
| `canCreatePoison` overloads
| xref:llvm/canCreateUndefOrPoison-05.adoc[`canCreateUndefOrPoison`] 
| `canCreateUndefOrPoison` overloads
| xref:llvm/canHoistLoad.adoc[`canHoistLoad`] 
| Return true if load `LI` may legally be hoisted out of `CurLoop&period;`
| xref:llvm/canIgnoreSNaN.adoc[`canIgnoreSNaN`] 
| Returns true if the possibility of a signaling NaN can be safely ignored&period;
| xref:llvm/canIgnoreSignBitOfNaN.adoc[`canIgnoreSignBitOfNaN`] 
| Return true if the sign bit of the FP value can be ignored by the user when the value is NaN&period;
| xref:llvm/canIgnoreSignBitOfZero.adoc[`canIgnoreSignBitOfZero`] 
| Return true if the sign bit of the FP value can be ignored by the user when the value is zero&period;
| xref:llvm/canInstructionHaveMMRAs.adoc[`canInstructionHaveMMRAs`] 
| Return true if `I` can have !mmra metadata&period;
| xref:llvm/canLowerMemCpyFamily.adoc[`canLowerMemCpyFamily`] 
| Matcher for memcpy&hyphen;like instructions&period; For non&hyphen;zero lengths, `MemOps` contains the load&sol;store types to emit&period;
| xref:llvm/canParallelizeReductionWhenUnrolling.adoc[`canParallelizeReductionWhenUnrolling`] 
| Return a recurrence descriptor if `Phi` can be parallelized when unrolling&period;
| xref:llvm/canPeel.adoc[`canPeel`] 
| Return true if loop `L` is suitable for peeling&period;
| xref:llvm/canPeelLastIteration.adoc[`canPeelLastIteration`] 
| Return true if the last iteration of `L` can be peeled off&period;
| xref:llvm/canRenameComdatFunc.adoc[`canRenameComdatFunc`] 
| Return true if Comdat function `F` can safely share renamed counters&period;
| xref:llvm/canReplaceOperandWithVariable.adoc[`canReplaceOperandWithVariable`] 
| Return true if an operand may legally be replaced with a variable&period;
| xref:llvm/canReplacePointersIfEqual.adoc[`canReplacePointersIfEqual`] 
| Returns true if pointer `From` can be replaced with equal pointer `To&period;`
| xref:llvm/canReplacePointersInUseIfEqual.adoc[`canReplacePointersInUseIfEqual`] 
| Returns true if use `U` of a pointer can be rewritten to use `To&period;`
| xref:llvm/canReplaceReg.adoc[`canReplaceReg`] 
| Check if DstReg can be replaced with SrcReg depending on the register constraints&period;
| xref:llvm/canReturn.adoc[`canReturn`] 
| Return true if there is at least a path through which F can return, false if there is no such path&period;
| xref:llvm/canRoundingModeBe.adoc[`canRoundingModeBe`] 
| Returns true if the rounding mode RM may be QRM at compile time or at run time&period;
| xref:llvm/canSimplifyInvokeNoUnwind.adoc[`canSimplifyInvokeNoUnwind`] 
| Return true if invokes of nounwind callees in `F` may be simplified&period;
| xref:llvm/canSinkOrHoistInst.adoc[`canSinkOrHoistInst`] 
| Return true if `I` may legally be sunk or hoisted, ignoring faults&period;
| xref:llvm/canTrackArgumentsInterprocedurally.adoc[`canTrackArgumentsInterprocedurally`] 
| Return true if `F&apos;s` argument values can be tracked interprocedurally&period;
| xref:llvm/canTrackGlobalVariableInterprocedurally.adoc[`canTrackGlobalVariableInterprocedurally`] 
| Return true if the value in `GV` can be tracked interprocedurally&period;
| xref:llvm/canTrackReturnsInterprocedurally.adoc[`canTrackReturnsInterprocedurally`] 
| Return true if `F&apos;s` return values can be tracked interprocedurally&period;
| xref:llvm/canUseDebuginfod.adoc[`canUseDebuginfod`] 
| Returns false if a debuginfod lookup can be determined to have no chance of succeeding&period;
| xref:llvm/canVectorizeStructTy.adoc[`canVectorizeStructTy`] 
| Returns true if `StructTy` is an unpacked literal struct where all elements are scalars that can be used as vector element types&period;
| xref:llvm/canVectorizeTy.adoc[`canVectorizeTy`] 
| Returns true if `Ty` can be used as a vector element or vectorized struct&period;
| xref:llvm/cannotBeMaxInLoop.adoc[`cannotBeMaxInLoop`] 
| Returns true if `S` is defined and never is equal to signed&sol;unsigned max&period;
| xref:llvm/cannotBeMinInLoop.adoc[`cannotBeMinInLoop`] 
| Returns true if `S` is defined and never is equal to signed&sol;unsigned min&period;
| xref:llvm/cannotBeNegativeZero.adoc[`cannotBeNegativeZero`] 
| Return true if we can prove that the specified FP value is never equal to &hyphen;0&period;0&period; Users should use caution when considering PreserveSign denormal&hyphen;fp&hyphen;math&period;
| xref:llvm/cannotBeOrderedLessThanZero.adoc[`cannotBeOrderedLessThanZero`] 
| Return true if we can prove that the specified FP value is either NaN or never less than &hyphen;0&period;0&period;
| xref:llvm/cannotOrderStrictlyGreater.adoc[`cannotOrderStrictlyGreater`] 
| Returns true if all values in `LHS` must be less than or equal to those in `RHS&period;` That is, the comparison `fcmp ogt LHS, RHS` will always return false&period;
| xref:llvm/cannotOrderStrictlyGreaterEq.adoc[`cannotOrderStrictlyGreaterEq`] 
| Returns true if all values in `LHS` must be less than those in `RHS&period;` That is, the comparison `fcmp oge LHS, RHS` will always return false&period;
| xref:llvm/cannotOrderStrictlyLess.adoc[`cannotOrderStrictlyLess`] 
| Returns true if all values in `LHS` must be greater than or equal to those in `RHS&period;` That is, the comparison `fcmp olt LHS, RHS` will always return false&period;
| xref:llvm/cannotOrderStrictlyLessEq.adoc[`cannotOrderStrictlyLessEq`] 
| Returns true if all values in `LHS` must be greater than to those in `RHS&period;` That is, the comparison `fcmp ole LHS, RHS` will always return false&period;
| xref:llvm/cantFail-0e.adoc[`cantFail`] 
| `cantFail` overloads
| xref:llvm/capacity_in_bytes-08.adoc[`capacity&lowbar;in&lowbar;bytes`] 
| `capacity&lowbar;in&lowbar;bytes` overloads
| xref:llvm/capturesAddress.adoc[`capturesAddress`] 
| Return whether `CC` captures any address component&period;
| xref:llvm/capturesAddressIsNullOnly.adoc[`capturesAddressIsNullOnly`] 
| Return whether `CC` captures only address&hyphen;is&hyphen;null, not the full address&period;
| xref:llvm/capturesAll.adoc[`capturesAll`] 
| Return whether `CC` includes every capture component&period;
| xref:llvm/capturesAnyProvenance.adoc[`capturesAnyProvenance`] 
| Return true if `CC` captures any provenance component&period;
| xref:llvm/capturesAnything.adoc[`capturesAnything`] 
| Return whether any pointer component may be captured in `CC&period;`
| xref:llvm/capturesFullProvenance.adoc[`capturesFullProvenance`] 
| Return whether `CC` captures full provenance (not merely read&hyphen;only)&period;
| xref:llvm/capturesNothing.adoc[`capturesNothing`] 
| Return whether `CC` captures no pointer components&period;
| xref:llvm/capturesReadProvenanceOnly.adoc[`capturesReadProvenanceOnly`] 
| Return whether `CC` captures read&hyphen;only provenance but not full provenance&period;
| xref:llvm/caseFoldingDjbHash.adoc[`caseFoldingDjbHash`] 
| Computes the Bernstein hash after folding the input according to the Dwarf 5 standard case folding rules&period;
| xref:llvm/cast-0b.adoc[`cast`] 
| `cast` overloads
| xref:llvm/cast_if_present-07a.adoc[`cast&lowbar;if&lowbar;present`] 
| `cast&lowbar;if&lowbar;present` overloads
| xref:llvm/cast_or_null-01.adoc[`cast&lowbar;or&lowbar;null`] 
| `cast&lowbar;or&lowbar;null` overloads
| xref:llvm/ceilDiv.adoc[`ceilDiv`] 
| Returns the ceiling of `LHS` divided by `RHS&period;`
| xref:llvm/center_justify.adoc[`center&lowbar;justify`] 
| center&lowbar;justify &hyphen; add spaces before and after string so total output is `Width` characters&period; If `Str` is larger that `Width,` full string is written with no padding&period;
| xref:llvm/cgdata_category.adoc[`cgdata&lowbar;category`] 
| Return the `std&colon;&colon;error&lowbar;category` for codegen data errors&period;
| xref:llvm/changeToCall.adoc[`changeToCall`] 
| Convert the specified invoke into a normal call&period;
| xref:llvm/changeToInvokeAndSplitBasicBlock.adoc[`changeToInvokeAndSplitBasicBlock`] 
| Convert a call into an invoke and split its basic block&period;
| xref:llvm/changeToUnreachable.adoc[`changeToUnreachable`] 
| Insert unreachable before an instruction and make the rest of the block dead&period;
| xref:llvm/checkDebugInfoMetadata.adoc[`checkDebugInfoMetadata`] 
| Check original debug information after a pass&period;
| xref:llvm/checkForCycles-0d.adoc[`checkForCycles`] 
| `checkForCycles` overloads
| xref:llvm/checkGEPType.adoc[`checkGEPType`] 
| Return `Ty` after asserting it is a valid GEP index result type&period;
| xref:llvm/checkIfAlreadyInstrumented.adoc[`checkIfAlreadyInstrumented`] 
| Check if module has flag attached, if not add the flag&period;
| xref:llvm/checkNotNull.adoc[`checkNotNull`] 
| Calls llvm&lowbar;unreachable if Pointer is null, otherwise returns the pointer as is&period;
| xref:llvm/checkedAdd.adoc[`checkedAdd`] 
| Add two signed integers `LHS` and `RHS&period;`
| xref:llvm/checkedAddUnsigned.adoc[`checkedAddUnsigned`] 
| Add two unsigned integers `LHS` and `RHS&period;`
| xref:llvm/checkedMul.adoc[`checkedMul`] 
| Multiply two signed integers `LHS` and `RHS&period;`
| xref:llvm/checkedMulAdd.adoc[`checkedMulAdd`] 
| Multiply A and B, and add C to the resulting product&period;
| xref:llvm/checkedMulAddUnsigned.adoc[`checkedMulAddUnsigned`] 
| Multiply unsigned integers A and B, and add C to the resulting product&period;
| xref:llvm/checkedMulUnsigned.adoc[`checkedMulUnsigned`] 
| Multiply two unsigned integers `LHS` and `RHS&period;`
| xref:llvm/checkedSub.adoc[`checkedSub`] 
| Subtract two signed integers `LHS` and `RHS&period;`
| xref:llvm/children.adoc[`children`] 
| Return a range over the children of node `G&period;`
| xref:llvm/children_edges.adoc[`children&lowbar;edges`] 
| Return a range over the outgoing child edges of node `G&period;`
| xref:llvm/clampStateAndIndicateChange.adoc[`clampStateAndIndicateChange`] 
| Clamp state `S` with `R` and return whether `S` changed&period;
| xref:llvm/classifyEHPersonality.adoc[`classifyEHPersonality`] 
| See if the given exception handling personality function is one that we understand&period; If so, return a description of it&semi; otherwise return Unknown&period;
| xref:llvm/cleanUpTempFiles.adoc[`cleanUpTempFiles`] 
| Removes the temporary files named in `FileName&period;`
| xref:llvm/cloneAndAdaptNoAliasScopes-0c.adoc[`cloneAndAdaptNoAliasScopes`] 
| `cloneAndAdaptNoAliasScopes` overloads
| xref:llvm/cloneLoop.adoc[`cloneLoop`] 
| Recursively clone the specified loop and all of its children, mapping the blocks with the specified map&period;
| xref:llvm/cloneLoopWithPreheader.adoc[`cloneLoopWithPreheader`] 
| Clones a loop `OrigLoop&period;`
| xref:llvm/cloneNoAliasScopes.adoc[`cloneNoAliasScopes`] 
| Duplicate the listed noalias declaration scopes&period;
| xref:llvm/collectChildrenInLoop.adoc[`collectChildrenInLoop`] 
| Does a BFS from a given node to all of its children inside a given loop&period; The returned vector of basic blocks includes the starting point&period;
| xref:llvm/collectDebugInfoMetadata.adoc[`collectDebugInfoMetadata`] 
| Collect original debug information before a pass&period;
| xref:llvm/collectGlobalObjectNameStrings.adoc[`collectGlobalObjectNameStrings`] 
| Serialize global&hyphen;object name strings into a profile&hyphen;ready blob&period;
| xref:llvm/collectPGOFuncNameStrings.adoc[`collectPGOFuncNameStrings`] 
| Serialize referenced PGO function&hyphen;name variables into `Result&period;`
| xref:llvm/collectParametricTerms.adoc[`collectParametricTerms`] 
| Collect parametric terms occurring in step expressions (first step of delinearization)&period;
| xref:llvm/collectPossibleValues.adoc[`collectPossibleValues`] 
| Enumerate immediate constant values of `V` into `Constants&period;`
| xref:llvm/collectUsedGlobalVariables.adoc[`collectUsedGlobalVariables`] 
| Given &quot;llvm&period;used&quot; or &quot;llvm&period;compiler&period;used&quot; as a global name, collect the initializer elements of that global in a SmallVector and return the global itself&period;
| xref:llvm/collectVTableStrings.adoc[`collectVTableStrings`] 
| Serialize vtable name strings into a profile&hyphen;ready blob&period;
| xref:llvm/colorEHFunclets.adoc[`colorEHFunclets`] 
| Recompute which basic blocks belong to which EH funclets in `F&period;`
| xref:llvm/combineAAMetadata.adoc[`combineAAMetadata`] 
| Combine alias&hyphen;analysis metadata after merging memory accesses&period;
| xref:llvm/combineMetadataForCSE.adoc[`combineMetadataForCSE`] 
| Combine metadata so one instruction can replace another after CSE&period;
| xref:llvm/commonAlignment.adoc[`commonAlignment`] 
| Returns the alignment that satisfies both alignments&period; Same semantic as MinAlign&period;
| xref:llvm/compareLoops.adoc[`compareLoops`] 
| Assert that loop `L` matches `OtherL` structurally for verification&period;
| xref:llvm/compareVectors.adoc[`compareVectors`] 
| Return true if `BB1` and `BB2` contain the same elements ignoring order&period;
| xref:llvm/computeAccessFunctions.adoc[`computeAccessFunctions`] 
| Return in Subscripts the access functions for each dimension in Sizes (third step of delinearization)&period;
| xref:llvm/computeAndAddLiveIns.adoc[`computeAndAddLiveIns`] 
| Convenience function combining computeLiveIns() and addLiveIns()&period;
| xref:llvm/computeArchiveRelativePath.adoc[`computeArchiveRelativePath`] 
| Compute a relative path from the directory of `From` to `To&period;`
| xref:llvm/computeConstantRange.adoc[`computeConstantRange`] 
| Determine the possible constant range of an integer or vector of integer value&period; This is intended as a cheap, non&hyphen;recursive check&period;
| xref:llvm/computeConstantRangeIncludingKnownBits.adoc[`computeConstantRangeIncludingKnownBits`] 
| Combine constant ranges from computeConstantRange() and computeKnownBits()&period;
| xref:llvm/computeDeadSymbolsAndUpdateIndirectCalls.adoc[`computeDeadSymbolsAndUpdateIndirectCalls`] 
| Compute dead symbols in the summary index and update SamplePGO edges&period;
| xref:llvm/computeDeadSymbolsWithConstProp.adoc[`computeDeadSymbolsWithConstProp`] 
| Compute dead symbols and run constant propagation in combined index after that&period;
| xref:llvm/computeEHOnlyBlocks.adoc[`computeEHOnlyBlocks`] 
| Compute a list of blocks that are only reachable via EH paths&period;
| xref:llvm/computeExpressionSize.adoc[`computeExpressionSize`] 
| Compute a saturated expression&hyphen;size estimate from operand sizes&period;
| xref:llvm/computeFunctionBodyMemoryAccess.adoc[`computeFunctionBodyMemoryAccess`] 
| Returns the memory access properties of this copy of the function&period;
| xref:llvm/computeKnownBits-027.adoc[`computeKnownBits`] 
| `computeKnownBits` overloads
| xref:llvm/computeKnownBitsFromContext.adoc[`computeKnownBitsFromContext`] 
| Merge bits known from context&hyphen;dependent facts into Known&period;
| xref:llvm/computeKnownBitsFromRangeMetadata.adoc[`computeKnownBitsFromRangeMetadata`] 
| Compute known bits from the range metadata&period; `KnownZero` the set of bits that are known to be zero `KnownOne` the set of bits that are known to be one
| xref:llvm/computeKnownFPClass-03.adoc[`computeKnownFPClass`] 
| `computeKnownFPClass` overloads
| xref:llvm/computeKnownFPSignBit.adoc[`computeKnownFPSignBit`] 
| Return the known sign bit of a floating&hyphen;point value, if provable&period;
| xref:llvm/computeLTOCacheKey.adoc[`computeLTOCacheKey`] 
| Compute a unique LTO cache key for a module&period;
| xref:llvm/computeLiveIns.adoc[`computeLiveIns`] 
| Computes registers live&hyphen;in to `MBB` assuming all of its successors live&hyphen;in lists are up&hyphen;to&hyphen;date&period; Puts the result into the given LivePhysReg instance `LiveRegs&period;`
| xref:llvm/computeMachineUniformityInfo.adoc[`computeMachineUniformityInfo`] 
| Compute uniformity information for a Machine IR function&period;
| xref:llvm/computeMinimumValueSizes.adoc[`computeMinimumValueSizes`] 
| Compute a map of integer instructions to their minimum legal type size&period;
| xref:llvm/computeOverflowForSignedAdd-09.adoc[`computeOverflowForSignedAdd`] 
| `computeOverflowForSignedAdd` overloads
| xref:llvm/computeOverflowForSignedMul.adoc[`computeOverflowForSignedMul`] 
| Compute whether a signed multiply of `LHS` and `RHS` can overflow&period;
| xref:llvm/computeOverflowForSignedSub.adoc[`computeOverflowForSignedSub`] 
| Compute whether a signed subtract of `LHS` and `RHS` can overflow&period;
| xref:llvm/computeOverflowForUnsignedAdd.adoc[`computeOverflowForUnsignedAdd`] 
| Compute whether an unsigned add of `LHS` and `RHS` can overflow&period;
| xref:llvm/computeOverflowForUnsignedMul.adoc[`computeOverflowForUnsignedMul`] 
| Compute whether an unsigned multiply of `LHS` and `RHS` can overflow&period;
| xref:llvm/computeOverflowForUnsignedSub.adoc[`computeOverflowForUnsignedSub`] 
| Compute whether an unsigned subtract of `LHS` and `RHS` can overflow&period;
| xref:llvm/computePeelCount.adoc[`computePeelCount`] 
| Compute a profitable peel count for loop `L` and store it in `PP&period;`
| xref:llvm/computeRemLatency.adoc[`computeRemLatency`] 
| Compute remaining latency for the current scheduling zone&period;
| xref:llvm/computeUnrollCount.adoc[`computeUnrollCount`] 
| Compute the unroll count for `L` from analysis, pragmas, and preferences&period;
| xref:llvm/computeValueLLTs-0f.adoc[`computeValueLLTs`] 
| Compute a sequence of LLTs for the non&hyphen;aggregate parts of an LLVM IR type&period;
| xref:llvm/concat.adoc[`concat`] 
| Return a concatenated range across two or more ranges&period;
| xref:llvm/concatenateVectors.adoc[`concatenateVectors`] 
| Concatenate a list of vectors&period;
| xref:llvm/const_mi_bundle_ops.adoc[`const&lowbar;mi&lowbar;bundle&lowbar;ops`] 
| Return a range over all operands in the const bundle containing `MI&period;`
| xref:llvm/constrainOperandRegClass-06.adoc[`constrainOperandRegClass`] 
| `constrainOperandRegClass` overloads
| xref:llvm/constrainRegToClass.adoc[`constrainRegToClass`] 
| Try to constrain Reg to the specified register class&period;
| xref:llvm/constrainSelectedInstRegOperands.adoc[`constrainSelectedInstRegOperands`] 
| Constrain selected&hyphen;instruction operands to the instruction register classes&period;
| xref:llvm/consumeError.adoc[`consumeError`] 
| Consume a Error without doing anything&period; This method should be used only where an error can be considered a reasonable and expected return value&period;
| xref:llvm/consumeSignedInteger.adoc[`consumeSignedInteger`] 
| Parse a signed integer from the front of `Str` using `Radix` into `Result&period;`
| xref:llvm/consumeUnsignedInteger.adoc[`consumeUnsignedInteger`] 
| Parse an unsigned integer from the front of `Str` using `Radix` into `Result&period;`
| xref:llvm/containsIrreducibleCFG.adoc[`containsIrreducibleCFG`] 
| Return true if the control flow in `RPOTraversal` is irreducible&period;
| xref:llvm/convertCtxProfToYaml.adoc[`convertCtxProfToYaml`] 
| Write `Profile` to `OS` as YAML&period;
| xref:llvm/convertExceptionBehaviorToStr.adoc[`convertExceptionBehaviorToStr`] 
| For any ExceptionBehavior enumerator, returns a string valid as input in constrained intrinsic exception behavior metadata&period;
| xref:llvm/convertRoundingModeToStr.adoc[`convertRoundingModeToStr`] 
| For any RoundingMode enumerator, returns a string valid as input in constrained intrinsic rounding mode metadata&period;
| xref:llvm/convertStrToExceptionBehavior.adoc[`convertStrToExceptionBehavior`] 
| Returns a valid ExceptionBehavior enumerator when given a string valid as input in constrained intrinsic exception behavior metadata&period;
| xref:llvm/convertStrToRoundingMode.adoc[`convertStrToRoundingMode`] 
| Returns a valid RoundingMode enumerator when given a string that is valid as input in constrained intrinsic rounding mode metadata&period;
| xref:llvm/convertToCamelFromSnakeCase.adoc[`convertToCamelFromSnakeCase`] 
| Convert a snake&hyphen;case string to camel&hyphen;case&period;
| xref:llvm/convertToDeclaration.adoc[`convertToDeclaration`] 
| Converts value `GV` to declaration, or replaces with a declaration if it is an alias&period;
| xref:llvm/convertToSnakeFromCamelCase.adoc[`convertToSnakeFromCamelCase`] 
| Convert a camel&hyphen;case string to snake&hyphen;case&period;
| xref:llvm/convertUTF16ToUTF8String-06.adoc[`convertUTF16ToUTF8String`] 
| `convertUTF16ToUTF8String` overloads
| xref:llvm/convertUTF32ToUTF8String-08.adoc[`convertUTF32ToUTF8String`] 
| `convertUTF32ToUTF8String` overloads
| xref:llvm/convertUTF8Sequence.adoc[`convertUTF8Sequence`] 
| Convert the first UTF8 sequence in the given source buffer to a UTF32 code point&period;
| xref:llvm/convertUTF8ToUTF16String.adoc[`convertUTF8ToUTF16String`] 
| Converts a UTF&hyphen;8 string into a UTF&hyphen;16 string with native endianness&period;
| xref:llvm/convertUsersOfConstantsToInstructions.adoc[`convertUsersOfConstantsToInstructions`] 
| Replace constant expressions users of the given constants with instructions&period;
| xref:llvm/convertWideToUTF8.adoc[`convertWideToUTF8`] 
| Converts a wide string view to a UTF&hyphen;8 encoded std&colon;&colon;string&period;
| xref:llvm/copy.adoc[`copy`] 
| Copy the elements of `Range` into the output range starting at `Out&period;`
| xref:llvm/copyMetadataForLoad.adoc[`copyMetadataForLoad`] 
| Copy metadata from a source load onto its replacement&period;
| xref:llvm/copyModuleAttrToFunctions.adoc[`copyModuleAttrToFunctions`] 
| Copies module attributes to the functions in the module&period;
| xref:llvm/copyNonnullMetadata.adoc[`copyNonnullMetadata`] 
| Copy nonnull metadata onto a replacement load&period;
| xref:llvm/copyRangeMetadata.adoc[`copyRangeMetadata`] 
| Copy range metadata onto a replacement load&period;
| xref:llvm/copy_if.adoc[`copy&lowbar;if`] 
| Copy elements of `Range` for which `P` is true into `Out&period;`
| xref:llvm/count.adoc[`count`] 
| Count how many times `Element` occurs in `Range&period;`
| xref:llvm/count_if.adoc[`count&lowbar;if`] 
| Count elements of `Range` for which `P` is true&period;
| xref:llvm/countl_one.adoc[`countl&lowbar;one`] 
| Count the number of ones from the most significant bit to the first zero bit&period;
| xref:llvm/countl_zero.adoc[`countl&lowbar;zero`] 
| Count number of 0&apos;s from the most significant bit to the least stopping at the first 1&period;
| xref:llvm/countl_zero_constexpr.adoc[`countl&lowbar;zero&lowbar;constexpr`] 
| Count number of 0&apos;s from the most significant bit to the least stopping at the first 1&period;
| xref:llvm/countr_one.adoc[`countr&lowbar;one`] 
| Count the number of ones from the least significant bit to the first zero bit&period;
| xref:llvm/countr_zero.adoc[`countr&lowbar;zero`] 
| Count number of 0&apos;s from the least significant bit to the most stopping at the first 1&period;
| xref:llvm/countr_zero_constexpr.adoc[`countr&lowbar;zero&lowbar;constexpr`] 
| Count number of 0&apos;s from the least significant bit to the most stopping at the first 1&period;
| xref:llvm/crc32-0d.adoc[`crc32`] 
| `crc32` overloads
| xref:llvm/createARMELFStreamer.adoc[`createARMELFStreamer`] 
| Create an ARM ELF object streamer&period;
| xref:llvm/createAggressiveAntiDepBreaker.adoc[`createAggressiveAntiDepBreaker`] 
| Create an aggressive anti&hyphen;dependence breaker&period;
| xref:llvm/createAlwaysInlinerLegacyPass.adoc[`createAlwaysInlinerLegacyPass`] 
| Create a legacy pass manager instance of a pass to inline and remove functions marked as &quot;always&lowbar;inline&quot;&period;
| xref:llvm/createAnyOfReduction.adoc[`createAnyOfReduction`] 
| Create a reduction of the given vector `Src` for a reduction of kind RecurKind&colon;&colon;AnyOf&period; The start value of the reduction is `InitVal&period;`
| xref:llvm/createAsmStreamer.adoc[`createAsmStreamer`] 
| Create a machine code streamer which will print out assembly for the native target, suitable for compiling with a native assembler&period;
| xref:llvm/createAtomicExpandLegacyPass.adoc[`createAtomicExpandLegacyPass`] 
| Create a pass that expands atomic IR for the target&period;
| xref:llvm/createBURRListDAGScheduler.adoc[`createBURRListDAGScheduler`] 
| Create a bottom&hyphen;up register usage reduction list scheduler&period;
| xref:llvm/createBarrierNoopPass.adoc[`createBarrierNoopPass`] 
| createBarrierNoopPass &hyphen; This pass is purely a module pass barrier in a pass manager&period;
| xref:llvm/createBasicAAWrapperPass.adoc[`createBasicAAWrapperPass`] 
| Creates an instance of `BasicAAWrapperPass&period;`
| xref:llvm/createBasicBlockMatchingAndInferencePass.adoc[`createBasicBlockMatchingAndInferencePass`] 
| createBasicBlockMatchingAndInferencePass &hyphen; This pass enables matching and inference when using propeller&period;
| xref:llvm/createBasicBlockPathCloningPass.adoc[`createBasicBlockPathCloningPass`] 
| Create a pass that clones machine basic&hyphen;block paths for BB sections&period;
| xref:llvm/createBasicBlockSectionsPass.adoc[`createBasicBlockSectionsPass`] 
| createBasicBlockSections Pass &hyphen; This pass assigns sections to machine basic blocks and is enabled with &hyphen;fbasic&hyphen;block&hyphen;sections&period;
| xref:llvm/createBasicBlockSectionsProfileReaderWrapperPass.adoc[`createBasicBlockSectionsProfileReaderWrapperPass`] 
| Create a pass that parses a basic block sections profile from `Buf&period;`
| xref:llvm/createBasicRegisterAllocator-0a.adoc[`createBasicRegisterAllocator`] 
| `createBasicRegisterAllocator` overloads
| xref:llvm/createBitMaskForGaps.adoc[`createBitMaskForGaps`] 
| Create a mask that filters the members of an interleave group where there are gaps&period;
| xref:llvm/createBitcodeWriterPass.adoc[`createBitcodeWriterPass`] 
| Create and return a pass that writes the module to the specified ostream&period; Note that this pass is designed for use with the legacy pass manager&period;
| xref:llvm/createBranchFolder.adoc[`createBranchFolder`] 
| Create a BranchFolder pass, with optional sub&hyphen;phases disabled&period;
| xref:llvm/createBreakCriticalEdgesPass.adoc[`createBreakCriticalEdgesPass`] 
| Create a pass that breaks all critical edges in the CFG&period;
| xref:llvm/createBreakFalseDepsLegacyPass.adoc[`createBreakFalseDepsLegacyPass`] 
| Creates Break False Dependencies pass&period;
| xref:llvm/createCFGSimplificationPass.adoc[`createCFGSimplificationPass`] 
| Create a pass that simplifies the CFG of a function&period;
| xref:llvm/createCFGuardLongjmpPass.adoc[`createCFGuardLongjmpPass`] 
| Creates CFGuard longjmp target identification pass&period;
| xref:llvm/createCFGuardPass.adoc[`createCFGuardPass`] 
| Insert Control Flow Guard checks on indirect function calls&period;
| xref:llvm/createCFIFixupLegacy.adoc[`createCFIFixupLegacy`] 
| Creates CFI Fixup pass&period;
| xref:llvm/createCFIInstrInserterLegacy.adoc[`createCFIInstrInserterLegacy`] 
| Creates CFI Instruction Inserter pass&period;
| xref:llvm/createCGSCCToFunctionPassAdaptor.adoc[`createCGSCCToFunctionPassAdaptor`] 
| A function to deduce a function pass type and wrap it in the templated adaptor&period;
| xref:llvm/createCOFFAsmParser.adoc[`createCOFFAsmParser`] 
| Create a COFF object&hyphen;file assembly parser extension&period;
| xref:llvm/createCOFFMasmParser.adoc[`createCOFFMasmParser`] 
| Create a COFF MASM object&hyphen;file assembly parser extension&period;
| xref:llvm/createCallGraphDOTPrinterPass.adoc[`createCallGraphDOTPrinterPass`] 
| Create a legacy pass that prints the call graph as DOT&period;
| xref:llvm/createCallGraphViewerPass.adoc[`createCallGraphViewerPass`] 
| Create a legacy pass that views the call graph&period;
| xref:llvm/createCallMatchingInvoke.adoc[`createCallMatchingInvoke`] 
| Create a call that matches an invoke&apos;s operands and attributes&period;
| xref:llvm/createCanonicalizeFreezeInLoopsPass.adoc[`createCanonicalizeFreezeInLoopsPass`] 
| Create a pass that canonicalizes freeze instructions in loops&period;
| xref:llvm/createCheckDebugMachineModuleLegacyPass.adoc[`createCheckDebugMachineModuleLegacyPass`] 
| Creates MIR Check Debug pass&period;
| xref:llvm/createCodeGenPrepareLegacyPass.adoc[`createCodeGenPrepareLegacyPass`] 
| createCodeGenPrepareLegacyPass &hyphen; Transform the code to expose more pattern matching during instruction selection&period;
| xref:llvm/createComplexDeinterleavingPass.adoc[`createComplexDeinterleavingPass`] 
| This pass implements generation of target&hyphen;specific intrinsics to support handling of complex number arithmetic
| xref:llvm/createConstantHoistingPass.adoc[`createConstantHoistingPass`] 
| Create a pass that prepares a function for expensive constants&period;
| xref:llvm/createCopyConstrainDAGMutation.adoc[`createCopyConstrainDAGMutation`] 
| Create a DAG mutation that constrains copies near their uses&sol;defs&period;
| xref:llvm/createCriticalAntiDepBreaker.adoc[`createCriticalAntiDepBreaker`] 
| Create a critical&hyphen;path anti&hyphen;dependence breaker&period;
| xref:llvm/createCtxProfFromYAML.adoc[`createCtxProfFromYAML`] 
| Convert a YAML contextual profile in `Profile` into bitstream form on `Out&period;`
| xref:llvm/createCustomBehaviour.adoc[`createCustomBehaviour`] 
| Create a default CustomBehaviour for llvm&hyphen;mca&period;
| xref:llvm/createDAGLinearizer.adoc[`createDAGLinearizer`] 
| Create a no&hyphen;scheduling scheduler that linearizes the DAG topologically&period;
| xref:llvm/createDXContainerStreamer.adoc[`createDXContainerStreamer`] 
| Create a DXContainer object streamer&period;
| xref:llvm/createDXILResourceBindingWrapperPassPass.adoc[`createDXILResourceBindingWrapperPassPass`] 
| Create a legacy pass that computes `DXILResourceBindingInfo&period;`
| xref:llvm/createDXILResourceTypeWrapperPassPass.adoc[`createDXILResourceTypeWrapperPassPass`] 
| Create a legacy pass that provides `DXILResourceTypeMap&period;`
| xref:llvm/createDXILResourceWrapperPassPass.adoc[`createDXILResourceWrapperPassPass`] 
| Create a legacy pass that computes `DXILResourceMap&period;`
| xref:llvm/createDarwinAsmParser.adoc[`createDarwinAsmParser`] 
| Create a Darwin (Mach&hyphen;O) object&hyphen;file assembly parser extension&period;
| xref:llvm/createDeadArgEliminationPass.adoc[`createDeadArgEliminationPass`] 
| createDeadArgEliminationPass &hyphen; This pass removes arguments from functions which are not used by the body of the function&period;
| xref:llvm/createDeadCodeEliminationPass.adoc[`createDeadCodeEliminationPass`] 
| Create a pass that eliminates dead code via a worklist&hyphen;driven walk&period;
| xref:llvm/createDeadStoreEliminationPass.adoc[`createDeadStoreEliminationPass`] 
| Create a pass that deletes stores post&hyphen;dominated by must&hyphen;aliased stores&period;
| xref:llvm/createDebugifyMachineModulePass.adoc[`createDebugifyMachineModulePass`] 
| Creates MIR Debugify pass&period;
| xref:llvm/createDefaultPBQPRegisterAllocator.adoc[`createDefaultPBQPRegisterAllocator`] 
| PBQPRegisterAllocation Pass &hyphen; This pass implements the Partitioned Boolean Quadratic Prograaming (PBQP) based register allocator&period;
| xref:llvm/createDefaultScheduler.adoc[`createDefaultScheduler`] 
| Create an instruction scheduler appropriate for the target&period;
| xref:llvm/createDependenceAnalysisWrapperPass.adoc[`createDependenceAnalysisWrapperPass`] 
| createDependenceAnalysisPass &hyphen; This creates an instance of the DependenceAnalysis wrapper pass&period;
| xref:llvm/createDevelopmentModeAdvisorAnalysisLegacy.adoc[`createDevelopmentModeAdvisorAnalysisLegacy`] 
| Create the legacy analysis for the development&hyphen;mode ML eviction advisor&period;
| xref:llvm/createDevelopmentModeAdvisorProvider.adoc[`createDevelopmentModeAdvisorProvider`] 
| Create a development&hyphen;mode ML eviction advisor provider&period;
| xref:llvm/createDevelopmentModePriorityAdvisorAnalysis.adoc[`createDevelopmentModePriorityAdvisorAnalysis`] 
| Create the legacy analysis for the development&hyphen;mode ML priority advisor&period;
| xref:llvm/createDevelopmentModePriorityAdvisorProvider.adoc[`createDevelopmentModePriorityAdvisorProvider`] 
| Create a development&hyphen;mode ML priority advisor provider&period;
| xref:llvm/createDevirtSCCRepeatedPass.adoc[`createDevirtSCCRepeatedPass`] 
| A function to deduce a function pass type and wrap it in the templated adaptor&period;
| xref:llvm/createDomOnlyPrinterWrapperPassPass.adoc[`createDomOnlyPrinterWrapperPassPass`] 
| Create a legacy pass that prints a label&hyphen;only dominator tree as DOT&period;
| xref:llvm/createDomOnlyViewerWrapperPassPass.adoc[`createDomOnlyViewerWrapperPassPass`] 
| Create a legacy pass that views a label&hyphen;only dominator tree&period;
| xref:llvm/createDomPrinterWrapperPassPass.adoc[`createDomPrinterWrapperPassPass`] 
| Create a legacy pass that prints the dominator tree as DOT&period;
| xref:llvm/createDomViewerWrapperPassPass.adoc[`createDomViewerWrapperPassPass`] 
| Create a legacy pass that views the dominator tree&period;
| xref:llvm/createDwarfEHPass.adoc[`createDwarfEHPass`] 
| createDwarfEHPass &hyphen; This pass mulches exception handling code into a form adapted to code generation&period; Required if using dwarf exception handling&period;
| xref:llvm/createEHContGuardTargetsLegacy.adoc[`createEHContGuardTargetsLegacy`] 
| Creates Windows EH Continuation Guard target identification pass&period;
| xref:llvm/createELFAsmParser.adoc[`createELFAsmParser`] 
| Create an ELF object&hyphen;file assembly parser extension&period;
| xref:llvm/createELFStreamer.adoc[`createELFStreamer`] 
| Create an ELF object streamer&period;
| xref:llvm/createEarlyCSEPass.adoc[`createEarlyCSEPass`] 
| Create a fast common&hyphen;subexpression elimination pass over the dominator tree&period;
| xref:llvm/createExpandIRInstsPass.adoc[`createExpandIRInstsPass`] 
| Create a pass that expands large div&sol;rem and floating&hyphen;point instructions&period;
| xref:llvm/createExpandReductionsPass.adoc[`createExpandReductionsPass`] 
| This pass expands the reduction intrinsics into sequences of shuffles&period;
| xref:llvm/createExpandVariadicsPass.adoc[`createExpandVariadicsPass`] 
| Create a legacy pass manager instance of the expand&hyphen;variadics pass&period;
| xref:llvm/createExternalAAWrapperPass.adoc[`createExternalAAWrapperPass`] 
| A wrapper pass around a callback which can be used to populate the AAResults in the AAResultsWrapperPass from an external AA&period;
| xref:llvm/createFastDAGScheduler.adoc[`createFastDAGScheduler`] 
| Create a fast SelectionDAG instruction scheduler&period;
| xref:llvm/createFastRegisterAllocator-0f.adoc[`createFastRegisterAllocator`] 
| `createFastRegisterAllocator` overloads
| xref:llvm/createFileError-09.adoc[`createFileError`] 
| `createFileError` overloads
| xref:llvm/createFixIrreduciblePass.adoc[`createFixIrreduciblePass`] 
| Create a pass that converts each irreducible SCC into a natural loop&period;
| xref:llvm/createFlattenCFGPass.adoc[`createFlattenCFGPass`] 
| Create a pass that flattens the CFG using parallel&hyphen;and&sol;or idioms&period;
| xref:llvm/createFreeMachineFunctionPass.adoc[`createFreeMachineFunctionPass`] 
| This pass frees the memory occupied by the MachineFunction&period;
| xref:llvm/createFunctionToLoopPassAdaptor-01c.adoc[`createFunctionToLoopPassAdaptor`] 
| `createFunctionToLoopPassAdaptor` overloads
| xref:llvm/createFunctionToMachineFunctionPassAdaptor.adoc[`createFunctionToMachineFunctionPassAdaptor`] 
| A function to deduce a machine function pass type and wrap it in the templated adaptor&period;
| xref:llvm/createGCEmptyBasicBlocksLegacyPass.adoc[`createGCEmptyBasicBlocksLegacyPass`] 
| Create a pass that garbage&hyphen;collects empty machine basic blocks&period;
| xref:llvm/createGCLoweringPass.adoc[`createGCLoweringPass`] 
| GCLowering Pass &hyphen; Used by gc&period;root to perform its default lowering operations&period;
| xref:llvm/createGOFFAsmParser.adoc[`createGOFFAsmParser`] 
| Create a GOFF object&hyphen;file assembly parser extension&period;
| xref:llvm/createGOFFObjectWriter-0b.adoc[`createGOFFObjectWriter`] 
| `createGOFFObjectWriter` overloads
| xref:llvm/createGOFFStreamer.adoc[`createGOFFStreamer`] 
| Create a GOFF object streamer&period;
| xref:llvm/createGVNPass-02.adoc[`createGVNPass`] 
| `createGVNPass` overloads
| xref:llvm/createGlobalDCEPass.adoc[`createGlobalDCEPass`] 
| Create a legacy pass manager instance of the global DCE pass&period;
| xref:llvm/createGlobalMergeFuncPass.adoc[`createGlobalMergeFuncPass`] 
| This pass performs merging similar functions globally&period;
| xref:llvm/createGlobalMergePass.adoc[`createGlobalMergePass`] 
| Create a pass that merges globals to share a base pointer&period;
| xref:llvm/createGlobalsAAWrapperPass.adoc[`createGlobalsAAWrapperPass`] 
| Creates an instance of `GlobalsAAWrapperPass&period;`
| xref:llvm/createGraphFilename.adoc[`createGraphFilename`] 
| Create a temporary file name suitable for writing a DOT graph&period;
| xref:llvm/createGreedyRegisterAllocator-02.adoc[`createGreedyRegisterAllocator`] 
| `createGreedyRegisterAllocator` overloads
| xref:llvm/createHardwareLoopsLegacyPass.adoc[`createHardwareLoopsLegacyPass`] 
| Create Hardware Loop pass&period;
| xref:llvm/createHybridListDAGScheduler.adoc[`createHybridListDAGScheduler`] 
| Create a bottom&hyphen;up register&hyphen;pressure&hyphen;aware list scheduler that uses latency&period;
| xref:llvm/createILPListDAGScheduler.adoc[`createILPListDAGScheduler`] 
| Create a bottom&hyphen;up register&hyphen;pressure&hyphen;aware list scheduler that favors ILP&period;
| xref:llvm/createIVUsersPass.adoc[`createIVUsersPass`] 
| Creates an instance of `IVUsersWrapperPass&period;`
| xref:llvm/createIfConverter.adoc[`createIfConverter`] 
| Create a pass that converts conditional branches into predicated code&period;
| xref:llvm/createImmutableModuleSummaryIndexWrapperPass.adoc[`createImmutableModuleSummaryIndexWrapperPass`] 
| Create a legacy immutable pass that wraps a provided ModuleSummaryIndex&period;
| xref:llvm/createIndirectBrExpandPass.adoc[`createIndirectBrExpandPass`] 
| Create a pass that expands indirectbr instructions into switches&period;
| xref:llvm/createInferAddressSpacesPass.adoc[`createInferAddressSpacesPass`] 
| Create a pass that infers better address spaces for pointer users&period;
| xref:llvm/createInlineAsmPreparePass.adoc[`createInlineAsmPreparePass`] 
| Create a pass that prepares inline asm for SelectionDAG codegen&period;
| xref:llvm/createInlineSpiller.adoc[`createInlineSpiller`] 
| Create and return a spiller that will insert spill code directly instead of deferring though VirtRegMap&period;
| xref:llvm/createInsertCodePrefetchPass.adoc[`createInsertCodePrefetchPass`] 
| createInsertCodePrefetchPass &hyphen; This pass enables inserting code prefetch hints based on the basic block section profile&period;
| xref:llvm/createInstSimplifyLegacyPass.adoc[`createInstSimplifyLegacyPass`] 
| Create a legacy pass that simplifies each instruction in a function&period;
| xref:llvm/createInstrPostProcess.adoc[`createInstrPostProcess`] 
| Create a default InstrPostProcess for llvm&hyphen;mca&period;
| xref:llvm/createInstructionCombiningPass.adoc[`createInstructionCombiningPass`] 
| Create a legacy pass that combines instructions into fewer, simpler forms&period;
| xref:llvm/createInstrumentManager.adoc[`createInstrumentManager`] 
| Create a default InstrumentManager for llvm&hyphen;mca&period;
| xref:llvm/createInterleaveMask.adoc[`createInterleaveMask`] 
| Create an interleave shuffle mask&period;
| xref:llvm/createInterleavedAccessPass.adoc[`createInterleavedAccessPass`] 
| InterleavedAccess Pass &hyphen; This pass identifies and matches interleaved memory accesses to target specific intrinsics&period;
| xref:llvm/createInterleavedLoadCombinePass.adoc[`createInterleavedLoadCombinePass`] 
| InterleavedLoadCombines Pass &hyphen; This pass identifies interleaved loads and combines them into wide loads detectable by InterleavedAccessPass
| xref:llvm/createJMCInstrumenterPass.adoc[`createJMCInstrumenterPass`] 
| JMC instrument pass&period;
| xref:llvm/createKCFIPass.adoc[`createKCFIPass`] 
| Lowers KCFI operand bundles for indirect calls&period;
| xref:llvm/createLCSSAPass.adoc[`createLCSSAPass`] 
| Create a pass that inserts phi nodes at loop boundaries to form LCSSA&period;
| xref:llvm/createLFIAsmParser.adoc[`createLFIAsmParser`] 
| Create an LFI assembly parser extension bound to rewriter `Exp&period;`
| xref:llvm/createLICMPass.adoc[`createLICMPass`] 
| Create a loop&hyphen;invariant code motion and memory promotion pass&period;
| xref:llvm/createLazyValueInfoPass.adoc[`createLazyValueInfoPass`] 
| createLazyValueInfoPass &hyphen; This creates an instance of the LazyValueInfo pass&period;
| xref:llvm/createLibcallLoweringInfoWrapper.adoc[`createLibcallLoweringInfoWrapper`] 
| Create a pass that wraps libcall lowering info for the legacy PM&period;
| xref:llvm/createLoadClusterDAGMutation.adoc[`createLoadClusterDAGMutation`] 
| Create a DAG mutation that clusters loads for better memory locality&period;
| xref:llvm/createLoadStoreVectorizerPass.adoc[`createLoadStoreVectorizerPass`] 
| Create a legacy pass manager instance of the LoadStoreVectorizer pass&period;
| xref:llvm/createLoopDataPrefetchPass.adoc[`createLoopDataPrefetchPass`] 
| Create a pass that inserts data prefetching in loops&period;
| xref:llvm/createLoopSimplifyPass.adoc[`createLoopSimplifyPass`] 
| Create a pass that inserts preheader blocks into the CFG for every loop&period;
| xref:llvm/createLoopStrengthReducePass.adoc[`createLoopStrengthReducePass`] 
| Create a pass that strength&hyphen;reduces GEPs using a loop induction variable&period;
| xref:llvm/createLoopTermFoldPass.adoc[`createLoopTermFoldPass`] 
| Create a pass that folds the last IV use in a loop terminator&period;
| xref:llvm/createLoopUnrollPass.adoc[`createLoopUnrollPass`] 
| Create a simple loop unrolling pass&period;
| xref:llvm/createLowerAtomicPass.adoc[`createLowerAtomicPass`] 
| Create a pass that lowers atomic intrinsics to non&hyphen;atomic form&period;
| xref:llvm/createLowerEmuTLSPass.adoc[`createLowerEmuTLSPass`] 
| LowerEmuTLS &hyphen; This pass generates &lowbar;&lowbar;emutls&lowbar;&lsqb;vt&rsqb;&period;xyz variables for all TLS variables for the emulated TLS model&period;
| xref:llvm/createLowerGlobalDtorsLegacyPass.adoc[`createLowerGlobalDtorsLegacyPass`] 
| Create a legacy pass that lowers llvm&period;global&lowbar;dtors via atexit wrappers&period;
| xref:llvm/createLowerInvokePass.adoc[`createLowerInvokePass`] 
| Create a pass that removes invoke instructions, converting them to calls&period;
| xref:llvm/createLowerSwitchPass.adoc[`createLowerSwitchPass`] 
| Create a pass that converts SwitchInst instructions into chained binary branches&period;
| xref:llvm/createMCAsmParser.adoc[`createMCAsmParser`] 
| Create an MCAsmParser instance for parsing assembly similar to gas syntax&period;
| xref:llvm/createMCMasmParser.adoc[`createMCMasmParser`] 
| Create an MCAsmParser instance for parsing Microsoft MASM&hyphen;style assembly&period;
| xref:llvm/createMCRelocationInfo.adoc[`createMCRelocationInfo`] 
| Create a default MCRelocationInfo for the given triple&period;
| xref:llvm/createMCSymbolizer.adoc[`createMCSymbolizer`] 
| Create a default MCSymbolizer for the given triple&period;
| xref:llvm/createMIR2VecPrinterLegacyPass.adoc[`createMIR2VecPrinterLegacyPass`] 
| MIR2VecPrinter pass &hyphen; This pass prints out the MIR2Vec embeddings for machine functions, basic blocks and instructions&period;
| xref:llvm/createMIR2VecVocabPrinterLegacyPass.adoc[`createMIR2VecVocabPrinterLegacyPass`] 
| MIR2VecVocabPrinter pass &hyphen; This pass prints out the MIR2Vec vocabulary contents to the given stream as a debugging tool&period;
| xref:llvm/createMIRAddFSDiscriminatorsPass.adoc[`createMIRAddFSDiscriminatorsPass`] 
| Add Flow Sensitive Discriminators&period; PassNum specifies the sequence number of this pass (starting from 1)&period;
| xref:llvm/createMIRParser.adoc[`createMIRParser`] 
| This function is another interface to the MIR serialization format parser&period;
| xref:llvm/createMIRParserFromFile.adoc[`createMIRParserFromFile`] 
| This function is the main interface to the MIR serialization format parser&period;
| xref:llvm/createMIRProfileLoaderPass.adoc[`createMIRProfileLoaderPass`] 
| Read Flow Sensitive Profile&period;
| xref:llvm/createMachOStreamer.adoc[`createMachOStreamer`] 
| Create a Mach&hyphen;O object streamer&period;
| xref:llvm/createMachineBlockHashInfoPass.adoc[`createMachineBlockHashInfoPass`] 
| createMachineBlockHashInfoPass &hyphen; This pass computes basic block hashes&period;
| xref:llvm/createMachineCopyPropagationPass.adoc[`createMachineCopyPropagationPass`] 
| Create a pass that performs copy propagation on machine instructions&period;
| xref:llvm/createMachineFunctionPrinterPass.adoc[`createMachineFunctionPrinterPass`] 
| MachineFunctionPrinter pass &hyphen; This pass prints out the machine function to the given stream as a debugging tool&period;
| xref:llvm/createMachineFunctionSplitterPass.adoc[`createMachineFunctionSplitterPass`] 
| createMachineFunctionSplitterPass &hyphen; This pass splits machine functions using profile information&period;
| xref:llvm/createMachineOutlinerPass.adoc[`createMachineOutlinerPass`] 
| This pass performs outlining on machine instructions directly before printing assembly&period;
| xref:llvm/createMachineVerifierPass.adoc[`createMachineVerifierPass`] 
| createMachineVerifierPass &hyphen; This pass verifies cenerated machine code instructions for correctness&period;
| xref:llvm/createMacroFusionDAGMutation.adoc[`createMacroFusionDAGMutation`] 
| Create a DAG mutation that fuses instruction pairs matching the given predicates&period;
| xref:llvm/createMemCpyLoopKnownSize.adoc[`createMemCpyLoopKnownSize`] 
| Emit a loop implementing llvm&period;memcpy when the size is a constant&period;
| xref:llvm/createMemCpyLoopUnknownSize.adoc[`createMemCpyLoopUnknownSize`] 
| Emit a loop implementing llvm&period;memcpy when the size is not a constant&period;
| xref:llvm/createMinMaxOp.adoc[`createMinMaxOp`] 
| Returns a Min&sol;Max operation corresponding to MinMaxRecurrenceKind&period; The Builder&apos;s fast&hyphen;math&hyphen;flags must be set to propagate the expected values&period;
| xref:llvm/createModuleSummaryIndexWrapperPass.adoc[`createModuleSummaryIndexWrapperPass`] 
| Create a legacy pass that builds a ModuleSummaryIndex for the module&period;
| xref:llvm/createModuleToFunctionPassAdaptor.adoc[`createModuleToFunctionPassAdaptor`] 
| A function to deduce a function pass type and wrap it in the templated adaptor&period;
| xref:llvm/createModuleToPostOrderCGSCCPassAdaptor.adoc[`createModuleToPostOrderCGSCCPassAdaptor`] 
| A function to deduce a function pass type and wrap it in the templated adaptor&period;
| xref:llvm/createNaryReassociatePass.adoc[`createNaryReassociatePass`] 
| Create a pass that simplifies n&hyphen;ary operations by reassociation&period;
| xref:llvm/createNullStreamer.adoc[`createNullStreamer`] 
| Create a no&hyphen;op streamer that discards all output&period;
| xref:llvm/createObjCARCContractPass.adoc[`createObjCARCContractPass`] 
| Create a late ObjC ARC cleanup pass for the legacy pass manager&period;
| xref:llvm/createOrderedReduction-06a.adoc[`createOrderedReduction`] 
| `createOrderedReduction` overloads
| xref:llvm/createPBQPRegisterAllocator.adoc[`createPBQPRegisterAllocator`] 
| Create a PBQP register allocator instance&period;
| xref:llvm/createPGOFuncNameMetadata.adoc[`createPGOFuncNameMetadata`] 
| Create PGOFuncName metadata when it differs from `F&apos;s` raw name&period;
| xref:llvm/createPGOFuncNameVar-04.adoc[`createPGOFuncNameVar`] 
| `createPGOFuncNameVar` overloads
| xref:llvm/createPGONameMetadata.adoc[`createPGONameMetadata`] 
| Create PGOName metadata when it differs from `GO&apos;s` mangled name&period;
| xref:llvm/createPHIsForSplitLoopExit.adoc[`createPHIsForSplitLoopExit`] 
| Insert LCSSA PHI nodes required after splitting a loop exit edge&period;
| xref:llvm/createPartiallyInlineLibCallsPass.adoc[`createPartiallyInlineLibCallsPass`] 
| Create a pass that partially inlines fast paths of library calls&period;
| xref:llvm/createPostDomOnlyPrinterWrapperPassPass.adoc[`createPostDomOnlyPrinterWrapperPassPass`] 
| Create a legacy pass that prints a label&hyphen;only post&hyphen;dominator tree as DOT&period;
| xref:llvm/createPostDomOnlyViewerWrapperPassPass.adoc[`createPostDomOnlyViewerWrapperPassPass`] 
| Create a legacy pass that views a label&hyphen;only post&hyphen;dominator tree&period;
| xref:llvm/createPostDomPrinterWrapperPassPass.adoc[`createPostDomPrinterWrapperPassPass`] 
| Create a legacy pass that prints the post&hyphen;dominator tree as DOT&period;
| xref:llvm/createPostDomTree.adoc[`createPostDomTree`] 
| Create a legacy FunctionPass that computes a PostDominatorTree&period;
| xref:llvm/createPostDomViewerWrapperPassPass.adoc[`createPostDomViewerWrapperPassPass`] 
| Create a legacy pass that views the post&hyphen;dominator tree&period;
| xref:llvm/createPostInlineEntryExitInstrumenterPass.adoc[`createPostInlineEntryExitInstrumenterPass`] 
| Create a post&hyphen;inlining pass that instruments function entry and exit&period;
| xref:llvm/createPreISelIntrinsicLoweringPass.adoc[`createPreISelIntrinsicLoweringPass`] 
| Create a pass that lowers load&period;relative and objc&period;&ast; intrinsics&period;
| xref:llvm/createPrintFunctionPass.adoc[`createPrintFunctionPass`] 
| Create and return a pass that prints functions to the specified `raw&lowbar;ostream` as they are processed&period;
| xref:llvm/createPrintMIRPass.adoc[`createPrintMIRPass`] 
| MIRPrinting pass &hyphen; this pass prints out the LLVM IR into the given stream using the MIR serialization format&period;
| xref:llvm/createPrintModulePass.adoc[`createPrintModulePass`] 
| Create and return a pass that writes the module to the specified `raw&lowbar;ostream&period;`
| xref:llvm/createPrivateGlobalForString.adoc[`createPrivateGlobalForString`] 
| Create a private global holding the bytes of `Str` for runtime use&period;
| xref:llvm/createProfileFileNameVar.adoc[`createProfileFileNameVar`] 
| Create the module global that holds the default profile output path&period;
| xref:llvm/createProfileSamplingVar.adoc[`createProfileSamplingVar`] 
| Create the module global used for profile sampling&period;
| xref:llvm/createPrologEpilogInserterPass.adoc[`createPrologEpilogInserterPass`] 
| Create a pass that inserts prolog&sol;epilog code and eliminates frame refs&period;
| xref:llvm/createPromoteMemoryToRegisterPass.adoc[`createPromoteMemoryToRegisterPass`] 
| Create a pass that promotes memory references to register references&period;
| xref:llvm/createPseudoProbeInserter.adoc[`createPseudoProbeInserter`] 
| This pass inserts pseudo probe annotation for callsite profiling&period;
| xref:llvm/createReassociatePass.adoc[`createReassociatePass`] 
| Create a pass that reassociates commutative expressions&period;
| xref:llvm/createRegAllocScoringPass.adoc[`createRegAllocScoringPass`] 
| When learning an eviction policy, extract score(reward) information, otherwise this does nothing
| xref:llvm/createRegToMemWrapperPass.adoc[`createRegToMemWrapperPass`] 
| Create a pass that demotes registers to memory references&period;
| xref:llvm/createRegUsageInfoCollector.adoc[`createRegUsageInfoCollector`] 
| This pass is executed POST&hyphen;RA to collect which physical registers are preserved by given machine function&period;
| xref:llvm/createRegUsageInfoPropPass.adoc[`createRegUsageInfoPropPass`] 
| Create a pass that propagates callee register usage to callers&period;
| xref:llvm/createRegionInfoPass.adoc[`createRegionInfoPass`] 
| Creates an instance of `RegionInfoPass&period;`
| xref:llvm/createRegionOnlyPrinterPass.adoc[`createRegionOnlyPrinterPass`] 
| Create a legacy pass that prints a label&hyphen;only region graph as DOT&period;
| xref:llvm/createRegionOnlyViewerPass.adoc[`createRegionOnlyViewerPass`] 
| Create a legacy pass that views a label&hyphen;only region graph&period;
| xref:llvm/createRegionPrinterPass.adoc[`createRegionPrinterPass`] 
| Create a legacy pass that prints the regions of a function as DOT&period;
| xref:llvm/createRegionViewerPass.adoc[`createRegionViewerPass`] 
| Create a legacy pass that views the regions of a function&period;
| xref:llvm/createReleaseModeAdvisorAnalysisLegacy.adoc[`createReleaseModeAdvisorAnalysisLegacy`] 
| Create the legacy analysis for the release&hyphen;mode ML eviction advisor&period;
| xref:llvm/createReleaseModeAdvisorProvider.adoc[`createReleaseModeAdvisorProvider`] 
| Create a release&hyphen;mode ML eviction advisor provider&period;
| xref:llvm/createReleaseModeModelRunner.adoc[`createReleaseModeModelRunner`] 
| Construct the appropriate MLModelRunner for release mode&period;
| xref:llvm/createReleaseModePriorityAdvisorAnalysis.adoc[`createReleaseModePriorityAdvisorAnalysis`] 
| Create the legacy analysis for the release&hyphen;mode ML priority advisor&period;
| xref:llvm/createReleaseModePriorityAdvisorProvider.adoc[`createReleaseModePriorityAdvisorProvider`] 
| Create a release&hyphen;mode ML priority advisor provider&period;
| xref:llvm/createReplaceWithVeclibLegacyPass.adoc[`createReplaceWithVeclibLegacyPass`] 
| Create a pass that replaces vector intrinsics with vector&hyphen;library calls&period;
| xref:llvm/createReplicatedMask.adoc[`createReplicatedMask`] 
| Create a mask with replicated elements&period;
| xref:llvm/createResetMachineFunctionPass.adoc[`createResetMachineFunctionPass`] 
| Create a pass that resets MachineFunctions that failed ISel&period;
| xref:llvm/createRuntimeLibraryInfoWrapperPass.adoc[`createRuntimeLibraryInfoWrapperPass`] 
| Create a legacy pass that provides `RTLIB&colon;&colon;RuntimeLibcallsInfo&period;`
| xref:llvm/createSCEVAAWrapperPass.adoc[`createSCEVAAWrapperPass`] 
| Creates an instance of `SCEVAAWrapperPass&period;`
| xref:llvm/createSPIRVObjectWriter.adoc[`createSPIRVObjectWriter`] 
| Construct a new SPIR&hyphen;V writer instance&period;
| xref:llvm/createSPIRVStreamer.adoc[`createSPIRVStreamer`] 
| Create a SPIR&hyphen;V object streamer&period;
| xref:llvm/createSROAPass.adoc[`createSROAPass`] 
| Create a pass that replaces aggregates with scalar SSA values (SROA)&period;
| xref:llvm/createSafeStackPass.adoc[`createSafeStackPass`] 
| This pass splits the stack into a safe stack and an unsafe stack to protect against stack&hyphen;based overflow vulnerabilities&period;
| xref:llvm/createSafepointIRVerifierPass.adoc[`createSafepointIRVerifierPass`] 
| Create an instance of the safepoint verifier pass which can be added to a pass pipeline to check for relocation bugs&period;
| xref:llvm/createSanitizerCtor.adoc[`createSanitizerCtor`] 
| Creates sanitizer constructor function&period;
| xref:llvm/createSanitizerCtorAndInitFunctions.adoc[`createSanitizerCtorAndInitFunctions`] 
| Creates sanitizer constructor function, and calls sanitizer&apos;s init function from it&period;
| xref:llvm/createScalarizeMaskedMemIntrinLegacyPass.adoc[`createScalarizeMaskedMemIntrinLegacyPass`] 
| Create a pass that scalarizes unsupported masked memory intrinsics&period;
| xref:llvm/createScalarizerPass.adoc[`createScalarizerPass`] 
| Create a legacy pass manager instance of the Scalarizer pass&period;
| xref:llvm/createSchedLive.adoc[`createSchedLive`] 
| Create the standard converging machine scheduler&period; This will be used as the default scheduler if the target does not set a default&period; Adds default DAG mutations&period;
| xref:llvm/createSchedPostRA.adoc[`createSchedPostRA`] 
| Create a generic scheduler with no vreg liveness or DAG mutation passes&period;
| xref:llvm/createScopedNoAliasAAWrapperPass.adoc[`createScopedNoAliasAAWrapperPass`] 
| Creates an instance of `ScopedNoAliasAAWrapperPass&period;`
| xref:llvm/createSelectOptimizePass.adoc[`createSelectOptimizePass`] 
| This pass converts conditional moves to conditional jumps when profitable&period;
| xref:llvm/createSeparateConstOffsetFromGEPPass.adoc[`createSeparateConstOffsetFromGEPPass`] 
| Create a pass that splits GEPs into a base and constant offset&period;
| xref:llvm/createSequentialMask.adoc[`createSequentialMask`] 
| Create a sequential shuffle mask&period;
| xref:llvm/createShadowStackGCLoweringPass.adoc[`createShadowStackGCLoweringPass`] 
| ShadowStackGCLowering &hyphen; Implements the custom lowering mechanism used by the shadow stack GC&period; Only runs on functions which opt in to the shadow stack collector&period;
| xref:llvm/createSimpleReduction-0a6.adoc[`createSimpleReduction`] 
| `createSimpleReduction` overloads
| xref:llvm/createSinkingPass.adoc[`createSinkingPass`] 
| Create a pass that sinks instructions to reduce register pressure&period;
| xref:llvm/createSjLjEHPreparePass.adoc[`createSjLjEHPreparePass`] 
| createSjLjEHPreparePass &hyphen; This pass adapts exception handling code to use the GCC&hyphen;style builtin setjmp&sol;longjmp (sjlj) to handling EH control flow&period;
| xref:llvm/createSourceListDAGScheduler.adoc[`createSourceListDAGScheduler`] 
| Create a bottom&hyphen;up list scheduler that prefers source code order&period;
| xref:llvm/createSpeculativeExecutionIfHasBranchDivergencePass.adoc[`createSpeculativeExecutionIfHasBranchDivergencePass`] 
| Create a speculative&hyphen;execution pass that runs only with branch divergence&period;
| xref:llvm/createSpeculativeExecutionPass.adoc[`createSpeculativeExecutionPass`] 
| Create a pass that hoists instructions for speculative execution&period;
| xref:llvm/createStackFrameLayoutAnalysisPass.adoc[`createStackFrameLayoutAnalysisPass`] 
| StackFramePrinter pass &hyphen; This pass prints out the machine function&apos;s stack frame to the given stream as a debugging tool&period;
| xref:llvm/createStackProtectorPass.adoc[`createStackProtectorPass`] 
| createStackProtectorPass &hyphen; This pass adds stack protectors to functions&period;
| xref:llvm/createStaticDataAnnotatorLegacyPass.adoc[`createStaticDataAnnotatorLegacyPass`] 
| createStaticDataAnnotatorPASS &hyphen; This is a module pass that reads from StaticDataProfileInfoWrapperPass and annotates the section prefix of global variables&period;
| xref:llvm/createStaticDataSplitterLegacyPass.adoc[`createStaticDataSplitterLegacyPass`] 
| createStaticDataSplitterPass &hyphen; This is a machine&hyphen;function pass that categorizes static data hotness using profile information&period;
| xref:llvm/createStoreClusterDAGMutation.adoc[`createStoreClusterDAGMutation`] 
| Create a DAG mutation that clusters stores for better memory locality&period;
| xref:llvm/createStraightLineStrengthReducePass.adoc[`createStraightLineStrengthReducePass`] 
| Create a pass that strength&hyphen;reduces patterns in straight&hyphen;line code&period;
| xref:llvm/createStrideMask.adoc[`createStrideMask`] 
| Create a stride shuffle mask&period;
| xref:llvm/createStringError-08.adoc[`createStringError`] 
| `createStringError` overloads
| xref:llvm/createStringErrorV-01.adoc[`createStringErrorV`] 
| `createStringErrorV` overloads
| xref:llvm/createStripConvergenceIntrinsicsPass.adoc[`createStripConvergenceIntrinsicsPass`] 
| Create a pass that strips convergence intrinsics and operand bundles&period;
| xref:llvm/createStripDebugMachineModuleLegacyPass.adoc[`createStripDebugMachineModuleLegacyPass`] 
| Creates MIR Strip Debug pass&period;
| xref:llvm/createStructurizeCFGPass.adoc[`createStructurizeCFGPass`] 
| Create a pass that removes irreducible control flow from the CFG&period;
| xref:llvm/createTailCallEliminationPass.adoc[`createTailCallEliminationPass`] 
| Create a pass that eliminates recursive tail calls before returns&period;
| xref:llvm/createTargetTransformInfoWrapperPass.adoc[`createTargetTransformInfoWrapperPass`] 
| Create an analysis pass wrapper around a TTI object&period;
| xref:llvm/createTriggerCrashFunctionPass.adoc[`createTriggerCrashFunctionPass`] 
| Create a legacy pass manager instance of the trigger&hyphen;crash function pass&period;
| xref:llvm/createTypeBasedAAWrapperPass.adoc[`createTypeBasedAAWrapperPass`] 
| Creates an instance of `TypeBasedAAWrapperPass&period;`
| xref:llvm/createTypePromotionLegacyPass.adoc[`createTypePromotionLegacyPass`] 
| Create IR Type Promotion pass&period;
| xref:llvm/createUnaryMask.adoc[`createUnaryMask`] 
| Create a unary shuffle mask from a binary shuffle mask&period;
| xref:llvm/createUnifyLoopExitsPass.adoc[`createUnifyLoopExitsPass`] 
| Create a pass that unifies each loop&apos;s exits through a single successor&period;
| xref:llvm/createUnpackMachineBundlesLegacy.adoc[`createUnpackMachineBundlesLegacy`] 
| Create a pass that unpacks machine instruction bundles&period;
| xref:llvm/createUnreachableBlockEliminationPass.adoc[`createUnreachableBlockEliminationPass`] 
| Create a pass that deletes unreachable IR basic blocks&period;
| xref:llvm/createVLIWDAGScheduler.adoc[`createVLIWDAGScheduler`] 
| Create a top&hyphen;down DFA&hyphen;driven list scheduler for VLIW targets&period;
| xref:llvm/createVerifierPass.adoc[`createVerifierPass`] 
| Create a verifier pass&period;
| xref:llvm/createVirtRegRewriter.adoc[`createVirtRegRewriter`] 
| Create a pass that rewrites virtual registers to physical registers&period;
| xref:llvm/createWasmAsmParser.adoc[`createWasmAsmParser`] 
| Create a WebAssembly object&hyphen;file assembly parser extension&period;
| xref:llvm/createWasmDwoObjectWriter.adoc[`createWasmDwoObjectWriter`] 
| Construct a new Wasm writer that emits split DWARF to a separate stream&period;
| xref:llvm/createWasmEHPass.adoc[`createWasmEHPass`] 
| createWasmEHPass &hyphen; This pass adapts exception handling code to use WebAssembly&apos;s exception handling scheme&period;
| xref:llvm/createWasmObjectWriter.adoc[`createWasmObjectWriter`] 
| Construct a new Wasm writer instance&period;
| xref:llvm/createWasmStreamer.adoc[`createWasmStreamer`] 
| Create a WebAssembly object streamer&period;
| xref:llvm/createWideIV.adoc[`createWideIV`] 
| Extend the width of an IV to cover its widest uses&period;
| xref:llvm/createWinCOFFDwoObjectWriter.adoc[`createWinCOFFDwoObjectWriter`] 
| Construct a new Win COFF writer instance with a split&hyphen;DWARF stream&period;
| xref:llvm/createWinCOFFObjectWriter.adoc[`createWinCOFFObjectWriter`] 
| Construct a new Win COFF writer instance&period;
| xref:llvm/createWinEHPass.adoc[`createWinEHPass`] 
| createWinEHPass &hyphen; Prepares personality functions used by MSVC on Windows, in addition to the Itanium LSDA based personalities&period;
| xref:llvm/createWindowsSecureHotPatchingPass.adoc[`createWindowsSecureHotPatchingPass`] 
| Creates Windows Secure Hot Patch pass&period;
| xref:llvm/createXCOFFAsmParser.adoc[`createXCOFFAsmParser`] 
| Create an XCOFF object&hyphen;file assembly parser extension&period;
| xref:llvm/createXCOFFObjectWriter.adoc[`createXCOFFObjectWriter`] 
| Construct a new XCOFF writer instance&period;
| xref:llvm/dbgs.adoc[`dbgs`] 
| dbgs() &hyphen; This returns a reference to a raw&lowbar;ostream for debugging messages&period; If debugging is disabled it returns errs()&period; Use it like&colon; dbgs() &lt;&lt; &quot;foo&quot; &lt;&lt; &quot;bar&quot;&semi;
| xref:llvm/deallocate_buffer.adoc[`deallocate&lowbar;buffer`] 
| Deallocate a buffer of memory with the given size and alignment&period;
| xref:llvm/debugString.adoc[`debugString`] 
| Return `Op` rendered to a string via `operator&lt;&lt;&period;`
| xref:llvm/declareSanitizerInitFunction.adoc[`declareSanitizerInitFunction`] 
| Declare a sanitizer initialization function in module `M&period;`
| xref:llvm/decodeBase64.adoc[`decodeBase64`] 
| Decode a Base64 string into raw bytes&period;
| xref:llvm/decodeMaybeAlign.adoc[`decodeMaybeAlign`] 
| Dual operation of the encode function above&period;
| xref:llvm/decodePackedBCD-05.adoc[`decodePackedBCD`] 
| `decodePackedBCD` overloads
| xref:llvm/decodeSLEB128.adoc[`decodeSLEB128`] 
| Utility function to decode a SLEB128 value&period;
| xref:llvm/decodeSLEB128AndInc.adoc[`decodeSLEB128AndInc`] 
| Decode a SLEB128 value and advance the pointer past the encoded bytes&period;
| xref:llvm/decodeULEB128.adoc[`decodeULEB128`] 
| Utility function to decode a ULEB128 value&period;
| xref:llvm/decodeULEB128AndInc.adoc[`decodeULEB128AndInc`] 
| Decode a ULEB128 value and advance the pointer past the encoded bytes&period;
| xref:llvm/decodeULEB128AndIncUnsafe.adoc[`decodeULEB128AndIncUnsafe`] 
| Decode a ULEB128 value and advance the pointer, without bounds checking&period;
| xref:llvm/decomposeBitTest.adoc[`decomposeBitTest`] 
| Decompose an icmp into the form ((X &amp; Mask) pred C) if possible&period;
| xref:llvm/decomposeBitTestICmp.adoc[`decomposeBitTestICmp`] 
| Decompose an icmp into the form ((X &amp; Mask) pred C) if possible&period;
| xref:llvm/decomposeLinearExpression.adoc[`decomposeLinearExpression`] 
| Decompose a pointer into a linear expression&period; This may look through multiple GEPs&period;
| xref:llvm/def_chain.adoc[`def&lowbar;chain`] 
| Return a range walking defining accesses from `MA` up to `UpTo&period;`
| xref:llvm/deleteDeadLoop.adoc[`deleteDeadLoop`] 
| Delete a loop that the caller has proven dead&period;
| xref:llvm/delinearize.adoc[`delinearize`] 
| Split this SCEVAddRecExpr into two vectors of SCEVs representing the subscripts and sizes of an array access&period;
| xref:llvm/delinearizeFixedSizeArray.adoc[`delinearizeFixedSizeArray`] 
| Split a fixed&hyphen;size array access into subscript and size SCEVs&period;
| xref:llvm/demangle.adoc[`demangle`] 
| Attempt to demangle a string using different demangling schemes&period; The function uses heuristics to determine which demangling scheme to use&period;
| xref:llvm/denormalModeKindName.adoc[`denormalModeKindName`] 
| Return the name used for the denormal handling mode used by the expected names from the denormal&hyphen;fp&hyphen;math attribute&period;
| xref:llvm/denormalizeForPostIncUse.adoc[`denormalizeForPostIncUse`] 
| Denormalize `S` to be post&hyphen;increment for all loops present in `Loops&period;`
| xref:llvm/depth_first.adoc[`depth&lowbar;first`] 
| Return a range that visits `G` in depth&hyphen;first order&period;
| xref:llvm/depth_first_ext.adoc[`depth&lowbar;first&lowbar;ext`] 
| Return a range that visits `G` in depth&hyphen;first order using visited set `S&period;`
| xref:llvm/describeFuzzerAggregateOps.adoc[`describeFuzzerAggregateOps`] 
| Append aggregate extractvalue and insertvalue descriptors to `Ops&period;`
| xref:llvm/describeFuzzerControlFlowOps.adoc[`describeFuzzerControlFlowOps`] 
| Append control&hyphen;flow operation descriptors to `Ops&period;`
| xref:llvm/describeFuzzerFloatOps.adoc[`describeFuzzerFloatOps`] 
| Append floating&hyphen;point arithmetic and fcmp descriptors to `Ops&period;`
| xref:llvm/describeFuzzerIntOps.adoc[`describeFuzzerIntOps`] 
| Append integer arithmetic and icmp descriptors to `Ops&period;`
| xref:llvm/describeFuzzerOtherOps.adoc[`describeFuzzerOtherOps`] 
| Append miscellaneous operation descriptors to `Ops&period;`
| xref:llvm/describeFuzzerPointerOps.adoc[`describeFuzzerPointerOps`] 
| Append pointer operation descriptors to `Ops&period;`
| xref:llvm/describeFuzzerUnaryOperations.adoc[`describeFuzzerUnaryOperations`] 
| Append unary operation descriptors to `Ops&period;`
| xref:llvm/describeFuzzerVectorOps.adoc[`describeFuzzerVectorOps`] 
| Append vector extractelement, insertelement, and shufflevector descriptors to `Ops&period;`
| xref:llvm/deserializeSectionKind.adoc[`deserializeSectionKind`] 
| Convert a value read from an index section to the internal representation&period;
| xref:llvm/detachDeadBlocks.adoc[`detachDeadBlocks`] 
| Replace every block in `BBs` with a single unreachable instruction&period;
| xref:llvm/df_begin.adoc[`df&lowbar;begin`] 
| Return a depth&hyphen;first iterator at the entry of `G&period;`
| xref:llvm/df_end.adoc[`df&lowbar;end`] 
| Return a past&hyphen;the&hyphen;end depth&hyphen;first iterator for `G&period;`
| xref:llvm/df_ext_begin.adoc[`df&lowbar;ext&lowbar;begin`] 
| Return an external&hyphen;storage depth&hyphen;first iterator at the entry of `G&period;`
| xref:llvm/df_ext_end.adoc[`df&lowbar;ext&lowbar;end`] 
| Return a past&hyphen;the&hyphen;end external&hyphen;storage depth&hyphen;first iterator for `G&period;`
| xref:llvm/diagnoseDontCall.adoc[`diagnoseDontCall`] 
| Emit a dontcall diagnostic for call instruction `CI&period;`
| xref:llvm/disableAutoConversion.adoc[`disableAutoConversion`] 
| Disable automatic ASCII&sol;EBCDIC conversion for a file descriptor&period;
| xref:llvm/divideCeil-0b.adoc[`divideCeil`] 
| `divideCeil` overloads
| xref:llvm/divideCeilSigned.adoc[`divideCeilSigned`] 
| Returns the integer ceil(Numerator &sol; Denominator)&period; Signed version&period; Overflow is explicitly forbidden with an assert&period;
| xref:llvm/divideFloorSigned.adoc[`divideFloorSigned`] 
| Returns the integer floor(Numerator &sol; Denominator)&period; Signed version&period; Overflow is explicitly forbidden with an assert&period;
| xref:llvm/divideNearest.adoc[`divideNearest`] 
| Returns (Numerator &sol; Denominator) rounded by round&hyphen;half&hyphen;up&period; Guaranteed to never overflow&period;
| xref:llvm/divideSignedWouldOverflow.adoc[`divideSignedWouldOverflow`] 
| Return true if signed ceil&sol;floor division would overflow&period;
| xref:llvm/djbHash.adoc[`djbHash`] 
| The Bernstein hash function used by the DWARF accelerator tables&period;
| xref:llvm/dlangDemangle.adoc[`dlangDemangle`] 
| Demangle a D mangled symbol&period;
| xref:llvm/dlltoolDriverMain.adoc[`dlltoolDriverMain`] 
| Entry point for the dlltool&period;exe&hyphen;compatible driver used by llvm&hyphen;dlltool&period;
| xref:llvm/doSystemDiff.adoc[`doSystemDiff`] 
| Performs a system&hyphen;based diff between `Before` and `After&period;`
| xref:llvm/downscaleWeights.adoc[`downscaleWeights`] 
| downscale the given weights preserving the ratio&period; If the maximum value is not already known and not provided via
| xref:llvm/dropDebugUsers.adoc[`dropDebugUsers`] 
| Remove debug intrinsic instructions for a given instruction&period;
| xref:llvm/drop_begin.adoc[`drop&lowbar;begin`] 
| Return a range covering `RangeOrContainer` with the first `N` elements excluded&period;
| xref:llvm/drop_end.adoc[`drop&lowbar;end`] 
| Return a range covering `RangeOrContainer` with the last `N` elements excluded&period;
| xref:llvm/dump.adoc[`dump`] 
| Write the set&hyphen;bit indices of `LHS` to `out` as a bracketed space list&period;
| xref:llvm/dumpBytes.adoc[`dumpBytes`] 
| Convert `Bytes&apos; to a hex string and output to `OS&apos;
| xref:llvm/dumpDotGraphToFile.adoc[`dumpDotGraphToFile`] 
| Dump a DOT graph to the user&hyphen;provided file name&period;
| xref:llvm/dumpMessage.adoc[`dumpMessage`] 
| Dump TableGen message `Message` as a note at `Loc&period;`
| xref:llvm/dumpRegSetPressure.adoc[`dumpRegSetPressure`] 
| Dump non&hyphen;zero entries of `SetPressure` to the debug stream&period;
| xref:llvm/dumpTypeQualifiedName.adoc[`dumpTypeQualifiedName`] 
| Dump the qualified type name of `DIE` to `OS&period;`
| xref:llvm/dumpTypeUnqualifiedName.adoc[`dumpTypeUnqualifiedName`] 
| Dump the unqualified type name of `DIE` to `OS&period;`
| xref:llvm/dyn_cast-0a1.adoc[`dyn&lowbar;cast`] 
| `dyn&lowbar;cast` overloads
| xref:llvm/dyn_cast_if_present-0c.adoc[`dyn&lowbar;cast&lowbar;if&lowbar;present`] 
| `dyn&lowbar;cast&lowbar;if&lowbar;present` overloads
| xref:llvm/dyn_cast_or_null-0c.adoc[`dyn&lowbar;cast&lowbar;or&lowbar;null`] 
| `dyn&lowbar;cast&lowbar;or&lowbar;null` overloads
| xref:llvm/dynamicAPIntFromInt64.adoc[`dynamicAPIntFromInt64`] 
| Constructs a DynamicAPInt from an `int64&lowbar;t` value&period;
| xref:llvm/ehAwareSplitEdge.adoc[`ehAwareSplitEdge`] 
| Split an edge when the successor is an exception&hyphen;handling block&period;
| xref:llvm/embedBitcodeInModule.adoc[`embedBitcodeInModule`] 
| Embed bitcode and optional command&hyphen;line data as sections in `M&period;`
| xref:llvm/embedBufferInModule.adoc[`embedBufferInModule`] 
| Embed memory buffer `Buf` into module `M` as a global&period;
| xref:llvm/emitAMDGPUPrintfCall.adoc[`emitAMDGPUPrintfCall`] 
| Lower a printf call into AMDGPU device library calls&period;
| xref:llvm/emitAppleAccelTable.adoc[`emitAppleAccelTable`] 
| Emit an Apple Accelerator Table consisting of entries in the specified AccelTable&period; The DataT template parameter should be derived from AppleAccelTableData&period;
| xref:llvm/emitAppleAccelTableImpl.adoc[`emitAppleAccelTableImpl`] 
| Emit an Apple accelerator table for `Contents` using atom list `Atoms&period;`
| xref:llvm/emitBCmp.adoc[`emitBCmp`] 
| Emit a call to the bcmp function&period;
| xref:llvm/emitBinaryFloatFnCall-05.adoc[`emitBinaryFloatFnCall`] 
| `emitBinaryFloatFnCall` overloads
| xref:llvm/emitCalloc.adoc[`emitCalloc`] 
| Emit a call to the calloc function&period;
| xref:llvm/emitDWARF5AccelTable-0f.adoc[`emitDWARF5AccelTable`] 
| `emitDWARF5AccelTable` overloads
| xref:llvm/emitFPutC.adoc[`emitFPutC`] 
| Emit a call to fputc with an int Char and a FILE pointer&period;
| xref:llvm/emitFPutS.adoc[`emitFPutS`] 
| Emit a call to fputs with a string pointer and a FILE pointer&period;
| xref:llvm/emitFWrite.adoc[`emitFWrite`] 
| Emit a call to fwrite with a pointer, size&lowbar;t Size, and FILE pointer&period;
| xref:llvm/emitGEPOffset.adoc[`emitGEPOffset`] 
| Emit code to compute a GEP&apos;s offset from its base pointer&period;
| xref:llvm/emitHotColdNew.adoc[`emitHotColdNew`] 
| Emit a call to the hot&sol;cold operator new function&period;
| xref:llvm/emitHotColdNewAligned.adoc[`emitHotColdNewAligned`] 
| Emit a call to the hot&sol;cold aligned operator new function&period;
| xref:llvm/emitHotColdNewAlignedNoThrow.adoc[`emitHotColdNewAlignedNoThrow`] 
| Emit a call to the hot&sol;cold aligned nothrow operator new function&period;
| xref:llvm/emitHotColdNewNoThrow.adoc[`emitHotColdNewNoThrow`] 
| Emit a call to the hot&sol;cold nothrow operator new function&period;
| xref:llvm/emitHotColdSizeReturningNew.adoc[`emitHotColdSizeReturningNew`] 
| Emit a call to the hot&sol;cold size&hyphen;returning operator new function&period;
| xref:llvm/emitHotColdSizeReturningNewAligned.adoc[`emitHotColdSizeReturningNewAligned`] 
| Emit a call to the hot&sol;cold size&hyphen;returning aligned operator new function&period;
| xref:llvm/emitInlinedInto.adoc[`emitInlinedInto`] 
| Emit an ORE message that `Callee` was inlined into `Caller&period;`
| xref:llvm/emitInlinedIntoBasedOnCost.adoc[`emitInlinedIntoBasedOnCost`] 
| Emit an ORE inlined&hyphen;into message based on default&hyphen;heuristic cost `IC&period;`
| xref:llvm/emitLFIBundleAlign.adoc[`emitLFIBundleAlign`] 
| Emit LFI bundle&hyphen;alignment mode for the current target, if required&period;
| xref:llvm/emitLFINoteSection.adoc[`emitLFINoteSection`] 
| Emit the ELF note section that identifies an LFI object file&period;
| xref:llvm/emitLinkerFlagsForGlobalCOFF.adoc[`emitLinkerFlagsForGlobalCOFF`] 
| Emit COFF linker flags to export or exclude a global&period;
| xref:llvm/emitLinkerFlagsForUsedCOFF.adoc[`emitLinkerFlagsForUsedCOFF`] 
| Emit a COFF &sol;INCLUDE&colon; directive so the linker keeps a global&period;
| xref:llvm/emitMalloc.adoc[`emitMalloc`] 
| Emit a call to the malloc function&period;
| xref:llvm/emitMemCCpy.adoc[`emitMemCCpy`] 
| Emit a call to the memccpy function&period;
| xref:llvm/emitMemChr.adoc[`emitMemChr`] 
| Emit a call to memchr with a pointer, int Val, and size&lowbar;t Len&period;
| xref:llvm/emitMemCmp.adoc[`emitMemCmp`] 
| Emit a call to the memcmp function&period;
| xref:llvm/emitMemCpyChk.adoc[`emitMemCpyChk`] 
| Emit a call to &lowbar;&lowbar;memcpy&lowbar;chk with size&lowbar;t Len&sol;ObjSize and pointer Dst&sol;Src&period;
| xref:llvm/emitMemPCpy.adoc[`emitMemPCpy`] 
| Emit a call to the mempcpy function&period;
| xref:llvm/emitMemRChr.adoc[`emitMemRChr`] 
| Emit a call to the memrchr function, analogously to emitMemChr&period;
| xref:llvm/emitPutChar.adoc[`emitPutChar`] 
| Emit a call to putchar, assuming Char is an int&period;
| xref:llvm/emitPutS.adoc[`emitPutS`] 
| Emit a call to puts, assuming Str is some pointer&period;
| xref:llvm/emitSNPrintf.adoc[`emitSNPrintf`] 
| Emit a call to the snprintf function&period;
| xref:llvm/emitSPrintf.adoc[`emitSPrintf`] 
| Emit a call to the sprintf function&period;
| xref:llvm/emitSourceFileHeader.adoc[`emitSourceFileHeader`] 
| Output an LLVM style file header to the specified raw&lowbar;ostream&period;
| xref:llvm/emitStpCpy.adoc[`emitStpCpy`] 
| Emit a call to stpcpy for the specified pointer arguments&period;
| xref:llvm/emitStpNCpy.adoc[`emitStpNCpy`] 
| Emit a call to stpncpy for the specified pointer arguments and length&period;
| xref:llvm/emitStrCat.adoc[`emitStrCat`] 
| Emit a call to the strcat function&period;
| xref:llvm/emitStrChr.adoc[`emitStrChr`] 
| Emit a call to strchr for the specified pointer and character&period;
| xref:llvm/emitStrCpy.adoc[`emitStrCpy`] 
| Emit a call to strcpy for the specified pointer arguments&period;
| xref:llvm/emitStrDup.adoc[`emitStrDup`] 
| Emit a call to strdup for the specified pointer&period;
| xref:llvm/emitStrLCat.adoc[`emitStrLCat`] 
| Emit a call to the strlcat function&period;
| xref:llvm/emitStrLCpy.adoc[`emitStrLCpy`] 
| Emit a call to the strlcpy function&period;
| xref:llvm/emitStrLen.adoc[`emitStrLen`] 
| Emit a call to strlen for the specified pointer&period;
| xref:llvm/emitStrNCat.adoc[`emitStrNCat`] 
| Emit a call to the strncat function&period;
| xref:llvm/emitStrNCmp.adoc[`emitStrNCmp`] 
| Emit a call to the strncmp function to the builder&period;
| xref:llvm/emitStrNCpy.adoc[`emitStrNCpy`] 
| Emit a call to strncpy for the specified pointer arguments and length&period;
| xref:llvm/emitUnaryFloatFnCall-05.adoc[`emitUnaryFloatFnCall`] 
| `emitUnaryFloatFnCall` overloads
| xref:llvm/emitVSNPrintf.adoc[`emitVSNPrintf`] 
| Emit a call to the vsnprintf function&period;
| xref:llvm/emitVSPrintf.adoc[`emitVSPrintf`] 
| Emit a call to the vsprintf function&period;
| xref:llvm/emitWcsLen.adoc[`emitWcsLen`] 
| Emit a call to wcslen for the specified pointer&period;
| xref:llvm/enableAutoConversion-02.adoc[`enableAutoConversion`] 
| `enableAutoConversion` overloads
| xref:llvm/encode-04.adoc[`encode`] 
| `encode` overloads
| xref:llvm/encodeBase64.adoc[`encodeBase64`] 
| Encode a byte sequence as a Base64 string&period;
| xref:llvm/encodeSLEB128-086.adoc[`encodeSLEB128`] 
| `encodeSLEB128` overloads
| xref:llvm/encodeULEB128-0c.adoc[`encodeULEB128`] 
| `encodeULEB128` overloads
| xref:llvm/enum_seq-0f.adoc[`enum&lowbar;seq`] 
| `enum&lowbar;seq` overloads
| xref:llvm/enum_seq_inclusive-0c.adoc[`enum&lowbar;seq&lowbar;inclusive`] 
| `enum&lowbar;seq&lowbar;inclusive` overloads
| xref:llvm/enumerate.adoc[`enumerate`] 
| Enumerate one or more ranges, yielding (index, values&period;&period;&period;)&period;
| xref:llvm/equal-0bd.adoc[`equal`] 
| `equal` overloads
| xref:llvm/equal_to.adoc[`equal&lowbar;to`] 
| Build a unary predicate that tests equality to `Arg&period;`
| xref:llvm/erase.adoc[`erase`] 
| Erase all occurrences of `V` from container `C&period;`
| xref:llvm/eraseInstr.adoc[`eraseInstr`] 
| Erase a single dead instruction, optionally notifying a debug observer&period;
| xref:llvm/eraseInstrs.adoc[`eraseInstrs`] 
| Erase a list of dead instructions, optionally notifying a debug observer&period;
| xref:llvm/erase_if.adoc[`erase&lowbar;if`] 
| Erase elements of `C` for which `P` is true&period;
| xref:llvm/errnoAsErrorCode.adoc[`errnoAsErrorCode`] 
| Helper to get errno as an std&colon;&colon;error&lowbar;code&period;
| xref:llvm/errorCodeToError.adoc[`errorCodeToError`] 
| Helper for converting an std&colon;&colon;error&lowbar;code to a Error&period;
| xref:llvm/errorOrToExpected.adoc[`errorOrToExpected`] 
| Convert an ErrorOr&lt;T&gt; to an Expected&lt;T&gt;&period;
| xref:llvm/errorToBool.adoc[`errorToBool`] 
| Helper for converting an Error to a bool&period;
| xref:llvm/errorToErrorCode.adoc[`errorToErrorCode`] 
| Helper for converting an ECError to a std&colon;&colon;error&lowbar;code&period;
| xref:llvm/errorToErrorCodeAndEmitErrors.adoc[`errorToErrorCodeAndEmitErrors`] 
| Convert `Err` to an error&lowbar;code and emit diagnostics into `Ctx&period;`
| xref:llvm/errs.adoc[`errs`] 
| Return a raw&lowbar;ostream reference for standard error&period;
| xref:llvm/exp.adoc[`exp`] 
| Implement IEEE 754&hyphen;2019 exp functions
| xref:llvm/expandAtomicMemCpyAsLoop.adoc[`expandAtomicMemCpyAsLoop`] 
| Expand `AtomicMemCpy` as a loop without deleting the intrinsic&period;
| xref:llvm/expandDivision.adoc[`expandDivision`] 
| Expand a division into generated integer arithmetic&period;
| xref:llvm/expandDivisionUpTo32Bits.adoc[`expandDivisionUpTo32Bits`] 
| Expand a division after promoting operands to at most 32 bits&period;
| xref:llvm/expandDivisionUpTo64Bits.adoc[`expandDivisionUpTo64Bits`] 
| Expand a division after promoting operands to at most 64 bits&period;
| xref:llvm/expandMemCpyAsLoop.adoc[`expandMemCpyAsLoop`] 
| Expand `MemCpy` as a loop without deleting the intrinsic&period;
| xref:llvm/expandMemMoveAsLoop.adoc[`expandMemMoveAsLoop`] 
| Expand `MemMove` as a loop without deleting the intrinsic&period;
| xref:llvm/expandMemSetAsLoop-0b.adoc[`expandMemSetAsLoop`] 
| `expandMemSetAsLoop` overloads
| xref:llvm/expandMemSetPatternAsLoop-0d.adoc[`expandMemSetPatternAsLoop`] 
| Expand `MemSetPattern` as a loop without deleting the intrinsic&period;
| xref:llvm/expandReductionViaLoop.adoc[`expandReductionViaLoop`] 
| Expand a scalable vector reduction into an element&hyphen;wise runtime loop&period;
| xref:llvm/expandRemainder.adoc[`expandRemainder`] 
| Expand a remainder into generated integer arithmetic&period;
| xref:llvm/expandRemainderUpTo32Bits.adoc[`expandRemainderUpTo32Bits`] 
| Expand a remainder after promoting operands to at most 32 bits&period;
| xref:llvm/expandRemainderUpTo64Bits.adoc[`expandRemainderUpTo64Bits`] 
| Expand a remainder after promoting operands to at most 64 bits&period;
| xref:llvm/expandVectorPredicationIntrinsic.adoc[`expandVectorPredicationIntrinsic`] 
| Expand a vector predication intrinsic&period;
| xref:llvm/expectedToErrorOr.adoc[`expectedToErrorOr`] 
| Convert an Expected&lt;T&gt; to an ErrorOr&lt;T&gt;&period;
| xref:llvm/expectedToErrorOrAndEmitErrors.adoc[`expectedToErrorOrAndEmitErrors`] 
| Convert `Val` to ErrorOr, emitting diagnostics into `Ctx` on failure&period;
| xref:llvm/expectedToOptional.adoc[`expectedToOptional`] 
| Convert an Expected to an optional, discarding any error&period;
| xref:llvm/exportDebugifyStats.adoc[`exportDebugifyStats`] 
| Write debugify statistics from `Map` to the file at `Path&period;`
| xref:llvm/extractBranchWeights-05.adoc[`extractBranchWeights`] 
| `extractBranchWeights` overloads
| xref:llvm/extractBuildAttributesSubsections.adoc[`extractBuildAttributesSubsections`] 
| Extract AArch64 build&hyphen;attribute subsections from a parsed attribute section&period;
| xref:llvm/extractFromBranchWeightMD32.adoc[`extractFromBranchWeightMD32`] 
| Faster version of extractBranchWeights() that skips checks and must only be called with &quot;branch&lowbar;weights&quot; metadata nodes&period; Supports uint32&lowbar;t&period;
| xref:llvm/extractFromBranchWeightMD64.adoc[`extractFromBranchWeightMD64`] 
| Faster version of extractBranchWeights() that skips checks and must only be called with &quot;branch&lowbar;weights&quot; metadata nodes&period; Supports uint64&lowbar;t&period;
| xref:llvm/extractParts-0cf.adoc[`extractParts`] 
| `extractParts` overloads
| xref:llvm/extractProbe.adoc[`extractProbe`] 
| Extract the pseudo probe stored on `Inst,` if present&period;
| xref:llvm/extractProfTotalWeight-0a.adoc[`extractProfTotalWeight`] 
| `extractProfTotalWeight` overloads
| xref:llvm/extractVectorParts.adoc[`extractVectorParts`] 
| Version which handles irregular sub&hyphen;vector splits&period;
| xref:llvm/extractWidenableCondition.adoc[`extractWidenableCondition`] 
| Returns the widenable condition in `U&apos;s` expression tree, if uniquely used&period;
| xref:llvm/failed.adoc[`failed`] 
| Utility function that returns true if the provided LogicalResult corresponds to a failure value&period;
| xref:llvm/failure.adoc[`failure`] 
| Utility function to generate a LogicalResult&period; If isFailure is true a `failure` result is generated, otherwise a &apos;success&apos; result is generated&period;
| xref:llvm/fcmpImpliesClass-0f.adoc[`fcmpImpliesClass`] 
| `fcmpImpliesClass` overloads
| xref:llvm/fcmpToClassTest-04.adoc[`fcmpToClassTest`] 
| Returns a pair of values, which if passed to llvm&period;is&period;fpclass, returns the same result as an fcmp with the given operands&period;
| xref:llvm/fdbgs.adoc[`fdbgs`] 
| fdbgs() &hyphen; This returns a reference to a formatted&lowbar;raw&lowbar;ostream for debug output&period; Use it like&colon; fdbgs() &lt;&lt; &quot;foo&quot; &lt;&lt; &quot;bar&quot;&semi;
| xref:llvm/ferrs.adoc[`ferrs`] 
| ferrs() &hyphen; This returns a reference to a formatted&lowbar;raw&lowbar;ostream for standard error&period; Use it like&colon; ferrs() &lt;&lt; &quot;foo&quot; &lt;&lt; &quot;bar&quot;&semi;
| xref:llvm/fill.adoc[`fill`] 
| Assign `Value` to every element of `Range&period;`
| xref:llvm/fillMapFromAssume.adoc[`fillMapFromAssume`] 
| Populate a map with all knowledge from an llvm&period;assume&apos;s operand bundles&period;
| xref:llvm/filterDeadComdatFunctions.adoc[`filterDeadComdatFunctions`] 
| Filter out potentially dead comdat functions where other entries keep the entire comdat group alive&period;
| xref:llvm/filter_to_vector-07.adoc[`filter&lowbar;to&lowbar;vector`] 
| Filter a range to a SmallVector with the element types deduced&period;
| xref:llvm/finalizeBundle-0e.adoc[`finalizeBundle`] 
| `finalizeBundle` overloads
| xref:llvm/finalizeBundles.adoc[`finalizeBundles`] 
| Finalize instruction bundles in the specified MachineFunction&period;
| xref:llvm/finalizeLLVMOptimizationRemarks.adoc[`finalizeLLVMOptimizationRemarks`] 
| Finalize optimization remarks and deregister the RemarkStreamer from the Context&period;
| xref:llvm/find.adoc[`find`] 
| Return an iterator to the first occurrence of `Val` in `Range&period;`
| xref:llvm/findAllocaForValue-007.adoc[`findAllocaForValue`] 
| `findAllocaForValue` overloads
| xref:llvm/findArrayDimensions.adoc[`findArrayDimensions`] 
| Compute the array dimensions Sizes from the set of Terms extracted from the memory access function of this SCEVAddRecExpr (second step of delinearization)&period;
| xref:llvm/findAvailablePtrLoadStore.adoc[`findAvailablePtrLoadStore`] 
| Scan backwards to see if we have the value of the given pointer available locally within a small number of instructions&period;
| xref:llvm/findBooleanLoopTags.adoc[`findBooleanLoopTags`] 
| Return the replacement tags for the enable tag `Name,` or nullptr&period;
| xref:llvm/findDVRDeclareValues.adoc[`findDVRDeclareValues`] 
| As above, for DVRDeclareValues&period;
| xref:llvm/findDVRDeclares.adoc[`findDVRDeclares`] 
| Finds dbg&period;declare records declaring local variables as living in the memory that &apos;V&apos; points to&period;
| xref:llvm/findDVRValues.adoc[`findDVRValues`] 
| As above, for DVRValues&period;
| xref:llvm/findDbgUsers.adoc[`findDbgUsers`] 
| Finds the debug info records describing a value&period;
| xref:llvm/findDbgValues.adoc[`findDbgValues`] 
| Finds the dbg&period;values describing a value&period;
| xref:llvm/findDefsUsedOutsideOfLoop.adoc[`findDefsUsedOutsideOfLoop`] 
| Returns the instructions that use values defined in the loop&period;
| xref:llvm/findDevirtualizableCallsForTypeCheckedLoad.adoc[`findDevirtualizableCallsForTypeCheckedLoad`] 
| Given a call to the intrinsic @llvm&period;type&period;checked&period;load, find all devirtualizable call sites based on the call and return them in DevirtCalls&period;
| xref:llvm/findDevirtualizableCallsForTypeTest.adoc[`findDevirtualizableCallsForTypeTest`] 
| Given a call to the intrinsic @llvm&period;type&period;test, find all devirtualizable call sites based on the call and return them in DevirtCalls&period;
| xref:llvm/findFixedSizeArrayDimensions.adoc[`findFixedSizeArrayDimensions`] 
| Compute the dimensions of fixed size array from `Expr` and save the results in `Sizes&period;`
| xref:llvm/findIndirectCalls.adoc[`findIndirectCalls`] 
| Return all indirect call sites in function `F&period;`
| xref:llvm/findMaximalSubpartOfIllFormedUTF8Sequence.adoc[`findMaximalSubpartOfIllFormedUTF8Sequence`] 
| Returns the length of the maximal subpart of an ill&hyphen;formed UTF&hyphen;8 sequence&period;
| xref:llvm/findOptionMDForLoop.adoc[`findOptionMDForLoop`] 
| Find string metadata for a loop&period;
| xref:llvm/findOptionMDForLoopID.adoc[`findOptionMDForLoopID`] 
| Find and return the loop attribute node for the attribute `Name` in `LoopID&period;` Return nullptr if there is no such attribute&period;
| xref:llvm/findScalarElement.adoc[`findScalarElement`] 
| Given a vector and an element number, see if the scalar value is already around as a register, for example if it were inserted then extracted from the vector&period;
| xref:llvm/findSplitPointForStackProtector.adoc[`findSplitPointForStackProtector`] 
| Find the split point at which to splice the end of BB into its success stack protector check machine basic block&period;
| xref:llvm/findStringMetadataForLoop.adoc[`findStringMetadataForLoop`] 
| Find string metadata for loop
| xref:llvm/findVTableAddrs.adoc[`findVTableAddrs`] 
| Return vtable address instructions feeding indirect calls in `F&period;`
| xref:llvm/findValuesAffectedByCondition.adoc[`findValuesAffectedByCondition`] 
| Call `InsertAffected` on all Values whose known bits &sol; value may be affected by the condition `Cond&period;` Used by AssumptionCache and DomConditionCache&period;
| xref:llvm/find_if.adoc[`find&lowbar;if`] 
| Return an iterator to the first element of `Range` for which `P` is true&period;
| xref:llvm/find_if_not.adoc[`find&lowbar;if&lowbar;not`] 
| Return an iterator to the first element of `Range` for which `P` is false&period;
| xref:llvm/find_singleton.adoc[`find&lowbar;singleton`] 
| Return the single value in `Range` accepted by `P,` else nullptr&period;
| xref:llvm/find_singleton_nested.adoc[`find&lowbar;singleton&lowbar;nested`] 
| Return the nested singleton match in `Range,` or a failure pair&period;
| xref:llvm/fitWeights.adoc[`fitWeights`] 
| Push the weights right to fit in uint32&lowbar;t&period;
| xref:llvm/floorDiv.adoc[`floorDiv`] 
| Returns the floor of `LHS` divided by `RHS&period;`
| xref:llvm/fmt_align.adoc[`fmt&lowbar;align`] 
| Format `Item` aligned within a field of width `Amount&period;`
| xref:llvm/fmt_consume.adoc[`fmt&lowbar;consume`] 
| Wrap an Error so formatv takes ownership and consumes it&period;
| xref:llvm/fmt_pad.adoc[`fmt&lowbar;pad`] 
| Format `Item` with `Left` spaces before and `Right` spaces after&period;
| xref:llvm/fmt_repeat.adoc[`fmt&lowbar;repeat`] 
| Format `Item` repeated `Count` times&period;
| xref:llvm/fneg.adoc[`fneg`] 
| Return the test mask which returns true if the value&apos;s sign bit is flipped&period;
| xref:llvm/foldBranchToCommonDest.adoc[`foldBranchToCommonDest`] 
| Fold a setcc&hyphen;and&hyphen;branch block into a predecessor that already targets both&period;
| xref:llvm/forEachCallbackCallSite.adoc[`forEachCallbackCallSite`] 
| Apply function Func to each CB&apos;s callback call site&period;
| xref:llvm/forEachCallbackFunction.adoc[`forEachCallbackFunction`] 
| Apply function Func to each CB&apos;s callback function&period;
| xref:llvm/for_each.adoc[`for&lowbar;each`] 
| Apply `F` to each element of `Range&period;`
| xref:llvm/forcePrintFuncIR.adoc[`forcePrintFuncIR`] 
| Returns true if loop&hyphen;pass IR dumps should print the entire function&period;
| xref:llvm/forcePrintModuleIR.adoc[`forcePrintModuleIR`] 
| Returns true if function&hyphen;level IR dumps should print the entire module&period;
| xref:llvm/formDedicatedExitBlocks.adoc[`formDedicatedExitBlocks`] 
| Ensure that all exit blocks of the loop are dedicated exits&period;
| xref:llvm/formLCSSA.adoc[`formLCSSA`] 
| Put loop into LCSSA form&period;
| xref:llvm/formLCSSAForInstructions.adoc[`formLCSSAForInstructions`] 
| Ensures LCSSA form for every instruction from the Worklist in the scope of innermost containing loop&period;
| xref:llvm/formLCSSARecursively.adoc[`formLCSSARecursively`] 
| Put a loop nest into LCSSA form&period;
| xref:llvm/format.adoc[`format`] 
| Create a printf&hyphen;style format object from `Fmt` and `Vals&period;`
| xref:llvm/formatCallSiteLocation.adoc[`formatCallSiteLocation`] 
| Get call site location as a string with the given format
| xref:llvm/format_bytes.adoc[`format&lowbar;bytes`] 
| Format `Bytes` as a hex dump without an ASCII column&period;
| xref:llvm/format_bytes_with_ascii.adoc[`format&lowbar;bytes&lowbar;with&lowbar;ascii`] 
| Format `Bytes` as hex with an ASCII column&period;
| xref:llvm/format_decimal.adoc[`format&lowbar;decimal`] 
| Output `N` as a right&hyphen;justified, fixed&hyphen;width decimal&period;
| xref:llvm/format_hex.adoc[`format&lowbar;hex`] 
| Output `N` as a fixed&hyphen;width hexadecimal value with a &quot;0x&quot; prefix&period;
| xref:llvm/format_hex_no_prefix.adoc[`format&lowbar;hex&lowbar;no&lowbar;prefix`] 
| Output `N` as a fixed&hyphen;width hexadecimal value without a &quot;0x&quot; prefix&period;
| xref:llvm/formatv-0e6.adoc[`formatv`] 
| `formatv` overloads
| xref:llvm/fouts.adoc[`fouts`] 
| fouts() &hyphen; This returns a reference to a formatted&lowbar;raw&lowbar;ostream for standard output&period; Use it like&colon; fouts() &lt;&lt; &quot;foo&quot; &lt;&lt; &quot;bar&quot;&semi;
| xref:llvm/frexp.adoc[`frexp`] 
| Equivalent of C standard library function&period;
| xref:llvm/fromHex.adoc[`fromHex`] 
| Convert hexadecimal string `Input` to its binary representation&period; The return string is half the size of `Input&period;`
| xref:llvm/fullyRecomputeLiveIns.adoc[`fullyRecomputeLiveIns`] 
| Convenience function for recomputing live&hyphen;in&apos;s for a set of MBBs until the computation converges&period;
| xref:llvm/funcReturnsFirstArgOfCall.adoc[`funcReturnsFirstArgOfCall`] 
| Returns true if the parent of `CI` returns CI&apos;s first argument after calling `CI&period;`
| xref:llvm/fuseInstructionPair.adoc[`fuseInstructionPair`] 
| Fuse two scheduling units so they are scheduled back to back&period;
| xref:llvm/gatherImportedSummariesForModule.adoc[`gatherImportedSummariesForModule`] 
| Compute summaries needed for ThinLTO backend compilation of a module&period;
| xref:llvm/gatherPeelingPreferences.adoc[`gatherPeelingPreferences`] 
| Gather peeling preferences for loop `L` from the target and user overrides&period;
| xref:llvm/gatherUnrollingPreferences.adoc[`gatherUnrollingPreferences`] 
| Gather unrolling preferences from defaults, flags, TTI, and user overrides&period;
| xref:llvm/gcd.adoc[`gcd`] 
| Returns the greatest common divisor of `A` and `B&period;`
| xref:llvm/gcovOneInput.adoc[`gcovOneInput`] 
| Process one input coverage file pair and emit reports per `options&period;`
| xref:llvm/generateParamAccessSummary.adoc[`generateParamAccessSummary`] 
| Generate parameter access summary information in `Index&period;`
| xref:llvm/gep_type_begin-0a.adoc[`gep&lowbar;type&lowbar;begin`] 
| `gep&lowbar;type&lowbar;begin` overloads
| xref:llvm/gep_type_end-03.adoc[`gep&lowbar;type&lowbar;end`] 
| `gep&lowbar;type&lowbar;end` overloads
| xref:llvm/get-07.adoc[`get`] 
| `get` overloads
| xref:llvm/getAddressSanitizerParams.adoc[`getAddressSanitizerParams`] 
| Fill AddressSanitizer shadow&hyphen;mapping parameters for a target&period;
| xref:llvm/getAllocAlignment.adoc[`getAllocAlignment`] 
| Gets the alignment argument for an aligned&lowbar;alloc&hyphen;like function&period;
| xref:llvm/getAllocSize.adoc[`getAllocSize`] 
| Return the size of the requested allocation&period;
| xref:llvm/getAllocToken.adoc[`getAllocToken`] 
| Calculates stable allocation token ID&period; Returns std&colon;&colon;nullopt for stateful modes that are only available in the AllocToken pass&period;
| xref:llvm/getAllocTokenModeAsString.adoc[`getAllocTokenModeAsString`] 
| Returns the canonical string name for the given AllocTokenMode&period;
| xref:llvm/getAllocTokenModeFromString.adoc[`getAllocTokenModeFromString`] 
| Returns the AllocTokenMode from its canonical string name&semi; if an invalid name was provided returns nullopt&period;
| xref:llvm/getAllocationFamily.adoc[`getAllocationFamily`] 
| If a function is part of an allocation family (e&period;g&period; malloc&sol;realloc&sol;calloc&sol;free), return the identifier for its family of functions&period;
| xref:llvm/getAnyConstantVRegValWithLookThrough.adoc[`getAnyConstantVRegValWithLookThrough`] 
| If `VReg` is defined by a statically evaluable chain of instructions rooted on a G&lowbar;CONSTANT or G&lowbar;FCONSTANT returns its value as APInt and def register&period;
| xref:llvm/getApproximateEVTForLLT.adoc[`getApproximateEVTForLLT`] 
| Get a rough equivalent of an EVT for a given LLT&period;
| xref:llvm/getArgumentAliasingToReturnedPointer-03.adoc[`getArgumentAliasingToReturnedPointer`] 
| `getArgumentAliasingToReturnedPointer` overloads
| xref:llvm/getArithmeticReductionInstruction.adoc[`getArithmeticReductionInstruction`] 
| Returns the arithmetic instruction opcode used when expanding a reduction&period;
| xref:llvm/getArm64ECDemangledFunctionName.adoc[`getArm64ECDemangledFunctionName`] 
| Returns the ARM64EC demangled function name, unless the input is not mangled&period;
| xref:llvm/getArm64ECInsertionPointInMangledName.adoc[`getArm64ECInsertionPointInMangledName`] 
| Find the Arm64EC name insertion point in a Microsoft mangled name&period;
| xref:llvm/getArm64ECMangledFunctionName.adoc[`getArm64ECMangledFunctionName`] 
| Returns the ARM64EC mangled function name unless the input is already mangled&period;
| xref:llvm/getAsSignedInteger.adoc[`getAsSignedInteger`] 
| Parse a signed integer from `Str` using `Radix` into `Result&period;`
| xref:llvm/getAsUnsignedInteger.adoc[`getAsUnsignedInteger`] 
| Parse an unsigned integer from `Str` using `Radix` into `Result&period;`
| xref:llvm/getAssumeAlignInfo.adoc[`getAssumeAlignInfo`] 
| Extract alignment information from an `align` assume operand bundle&period;
| xref:llvm/getAssumeDereferenceableInfo.adoc[`getAssumeDereferenceableInfo`] 
| Extract dereferenceable information from a `dereferenceable` assume operand bundle&period;
| xref:llvm/getAssumeNoUndefInfo.adoc[`getAssumeNoUndefInfo`] 
| Extract noundef information from a `noundef` assume operand bundle&period;
| xref:llvm/getAssumeNonNullInfo.adoc[`getAssumeNonNullInfo`] 
| Extract non&hyphen;null information from a `nonnull` assume operand bundle&period;
| xref:llvm/getAssumeSeparateStorageInfo.adoc[`getAssumeSeparateStorageInfo`] 
| Extract separate&hyphen;storage information from a `separate&lowbar;storage` assume operand bundle&period;
| xref:llvm/getAssumptions-04.adoc[`getAssumptions`] 
| `getAssumptions` overloads
| xref:llvm/getAtomicScopeIRString.adoc[`getAtomicScopeIRString`] 
| Returns the LLVM IR syncscope string that `T` uses to spell `S&period;`
| xref:llvm/getAtomicSyncScopeID.adoc[`getAtomicSyncScopeID`] 
| Return the sync scope of atomic instruction `I,` or nullopt if not atomic&period;
| xref:llvm/getAttributeBasedInliningDecision.adoc[`getAttributeBasedInliningDecision`] 
| Decide inlining from user directives and viability, without cost modeling&period;
| xref:llvm/getAutoSenseRadix.adoc[`getAutoSenseRadix`] 
| Detect and strip a radix prefix from `Str,` returning the inferred radix&period;
| xref:llvm/getBaseObjectSize.adoc[`getBaseObjectSize`] 
| Like getObjectSize(), but only for base objects&period;
| xref:llvm/getBestSimplifyQuery-06.adoc[`getBestSimplifyQuery`] 
| `getBestSimplifyQuery` overloads
| xref:llvm/getBitcodeFileContents.adoc[`getBitcodeFileContents`] 
| Return the modules and raw symbol table from a bitcode buffer&period;
| xref:llvm/getBitcodeLTOInfo.adoc[`getBitcodeLTOInfo`] 
| Returns LTO information for the specified bitcode file&period;
| xref:llvm/getBitcodeModuleList.adoc[`getBitcodeModuleList`] 
| Returns a list of modules in the specified bitcode buffer&period;
| xref:llvm/getBitcodeProducerString.adoc[`getBitcodeProducerString`] 
| Read the producer string from the header of a bitcode buffer&period;
| xref:llvm/getBitcodeTargetTriple.adoc[`getBitcodeTargetTriple`] 
| Read the header of the specified bitcode buffer and extract just the triple information&period; If successful, this returns a string&period; On error, this returns &quot;&quot;&period;
| xref:llvm/getBitwiseNotOperand.adoc[`getBitwiseNotOperand`] 
| If `V` is a bitwise not, return the inverted operand&period;
| xref:llvm/getBooleanLoopAttribute.adoc[`getBooleanLoopAttribute`] 
| Returns true if Name is applied to TheLoop and enabled&period;
| xref:llvm/getBranchProbability-04.adoc[`getBranchProbability`] 
| `getBranchProbability` overloads
| xref:llvm/getBranchWeightMDNode.adoc[`getBranchWeightMDNode`] 
| Get the branch weights metadata node
| xref:llvm/getBranchWeightOffset.adoc[`getBranchWeightOffset`] 
| Return the offset to the first branch weight data
| xref:llvm/getBugReportMsg.adoc[`getBugReportMsg`] 
| Get the bug report message that will be output upon a crash&period;
| xref:llvm/getBundleAttrFromID.adoc[`getBundleAttrFromID`] 
| Return the bundle attribute kind for the given operand&hyphen;bundle tag ID&period;
| xref:llvm/getBundleAttrFromOBU.adoc[`getBundleAttrFromOBU`] 
| Return the bundle attribute kind carried by the given operand bundle&period;
| xref:llvm/getBundleEnd-06.adoc[`getBundleEnd`] 
| Returns an iterator pointing beyond the bundle containing `I&period;`
| xref:llvm/getBundleStart-02.adoc[`getBundleStart`] 
| Returns an iterator to the first instruction in the bundle containing `I&period;`
| xref:llvm/getCGPassBuilderOption.adoc[`getCGPassBuilderOption`] 
| Return codegen pass&hyphen;builder options populated from command&hyphen;line flags&period;
| xref:llvm/getCPUDefaultTargetFeatures.adoc[`getCPUDefaultTargetFeatures`] 
| Returns the default enabled features for `CPU,` or nullopt if unknown&period;
| xref:llvm/getCachedOrDownloadArtifact-05.adoc[`getCachedOrDownloadArtifact`] 
| `getCachedOrDownloadArtifact` overloads
| xref:llvm/getCachedOrDownloadDebuginfo.adoc[`getCachedOrDownloadDebuginfo`] 
| Fetches a debug binary by searching the default local cache directory and server URLs&period;
| xref:llvm/getCachedOrDownloadExecutable.adoc[`getCachedOrDownloadExecutable`] 
| Fetches an executable by searching the default local cache directory and server URLs&period;
| xref:llvm/getCachedOrDownloadSource.adoc[`getCachedOrDownloadSource`] 
| Fetches a specified source file by searching the default local cache directory and server URLs&period;
| xref:llvm/getCallsiteCost.adoc[`getCallsiteCost`] 
| Return the cost associated with a callsite, including parameter passing and the call&sol;return instruction&period;
| xref:llvm/getCodeGenDataSectionName.adoc[`getCodeGenDataSectionName`] 
| Return the object&hyphen;file section name for codegen data kind `CGSK&period;`
| xref:llvm/getColorCategory.adoc[`getColorCategory`] 
| Return the command&hyphen;line option category for color&hyphen;related flags&period;
| xref:llvm/getConstantDataArrayInfo.adoc[`getConstantDataArrayInfo`] 
| Returns true if the value `V` is a pointer into a ConstantDataArray&period; If successful `Slice` will point to a ConstantDataArray info object with an appropriate offset&period;
| xref:llvm/getConstantFPVRegVal.adoc[`getConstantFPVRegVal`] 
| Return the ConstantFP defining `VReg,` or nullptr if it is not a G&lowbar;FCONSTANT&period;
| xref:llvm/getConstantRangeFromMetadata.adoc[`getConstantRangeFromMetadata`] 
| Parse out a conservative ConstantRange from !range metadata&period;
| xref:llvm/getConstantStringInfo.adoc[`getConstantStringInfo`] 
| Compute the contents of a null&hyphen;terminated C string pointed to by `V&period;`
| xref:llvm/getConstrainedIntrinsicID.adoc[`getConstrainedIntrinsicID`] 
| Return the constrained intrinsic ID for an instruction under strictfp&period;
| xref:llvm/getContainedTypes.adoc[`getContainedTypes`] 
| Returns the types contained in `Ty`&period; For struct types, it returns the elements, all other types are returned directly&period;
| xref:llvm/getCoverTy.adoc[`getCoverTy`] 
| Return the smallest type that covers both types and is a multiple of TargetTy&period;
| xref:llvm/getCoverageMappingVarName.adoc[`getCoverageMappingVarName`] 
| Return the name of a coverage mapping variable for an instrumented module&period;
| xref:llvm/getCoverageUnusedNamesVarName.adoc[`getCoverageUnusedNamesVarName`] 
| Return the name of the variable listing PGO names referenced by coverage&period;
| xref:llvm/getDISubprogram.adoc[`getDISubprogram`] 
| Find subprogram that is enclosing this scope&period;
| xref:llvm/getDWARFUnitIndex.adoc[`getDWARFUnitIndex`] 
| Return the CU or TU index table for section kind `Kind&period;`
| xref:llvm/getDbgRecordRange.adoc[`getDbgRecordRange`] 
| Return the range of DbgRecords attached to `DebugMarker&period;`
| xref:llvm/getDeadRegState.adoc[`getDeadRegState`] 
| Return `RegState&colon;&colon;Dead` when `B` is true, else `RegState&colon;&colon;NoFlags&period;`
| xref:llvm/getDebugMetadataVersionFromModule.adoc[`getDebugMetadataVersionFromModule`] 
| Return Debug Info Metadata Version by checking module flags&period;
| xref:llvm/getDebugRegState.adoc[`getDebugRegState`] 
| Return `RegState&colon;&colon;Debug` when `B` is true, else `RegState&colon;&colon;NoFlags&period;`
| xref:llvm/getDebugValueLoc.adoc[`getDebugValueLoc`] 
| Produce a DebugLoc to use for each dbg&period;declare that is promoted to a dbg&period;value&period;
| xref:llvm/getDebuginfodCacheKey.adoc[`getDebuginfodCacheKey`] 
| Returns the cache key for a given debuginfod URL path&period;
| xref:llvm/getDebuginfodDebuginfoUrlPath.adoc[`getDebuginfodDebuginfoUrlPath`] 
| Get the full URL path for a debug binary request of a given BuildID&period;
| xref:llvm/getDebuginfodExecutableUrlPath.adoc[`getDebuginfodExecutableUrlPath`] 
| Get the full URL path for an executable request of a given BuildID&period;
| xref:llvm/getDebuginfodSourceUrlPath.adoc[`getDebuginfodSourceUrlPath`] 
| Get the full URL path for a source request of a given BuildID and file path&period;
| xref:llvm/getDefIgnoringCopies.adoc[`getDefIgnoringCopies`] 
| Find the def instruction for `Reg,` folding away any trivial copies&period; May return nullptr if `Reg` is not a generic virtual register&period;
| xref:llvm/getDefRegState.adoc[`getDefRegState`] 
| Return `RegState&colon;&colon;Define` when `B` is true, else `RegState&colon;&colon;NoFlags&period;`
| xref:llvm/getDefSrcRegIgnoringCopies.adoc[`getDefSrcRegIgnoringCopies`] 
| Find the def instruction for `Reg,` and underlying value Register folding away any copies&period;
| xref:llvm/getDefaultDebuginfodCacheDirectory.adoc[`getDefaultDebuginfodCacheDirectory`] 
| Finds a default local file caching directory for the debuginfod client, first checking DEBUGINFOD&lowbar;CACHE&lowbar;PATH&period;
| xref:llvm/getDefaultDebuginfodTimeout.adoc[`getDefaultDebuginfodTimeout`] 
| Finds a default timeout for debuginfod HTTP requests&period; Checks DEBUGINFOD&lowbar;TIMEOUT environment variable, default is 90 seconds (90000 ms)&period;
| xref:llvm/getDefaultDebuginfodUrls.adoc[`getDefaultDebuginfodUrls`] 
| Finds default array of Debuginfod server URLs by checking DEBUGINFOD&lowbar;URLS environment variable&period;
| xref:llvm/getDefaultEHPersonality.adoc[`getDefaultEHPersonality`] 
| Return the default exception&hyphen;handling personality for target `T&period;`
| xref:llvm/getDefaultInlineOrder.adoc[`getDefaultInlineOrder`] 
| Create the default heuristic&hyphen;based inline order for module `M&period;`
| xref:llvm/getDefaultMaxUsesToExploreForCaptureTracking.adoc[`getDefaultMaxUsesToExploreForCaptureTracking`] 
| Return the default max uses to explore for capture tracking&period;
| xref:llvm/getDefaultPrecision.adoc[`getDefaultPrecision`] 
| Return the default digit precision for a float formatting style&period;
| xref:llvm/getDefaultStackSize.adoc[`getDefaultStackSize`] 
| Based on `RLIMIT&lowbar;STACK` or the equivalent&period;
| xref:llvm/getDeinterleaveIntrinsicFactor.adoc[`getDeinterleaveIntrinsicFactor`] 
| Returns the corresponding factor of llvm&period;vector&period;deinterleaveN intrinsics&period;
| xref:llvm/getDeinterleavedVectorType.adoc[`getDeinterleavedVectorType`] 
| Given a deinterleaveN intrinsic, return the (narrow) vector type of each factor&period;
| xref:llvm/getDevelopmentModeAdvisor.adoc[`getDevelopmentModeAdvisor`] 
| Create a development&hyphen;mode (dynamic model) InlineAdvisor for `M&period;`
| xref:llvm/getDisjunctionWeights.adoc[`getDisjunctionWeights`] 
| Get the branch weights of a branch conditioned on b1 &verbar;&verbar; b2&period;
| xref:llvm/getEHPersonalityName.adoc[`getEHPersonalityName`] 
| Return the canonical name string for personality `Pers&period;`
| xref:llvm/getEHScopeMembership.adoc[`getEHScopeMembership`] 
| Compute EH scope membership for each basic block in a machine function&period;
| xref:llvm/getEarlyClobberRegState.adoc[`getEarlyClobberRegState`] 
| Return `EarlyClobber` when `B` is true, else `RegState&colon;&colon;NoFlags&period;`
| xref:llvm/getEffectiveCodeModel.adoc[`getEffectiveCodeModel`] 
| Return the effective code model, or `Default` when `CM` has no value&period;
| xref:llvm/getExitBlockHelper.adoc[`getExitBlockHelper`] 
| Find an exit block of `L,` optionally requiring uniqueness&period;
| xref:llvm/getExplicitlyUnknownBranchWeightsIfProfiled.adoc[`getExplicitlyUnknownBranchWeightsIfProfiled`] 
| Returns a metadata node containing unknown branch weights if the function has an entry count, otherwise returns nullptr&period;
| xref:llvm/getExpressionForConstant.adoc[`getExpressionForConstant`] 
| Create a debug&hyphen;info expression for a constant&period;
| xref:llvm/getExtDivCycle.adoc[`getExtDivCycle`] 
| Return the outermost cycle made divergent by branch outside it&period;
| xref:llvm/getFCmpCode.adoc[`getFCmpCode`] 
| Similar to getICmpCode but for FCmpInst&period; This encodes a fcmp predicate into a four bit mask&period;
| xref:llvm/getFCmpCodeWithoutNaN.adoc[`getFCmpCodeWithoutNaN`] 
| getFCmpCodeWithoutNaN &hyphen; Given an ISD condition code comparing floats, return the equivalent code if we&apos;re allowed to assume that NaNs won&apos;t occur&period;
| xref:llvm/getFCmpCondCode.adoc[`getFCmpCondCode`] 
| Return the ISD condition code for an LLVM IR floating&hyphen;point predicate&period;
| xref:llvm/getFConstantSplat.adoc[`getFConstantSplat`] 
| Returns a floating point scalar constant of a build vector splat if it exists&period; When `AllowUndef` &equals;&equals; true some elements can be undef but not all&period;
| xref:llvm/getFConstantVRegValWithLookThrough.adoc[`getFConstantVRegValWithLookThrough`] 
| If `VReg` is defined by a statically evaluable chain of instructions rooted on a G&lowbar;FCONSTANT returns its APFloat value and def register&period;
| xref:llvm/getFlippedStrictnessPredicateAndConstant.adoc[`getFlippedStrictnessPredicateAndConstant`] 
| Flip the strictness of an integer compare against a constant RHS&period;
| xref:llvm/getFloatFn.adoc[`getFloatFn`] 
| Get the name of the overloaded floating point function corresponding to Ty&period;
| xref:llvm/getFltSemanticForLLT.adoc[`getFltSemanticForLLT`] 
| Get the appropriate floating point arithmetic semantic based on the bit size of the given scalar LLT&period;
| xref:llvm/getFreedOperand.adoc[`getFreedOperand`] 
| If this if a call to a free function, return the freed operand&period;
| xref:llvm/getFuncNameWithoutPrefix.adoc[`getFuncNameWithoutPrefix`] 
| Strip the filename prefix from a PGO function name&period;
| xref:llvm/getFunctionAtVTableOffset.adoc[`getFunctionAtVTableOffset`] 
| Return the function and pointer at a vtable offset, if they refer to a function&period;
| xref:llvm/getFunctionLiveInPhysReg.adoc[`getFunctionLiveInPhysReg`] 
| Return a virtual register for an incoming physical argument register&period;
| xref:llvm/getGCDType.adoc[`getGCDType`] 
| Return a type whose total size is the GCD of `OrigTy` and `TargetTy&period;`
| xref:llvm/getGCStrategy.adoc[`getGCStrategy`] 
| Lookup the GCStrategy object associated with the given gc name&period;
| xref:llvm/getGlobalContextForCAPI.adoc[`getGlobalContextForCAPI`] 
| Get the deprecated global context for use by the C API&period;
| xref:llvm/getGlobalPassGate.adoc[`getGlobalPassGate`] 
| Singleton instance of the OptPassGate class, so multiple pass managers don&apos;t need to coordinate their uses of OptBisect and OptDisable&period;
| xref:llvm/getHeatColor-02.adoc[`getHeatColor`] 
| `getHeatColor` overloads
| xref:llvm/getHorizDemandedEltsForFirstOperand.adoc[`getHorizDemandedEltsForFirstOperand`] 
| Compute the demanded elements mask of horizontal binary operations&period;
| xref:llvm/getHotnessName.adoc[`getHotnessName`] 
| Return a printable name for hotness type `HT&period;`
| xref:llvm/getICmpCode.adoc[`getICmpCode`] 
| Encode a icmp predicate into a three bit mask&period; These bits are carefully arranged to allow folding of expressions such as&colon;
| xref:llvm/getICmpCondCode-0e5.adoc[`getICmpCondCode`] 
| `getICmpCondCode` overloads
| xref:llvm/getICmpTrueVal.adoc[`getICmpTrueVal`] 
| Returns an integer representing true, as defined by the TargetBooleanContents&period;
| xref:llvm/getIConstantFromReg.adoc[`getIConstantFromReg`] 
| `VReg` is defined by a G&lowbar;CONSTANT, return the corresponding value&period;
| xref:llvm/getIConstantSplatSExtVal-00.adoc[`getIConstantSplatSExtVal`] 
| `getIConstantSplatSExtVal` overloads
| xref:llvm/getIConstantSplatVal-0f.adoc[`getIConstantSplatVal`] 
| `getIConstantSplatVal` overloads
| xref:llvm/getIConstantVRegSExtVal.adoc[`getIConstantVRegSExtVal`] 
| If `VReg` is defined by a G&lowbar;CONSTANT fits in int64&lowbar;t returns it&period;
| xref:llvm/getIConstantVRegVal.adoc[`getIConstantVRegVal`] 
| If `VReg` is defined by a G&lowbar;CONSTANT, return the corresponding value&period;
| xref:llvm/getIConstantVRegValWithLookThrough.adoc[`getIConstantVRegValWithLookThrough`] 
| If `VReg` is defined by a statically evaluable chain of instructions rooted on a G&lowbar;CONSTANT returns its APInt value and def register&period;
| xref:llvm/getIRPGOFuncName.adoc[`getIRPGOFuncName`] 
| Return the IRPGO profile lookup name for function `F&period;`
| xref:llvm/getImplRegState.adoc[`getImplRegState`] 
| Return `RegState&colon;&colon;Implicit` when `B` is true, else `RegState&colon;&colon;NoFlags&period;`
| xref:llvm/getIndexExpressionsFromGEP.adoc[`getIndexExpressionsFromGEP`] 
| Gathers the individual index expressions from a GEP instruction&period;
| xref:llvm/getInitialValueOfAllocation.adoc[`getInitialValueOfAllocation`] 
| If this is a call to an allocation function that initializes memory to a fixed value, return said value in the requested type&period; Otherwise, return nullptr&period;
| xref:llvm/getInlineCost-0c.adoc[`getInlineCost`] 
| `getInlineCost` overloads
| xref:llvm/getInlineOrder.adoc[`getInlineOrder`] 
| Create an InlineOrder for module `M,` preferring a plugin factory if one is registered&period;
| xref:llvm/getInlineParams-06.adoc[`getInlineParams`] 
| `getInlineParams` overloads
| xref:llvm/getInlineParamsFromOptLevel.adoc[`getInlineParamsFromOptLevel`] 
| Generate the parameters to tune the inline cost analysis based on command line options&period;
| xref:llvm/getInliningCostEstimate.adoc[`getInliningCostEstimate`] 
| Get the cost estimate ignoring thresholds&period;
| xref:llvm/getInliningCostFeatures.adoc[`getInliningCostFeatures`] 
| Get the expanded cost features&period; The features are returned unconditionally, even if inlining is impossible&period;
| xref:llvm/getInstrMaxCountValue.adoc[`getInstrMaxCountValue`] 
| Return the max count value&period; We reserver a few large values for special use&period;
| xref:llvm/getInstrProfBitmapBiasVarName.adoc[`getInstrProfBitmapBiasVarName`] 
| Return the name of the runtime bitmap&hyphen;bias global variable&period;
| xref:llvm/getInstrProfBitmapVarPrefix.adoc[`getInstrProfBitmapVarPrefix`] 
| Return the name prefix of profile bitmap variables&period;
| xref:llvm/getInstrProfCounterBiasVarName.adoc[`getInstrProfCounterBiasVarName`] 
| Return the name of the runtime counter&hyphen;bias global variable&period;
| xref:llvm/getInstrProfCountersVarPrefix.adoc[`getInstrProfCountersVarPrefix`] 
| Return the name prefix of profile counter variables&period;
| xref:llvm/getInstrProfDataVarPrefix.adoc[`getInstrProfDataVarPrefix`] 
| Return the name prefix of variables containing per&hyphen;function control data&period;
| xref:llvm/getInstrProfInitFuncName.adoc[`getInstrProfInitFuncName`] 
| Return the name of the compiler&hyphen;generated profile runtime initializer&period;
| xref:llvm/getInstrProfInstrumentGPUFuncName.adoc[`getInstrProfInstrumentGPUFuncName`] 
| Return the name of the GPU wave&hyphen;cooperative counter increment helper&period;
| xref:llvm/getInstrProfNameSeparator.adoc[`getInstrProfNameSeparator`] 
| Return the marker used to separate PGO names during serialization&period;
| xref:llvm/getInstrProfNameVarPrefix.adoc[`getInstrProfNameVarPrefix`] 
| Return the name prefix of variables containing instrumented function names&period;
| xref:llvm/getInstrProfNamesRegFuncName.adoc[`getInstrProfNamesRegFuncName`] 
| Return the name of the runtime interface that registers the PGO name strings&period;
| xref:llvm/getInstrProfNamesVarName.adoc[`getInstrProfNamesVarName`] 
| Return the name of the variable holding the strings (possibly compressed) of all function&apos;s PGO names&period;
| xref:llvm/getInstrProfNamesVarPostfixVarName.adoc[`getInstrProfNamesVarPostfixVarName`] 
| Return the name of the post&hyphen;fix marker for the PGO names variable&period;
| xref:llvm/getInstrProfRegFuncName.adoc[`getInstrProfRegFuncName`] 
| Return the name of the runtime interface that registers per&hyphen;function control data for one instrumented function&period;
| xref:llvm/getInstrProfRegFuncsName.adoc[`getInstrProfRegFuncsName`] 
| Return the name of the function that registers per&hyphen;function control data&period;
| xref:llvm/getInstrProfRuntimeHookVarName.adoc[`getInstrProfRuntimeHookVarName`] 
| Return the name of the profile runtime hook variable&period;
| xref:llvm/getInstrProfRuntimeHookVarUseFuncName.adoc[`getInstrProfRuntimeHookVarUseFuncName`] 
| Return the name of the compiler generated function that references the runtime hook variable&period; The function is a weak global&period;
| xref:llvm/getInstrProfSectionName.adoc[`getInstrProfSectionName`] 
| Return the name of the profile section corresponding to `IPSK&period;`
| xref:llvm/getInstrProfVNodesVarName.adoc[`getInstrProfVNodesVarName`] 
| Return the name of value profile node array variables&colon;
| xref:llvm/getInstrProfVTableNamesVarName.adoc[`getInstrProfVTableNamesVarName`] 
| Return the name of the variable holding (possibly compressed) vtable names&period;
| xref:llvm/getInstrProfVTableVarPrefix.adoc[`getInstrProfVTableVarPrefix`] 
| Return the name prefix of variables containing virtual table profile data&period;
| xref:llvm/getInstrProfValueProfFuncName.adoc[`getInstrProfValueProfFuncName`] 
| Return the name profile runtime entry point to do value profiling for a given site&period;
| xref:llvm/getInstrProfValueProfMemOpFuncName.adoc[`getInstrProfValueProfMemOpFuncName`] 
| Return the name profile runtime entry point to do memop size value profiling&period;
| xref:llvm/getInstrProfValuesVarPrefix.adoc[`getInstrProfValuesVarPrefix`] 
| Return the name prefix of value profile variables&period;
| xref:llvm/getInstrProfVarPrefix.adoc[`getInstrProfVarPrefix`] 
| Return the prefix of the name of the variables to function as a filter&period;
| xref:llvm/getIntDivCycle.adoc[`getIntDivCycle`] 
| Return the outermost cycle made divergent by branch inside it&period;
| xref:llvm/getIntLoopAttribute.adoc[`getIntLoopAttribute`] 
| Find named metadata for a loop with an integer value&period; Return `Default` if not set&period;
| xref:llvm/getInterleaveIntrinsicFactor.adoc[`getInterleaveIntrinsicFactor`] 
| Returns the corresponding factor of llvm&period;vector&period;interleaveN intrinsics&period;
| xref:llvm/getInternalReadRegState.adoc[`getInternalReadRegState`] 
| Return `InternalRead` when `B` is true, else `RegState&colon;&colon;NoFlags&period;`
| xref:llvm/getIntrinsicForCallSite.adoc[`getIntrinsicForCallSite`] 
| Map a call instruction to an intrinsic ID&period; Libcalls which have equivalent intrinsics are treated as&hyphen;if they were intrinsics&period;
| xref:llvm/getInverseGMinMaxOpcode.adoc[`getInverseGMinMaxOpcode`] 
| Returns the inverse opcode of `MinMaxOpc,` which is a generic min&sol;max opcode like G&lowbar;SMIN&period;
| xref:llvm/getInverseMinMaxFlavor.adoc[`getInverseMinMaxFlavor`] 
| Return the inverse minimum&sol;maximum flavor of the specified flavor&period; For example, signed minimum is the inverse of signed maximum&period;
| xref:llvm/getInverseMinMaxIntrinsic.adoc[`getInverseMinMaxIntrinsic`] 
| Return the inverse min&sol;max intrinsic of `MinMaxID&period;`
| xref:llvm/getKCFITypeID.adoc[`getKCFITypeID`] 
| Compute KCFI type ID from mangled type name&period; The algorithm can be xxHash64 or FNV&hyphen;1a&period;
| xref:llvm/getKillRegState.adoc[`getKillRegState`] 
| Return `RegState&colon;&colon;Kill` when `B` is true, else `RegState&colon;&colon;NoFlags&period;`
| xref:llvm/getKnowledgeForValue.adoc[`getKnowledgeForValue`] 
| Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and it matches the Filter&period;
| xref:llvm/getKnowledgeFromBundle.adoc[`getKnowledgeFromBundle`] 
| This extracts the Knowledge from an element of an operand bundle&period; This is mostly for use in the assume builder&period;
| xref:llvm/getKnowledgeFromUse.adoc[`getKnowledgeFromUse`] 
| Return a valid Knowledge associated to the Use U if its Attribute kind is in AttrKinds&period;
| xref:llvm/getKnowledgeValidInContext.adoc[`getKnowledgeValidInContext`] 
| Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and the knowledge is suitable to be used in the context of CtxI&period;
| xref:llvm/getKnownAlignment.adoc[`getKnownAlignment`] 
| Infer a known alignment for the specified pointer&period;
| xref:llvm/getKnownAssumptionStrings.adoc[`getKnownAssumptionStrings`] 
| A set of known assumption strings that are accepted without warning and which can be recommended as typo correction&period;
| xref:llvm/getLCMType.adoc[`getLCMType`] 
| Return the least common multiple type of `OrigTy` and `TargetTy&period;`
| xref:llvm/getLLTForMVT.adoc[`getLLTForMVT`] 
| Get a rough equivalent of an LLT for a given MVT&period; LLT does not yet support scalarable vector types, and will assert if used&period;
| xref:llvm/getLLTForType.adoc[`getLLTForType`] 
| Construct a low&hyphen;level type based on an LLVM type&period;
| xref:llvm/getLazyBitcodeModule.adoc[`getLazyBitcodeModule`] 
| Read bitcode and prepare a module for lazy function deserialization&period;
| xref:llvm/getLazyIRFileModule.adoc[`getLazyIRFileModule`] 
| Create a Module from a file, with lazy function&hyphen;body loading for bitcode&period;
| xref:llvm/getLazyIRModule.adoc[`getLazyIRModule`] 
| Create a Module from a MemoryBuffer, with lazy function&hyphen;body loading for bitcode&period;
| xref:llvm/getLibcallLowering.adoc[`getLibcallLowering`] 
| Resolve the LibcallLoweringInfo for `Subtarget` from the module&hyphen;level `ModuleInfo,` applying the subtarget&apos;s libcall overrides&period;
| xref:llvm/getLoadStoreAddressSpace.adoc[`getLoadStoreAddressSpace`] 
| Return the address space of the pointer operand of load or store `I&period;`
| xref:llvm/getLoadStoreAlignment.adoc[`getLoadStoreAlignment`] 
| Return the alignment of load or store instruction `I&period;`
| xref:llvm/getLoadStorePointerOperand-0a.adoc[`getLoadStorePointerOperand`] 
| Return the pointer operand of a load or store, or null if `V` is neither&period;
| xref:llvm/getLoadStoreType.adoc[`getLoadStoreType`] 
| Return the value type accessed by load or store instruction `I&period;`
| xref:llvm/getLongDoubleFormatName.adoc[`getLongDoubleFormatName`] 
| Returns the IR floating&hyphen;point type name for a LongDoubleFormat&period;
| xref:llvm/getLoopAnalysisUsage.adoc[`getLoopAnalysisUsage`] 
| Helper to consistently add the set of standard passes to a loop pass&apos;s `AnalysisUsage&period;`
| xref:llvm/getLoopConvergenceHeart.adoc[`getLoopConvergenceHeart`] 
| Find the convergence heart of the loop&period;
| xref:llvm/getLoopEstimatedTripCount.adoc[`getLoopEstimatedTripCount`] 
| Return an estimated trip count for `L,` or std&colon;&colon;nullopt if unavailable&period;
| xref:llvm/getLoopPassPreservedAnalyses.adoc[`getLoopPassPreservedAnalyses`] 
| Returns the minimum set of Analyses that all loop passes must preserve&period;
| xref:llvm/getLoopProbability.adoc[`getLoopProbability`] 
| Return the probability that the latch of `L` continues the loop&period;
| xref:llvm/getLoopVectorizeKindPrefix.adoc[`getLoopVectorizeKindPrefix`] 
| Return a short prefix describing the loop&apos;s vectorizer origin&period;
| xref:llvm/getLosslessInvCast.adoc[`getLosslessInvCast`] 
| Try to cast C to InvC losslessly, satisfying CastOp(InvC) equals C, or CastOp(InvC) is a refined value of undefined C&period; Will try best to preserve the flags&period;
| xref:llvm/getLosslessSignedTrunc.adoc[`getLosslessSignedTrunc`] 
| Compute a lossless inverse of a signed extend (sext) of `C&period;`
| xref:llvm/getLosslessUnsignedTrunc.adoc[`getLosslessUnsignedTrunc`] 
| Compute a lossless inverse of an unsigned extend (zext) of `C&period;`
| xref:llvm/getMVTForLLT.adoc[`getMVTForLLT`] 
| Get a rough equivalent of an MVT for a given LLT&period; MVT can&apos;t distinguish pointers, so these will convert to a plain integer&period;
| xref:llvm/getMachineArchType.adoc[`getMachineArchType`] 
| Map a COFF machine type to a Triple architecture&period;
| xref:llvm/getMachineFunctionPassPreservedAnalyses.adoc[`getMachineFunctionPassPreservedAnalyses`] 
| Returns the minimum set of Analyses that all machine function passes must preserve&period;
| xref:llvm/getMachineType.adoc[`getMachineType`] 
| Map a `&sol;machine` flag argument to a COFF machine type&period;
| xref:llvm/getMaxFreq.adoc[`getMaxFreq`] 
| Return the maximum frequency of a basic block in a function&period;
| xref:llvm/getMemCacheHintMetadata.adoc[`getMemCacheHintMetadata`] 
| Return the cache hint metadata node for a memory operand&period;
| xref:llvm/getMergedAtomicOrdering.adoc[`getMergedAtomicOrdering`] 
| Return a single atomic ordering that is at least as strong as both the `AO` and `Other` orderings for an atomic operation&period;
| xref:llvm/getMetadataToPropagate.adoc[`getMetadataToPropagate`] 
| Collect metadata from `Inst` that can be preserved after vectorization&period;
| xref:llvm/getMinMaxIntrinsic.adoc[`getMinMaxIntrinsic`] 
| Convert given `SPF` to equivalent min&sol;max intrinsic&period; Caller must ensure `SPF` is an integer min or max pattern&period;
| xref:llvm/getMinMaxLimit.adoc[`getMinMaxLimit`] 
| Return the minimum or maximum constant value for the specified integer min&sol;max flavor and type&period;
| xref:llvm/getMinMaxPred.adoc[`getMinMaxPred`] 
| Return the canonical comparison predicate for the specified minimum&sol;maximum flavor&period;
| xref:llvm/getMinMaxReductionIntrinsicID.adoc[`getMinMaxReductionIntrinsicID`] 
| Returns the llvm&period;vector&period;reduce min&sol;max intrinsic that corresponds to the intrinsic op&period;
| xref:llvm/getMinMaxReductionIntrinsicOp-0c.adoc[`getMinMaxReductionIntrinsicOp`] 
| Returns the min&sol;max intrinsic used when expanding a min&sol;max reduction&period;
| xref:llvm/getMinMaxReductionPredicate.adoc[`getMinMaxReductionPredicate`] 
| Returns the comparison predicate used when expanding a min&sol;max reduction&period;
| xref:llvm/getMinMaxReductionRecurKind.adoc[`getMinMaxReductionRecurKind`] 
| Returns the recurence kind used when expanding a min&sol;max reduction&period;
| xref:llvm/getModuleSummaryIndex.adoc[`getModuleSummaryIndex`] 
| Parse the specified bitcode buffer, returning the module summary index&period;
| xref:llvm/getModuleSummaryIndexForFile.adoc[`getModuleSummaryIndexForFile`] 
| Parse the module summary index out of an IR file&period;
| xref:llvm/getNameFromBundleAttr.adoc[`getNameFromBundleAttr`] 
| Return the string name of the given operand&hyphen;bundle attribute kind&period;
| xref:llvm/getNextAvailablePluginDiagnosticKind.adoc[`getNextAvailablePluginDiagnosticKind`] 
| Return the next available kind ID for a plugin diagnostic&period;
| xref:llvm/getNoCommonBitsSetResult.adoc[`getNoCommonBitsSetResult`] 
| Return how strongly LHS and RHS are known to have no common set bits&period;
| xref:llvm/getNonFoldableAlwaysTrue.adoc[`getNonFoldableAlwaysTrue`] 
| Return a constant true value that the compiler cannot fold&period;
| xref:llvm/getNumBranchWeights.adoc[`getNumBranchWeights`] 
| Return the number of branch weights stored in `ProfileData`
| xref:llvm/getNumBytesForUTF8.adoc[`getNumBytesForUTF8`] 
| Returns the expected byte length of a UTF&hyphen;8 sequence from its first byte&period;
| xref:llvm/getNumOfCalls.adoc[`getNumOfCalls`] 
| Return the number of calls of `CalledFunction` by `CallerFunction&period;`
| xref:llvm/getObjCNamesIfSelector.adoc[`getObjCNamesIfSelector`] 
| Parses an Objective&hyphen;C selector name into its component parts&period;
| xref:llvm/getObjectSize.adoc[`getObjectSize`] 
| Compute the size of the object pointed by Ptr&period;
| xref:llvm/getOpcodeDef-06.adoc[`getOpcodeDef`] 
| `getOpcodeDef` overloads
| xref:llvm/getOptionalBoolLoopAttribute.adoc[`getOptionalBoolLoopAttribute`] 
| Return the optional boolean value of loop attribute `Name` on `TheLoop&period;`
| xref:llvm/getOptionalElementCountLoopAttribute.adoc[`getOptionalElementCountLoopAttribute`] 
| Build an ElementCount from loop vectorize width metadata, if present&period;
| xref:llvm/getOptionalIntLoopAttribute.adoc[`getOptionalIntLoopAttribute`] 
| Find named metadata for a loop with an integer value&period;
| xref:llvm/getOrCreateFunctionComdat.adoc[`getOrCreateFunctionComdat`] 
| Return `F&apos;s` comdat, creating and attaching one when missing&period;
| xref:llvm/getOrCreateSanitizerCtorAndInitFunctions.adoc[`getOrCreateSanitizerCtorAndInitFunctions`] 
| Creates sanitizer constructor and init functions lazily&period;
| xref:llvm/getOrEnforceKnownAlignment.adoc[`getOrEnforceKnownAlignment`] 
| Return a known alignment for a value, optionally raising it first&period;
| xref:llvm/getOrInsertLibFunc-0d.adoc[`getOrInsertLibFunc`] 
| `getOrInsertLibFunc` overloads
| xref:llvm/getOrderedReduction.adoc[`getOrderedReduction`] 
| Generates an ordered vector reduction using extracts to reduce the value&period;
| xref:llvm/getOrdinalSuffix.adoc[`getOrdinalSuffix`] 
| Returns the English suffix for an ordinal integer (&hyphen;st, &hyphen;nd, &hyphen;rd, &hyphen;th)&period;
| xref:llvm/getOutermostDivergentCycle.adoc[`getOutermostDivergentCycle`] 
| Return the outermost cycle made divergent by a join of paths from `DivTermBlock` through `JoinBlock&period;`
| xref:llvm/getOwningLazyBitcodeModule.adoc[`getOwningLazyBitcodeModule`] 
| Like getLazyBitcodeModule, but the module owns the memory buffer&period;
| xref:llvm/getPGOFuncName-06.adoc[`getPGOFuncName`] 
| `getPGOFuncName` overloads
| xref:llvm/getPGOFuncNameMetadata.adoc[`getPGOFuncNameMetadata`] 
| Return the PGOFuncName metadata node associated with function `F&period;`
| xref:llvm/getPGOFuncNameMetadataName.adoc[`getPGOFuncNameMetadataName`] 
| Return the metadata kind name used for legacy PGO function names&period;
| xref:llvm/getPGOFuncNameVarInitializer.adoc[`getPGOFuncNameVarInitializer`] 
| Return the string initializer of PGO name variable `NameVar&period;`
| xref:llvm/getPGOFuncNameVarName.adoc[`getPGOFuncNameVarName`] 
| Return the global variable name used to store a PGO function name&period;
| xref:llvm/getPGOName.adoc[`getPGOName`] 
| Return the PGO name for global variable `V&period;`
| xref:llvm/getPGONameMetadataName.adoc[`getPGONameMetadataName`] 
| Return the metadata kind name used for PGO global&hyphen;object names&period;
| xref:llvm/getParsedIRPGOName.adoc[`getParsedIRPGOName`] 
| Parse a filename and function name from an IRPGO name string&period;
| xref:llvm/getPassTimer.adoc[`getPassTimer`] 
| Request the timer for this legacy&hyphen;pass&hyphen;manager&apos;s pass instance&period;
| xref:llvm/getPointerAtOffset.adoc[`getPointerAtOffset`] 
| Find a trivial pointer located at a byte offset within a constant&period;
| xref:llvm/getPointerAuthStableSipHash.adoc[`getPointerAuthStableSipHash`] 
| Compute a stable non&hyphen;zero 16&hyphen;bit hash of the given string&period;
| xref:llvm/getPointerOperand-01b.adoc[`getPointerOperand`] 
| `getPointerOperand` overloads
| xref:llvm/getPointersDiff.adoc[`getPointersDiff`] 
| Returns the distance between compatible pointers `PtrA` and `PtrB&period;`
| xref:llvm/getPredForFCmpCode.adoc[`getPredForFCmpCode`] 
| Convert a predicate code into a constant or an FCmp predicate&period;
| xref:llvm/getPredForICmpCode.adoc[`getPredForICmpCode`] 
| Convert a predicate code into a constant or an ICmp predicate&period;
| xref:llvm/getPrefetchTargetSymbolName.adoc[`getPrefetchTargetSymbolName`] 
| Return the symbol name for a prefetch target&period;
| xref:llvm/getPtrStride-0d.adoc[`getPtrStride`] 
| `getPtrStride` overloads
| xref:llvm/getRandomBytes.adoc[`getRandomBytes`] 
| Fills a buffer with random bytes from the operating system&period;
| xref:llvm/getReallocatedOperand.adoc[`getReallocatedOperand`] 
| If this is a call to a realloc function, return the reallocated operand&period;
| xref:llvm/getRecurrenceIdentity.adoc[`getRecurrenceIdentity`] 
| Given information about an recurrence kind, return the identity for the llvm&period;vector&period;reduce&period;&ast; used to generate it&period;
| xref:llvm/getReductionForBinop.adoc[`getReductionForBinop`] 
| Returns the reduction intrinsic id corresponding to the binary operation&period;
| xref:llvm/getReductionIdentity.adoc[`getReductionIdentity`] 
| Given information about an llvm&period;vector&period;reduce&period;&ast; intrinsic, return the identity value for the reduction&period;
| xref:llvm/getReductionIntrinsicID.adoc[`getReductionIntrinsicID`] 
| Returns the llvm&period;vector&period;reduce intrinsic that corresponds to the recurrence kind&period;
| xref:llvm/getRegState.adoc[`getRegState`] 
| Get all register state flags from machine operand `RegOp&period;`
| xref:llvm/getReleaseModeAdvisor.adoc[`getReleaseModeAdvisor`] 
| Create a release&hyphen;mode (compiled&hyphen;in model) InlineAdvisor for `M&period;`
| xref:llvm/getRenamableRegState.adoc[`getRenamableRegState`] 
| Return `Renamable` when `B` is true, else `RegState&colon;&colon;NoFlags&period;`
| xref:llvm/getReplayInlineAdvisor.adoc[`getReplayInlineAdvisor`] 
| Create a replay inline advisor that consults prior inlining remarks&period;
| xref:llvm/getSLEB128Size.adoc[`getSLEB128Size`] 
| Utility function to get the size of the SLEB128&hyphen;encoded value&period;
| xref:llvm/getScope-0a.adoc[`getScope`] 
| `getScope` overloads
| xref:llvm/getSelectPattern.adoc[`getSelectPattern`] 
| Determine the pattern for predicate `X Pred Y ? X &colon; Y`&period;
| xref:llvm/getSelectionDAGFallbackAnalysisUsage.adoc[`getSelectionDAGFallbackAnalysisUsage`] 
| Modify analysis usage so it preserves passes required for the SelectionDAG fallback&period;
| xref:llvm/getShuffleDemandedElts.adoc[`getShuffleDemandedElts`] 
| Map a shuffle&apos;s demanded outputs to demanded elements of its operands&period;
| xref:llvm/getShuffleMaskWithWidestElts.adoc[`getShuffleMaskWithWidestElts`] 
| Repetitively apply `widenShuffleMaskElts()` for as long as it succeeds, to get the shuffle mask with widest possible elements&period;
| xref:llvm/getShuffleReduction.adoc[`getShuffleReduction`] 
| Generates a vector reduction using shufflevectors to reduce the value&period; Fast&hyphen;math&hyphen;flags are propagated using the IRBuilder&apos;s setting&period;
| xref:llvm/getSingleElement.adoc[`getSingleElement`] 
| Assert that `C` has a single element and return that element&period;
| xref:llvm/getSipHash_2_4_128.adoc[`getSipHash&lowbar;2&lowbar;4&lowbar;128`] 
| Computes a SipHash&hyphen;2&hyphen;4 128&hyphen;bit result&period;
| xref:llvm/getSipHash_2_4_64.adoc[`getSipHash&lowbar;2&lowbar;4&lowbar;64`] 
| Computes a SipHash&hyphen;2&hyphen;4 64&hyphen;bit result&period;
| xref:llvm/getSplatIndex-0e.adoc[`getSplatIndex`] 
| `getSplatIndex` overloads
| xref:llvm/getSplatValue.adoc[`getSplatValue`] 
| Get splat value if the input is a splat vector or return nullptr&period;
| xref:llvm/getSrcRegIgnoringCopies.adoc[`getSrcRegIgnoringCopies`] 
| Find the source register for `Reg,` folding away any trivial copies&period;
| xref:llvm/getStableSipHash.adoc[`getStableSipHash`] 
| Compute a stable 64&hyphen;bit hash of the given string&period;
| xref:llvm/getStackPointer.adoc[`getStackPointer`] 
| The value is not guaranteed to point to anything specific&period; It can be used to estimate how much stack space has been used since the previous call&period;
| xref:llvm/getStandardCSEConfigForOpt.adoc[`getStandardCSEConfigForOpt`] 
| Return the standard CSEConfig for the given optimization level&period;
| xref:llvm/getStartAndEndForAccess-01.adoc[`getStartAndEndForAccess`] 
| `getStartAndEndForAccess` overloads
| xref:llvm/getStrideFromAddRec.adoc[`getStrideFromAddRec`] 
| Return the constant step of affine AddRec `AR` in units of `AccessTy&period;`
| xref:llvm/getStringFnAttrAsInt.adoc[`getStringFnAttrAsInt`] 
| Parse a function string attribute on `CB` as a decimal integer&period;
| xref:llvm/getSwappedBytes.adoc[`getSwappedBytes`] 
| Needed by swapByteOrder()&period;
| xref:llvm/getSyncEffects.adoc[`getSyncEffects`] 
| Get ModRefInfo for a synchronizing operation, such as a fence or stronger than monotonic atomic load&sol;store&period;
| xref:llvm/getTensorSpecFromJSON.adoc[`getTensorSpecFromJSON`] 
| Construct a TensorSpec from a JSON dictionary describing the tensor&period;
| xref:llvm/getTimeTraceProfilerInstance.adoc[`getTimeTraceProfilerInstance`] 
| Return the time&hyphen;trace profiler for the current thread, or null if none&period;
| xref:llvm/getToken.adoc[`getToken`] 
| Extract one token from `Source` using the characters in `Delimiters&period;`
| xref:llvm/getTypeForLLT.adoc[`getTypeForLLT`] 
| Get the type back from LLT&period; It won&apos;t be 100 percent accurate but returns an estimate of the type&period;
| xref:llvm/getTypeName.adoc[`getTypeName`] 
| We provide a function which tries to compute the (demangled) name of a type statically&period;
| xref:llvm/getULEB128Size.adoc[`getULEB128Size`] 
| Utility function to get the size of the ULEB128&hyphen;encoded value&period;
| xref:llvm/getUTF8SequenceSize.adoc[`getUTF8SequenceSize`] 
| Returns the byte length of the first UTF&hyphen;8 sequence, or 0 if it is invalid&period;
| xref:llvm/getUndefRegState.adoc[`getUndefRegState`] 
| Return `RegState&colon;&colon;Undef` when `B` is true, else `RegState&colon;&colon;NoFlags&period;`
| xref:llvm/getUnderlyingObject-05.adoc[`getUnderlyingObject`] 
| `getUnderlyingObject` overloads
| xref:llvm/getUnderlyingObjectAggressive.adoc[`getUnderlyingObjectAggressive`] 
| Like getUnderlyingObject(), but will try harder to find a single underlying object&period; In particular, this function also looks through selects and phis&period;
| xref:llvm/getUnderlyingObjects.adoc[`getUnderlyingObjects`] 
| This method is similar to getUnderlyingObject except that it can look through phi and select instructions and return multiple objects&period;
| xref:llvm/getUnderlyingObjectsForCodeGen.adoc[`getUnderlyingObjectsForCodeGen`] 
| This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint&plus;arithmetic&plus;inttoptr sequences&period;
| xref:llvm/getUniqueExitBlocksHelper.adoc[`getUniqueExitBlocksHelper`] 
| Append unique exit blocks of `L` whose sources satisfy `Pred&period;`
| xref:llvm/getUniqueInternalLinkagePostfix.adoc[`getUniqueInternalLinkagePostfix`] 
| Build a unique&hyphen;internal&hyphen;linkage post&hyphen;fix hash for `FName&period;`
| xref:llvm/getUniqueModuleId.adoc[`getUniqueModuleId`] 
| Produce a unique identifier for this module by taking the MD5 sum of the names of the module&apos;s strong external symbols that are not comdat members&period;
| xref:llvm/getUnrollMetadataForLoop.adoc[`getUnrollMetadataForLoop`] 
| Return the named unroll hint metadata node attached to loop `L&period;`
| xref:llvm/getVScaleRange.adoc[`getVScaleRange`] 
| Determine the possible constant range of vscale with the given bit width, based on the vscale&lowbar;range function attribute&period;
| xref:llvm/getValidBranchWeightMDNode.adoc[`getValidBranchWeightMDNode`] 
| Get the valid branch weights metadata node
| xref:llvm/getValueProfDataFromInst.adoc[`getValueProfDataFromInst`] 
| Extract value&hyphen;profile data annotated on instruction `Inst&period;`
| xref:llvm/getVectorIntrinsicIDForCall.adoc[`getVectorIntrinsicIDForCall`] 
| Return the intrinsic ID mapped from a call, or not&lowbar;intrinsic&period;
| xref:llvm/getVectorSplat.adoc[`getVectorSplat`] 
| Examples&colon;
| xref:llvm/getVectorizedTypeVF.adoc[`getVectorizedTypeVF`] 
| Returns the number of vector elements for a vectorized type&period;
| xref:llvm/getVisibleToRegularObjVtableGUIDs.adoc[`getVisibleToRegularObjVtableGUIDs`] 
| Collect GUIDs of vtables visible to regular object files&period;
| xref:llvm/getWeakLeft.adoc[`getWeakLeft`] 
| Return the number of unresolved weak edges for `SU&period;`
| xref:llvm/getWeightFromBranchProb.adoc[`getWeightFromBranchProb`] 
| Convert a branch probability into an unscaled edge weight&period;
| xref:llvm/get_array_pod_sort_comparator.adoc[`get&lowbar;array&lowbar;pod&lowbar;sort&lowbar;comparator`] 
| Return the qsort comparator for elements of type `T&period;`
| xref:llvm/get_cpus.adoc[`get&lowbar;cpus`] 
| Returns how many physical CPUs or NUMA groups the system has&period;
| xref:llvm/get_max_thread_name_length.adoc[`get&lowbar;max&lowbar;thread&lowbar;name&lowbar;length`] 
| Get the maximum length of a thread name on this platform&period; A value of 0 means there is no limit&period;
| xref:llvm/get_physical_cores.adoc[`get&lowbar;physical&lowbar;cores`] 
| Return the number of physical cores on the host, or &hyphen;1 if unknown&period;
| xref:llvm/get_stable_name.adoc[`get&lowbar;stable&lowbar;name`] 
| Strip LLVM&hyphen;introduced suffixes so the name is stable across builds&period;
| xref:llvm/get_thread_affinity_mask.adoc[`get&lowbar;thread&lowbar;affinity&lowbar;mask`] 
| Return a mask of hardware units the calling thread may run on&period;
| xref:llvm/get_thread_name.adoc[`get&lowbar;thread&lowbar;name`] 
| Get the name of the current thread&period;
| xref:llvm/get_threadid.adoc[`get&lowbar;threadid`] 
| Return the current thread id, as used in various OS system calls&period;
| xref:llvm/get_threadpool_strategy.adoc[`get&lowbar;threadpool&lowbar;strategy`] 
| Build a strategy from a number of threads as a string provided in `Num&period;`
| xref:llvm/guessSuccessors.adoc[`guessSuccessors`] 
| Guess likely successors of a machine basic block from its operands&period;
| xref:llvm/handleAllErrors-0d.adoc[`handleAllErrors`] 
| `handleAllErrors` overloads
| xref:llvm/handleErrorImpl-07.adoc[`handleErrorImpl`] 
| `handleErrorImpl` overloads
| xref:llvm/handleErrors.adoc[`handleErrors`] 
| Pass ErrorInfo payloads in `E` to matching handlers among `Handlers&period;`
| xref:llvm/handleExecNameEncodedBEOpts.adoc[`handleExecNameEncodedBEOpts`] 
| Handle backend options that are encoded in the executable name&period;
| xref:llvm/handleExecNameEncodedOptimizerOpts.adoc[`handleExecNameEncodedOptimizerOpts`] 
| Handle optimizer options which are encoded in the executable name&period; Same semantics as in &apos;handleExecNameEncodedBEOpts&apos;&period;
| xref:llvm/handleExpected.adoc[`handleExpected`] 
| Handle any errors (if present) in an Expected&lt;T&gt;, then try a recovery path&period;
| xref:llvm/handleUnreachableTerminator.adoc[`handleUnreachableTerminator`] 
| Replace instruction operands of an unreachable terminator with poison&period;
| xref:llvm/hardware_concurrency-0b.adoc[`hardware&lowbar;concurrency`] 
| `hardware&lowbar;concurrency` overloads
| xref:llvm/hasAssumption-0d.adoc[`hasAssumption`] 
| `hasAssumption` overloads
| xref:llvm/hasBranchWeightMD.adoc[`hasBranchWeightMD`] 
| Checks if an instructions has Branch Weight Metadata
| xref:llvm/hasBranchWeightOrigin-01.adoc[`hasBranchWeightOrigin`] 
| Check if Branch Weight Metadata has an &quot;expected&quot; field from an llvm&period;expect&ast; intrinsic
| xref:llvm/hasDisableAllTransformsHint.adoc[`hasDisableAllTransformsHint`] 
| Look for the loop attribute that disables all transformation heuristic&period;
| xref:llvm/hasDisableLICMTransformsHint.adoc[`hasDisableLICMTransformsHint`] 
| Look for the loop attribute that disables the LICM transformation heuristics&period;
| xref:llvm/hasDistributeTransformation.adoc[`hasDistributeTransformation`] 
| Get the distribute transformation mode for `L&period;`
| xref:llvm/hasExplicitlyUnknownBranchWeights.adoc[`hasExplicitlyUnknownBranchWeights`] 
| Check whether `I` has explicitly&hyphen;unknown branch&hyphen;weight metadata&period;
| xref:llvm/hasFloatFn.adoc[`hasFloatFn`] 
| Check whether the overloaded floating point function corresponding to Ty is available&period;
| xref:llvm/hasInstrProfHashMismatch.adoc[`hasInstrProfHashMismatch`] 
| Return whether the function has an instrumented&hyphen;profile hash mismatch&period;
| xref:llvm/hasIterationCountInvariantInParent.adoc[`hasIterationCountInvariantInParent`] 
| Check inner loop (L) backedge count is known to be invariant on all iterations of its outer loop&period; If the loop has no parent, this is trivially true&period;
| xref:llvm/hasLICMVersioningTransformation.adoc[`hasLICMVersioningTransformation`] 
| Get the LICM versioning transformation mode for `L&period;`
| xref:llvm/hasLessThanNumFused.adoc[`hasLessThanNumFused`] 
| Checks if the number of cluster edges between SU and its predecessors is less than FuseLimit&period;
| xref:llvm/hasMustProgress.adoc[`hasMustProgress`] 
| Return true if the loop itself has the mustprogress attribute&period;
| xref:llvm/hasNItems-00.adoc[`hasNItems`] 
| `hasNItems` overloads
| xref:llvm/hasNItemsOrLess-0a.adoc[`hasNItemsOrLess`] 
| `hasNItemsOrLess` overloads
| xref:llvm/hasNItemsOrMore-0a.adoc[`hasNItemsOrMore`] 
| `hasNItemsOrMore` overloads
| xref:llvm/hasPartialIVCondition.adoc[`hasPartialIVCondition`] 
| Detect a partially invariant header condition suitable for unswitching&period;
| xref:llvm/hasProfMD.adoc[`hasProfMD`] 
| Checks if an Instruction has MD&lowbar;prof Metadata
| xref:llvm/hasRegState.adoc[`hasRegState`] 
| Return true if `Value` includes every flag in `Test&period;`
| xref:llvm/hasSingleElement.adoc[`hasSingleElement`] 
| Return true if `C` contains exactly one element&period;
| xref:llvm/hasUTF16ByteOrderMark.adoc[`hasUTF16ByteOrderMark`] 
| Returns true if a blob of text starts with a UTF&hyphen;16 big or little endian byte order mark&period;
| xref:llvm/hasUnrollAndJamTransformation.adoc[`hasUnrollAndJamTransformation`] 
| Get the unroll&hyphen;and&hyphen;jam transformation mode for `L&period;`
| xref:llvm/hasUnrollTransformation.adoc[`hasUnrollTransformation`] 
| Get the unroll transformation mode for `L&period;`
| xref:llvm/hasValidBranchWeightMD.adoc[`hasValidBranchWeightMD`] 
| Checks if an instructions has valid Branch Weight Metadata
| xref:llvm/hasVectorizeTransformation.adoc[`hasVectorizeTransformation`] 
| Get the vectorize transformation mode for `L&period;`
| xref:llvm/hasWholeProgramVisibility.adoc[`hasWholeProgramVisibility`] 
| Return whether whole&hyphen;program visibility is enabled for this LTO link&period;
| xref:llvm/has_single_bit.adoc[`has&lowbar;single&lowbar;bit`] 
| Return true if `Value` is a non&hyphen;zero power of two&period;
| xref:llvm/hash_combine.adoc[`hash&lowbar;combine`] 
| Combine values into a single hash&lowbar;code&period;
| xref:llvm/hash_combine_range-01.adoc[`hash&lowbar;combine&lowbar;range`] 
| `hash&lowbar;combine&lowbar;range` overloads
| xref:llvm/hash_value-0c0.adoc[`hash&lowbar;value`] 
| `hash&lowbar;value` overloads
| xref:llvm/haveNoCommonBitsSet.adoc[`haveNoCommonBitsSet`] 
| Return true if LHS and RHS have no common bits set&period;
| xref:llvm/heavyweight_hardware_concurrency-06.adoc[`heavyweight&lowbar;hardware&lowbar;concurrency`] 
| `heavyweight&lowbar;hardware&lowbar;concurrency` overloads
| xref:llvm/hexDigitValue.adoc[`hexDigitValue`] 
| Interpret the given character `C` as a hexadecimal digit and return its value&period;
| xref:llvm/hexFromNibbles.adoc[`hexFromNibbles`] 
| Return the binary representation of the two provided values, `MSB` and `LSB,` that make up the nibbles of a hexadecimal digit&period;
| xref:llvm/hexdigit.adoc[`hexdigit`] 
| Return the hexadecimal character for the given number `X` (which should be less than 16)&period;
| xref:llvm/hoistAllInstructionsInto.adoc[`hoistAllInstructionsInto`] 
| Hoist all instructions from a block into a dominating insertion point&period;
| xref:llvm/hoistRegion.adoc[`hoistRegion`] 
| Hoist invariant instructions into a loop preheader in DFS order&period;
| xref:llvm/identifyNoAliasScopesToClone-06.adoc[`identifyNoAliasScopesToClone`] 
| `identifyNoAliasScopesToClone` overloads
| xref:llvm/identify_magic-0e.adoc[`identify&lowbar;magic`] 
| `identify&lowbar;magic` overloads
| xref:llvm/idf_begin.adoc[`idf&lowbar;begin`] 
| Return an inverse depth&hyphen;first iterator at the entry of `G&period;`
| xref:llvm/idf_end.adoc[`idf&lowbar;end`] 
| Return a past&hyphen;the&hyphen;end inverse depth&hyphen;first iterator for `G&period;`
| xref:llvm/idf_ext_begin.adoc[`idf&lowbar;ext&lowbar;begin`] 
| Return an external inverse depth&hyphen;first iterator at the entry of `G&period;`
| xref:llvm/idf_ext_end.adoc[`idf&lowbar;ext&lowbar;end`] 
| Return a past&hyphen;the&hyphen;end external inverse depth&hyphen;first iterator for `G&period;`
| xref:llvm/ilogb.adoc[`ilogb`] 
| Returns the exponent of the internal representation of the APFloat&period;
| xref:llvm/impliesPoison.adoc[`impliesPoison`] 
| Return true if V is poison given that ValAssumedPoison is already poison&period;
| xref:llvm/includes-0f.adoc[`includes`] 
| Return true if sorted `Range2` is a subsequence of sorted `Range1&period;`
| xref:llvm/includesPoison.adoc[`includesPoison`] 
| Returns true if `Kind` includes the Poison bit&period;
| xref:llvm/includesUndef.adoc[`includesUndef`] 
| Returns true if `Kind` includes the Undef bit&period;
| xref:llvm/inconvertibleErrorCode.adoc[`inconvertibleErrorCode`] 
| Return an inconvertible sentinel `std&colon;&colon;error&lowbar;code&period;`
| xref:llvm/inferAlignFromPtrInfo.adoc[`inferAlignFromPtrInfo`] 
| Infer an alignment from machine pointer info for a memory access&period;
| xref:llvm/inferAttributesFromOthers.adoc[`inferAttributesFromOthers`] 
| Materialize attributes that can be inferred from others on a function&period;
| xref:llvm/inferNonMandatoryLibFuncAttrs-0b.adoc[`inferNonMandatoryLibFuncAttrs`] 
| `inferNonMandatoryLibFuncAttrs` overloads
| xref:llvm/initializeAAResultsWrapperPassPass.adoc[`initializeAAResultsWrapperPassPass`] 
| Initialize the AAResultsWrapperPass pass&period;
| xref:llvm/initializeAlwaysInlinerLegacyPassPass.adoc[`initializeAlwaysInlinerLegacyPassPass`] 
| Initialize the AlwaysInlinerLegacyPass pass&period;
| xref:llvm/initializeAnalysis.adoc[`initializeAnalysis`] 
| Initialize all passes linked into the Analysis library&period;
| xref:llvm/initializeAssignmentTrackingAnalysisPass.adoc[`initializeAssignmentTrackingAnalysisPass`] 
| Initialize the AssignmentTrackingAnalysis pass&period;
| xref:llvm/initializeAssumptionCacheTrackerPass.adoc[`initializeAssumptionCacheTrackerPass`] 
| Initialize the AssumptionCacheTracker pass&period;
| xref:llvm/initializeAtomicExpandLegacyPass.adoc[`initializeAtomicExpandLegacyPass`] 
| Initialize the AtomicExpandLegacy pass&period;
| xref:llvm/initializeBarrierNoopPass.adoc[`initializeBarrierNoopPass`] 
| Initialize the BarrierNoop pass&period;
| xref:llvm/initializeBasicAAWrapperPassPass.adoc[`initializeBasicAAWrapperPassPass`] 
| Initialize the BasicAAWrapperPass pass&period;
| xref:llvm/initializeBasicBlockMatchingAndInferencePass.adoc[`initializeBasicBlockMatchingAndInferencePass`] 
| Initialize the BasicBlockMatchingAndInference pass&period;
| xref:llvm/initializeBasicBlockPathCloningPass.adoc[`initializeBasicBlockPathCloningPass`] 
| Initialize the BasicBlockPathCloning pass&period;
| xref:llvm/initializeBasicBlockSectionsPass.adoc[`initializeBasicBlockSectionsPass`] 
| Initialize the BasicBlockSections pass&period;
| xref:llvm/initializeBasicBlockSectionsProfileReaderWrapperPassPass.adoc[`initializeBasicBlockSectionsProfileReaderWrapperPassPass`] 
| Initialize the BasicBlockSectionsProfileReaderWrapperPass pass&period;
| xref:llvm/initializeBlockFrequencyInfoWrapperPassPass.adoc[`initializeBlockFrequencyInfoWrapperPassPass`] 
| Initialize the BlockFrequencyInfoWrapperPass pass&period;
| xref:llvm/initializeBranchFolderLegacyPass.adoc[`initializeBranchFolderLegacyPass`] 
| Initialize the BranchFolderLegacy pass&period;
| xref:llvm/initializeBranchProbabilityInfoWrapperPassPass.adoc[`initializeBranchProbabilityInfoWrapperPassPass`] 
| Initialize the BranchProbabilityInfoWrapperPass pass&period;
| xref:llvm/initializeBranchRelaxationLegacyPass.adoc[`initializeBranchRelaxationLegacyPass`] 
| Initialize the BranchRelaxationLegacy pass&period;
| xref:llvm/initializeBreakCriticalEdgesPass.adoc[`initializeBreakCriticalEdgesPass`] 
| Initialize the BreakCriticalEdges pass&period;
| xref:llvm/initializeBreakFalseDepsLegacyPass.adoc[`initializeBreakFalseDepsLegacyPass`] 
| Initialize the BreakFalseDepsLegacy pass&period;
| xref:llvm/initializeCFGSimplifyPassPass.adoc[`initializeCFGSimplifyPassPass`] 
| Initialize the CFGSimplifyPass pass&period;
| xref:llvm/initializeCFGuardLongjmpPass.adoc[`initializeCFGuardLongjmpPass`] 
| Initialize the CFGuardLongjmp pass&period;
| xref:llvm/initializeCFGuardPass.adoc[`initializeCFGuardPass`] 
| Initialize the CFGuard pass&period;
| xref:llvm/initializeCFIFixupLegacyPass.adoc[`initializeCFIFixupLegacyPass`] 
| Initialize the CFIFixupLegacy pass&period;
| xref:llvm/initializeCFIInstrInserterLegacyPass.adoc[`initializeCFIInstrInserterLegacyPass`] 
| Initialize the CFIInstrInserterLegacy pass&period;
| xref:llvm/initializeCallGraphDOTPrinterPass.adoc[`initializeCallGraphDOTPrinterPass`] 
| Initialize the CallGraphDOTPrinter pass&period;
| xref:llvm/initializeCallGraphViewerPass.adoc[`initializeCallGraphViewerPass`] 
| Initialize the CallGraphViewer pass&period;
| xref:llvm/initializeCallGraphWrapperPassPass.adoc[`initializeCallGraphWrapperPassPass`] 
| Initialize the CallGraphWrapperPass pass&period;
| xref:llvm/initializeCanonicalizeFreezeInLoopsPass.adoc[`initializeCanonicalizeFreezeInLoopsPass`] 
| Initialize the CanonicalizeFreezeInLoops pass&period;
| xref:llvm/initializeCheckDebugMachineModuleLegacyPass.adoc[`initializeCheckDebugMachineModuleLegacyPass`] 
| Initialize the CheckDebugMachineModuleLegacy pass&period;
| xref:llvm/initializeCodeGen.adoc[`initializeCodeGen`] 
| Initialize all passes linked into the CodeGen library&period;
| xref:llvm/initializeCodeGenPrepareLegacyPassPass.adoc[`initializeCodeGenPrepareLegacyPassPass`] 
| Initialize the CodeGenPrepareLegacyPass pass&period;
| xref:llvm/initializeComplexDeinterleavingLegacyPassPass.adoc[`initializeComplexDeinterleavingLegacyPassPass`] 
| Initialize the ComplexDeinterleavingLegacyPass pass&period;
| xref:llvm/initializeConstantHoistingLegacyPassPass.adoc[`initializeConstantHoistingLegacyPassPass`] 
| Initialize the ConstantHoistingLegacyPass pass&period;
| xref:llvm/initializeCore.adoc[`initializeCore`] 
| Initialize all passes linked into the Core library&period;
| xref:llvm/initializeCycleInfoWrapperPassPass.adoc[`initializeCycleInfoWrapperPassPass`] 
| Initialize the CycleInfoWrapperPass pass&period;
| xref:llvm/initializeDAEPass.adoc[`initializeDAEPass`] 
| Initialize the DAE pass&period;
| xref:llvm/initializeDCELegacyPassPass.adoc[`initializeDCELegacyPassPass`] 
| Initialize the DCELegacyPass pass&period;
| xref:llvm/initializeDSELegacyPassPass.adoc[`initializeDSELegacyPassPass`] 
| Initialize the DSELegacyPass pass&period;
| xref:llvm/initializeDXILMetadataAnalysisWrapperPassPass.adoc[`initializeDXILMetadataAnalysisWrapperPassPass`] 
| Initialize the DXILMetadataAnalysisWrapperPass pass&period;
| xref:llvm/initializeDXILMetadataAnalysisWrapperPrinterPass.adoc[`initializeDXILMetadataAnalysisWrapperPrinterPass`] 
| Initialize the DXILMetadataAnalysisWrapperPrinter pass&period;
| xref:llvm/initializeDXILResourceBindingWrapperPassPass.adoc[`initializeDXILResourceBindingWrapperPassPass`] 
| Initialize the DXILResourceBindingWrapperPass pass&period;
| xref:llvm/initializeDXILResourceTypeWrapperPassPass.adoc[`initializeDXILResourceTypeWrapperPassPass`] 
| Initialize the DXILResourceTypeWrapperPass pass&period;
| xref:llvm/initializeDXILResourceWrapperPassPass.adoc[`initializeDXILResourceWrapperPassPass`] 
| Initialize the DXILResourceWrapperPass pass&period;
| xref:llvm/initializeDeadMachineInstructionElimPass.adoc[`initializeDeadMachineInstructionElimPass`] 
| Initialize the DeadMachineInstructionElim pass&period;
| xref:llvm/initializeDebugifyMachineModulePass.adoc[`initializeDebugifyMachineModulePass`] 
| Initialize the DebugifyMachineModule pass&period;
| xref:llvm/initializeDependenceAnalysisWrapperPassPass.adoc[`initializeDependenceAnalysisWrapperPassPass`] 
| Initialize the DependenceAnalysisWrapperPass pass&period;
| xref:llvm/initializeDetectDeadLanesLegacyPass.adoc[`initializeDetectDeadLanesLegacyPass`] 
| Initialize the DetectDeadLanesLegacy pass&period;
| xref:llvm/initializeDomOnlyPrinterWrapperPassPass.adoc[`initializeDomOnlyPrinterWrapperPassPass`] 
| Initialize the DomOnlyPrinterWrapperPass pass&period;
| xref:llvm/initializeDomOnlyViewerWrapperPassPass.adoc[`initializeDomOnlyViewerWrapperPassPass`] 
| Initialize the DomOnlyViewerWrapperPass pass&period;
| xref:llvm/initializeDomPrinterWrapperPassPass.adoc[`initializeDomPrinterWrapperPassPass`] 
| Initialize the DomPrinterWrapperPass pass&period;
| xref:llvm/initializeDomViewerWrapperPassPass.adoc[`initializeDomViewerWrapperPassPass`] 
| Initialize the DomViewerWrapperPass pass&period;
| xref:llvm/initializeDominanceFrontierWrapperPassPass.adoc[`initializeDominanceFrontierWrapperPassPass`] 
| Initialize the DominanceFrontierWrapperPass pass&period;
| xref:llvm/initializeDominatorTreeWrapperPassPass.adoc[`initializeDominatorTreeWrapperPassPass`] 
| Initialize the DominatorTreeWrapperPass pass&period;
| xref:llvm/initializeDummyCGSCCPassPass.adoc[`initializeDummyCGSCCPassPass`] 
| Initialize the DummyCGSCCPass pass&period;
| xref:llvm/initializeDwarfEHPrepareLegacyPassPass.adoc[`initializeDwarfEHPrepareLegacyPassPass`] 
| Initialize the DwarfEHPrepareLegacyPass pass&period;
| xref:llvm/initializeEHContGuardTargetsLegacyPass.adoc[`initializeEHContGuardTargetsLegacyPass`] 
| Initialize the EHContGuardTargetsLegacy pass&period;
| xref:llvm/initializeEarlyCSELegacyPassPass.adoc[`initializeEarlyCSELegacyPassPass`] 
| Initialize the EarlyCSELegacyPass pass&period;
| xref:llvm/initializeEarlyCSEMemSSALegacyPassPass.adoc[`initializeEarlyCSEMemSSALegacyPassPass`] 
| Initialize the EarlyCSEMemSSALegacyPass pass&period;
| xref:llvm/initializeEarlyIfConverterLegacyPass.adoc[`initializeEarlyIfConverterLegacyPass`] 
| Initialize the EarlyIfConverterLegacy pass&period;
| xref:llvm/initializeEarlyIfPredicatorPass.adoc[`initializeEarlyIfPredicatorPass`] 
| Initialize the EarlyIfPredicator pass&period;
| xref:llvm/initializeEarlyMachineLICMPass.adoc[`initializeEarlyMachineLICMPass`] 
| Initialize the EarlyMachineLICM pass&period;
| xref:llvm/initializeEarlyTailDuplicateLegacyPass.adoc[`initializeEarlyTailDuplicateLegacyPass`] 
| Initialize the EarlyTailDuplicateLegacy pass&period;
| xref:llvm/initializeEdgeBundlesWrapperLegacyPass.adoc[`initializeEdgeBundlesWrapperLegacyPass`] 
| Initialize the EdgeBundlesWrapperLegacy pass&period;
| xref:llvm/initializeExpandIRInstsLegacyPassPass.adoc[`initializeExpandIRInstsLegacyPassPass`] 
| Initialize the ExpandIRInstsLegacyPass pass&period;
| xref:llvm/initializeExpandPostRALegacyPass.adoc[`initializeExpandPostRALegacyPass`] 
| Initialize the ExpandPostRALegacy pass&period;
| xref:llvm/initializeExpandReductionsPass.adoc[`initializeExpandReductionsPass`] 
| Initialize the ExpandReductions pass&period;
| xref:llvm/initializeExpandVariadicsPass.adoc[`initializeExpandVariadicsPass`] 
| Initialize the ExpandVariadics pass&period;
| xref:llvm/initializeExternalAAWrapperPassPass.adoc[`initializeExternalAAWrapperPassPass`] 
| Initialize the ExternalAAWrapperPass pass&period;
| xref:llvm/initializeFEntryInserterLegacyPass.adoc[`initializeFEntryInserterLegacyPass`] 
| Initialize the FEntryInserterLegacy pass&period;
| xref:llvm/initializeFinalizeISelPass.adoc[`initializeFinalizeISelPass`] 
| Initialize the FinalizeISel pass&period;
| xref:llvm/initializeFixIrreduciblePass.adoc[`initializeFixIrreduciblePass`] 
| Initialize the FixIrreducible pass&period;
| xref:llvm/initializeFixupStatepointCallerSavedLegacyPass.adoc[`initializeFixupStatepointCallerSavedLegacyPass`] 
| Initialize the FixupStatepointCallerSavedLegacy pass&period;
| xref:llvm/initializeFlattenCFGLegacyPassPass.adoc[`initializeFlattenCFGLegacyPassPass`] 
| Initialize the FlattenCFGLegacyPass pass&period;
| xref:llvm/initializeFuncletLayoutLegacyPass.adoc[`initializeFuncletLayoutLegacyPass`] 
| Initialize the FuncletLayoutLegacy pass&period;
| xref:llvm/initializeGCEmptyBasicBlocksLegacyPass.adoc[`initializeGCEmptyBasicBlocksLegacyPass`] 
| Initialize the GCEmptyBasicBlocksLegacy pass&period;
| xref:llvm/initializeGCMachineCodeAnalysisPass.adoc[`initializeGCMachineCodeAnalysisPass`] 
| Initialize the GCMachineCodeAnalysis pass&period;
| xref:llvm/initializeGCModuleInfoPass.adoc[`initializeGCModuleInfoPass`] 
| Initialize the GCModuleInfo pass&period;
| xref:llvm/initializeGISelCSEAnalysisWrapperPassPass.adoc[`initializeGISelCSEAnalysisWrapperPassPass`] 
| Initialize the GISelCSEAnalysisWrapperPass pass&period;
| xref:llvm/initializeGISelValueTrackingAnalysisLegacyPass.adoc[`initializeGISelValueTrackingAnalysisLegacyPass`] 
| Initialize the GISelValueTrackingAnalysisLegacy pass&period;
| xref:llvm/initializeGVNLegacyPassPass.adoc[`initializeGVNLegacyPassPass`] 
| Initialize the GVNLegacyPass pass&period;
| xref:llvm/initializeGlobalDCELegacyPassPass.adoc[`initializeGlobalDCELegacyPassPass`] 
| Initialize the GlobalDCELegacyPass pass&period;
| xref:llvm/initializeGlobalISel.adoc[`initializeGlobalISel`] 
| Initialize all passes linked into the GlobalISel library&period;
| xref:llvm/initializeGlobalMergeFuncPassWrapperPass.adoc[`initializeGlobalMergeFuncPassWrapperPass`] 
| Initialize the GlobalMergeFuncPassWrapper pass&period;
| xref:llvm/initializeGlobalMergePass.adoc[`initializeGlobalMergePass`] 
| Initialize the GlobalMerge pass&period;
| xref:llvm/initializeGlobalsAAWrapperPassPass.adoc[`initializeGlobalsAAWrapperPassPass`] 
| Initialize the GlobalsAAWrapperPass pass&period;
| xref:llvm/initializeHardwareLoopsLegacyPass.adoc[`initializeHardwareLoopsLegacyPass`] 
| Initialize the HardwareLoopsLegacy pass&period;
| xref:llvm/initializeIPO.adoc[`initializeIPO`] 
| Initialize all passes linked into the IPO library&period;
| xref:llvm/initializeIRTranslatorLegacyPass.adoc[`initializeIRTranslatorLegacyPass`] 
| Initialize the IRTranslatorLegacy pass&period;
| xref:llvm/initializeIVUsersWrapperPassPass.adoc[`initializeIVUsersWrapperPassPass`] 
| Initialize the IVUsersWrapperPass pass&period;
| xref:llvm/initializeIfConverterPass.adoc[`initializeIfConverterPass`] 
| Initialize the IfConverter pass&period;
| xref:llvm/initializeImmutableModuleSummaryIndexWrapperPassPass.adoc[`initializeImmutableModuleSummaryIndexWrapperPassPass`] 
| Initialize the ImmutableModuleSummaryIndexWrapperPass pass&period;
| xref:llvm/initializeImplicitNullChecksLegacyPass.adoc[`initializeImplicitNullChecksLegacyPass`] 
| Initialize the ImplicitNullChecksLegacy pass&period;
| xref:llvm/initializeIndirectBrExpandLegacyPassPass.adoc[`initializeIndirectBrExpandLegacyPassPass`] 
| Initialize the IndirectBrExpandLegacyPass pass&period;
| xref:llvm/initializeInferAddressSpacesPass.adoc[`initializeInferAddressSpacesPass`] 
| Initialize the InferAddressSpaces pass&period;
| xref:llvm/initializeInitUndefLegacyPass.adoc[`initializeInitUndefLegacyPass`] 
| Initialize the InitUndefLegacy pass&period;
| xref:llvm/initializeInlineAsmPreparePass.adoc[`initializeInlineAsmPreparePass`] 
| Initialize the InlineAsmPrepare pass&period;
| xref:llvm/initializeInsertCodePrefetchPass.adoc[`initializeInsertCodePrefetchPass`] 
| Initialize the InsertCodePrefetch pass&period;
| xref:llvm/initializeInstCombine.adoc[`initializeInstCombine`] 
| Initialize all passes linked into the InstCombine library&period;
| xref:llvm/initializeInstSimplifyLegacyPassPass.adoc[`initializeInstSimplifyLegacyPassPass`] 
| Initialize the InstSimplifyLegacyPass pass&period;
| xref:llvm/initializeInstructionCombiningPassPass.adoc[`initializeInstructionCombiningPassPass`] 
| Initialize the InstructionCombiningPass pass&period;
| xref:llvm/initializeInstructionSelectLegacyPass.adoc[`initializeInstructionSelectLegacyPass`] 
| Initialize the InstructionSelectLegacy pass&period;
| xref:llvm/initializeInterleavedAccessPass.adoc[`initializeInterleavedAccessPass`] 
| Initialize the InterleavedAccess pass&period;
| xref:llvm/initializeInterleavedLoadCombinePass.adoc[`initializeInterleavedLoadCombinePass`] 
| Initialize the InterleavedLoadCombine pass&period;
| xref:llvm/initializeJMCInstrumenterPass.adoc[`initializeJMCInstrumenterPass`] 
| Initialize the JMCInstrumenter pass&period;
| xref:llvm/initializeLCSSAVerificationPassPass.adoc[`initializeLCSSAVerificationPassPass`] 
| Initialize the LCSSAVerificationPass pass&period;
| xref:llvm/initializeLCSSAWrapperPassPass.adoc[`initializeLCSSAWrapperPassPass`] 
| Initialize the LCSSAWrapperPass pass&period;
| xref:llvm/initializeLFIMCStreamer.adoc[`initializeLFIMCStreamer`] 
| Initialize `Streamer` with LFI rewriting support for `TheTriple&period;`
| xref:llvm/initializeLazyBFIPassPass.adoc[`initializeLazyBFIPassPass`] 
| Initialize the LazyBFIPass pass&period;
| xref:llvm/initializeLazyBPIPassPass.adoc[`initializeLazyBPIPassPass`] 
| Helper for client passes to initialize dependent passes for LBPI&period;
| xref:llvm/initializeLazyBlockFrequencyInfoPassPass.adoc[`initializeLazyBlockFrequencyInfoPassPass`] 
| Initialize the LazyBlockFrequencyInfoPass pass&period;
| xref:llvm/initializeLazyBranchProbabilityInfoPassPass.adoc[`initializeLazyBranchProbabilityInfoPassPass`] 
| Initialize the LazyBranchProbabilityInfoPass pass&period;
| xref:llvm/initializeLazyMachineBlockFrequencyInfoPassPass.adoc[`initializeLazyMachineBlockFrequencyInfoPassPass`] 
| Initialize the LazyMachineBlockFrequencyInfoPass pass&period;
| xref:llvm/initializeLazyValueInfoWrapperPassPass.adoc[`initializeLazyValueInfoWrapperPassPass`] 
| Initialize the LazyValueInfoWrapperPass pass&period;
| xref:llvm/initializeLegacyLICMPassPass.adoc[`initializeLegacyLICMPassPass`] 
| Initialize the LegacyLICMPass pass&period;
| xref:llvm/initializeLegalizerLegacyPass.adoc[`initializeLegalizerLegacyPass`] 
| Initialize the LegalizerLegacy pass&period;
| xref:llvm/initializeLibcallLoweringInfoWrapperPass.adoc[`initializeLibcallLoweringInfoWrapperPass`] 
| Initialize the LibcallLoweringInfoWrapper pass&period;
| xref:llvm/initializeLiveDebugValuesLegacyPass.adoc[`initializeLiveDebugValuesLegacyPass`] 
| Initialize the LiveDebugValuesLegacy pass&period;
| xref:llvm/initializeLiveDebugVariablesWrapperLegacyPass.adoc[`initializeLiveDebugVariablesWrapperLegacyPass`] 
| Initialize the LiveDebugVariablesWrapperLegacy pass&period;
| xref:llvm/initializeLiveIntervalsWrapperPassPass.adoc[`initializeLiveIntervalsWrapperPassPass`] 
| Initialize the LiveIntervalsWrapperPass pass&period;
| xref:llvm/initializeLiveRangeShrinkPass.adoc[`initializeLiveRangeShrinkPass`] 
| Initialize the LiveRangeShrink pass&period;
| xref:llvm/initializeLiveRegMatrixWrapperLegacyPass.adoc[`initializeLiveRegMatrixWrapperLegacyPass`] 
| Initialize the LiveRegMatrixWrapperLegacy pass&period;
| xref:llvm/initializeLiveStacksWrapperLegacyPass.adoc[`initializeLiveStacksWrapperLegacyPass`] 
| Initialize the LiveStacksWrapperLegacy pass&period;
| xref:llvm/initializeLiveVariablesWrapperPassPass.adoc[`initializeLiveVariablesWrapperPassPass`] 
| Initialize the LiveVariablesWrapperPass pass&period;
| xref:llvm/initializeLoadStoreOptLegacyPass.adoc[`initializeLoadStoreOptLegacyPass`] 
| Initialize the LoadStoreOptLegacy pass&period;
| xref:llvm/initializeLoadStoreVectorizerLegacyPassPass.adoc[`initializeLoadStoreVectorizerLegacyPassPass`] 
| Initialize the LoadStoreVectorizerLegacyPass pass&period;
| xref:llvm/initializeLocalStackSlotPassPass.adoc[`initializeLocalStackSlotPassPass`] 
| Initialize the LocalStackSlotPass pass&period;
| xref:llvm/initializeLocalizerLegacyPass.adoc[`initializeLocalizerLegacyPass`] 
| Initialize the LocalizerLegacy pass&period;
| xref:llvm/initializeLogicalSROALegacyPassPass.adoc[`initializeLogicalSROALegacyPassPass`] 
| Initialize the LogicalSROALegacyPass pass&period;
| xref:llvm/initializeLoopDataPrefetchLegacyPassPass.adoc[`initializeLoopDataPrefetchLegacyPassPass`] 
| Initialize the LoopDataPrefetchLegacyPass pass&period;
| xref:llvm/initializeLoopInfoWrapperPassPass.adoc[`initializeLoopInfoWrapperPassPass`] 
| Initialize the LoopInfoWrapperPass pass&period;
| xref:llvm/initializeLoopPassPass.adoc[`initializeLoopPassPass`] 
| Initialize the LoopPass pass&period;
| xref:llvm/initializeLoopSimplifyPass.adoc[`initializeLoopSimplifyPass`] 
| Initialize the LoopSimplify pass&period;
| xref:llvm/initializeLoopStrengthReducePass.adoc[`initializeLoopStrengthReducePass`] 
| Initialize the LoopStrengthReduce pass&period;
| xref:llvm/initializeLoopTermFoldPass.adoc[`initializeLoopTermFoldPass`] 
| Initialize the LoopTermFold pass&period;
| xref:llvm/initializeLoopUnrollPass.adoc[`initializeLoopUnrollPass`] 
| Initialize the LoopUnroll pass&period;
| xref:llvm/initializeLowerAtomicLegacyPassPass.adoc[`initializeLowerAtomicLegacyPassPass`] 
| Initialize the LowerAtomicLegacyPass pass&period;
| xref:llvm/initializeLowerEmuTLSPass.adoc[`initializeLowerEmuTLSPass`] 
| Initialize the LowerEmuTLS pass&period;
| xref:llvm/initializeLowerGlobalDtorsLegacyPassPass.adoc[`initializeLowerGlobalDtorsLegacyPassPass`] 
| Initialize the LowerGlobalDtorsLegacyPass pass&period;
| xref:llvm/initializeLowerIntrinsicsPass.adoc[`initializeLowerIntrinsicsPass`] 
| Initialize the LowerIntrinsics pass&period;
| xref:llvm/initializeLowerInvokeLegacyPassPass.adoc[`initializeLowerInvokeLegacyPassPass`] 
| Initialize the LowerInvokeLegacyPass pass&period;
| xref:llvm/initializeLowerSwitchLegacyPassPass.adoc[`initializeLowerSwitchLegacyPassPass`] 
| Initialize the LowerSwitchLegacyPass pass&period;
| xref:llvm/initializeMIR2VecPrinterLegacyPassPass.adoc[`initializeMIR2VecPrinterLegacyPassPass`] 
| Initialize the MIR2VecPrinterLegacyPass pass&period;
| xref:llvm/initializeMIR2VecVocabLegacyAnalysisPass.adoc[`initializeMIR2VecVocabLegacyAnalysisPass`] 
| Initialize the MIR2VecVocabLegacyAnalysis pass&period;
| xref:llvm/initializeMIR2VecVocabPrinterLegacyPassPass.adoc[`initializeMIR2VecVocabPrinterLegacyPassPass`] 
| Initialize the MIR2VecVocabPrinterLegacyPass pass&period;
| xref:llvm/initializeMIRAddFSDiscriminatorsPass.adoc[`initializeMIRAddFSDiscriminatorsPass`] 
| Initialize the MIRAddFSDiscriminators pass&period;
| xref:llvm/initializeMIRCanonicalizerPass.adoc[`initializeMIRCanonicalizerPass`] 
| Initialize the MIRCanonicalizer pass&period;
| xref:llvm/initializeMIRNamerPass.adoc[`initializeMIRNamerPass`] 
| Initialize the MIRNamer pass&period;
| xref:llvm/initializeMIRPrintingPassPass.adoc[`initializeMIRPrintingPassPass`] 
| Initialize the MIRPrintingPass pass&period;
| xref:llvm/initializeMIRProfileLoaderPassPass.adoc[`initializeMIRProfileLoaderPassPass`] 
| Initialize the MIRProfileLoaderPass pass&period;
| xref:llvm/initializeMachineBlockFrequencyInfoWrapperPassPass.adoc[`initializeMachineBlockFrequencyInfoWrapperPassPass`] 
| Initialize the MachineBlockFrequencyInfoWrapperPass pass&period;
| xref:llvm/initializeMachineBlockHashInfoPass.adoc[`initializeMachineBlockHashInfoPass`] 
| Initialize the MachineBlockHashInfo pass&period;
| xref:llvm/initializeMachineBlockPlacementLegacyPass.adoc[`initializeMachineBlockPlacementLegacyPass`] 
| Initialize the MachineBlockPlacementLegacy pass&period;
| xref:llvm/initializeMachineBlockPlacementStatsLegacyPass.adoc[`initializeMachineBlockPlacementStatsLegacyPass`] 
| Initialize the MachineBlockPlacementStatsLegacy pass&period;
| xref:llvm/initializeMachineBranchProbabilityInfoWrapperPassPass.adoc[`initializeMachineBranchProbabilityInfoWrapperPassPass`] 
| Initialize the MachineBranchProbabilityInfoWrapperPass pass&period;
| xref:llvm/initializeMachineCFGPrinterLegacyPass.adoc[`initializeMachineCFGPrinterLegacyPass`] 
| Initialize the MachineCFGPrinterLegacy pass&period;
| xref:llvm/initializeMachineCSELegacyPass.adoc[`initializeMachineCSELegacyPass`] 
| Initialize the MachineCSELegacy pass&period;
| xref:llvm/initializeMachineCombinerLegacyPass.adoc[`initializeMachineCombinerLegacyPass`] 
| Initialize the MachineCombinerLegacy pass&period;
| xref:llvm/initializeMachineCopyPropagationLegacyPass.adoc[`initializeMachineCopyPropagationLegacyPass`] 
| Initialize the MachineCopyPropagationLegacy pass&period;
| xref:llvm/initializeMachineCycleInfoPrinterLegacyPass.adoc[`initializeMachineCycleInfoPrinterLegacyPass`] 
| Initialize the MachineCycleInfoPrinterLegacy pass&period;
| xref:llvm/initializeMachineCycleInfoWrapperPassPass.adoc[`initializeMachineCycleInfoWrapperPassPass`] 
| Initialize the MachineCycleInfoWrapperPass pass&period;
| xref:llvm/initializeMachineDominanceFrontierWrapperPassPass.adoc[`initializeMachineDominanceFrontierWrapperPassPass`] 
| Initialize the MachineDominanceFrontierWrapperPass pass&period;
| xref:llvm/initializeMachineDominatorTreeWrapperPassPass.adoc[`initializeMachineDominatorTreeWrapperPassPass`] 
| Initialize the MachineDominatorTreeWrapperPass pass&period;
| xref:llvm/initializeMachineFunctionPrinterPassPass.adoc[`initializeMachineFunctionPrinterPassPass`] 
| Initialize the MachineFunctionPrinterPass pass&period;
| xref:llvm/initializeMachineFunctionSplitterPass.adoc[`initializeMachineFunctionSplitterPass`] 
| Initialize the MachineFunctionSplitter pass&period;
| xref:llvm/initializeMachineKCFILegacyPass.adoc[`initializeMachineKCFILegacyPass`] 
| Initialize the MachineKCFILegacy pass&period;
| xref:llvm/initializeMachineLICMPass.adoc[`initializeMachineLICMPass`] 
| Initialize the MachineLICM pass&period;
| xref:llvm/initializeMachineLateInstrsCleanupLegacyPass.adoc[`initializeMachineLateInstrsCleanupLegacyPass`] 
| Initialize the MachineLateInstrsCleanupLegacy pass&period;
| xref:llvm/initializeMachineLoopInfoWrapperPassPass.adoc[`initializeMachineLoopInfoWrapperPassPass`] 
| Initialize the MachineLoopInfoWrapperPass pass&period;
| xref:llvm/initializeMachineModuleInfoWrapperPassPass.adoc[`initializeMachineModuleInfoWrapperPassPass`] 
| Initialize the MachineModuleInfoWrapperPass pass&period;
| xref:llvm/initializeMachineOptimizationRemarkEmitterPassPass.adoc[`initializeMachineOptimizationRemarkEmitterPassPass`] 
| Initialize the MachineOptimizationRemarkEmitterPass pass&period;
| xref:llvm/initializeMachineOutlinerPass.adoc[`initializeMachineOutlinerPass`] 
| Initialize the MachineOutliner pass&period;
| xref:llvm/initializeMachinePipelinerPass.adoc[`initializeMachinePipelinerPass`] 
| Initialize the MachinePipeliner pass&period;
| xref:llvm/initializeMachinePostDominatorTreeWrapperPassPass.adoc[`initializeMachinePostDominatorTreeWrapperPassPass`] 
| Initialize the MachinePostDominatorTreeWrapperPass pass&period;
| xref:llvm/initializeMachineRegionInfoPassPass.adoc[`initializeMachineRegionInfoPassPass`] 
| Initialize the MachineRegionInfoPass pass&period;
| xref:llvm/initializeMachineRegisterClassInfoWrapperPassPass.adoc[`initializeMachineRegisterClassInfoWrapperPassPass`] 
| Initialize the MachineRegisterClassInfoWrapperPass pass&period;
| xref:llvm/initializeMachineSanitizerBinaryMetadataLegacyPass.adoc[`initializeMachineSanitizerBinaryMetadataLegacyPass`] 
| Initialize the MachineSanitizerBinaryMetadataLegacy pass&period;
| xref:llvm/initializeMachineSchedulerLegacyPass.adoc[`initializeMachineSchedulerLegacyPass`] 
| Initialize the MachineSchedulerLegacy pass&period;
| xref:llvm/initializeMachineSinkingLegacyPass.adoc[`initializeMachineSinkingLegacyPass`] 
| Initialize the MachineSinkingLegacy pass&period;
| xref:llvm/initializeMachineTraceMetricsWrapperPassPass.adoc[`initializeMachineTraceMetricsWrapperPassPass`] 
| Initialize the MachineTraceMetricsWrapperPass pass&period;
| xref:llvm/initializeMachineUniformityAnalysisPassPass.adoc[`initializeMachineUniformityAnalysisPassPass`] 
| Initialize the MachineUniformityAnalysisPass pass&period;
| xref:llvm/initializeMachineUniformityInfoPrinterPassPass.adoc[`initializeMachineUniformityInfoPrinterPassPass`] 
| Initialize the MachineUniformityInfoPrinterPass pass&period;
| xref:llvm/initializeMachineVerifierLegacyPassPass.adoc[`initializeMachineVerifierLegacyPassPass`] 
| Initialize the MachineVerifierLegacyPass pass&period;
| xref:llvm/initializeMemoryDependenceWrapperPassPass.adoc[`initializeMemoryDependenceWrapperPassPass`] 
| Initialize the MemoryDependenceWrapperPass pass&period;
| xref:llvm/initializeMemorySSAWrapperPassPass.adoc[`initializeMemorySSAWrapperPassPass`] 
| Initialize the MemorySSAWrapperPass pass&period;
| xref:llvm/initializeModuleSummaryIndexWrapperPassPass.adoc[`initializeModuleSummaryIndexWrapperPassPass`] 
| Initialize the ModuleSummaryIndexWrapperPass pass&period;
| xref:llvm/initializeModuloScheduleTestPass.adoc[`initializeModuloScheduleTestPass`] 
| Initialize the ModuloScheduleTest pass&period;
| xref:llvm/initializeNaryReassociateLegacyPassPass.adoc[`initializeNaryReassociateLegacyPassPass`] 
| Initialize the NaryReassociateLegacyPass pass&period;
| xref:llvm/initializeObjCARCContractLegacyPassPass.adoc[`initializeObjCARCContractLegacyPassPass`] 
| Initialize the ObjCARCContractLegacyPass pass&period;
| xref:llvm/initializeOptimizationRemarkEmitterWrapperPassPass.adoc[`initializeOptimizationRemarkEmitterWrapperPassPass`] 
| Initialize the OptimizationRemarkEmitterWrapperPass pass&period;
| xref:llvm/initializeOptimizePHIsLegacyPass.adoc[`initializeOptimizePHIsLegacyPass`] 
| Initialize the OptimizePHIsLegacy pass&period;
| xref:llvm/initializePEILegacyPass.adoc[`initializePEILegacyPass`] 
| Initialize the PEILegacy pass&period;
| xref:llvm/initializePHIEliminationPass.adoc[`initializePHIEliminationPass`] 
| Initialize the PHIElimination pass&period;
| xref:llvm/initializePartiallyInlineLibCallsLegacyPassPass.adoc[`initializePartiallyInlineLibCallsLegacyPassPass`] 
| Initialize the PartiallyInlineLibCallsLegacyPass pass&period;
| xref:llvm/initializePatchableFunctionLegacyPass.adoc[`initializePatchableFunctionLegacyPass`] 
| Initialize the PatchableFunctionLegacy pass&period;
| xref:llvm/initializePeepholeOptimizerLegacyPass.adoc[`initializePeepholeOptimizerLegacyPass`] 
| Initialize the PeepholeOptimizerLegacy pass&period;
| xref:llvm/initializePhiValuesWrapperPassPass.adoc[`initializePhiValuesWrapperPassPass`] 
| Initialize the PhiValuesWrapperPass pass&period;
| xref:llvm/initializePhysicalRegisterUsageInfoWrapperLegacyPass.adoc[`initializePhysicalRegisterUsageInfoWrapperLegacyPass`] 
| Initialize the PhysicalRegisterUsageInfoWrapperLegacy pass&period;
| xref:llvm/initializePlaceBackedgeSafepointsLegacyPassPass.adoc[`initializePlaceBackedgeSafepointsLegacyPassPass`] 
| Initialize the PlaceBackedgeSafepointsLegacyPass pass&period;
| xref:llvm/initializePostDomOnlyPrinterWrapperPassPass.adoc[`initializePostDomOnlyPrinterWrapperPassPass`] 
| Initialize the PostDomOnlyPrinterWrapperPass pass&period;
| xref:llvm/initializePostDomOnlyViewerWrapperPassPass.adoc[`initializePostDomOnlyViewerWrapperPassPass`] 
| Initialize the PostDomOnlyViewerWrapperPass pass&period;
| xref:llvm/initializePostDomPrinterWrapperPassPass.adoc[`initializePostDomPrinterWrapperPassPass`] 
| Initialize the PostDomPrinterWrapperPass pass&period;
| xref:llvm/initializePostDomViewerWrapperPassPass.adoc[`initializePostDomViewerWrapperPassPass`] 
| Initialize the PostDomViewerWrapperPass pass&period;
| xref:llvm/initializePostDominatorTreeWrapperPassPass.adoc[`initializePostDominatorTreeWrapperPassPass`] 
| Initialize the PostDominatorTreeWrapperPass pass&period;
| xref:llvm/initializePostInlineEntryExitInstrumenterPass.adoc[`initializePostInlineEntryExitInstrumenterPass`] 
| Initialize the PostInlineEntryExitInstrumenter pass&period;
| xref:llvm/initializePostMachineSchedulerLegacyPass.adoc[`initializePostMachineSchedulerLegacyPass`] 
| Initialize the PostMachineSchedulerLegacy pass&period;
| xref:llvm/initializePostRAHazardRecognizerLegacyPass.adoc[`initializePostRAHazardRecognizerLegacyPass`] 
| Initialize the PostRAHazardRecognizerLegacy pass&period;
| xref:llvm/initializePostRAMachineSinkingLegacyPass.adoc[`initializePostRAMachineSinkingLegacyPass`] 
| Initialize the PostRAMachineSinkingLegacy pass&period;
| xref:llvm/initializePostRASchedulerLegacyPass.adoc[`initializePostRASchedulerLegacyPass`] 
| Initialize the PostRASchedulerLegacy pass&period;
| xref:llvm/initializePreISelIntrinsicLoweringLegacyPassPass.adoc[`initializePreISelIntrinsicLoweringLegacyPassPass`] 
| Initialize the PreISelIntrinsicLoweringLegacyPass pass&period;
| xref:llvm/initializePrintFunctionPassWrapperPass.adoc[`initializePrintFunctionPassWrapperPass`] 
| Initialize the PrintFunctionPassWrapper pass&period;
| xref:llvm/initializePrintModulePassWrapperPass.adoc[`initializePrintModulePassWrapperPass`] 
| Initialize the PrintModulePassWrapper pass&period;
| xref:llvm/initializeProcessImplicitDefsLegacyPass.adoc[`initializeProcessImplicitDefsLegacyPass`] 
| Initialize the ProcessImplicitDefsLegacy pass&period;
| xref:llvm/initializeProfileSummaryInfoWrapperPassPass.adoc[`initializeProfileSummaryInfoWrapperPassPass`] 
| Initialize the ProfileSummaryInfoWrapperPass pass&period;
| xref:llvm/initializePromoteLegacyPassPass.adoc[`initializePromoteLegacyPassPass`] 
| Initialize the PromoteLegacyPass pass&period;
| xref:llvm/initializePseudoProbeInserterPass.adoc[`initializePseudoProbeInserterPass`] 
| Initialize the PseudoProbeInserter pass&period;
| xref:llvm/initializeRABasicPass.adoc[`initializeRABasicPass`] 
| Initialize the RABasic pass&period;
| xref:llvm/initializeRAGreedyLegacyPass.adoc[`initializeRAGreedyLegacyPass`] 
| Initialize the RAGreedyLegacy pass&period;
| xref:llvm/initializeReachingDefInfoWrapperPassPass.adoc[`initializeReachingDefInfoWrapperPassPass`] 
| Initialize the ReachingDefInfoWrapperPass pass&period;
| xref:llvm/initializeReassociateLegacyPassPass.adoc[`initializeReassociateLegacyPassPass`] 
| Initialize the ReassociateLegacyPass pass&period;
| xref:llvm/initializeRegAllocEvictionAdvisorAnalysisLegacyPass.adoc[`initializeRegAllocEvictionAdvisorAnalysisLegacyPass`] 
| Initialize the RegAllocEvictionAdvisorAnalysisLegacy pass&period;
| xref:llvm/initializeRegAllocFastPass.adoc[`initializeRegAllocFastPass`] 
| Initialize the RegAllocFast pass&period;
| xref:llvm/initializeRegAllocPriorityAdvisorAnalysisLegacyPass.adoc[`initializeRegAllocPriorityAdvisorAnalysisLegacyPass`] 
| Initialize the RegAllocPriorityAdvisorAnalysisLegacy pass&period;
| xref:llvm/initializeRegAllocScoringPass.adoc[`initializeRegAllocScoringPass`] 
| Initialize the RegAllocScoring pass&period;
| xref:llvm/initializeRegBankSelectLegacyPass.adoc[`initializeRegBankSelectLegacyPass`] 
| Initialize the RegBankSelectLegacy pass&period;
| xref:llvm/initializeRegToMemWrapperPassPass.adoc[`initializeRegToMemWrapperPassPass`] 
| Initialize the RegToMemWrapperPass pass&period;
| xref:llvm/initializeRegUsageInfoCollectorLegacyPass.adoc[`initializeRegUsageInfoCollectorLegacyPass`] 
| Initialize the RegUsageInfoCollectorLegacy pass&period;
| xref:llvm/initializeRegUsageInfoPropagationLegacyPass.adoc[`initializeRegUsageInfoPropagationLegacyPass`] 
| Initialize the RegUsageInfoPropagationLegacy pass&period;
| xref:llvm/initializeRegionInfoPassPass.adoc[`initializeRegionInfoPassPass`] 
| Initialize the RegionInfoPass pass&period;
| xref:llvm/initializeRegionOnlyPrinterPass.adoc[`initializeRegionOnlyPrinterPass`] 
| Initialize the RegionOnlyPrinter pass&period;
| xref:llvm/initializeRegionOnlyViewerPass.adoc[`initializeRegionOnlyViewerPass`] 
| Initialize the RegionOnlyViewer pass&period;
| xref:llvm/initializeRegionPrinterPass.adoc[`initializeRegionPrinterPass`] 
| Initialize the RegionPrinter pass&period;
| xref:llvm/initializeRegionViewerPass.adoc[`initializeRegionViewerPass`] 
| Initialize the RegionViewer pass&period;
| xref:llvm/initializeRegisterCoalescerLegacyPass.adoc[`initializeRegisterCoalescerLegacyPass`] 
| Initialize the RegisterCoalescerLegacy pass&period;
| xref:llvm/initializeRemoveLoadsIntoFakeUsesLegacyPass.adoc[`initializeRemoveLoadsIntoFakeUsesLegacyPass`] 
| Initialize the RemoveLoadsIntoFakeUsesLegacy pass&period;
| xref:llvm/initializeRemoveRedundantDebugValuesLegacyPass.adoc[`initializeRemoveRedundantDebugValuesLegacyPass`] 
| Initialize the RemoveRedundantDebugValuesLegacy pass&period;
| xref:llvm/initializeRenameIndependentSubregsLegacyPass.adoc[`initializeRenameIndependentSubregsLegacyPass`] 
| Initialize the RenameIndependentSubregsLegacy pass&period;
| xref:llvm/initializeReplaceWithVeclibLegacyPass.adoc[`initializeReplaceWithVeclibLegacyPass`] 
| Initialize the ReplaceWithVeclibLegacy pass&period;
| xref:llvm/initializeResetMachineFunctionPass.adoc[`initializeResetMachineFunctionPass`] 
| Initialize the ResetMachineFunction pass&period;
| xref:llvm/initializeRuntimeLibraryInfoWrapperPass.adoc[`initializeRuntimeLibraryInfoWrapperPass`] 
| Initialize the RuntimeLibraryInfoWrapper pass&period;
| xref:llvm/initializeSCEVAAWrapperPassPass.adoc[`initializeSCEVAAWrapperPassPass`] 
| Initialize the SCEVAAWrapperPass pass&period;
| xref:llvm/initializeSROALegacyPassPass.adoc[`initializeSROALegacyPassPass`] 
| Initialize the SROALegacyPass pass&period;
| xref:llvm/initializeSafeStackLegacyPassPass.adoc[`initializeSafeStackLegacyPassPass`] 
| Initialize the SafeStackLegacyPass pass&period;
| xref:llvm/initializeSafepointIRVerifierPass.adoc[`initializeSafepointIRVerifierPass`] 
| Initialize the SafepointIRVerifier pass&period;
| xref:llvm/initializeScalarEvolutionWrapperPassPass.adoc[`initializeScalarEvolutionWrapperPassPass`] 
| Initialize the ScalarEvolutionWrapperPass pass&period;
| xref:llvm/initializeScalarOpts.adoc[`initializeScalarOpts`] 
| Initialize all passes linked into the ScalarOpts library&period;
| xref:llvm/initializeScalarizeMaskedMemIntrinLegacyPassPass.adoc[`initializeScalarizeMaskedMemIntrinLegacyPassPass`] 
| Initialize the ScalarizeMaskedMemIntrinLegacyPass pass&period;
| xref:llvm/initializeScalarizerLegacyPassPass.adoc[`initializeScalarizerLegacyPassPass`] 
| Initialize the ScalarizerLegacyPass pass&period;
| xref:llvm/initializeScavengerTestPass.adoc[`initializeScavengerTestPass`] 
| Initialize the ScavengerTest pass&period;
| xref:llvm/initializeScopedNoAliasAAWrapperPassPass.adoc[`initializeScopedNoAliasAAWrapperPassPass`] 
| Initialize the ScopedNoAliasAAWrapperPass pass&period;
| xref:llvm/initializeSelectOptimizePass.adoc[`initializeSelectOptimizePass`] 
| Initialize the SelectOptimize pass&period;
| xref:llvm/initializeSeparateConstOffsetFromGEPLegacyPassPass.adoc[`initializeSeparateConstOffsetFromGEPLegacyPassPass`] 
| Initialize the SeparateConstOffsetFromGEPLegacyPass pass&period;
| xref:llvm/initializeShadowStackGCLoweringPass.adoc[`initializeShadowStackGCLoweringPass`] 
| Initialize the ShadowStackGCLowering pass&period;
| xref:llvm/initializeShrinkWrapLegacyPass.adoc[`initializeShrinkWrapLegacyPass`] 
| Initialize the ShrinkWrapLegacy pass&period;
| xref:llvm/initializeSinkingLegacyPassPass.adoc[`initializeSinkingLegacyPassPass`] 
| Initialize the SinkingLegacyPass pass&period;
| xref:llvm/initializeSjLjEHPreparePass.adoc[`initializeSjLjEHPreparePass`] 
| Initialize the SjLjEHPrepare pass&period;
| xref:llvm/initializeSlotIndexesWrapperPassPass.adoc[`initializeSlotIndexesWrapperPassPass`] 
| Initialize the SlotIndexesWrapperPass pass&period;
| xref:llvm/initializeSpeculativeExecutionLegacyPassPass.adoc[`initializeSpeculativeExecutionLegacyPassPass`] 
| Initialize the SpeculativeExecutionLegacyPass pass&period;
| xref:llvm/initializeSpillPlacementWrapperLegacyPass.adoc[`initializeSpillPlacementWrapperLegacyPass`] 
| Initialize the SpillPlacementWrapperLegacy pass&period;
| xref:llvm/initializeStackColoringLegacyPass.adoc[`initializeStackColoringLegacyPass`] 
| Initialize the StackColoringLegacy pass&period;
| xref:llvm/initializeStackFrameLayoutAnalysisLegacyPass.adoc[`initializeStackFrameLayoutAnalysisLegacyPass`] 
| Initialize the StackFrameLayoutAnalysisLegacy pass&period;
| xref:llvm/initializeStackMapLivenessPass.adoc[`initializeStackMapLivenessPass`] 
| Initialize the StackMapLiveness pass&period;
| xref:llvm/initializeStackProtectorPass.adoc[`initializeStackProtectorPass`] 
| Initialize the StackProtector pass&period;
| xref:llvm/initializeStackSafetyGlobalInfoWrapperPassPass.adoc[`initializeStackSafetyGlobalInfoWrapperPassPass`] 
| Initialize the StackSafetyGlobalInfoWrapperPass pass&period;
| xref:llvm/initializeStackSafetyInfoWrapperPassPass.adoc[`initializeStackSafetyInfoWrapperPassPass`] 
| Initialize the StackSafetyInfoWrapperPass pass&period;
| xref:llvm/initializeStackSlotColoringLegacyPass.adoc[`initializeStackSlotColoringLegacyPass`] 
| Initialize the StackSlotColoringLegacy pass&period;
| xref:llvm/initializeStaticDataAnnotatorLegacyPass.adoc[`initializeStaticDataAnnotatorLegacyPass`] 
| Initialize the StaticDataAnnotatorLegacy pass&period;
| xref:llvm/initializeStaticDataProfileInfoWrapperPassPass.adoc[`initializeStaticDataProfileInfoWrapperPassPass`] 
| Initialize the StaticDataProfileInfoWrapperPass pass&period;
| xref:llvm/initializeStaticDataSplitterLegacyPass.adoc[`initializeStaticDataSplitterLegacyPass`] 
| Initialize the StaticDataSplitterLegacy pass&period;
| xref:llvm/initializeStraightLineStrengthReduceLegacyPassPass.adoc[`initializeStraightLineStrengthReduceLegacyPassPass`] 
| Initialize the StraightLineStrengthReduceLegacyPass pass&period;
| xref:llvm/initializeStripConvergenceIntrinsicsLegacyPassPass.adoc[`initializeStripConvergenceIntrinsicsLegacyPassPass`] 
| Initialize the StripConvergenceIntrinsicsLegacyPass pass&period;
| xref:llvm/initializeStripDebugMachineModulePass.adoc[`initializeStripDebugMachineModulePass`] 
| Initialize the StripDebugMachineModule pass&period;
| xref:llvm/initializeStructurizeCFGLegacyPassPass.adoc[`initializeStructurizeCFGLegacyPassPass`] 
| Initialize the StructurizeCFGLegacyPass pass&period;
| xref:llvm/initializeTailCallElimPass.adoc[`initializeTailCallElimPass`] 
| Initialize the TailCallElim pass&period;
| xref:llvm/initializeTailDuplicateLegacyPass.adoc[`initializeTailDuplicateLegacyPass`] 
| Initialize the TailDuplicateLegacy pass&period;
| xref:llvm/initializeTarget.adoc[`initializeTarget`] 
| Initialize all passes linked into the CodeGen library&period;
| xref:llvm/initializeTargetLibraryInfoWrapperPassPass.adoc[`initializeTargetLibraryInfoWrapperPassPass`] 
| Initialize the TargetLibraryInfoWrapperPass pass&period;
| xref:llvm/initializeTargetPassConfigPass.adoc[`initializeTargetPassConfigPass`] 
| Initialize the TargetPassConfig pass&period;
| xref:llvm/initializeTargetTransformInfoWrapperPassPass.adoc[`initializeTargetTransformInfoWrapperPassPass`] 
| Initialize the TargetTransformInfoWrapperPass pass&period;
| xref:llvm/initializeTransformUtils.adoc[`initializeTransformUtils`] 
| Initialize all passes linked into the TransformUtils library&period;
| xref:llvm/initializeTwoAddressInstructionLegacyPassPass.adoc[`initializeTwoAddressInstructionLegacyPassPass`] 
| Initialize the TwoAddressInstructionLegacyPass pass&period;
| xref:llvm/initializeTypeBasedAAWrapperPassPass.adoc[`initializeTypeBasedAAWrapperPassPass`] 
| Initialize the TypeBasedAAWrapperPass pass&period;
| xref:llvm/initializeTypePromotionLegacyPass.adoc[`initializeTypePromotionLegacyPass`] 
| Initialize the TypePromotionLegacy pass&period;
| xref:llvm/initializeUniformityInfoWrapperPassPass.adoc[`initializeUniformityInfoWrapperPassPass`] 
| Initialize the UniformityInfoWrapperPass pass&period;
| xref:llvm/initializeUnifyLoopExitsLegacyPassPass.adoc[`initializeUnifyLoopExitsLegacyPassPass`] 
| Initialize the UnifyLoopExitsLegacyPass pass&period;
| xref:llvm/initializeUnpackMachineBundlesLegacyPass.adoc[`initializeUnpackMachineBundlesLegacyPass`] 
| Initialize the UnpackMachineBundlesLegacy pass&period;
| xref:llvm/initializeUnreachableBlockElimLegacyPassPass.adoc[`initializeUnreachableBlockElimLegacyPassPass`] 
| Initialize the UnreachableBlockElimLegacyPass pass&period;
| xref:llvm/initializeUnreachableMachineBlockElimLegacyPass.adoc[`initializeUnreachableMachineBlockElimLegacyPass`] 
| Initialize the UnreachableMachineBlockElimLegacy pass&period;
| xref:llvm/initializeVectorization.adoc[`initializeVectorization`] 
| Initialize all passes linked into the Vectorize library&period;
| xref:llvm/initializeVerifierLegacyPassPass.adoc[`initializeVerifierLegacyPassPass`] 
| Initialize the VerifierLegacyPass pass&period;
| xref:llvm/initializeVirtRegMapWrapperLegacyPass.adoc[`initializeVirtRegMapWrapperLegacyPass`] 
| Initialize the VirtRegMapWrapperLegacy pass&period;
| xref:llvm/initializeVirtRegRewriterLegacyPass.adoc[`initializeVirtRegRewriterLegacyPass`] 
| Initialize the VirtRegRewriterLegacy pass&period;
| xref:llvm/initializeWasmEHPreparePass.adoc[`initializeWasmEHPreparePass`] 
| Initialize the WasmEHPrepare pass&period;
| xref:llvm/initializeWinEHPreparePass.adoc[`initializeWinEHPreparePass`] 
| Initialize the WinEHPrepare pass&period;
| xref:llvm/initializeWindowsSecureHotPatchingPass.adoc[`initializeWindowsSecureHotPatchingPass`] 
| Initialize the WindowsSecureHotPatching pass&period;
| xref:llvm/initializeWriteBitcodePassPass.adoc[`initializeWriteBitcodePassPass`] 
| Initialize the WriteBitcodePass pass&period;
| xref:llvm/initializeXRayInstrumentationLegacyPass.adoc[`initializeXRayInstrumentationLegacyPass`] 
| Initialize the XRayInstrumentationLegacy pass&period;
| xref:llvm/inlineCostFeatureToMlFeature.adoc[`inlineCostFeatureToMlFeature`] 
| Map an inline&hyphen;cost feature index to the corresponding ML feature index&period;
| xref:llvm/inlineCostStr.adoc[`inlineCostStr`] 
| Utility for extracting the inline cost message to a string&period;
| xref:llvm/insertDebugValuesForPHIs.adoc[`insertDebugValuesForPHIs`] 
| Propagate dbg&period;value intrinsics through newly inserted PHIs&period;
| xref:llvm/insertIfNotContained.adoc[`insertIfNotContained`] 
| Add `Candidate` to `Cycles` if it is not already contained in `Cycles&period;`
| xref:llvm/inst_begin-02.adoc[`inst&lowbar;begin`] 
| `inst&lowbar;begin` overloads
| xref:llvm/inst_end-01.adoc[`inst&lowbar;end`] 
| `inst&lowbar;end` overloads
| xref:llvm/install_bad_alloc_error_handler.adoc[`install&lowbar;bad&lowbar;alloc&lowbar;error&lowbar;handler`] 
| Installs a new bad alloc error handler that should be used whenever a bad alloc error, e&period;g&period; failing malloc&sol;calloc, is encountered by LLVM&period;
| xref:llvm/install_fatal_error_handler.adoc[`install&lowbar;fatal&lowbar;error&lowbar;handler`] 
| install&lowbar;fatal&lowbar;error&lowbar;handler &hyphen; Installs a new error handler to be used whenever a serious (non&hyphen;recoverable) error is encountered by LLVM&period;
| xref:llvm/install_out_of_memory_new_handler.adoc[`install&lowbar;out&lowbar;of&lowbar;memory&lowbar;new&lowbar;handler`] 
| Install a new&hyphen;handler that reports out&hyphen;of&hyphen;memory as a fatal LLVM error&period;
| xref:llvm/instrprof_category.adoc[`instrprof&lowbar;category`] 
| Return the std&colon;&colon;error&lowbar;category used by instrprof&lowbar;error codes&period;
| xref:llvm/instrs-03.adoc[`instrs`] 
| `instrs` overloads
| xref:llvm/instructions-01d.adoc[`instructions`] 
| `instructions` overloads
| xref:llvm/instructionsWithoutDebug.adoc[`instructionsWithoutDebug`] 
| Return a range from `It` to `End` that skips debug instructions&period;
| xref:llvm/interleave-0e.adoc[`interleave`] 
| `interleave` overloads
| xref:llvm/interleaveComma-0a.adoc[`interleaveComma`] 
| `interleaveComma` overloads
| xref:llvm/interleaved.adoc[`interleaved`] 
| Create a format object that prints `R` with interleaved elements&period;
| xref:llvm/interleaved_array.adoc[`interleaved&lowbar;array`] 
| Create a format object that prints `R` as an interleaved array&period;
| xref:llvm/internalizeModule.adoc[`internalizeModule`] 
| Helper function to internalize functions and variables in a Module&period;
| xref:llvm/intersectAccessGroups.adoc[`intersectAccessGroups`] 
| Compute the intersection of access groups on two instructions&period;
| xref:llvm/intrinsicPropagatesPoison.adoc[`intrinsicPropagatesPoison`] 
| Return whether this intrinsic propagates poison for all operands&period;
| xref:llvm/inverse_children.adoc[`inverse&lowbar;children`] 
| Return a range over the inverse&hyphen;order children of node `G&period;`
| xref:llvm/inverse_depth_first.adoc[`inverse&lowbar;depth&lowbar;first`] 
| Return a range that visits the inverse of `G` in depth&hyphen;first order&period;
| xref:llvm/inverse_depth_first_ext.adoc[`inverse&lowbar;depth&lowbar;first&lowbar;ext`] 
| Return a range that visits the inverse of `G` in depth&hyphen;first order using visited set `S&period;`
| xref:llvm/inverse_fabs.adoc[`inverse&lowbar;fabs`] 
| Return the test mask which returns true after fabs is applied to the value&period;
| xref:llvm/inverse_nodes.adoc[`inverse&lowbar;nodes`] 
| Return a range over all nodes of `G` in inverse graph order&period;
| xref:llvm/inverse_post_order_ext.adoc[`inverse&lowbar;post&lowbar;order&lowbar;ext`] 
| Post&hyphen;order traversal of the inverse of `G` using external visited set `S&period;`
| xref:llvm/invertCondition.adoc[`invertCondition`] 
| Invert a boolean condition, reusing an existing inverted copy when possible&period;
| xref:llvm/invertFPClassTestIfSimpler.adoc[`invertFPClassTestIfSimpler`] 
| Return an inverted FP class test when inversion is cheaper to lower&period;
| xref:llvm/invoke.adoc[`invoke`] 
| C&plus;&plus;20 `constexpr` `invoke&period;`
| xref:llvm/invokeGlobalTargetPassConfigCallbacks.adoc[`invokeGlobalTargetPassConfigCallbacks`] 
| Invoke every registered `PassConfigCallback` for the given target setup&period;
| xref:llvm/isASCII-0b.adoc[`isASCII`] 
| `isASCII` overloads
| xref:llvm/isAcquireOrStronger.adoc[`isAcquireOrStronger`] 
| Return true if `AO` is `Acquire` or stronger in the atomic ordering lattice&period;
| xref:llvm/isAddrAligned.adoc[`isAddrAligned`] 
| Checks that Addr is a multiple of the alignment&period;
| xref:llvm/isAligned.adoc[`isAligned`] 
| Checks that SizeInBytes is a multiple of the alignment&period;
| xref:llvm/isAllOnesConstant.adoc[`isAllOnesConstant`] 
| Returns true if `V` is an integer constant with all bits set&period;
| xref:llvm/isAllOnesOrAllOnesSplat-09.adoc[`isAllOnesOrAllOnesSplat`] 
| `isAllOnesOrAllOnesSplat` overloads
| xref:llvm/isAllocLikeFn.adoc[`isAllocLikeFn`] 
| Tests if a value is a call or invoke to a library function that allocates memory (either malloc, calloc, or strdup like)&period;
| xref:llvm/isAllocaPromotable.adoc[`isAllocaPromotable`] 
| Return true if this alloca is legal for promotion&period;
| xref:llvm/isAllocationFn-0ba.adoc[`isAllocationFn`] 
| Tests if a value is a call or invoke to a library function that allocates or reallocates memory (either malloc, calloc, realloc, or strdup like)&period;
| xref:llvm/isAlmostDeadIV.adoc[`isAlmostDeadIV`] 
| Return true if removing exit test `Cond` would make induction variable `IV` dead&period;
| xref:llvm/isAlnum.adoc[`isAlnum`] 
| Checks whether character `C` is either a decimal digit or an uppercase or lowercase letter as classified by &quot;C&quot; locale&period;
| xref:llvm/isAlpha.adoc[`isAlpha`] 
| Checks if character `C` is a valid letter as classified by &quot;C&quot; locale&period;
| xref:llvm/isArm64ECMangledFunctionName.adoc[`isArm64ECMangledFunctionName`] 
| Check if an ARM64EC function name is mangled&period;
| xref:llvm/isAssertMI.adoc[`isAssertMI`] 
| Returns true if the instruction `MI` is one of the assert instructions&period;
| xref:llvm/isAssignmentTrackingEnabled.adoc[`isAssignmentTrackingEnabled`] 
| Return true if assignment tracking is enabled for module `M&period;`
| xref:llvm/isAssumeLikeIntrinsic.adoc[`isAssumeLikeIntrinsic`] 
| Return true if it is an intrinsic that cannot be speculated but also cannot trap&period;
| xref:llvm/isAssumeWithEmptyBundle.adoc[`isAssumeWithEmptyBundle`] 
| Return true if an llvm&period;assume&apos;s operand bundles hold no useful knowledge&period;
| xref:llvm/isAsynchronousEHPersonality.adoc[`isAsynchronousEHPersonality`] 
| Returns true if this personality function catches asynchronous exceptions&period;
| xref:llvm/isAtLeastOrStrongerThan.adoc[`isAtLeastOrStrongerThan`] 
| Return true if `AO` is at least as strong as `Other` in the atomic ordering lattice&period;
| xref:llvm/isBaseOfObject.adoc[`isBaseOfObject`] 
| Return true if V is known to be the base of its memory object&period;
| xref:llvm/isBitcode.adoc[`isBitcode`] 
| isBitcode &hyphen; Return true if the given bytes are the magic bytes for LLVM IR bitcode, either with or without a wrapper&period;
| xref:llvm/isBitcodeContainingObjCCategory.adoc[`isBitcodeContainingObjCCategory`] 
| Return true if `Buffer` contains a bitcode file with ObjC code (category or class) in it&period;
| xref:llvm/isBitcodeWrapper.adoc[`isBitcodeWrapper`] 
| isBitcodeWrapper &hyphen; Return true if the given bytes are the magic bytes for an LLVM IR bitcode wrapper&period;
| xref:llvm/isBitcodeWriterPass.adoc[`isBitcodeWriterPass`] 
| Check whether a pass is a BitcodeWriterPass&period;
| xref:llvm/isBitwiseNot.adoc[`isBitwiseNot`] 
| Returns true if `V` is a bitwise not operation&period;
| xref:llvm/isBranchWeightMD.adoc[`isBranchWeightMD`] 
| Checks if an MDNode contains Branch Weight Metadata
| xref:llvm/isBuildVectorAllOnes.adoc[`isBuildVectorAllOnes`] 
| Return true if the specified instruction is a G&lowbar;BUILD&lowbar;VECTOR or G&lowbar;BUILD&lowbar;VECTOR&lowbar;TRUNC where all of the elements are &#126;0 or undef&period;
| xref:llvm/isBuildVectorAllZeros.adoc[`isBuildVectorAllZeros`] 
| Return true if the specified instruction is a G&lowbar;BUILD&lowbar;VECTOR or G&lowbar;BUILD&lowbar;VECTOR&lowbar;TRUNC where all of the elements are 0 or undef&period;
| xref:llvm/isBuildVectorConstantSplat-004.adoc[`isBuildVectorConstantSplat`] 
| `isBuildVectorConstantSplat` overloads
| xref:llvm/isBytewiseValue.adoc[`isBytewiseValue`] 
| If the specified value can be set by repeating the same byte in memory, return the i8 value that it is represented with&period;
| xref:llvm/isCFGuardCall.adoc[`isCFGuardCall`] 
| Return true if `CB` is a Control Flow Guard check or dispatch call&period;
| xref:llvm/isCFGuardFunction.adoc[`isCFGuardFunction`] 
| Return true if `GV` is a Control Flow Guard runtime function&period;
| xref:llvm/isCallableCC.adoc[`isCallableCC`] 
| Return true if the calling convention allows the function to be called directly or indirectly via a call&hyphen;like instruction&period;
| xref:llvm/isCheckForZeroAndMulWithOverflow-08.adoc[`isCheckForZeroAndMulWithOverflow`] 
| Return true if `Op0` and `Op1` match a zero check with mul&hyphen;with&hyphen;overflow&period;
| xref:llvm/isCompileUnit.adoc[`isCompileUnit`] 
| True if `U` is a compile unit (not a type unit)&period;
| xref:llvm/isConsecutiveAccess.adoc[`isConsecutiveAccess`] 
| Returns true if the memory operations `A` and `B` are consecutive&period; This is a simple API that does not depend on the analysis pass&period;
| xref:llvm/isConstFalseVal.adoc[`isConstFalseVal`] 
| Returns true if given the TargetLowering&apos;s boolean contents information, the value `Val` contains a false value&period;
| xref:llvm/isConstOrConstSplat-08.adoc[`isConstOrConstSplat`] 
| `isConstOrConstSplat` overloads
| xref:llvm/isConstOrConstSplatFP-08.adoc[`isConstOrConstSplatFP`] 
| `isConstOrConstSplatFP` overloads
| xref:llvm/isConstTrueVal.adoc[`isConstTrueVal`] 
| Returns true if given the TargetLowering&apos;s boolean contents information, the value `Val` contains a true value&period;
| xref:llvm/isConstantOrConstantSplatVector.adoc[`isConstantOrConstantSplatVector`] 
| Determines if `Def` defines a constant integer or a splat vector of constant integers&period;
| xref:llvm/isConstantOrConstantSplatVectorFP.adoc[`isConstantOrConstantSplatVectorFP`] 
| Determines if `Def` defines a float constant integer or a splat vector of float constant integers&period;
| xref:llvm/isConstantOrConstantVector-04.adoc[`isConstantOrConstantVector`] 
| `isConstantOrConstantVector` overloads
| xref:llvm/isCriticalEdge-0e.adoc[`isCriticalEdge`] 
| `isCriticalEdge` overloads
| xref:llvm/isCurrentDebugType.adoc[`isCurrentDebugType`] 
| Return true if `Type` matches the active &hyphen;debug&hyphen;only filter&period;
| xref:llvm/isCycleInvariant.adoc[`isCycleInvariant`] 
| Return true if instruction `I` is invariant in cycle `Cycle&period;`
| xref:llvm/isDefaultFPEnvironment.adoc[`isDefaultFPEnvironment`] 
| Returns true if the exception handling behavior and rounding mode match what is used in the default floating point environment&period;
| xref:llvm/isDereferenceableAndAlignedInLoop-0e.adoc[`isDereferenceableAndAlignedInLoop`] 
| `isDereferenceableAndAlignedInLoop` overloads
| xref:llvm/isDereferenceableAndAlignedPointer-0d.adoc[`isDereferenceableAndAlignedPointer`] 
| `isDereferenceableAndAlignedPointer` overloads
| xref:llvm/isDereferenceablePointer-03.adoc[`isDereferenceablePointer`] 
| Equivalent to isDereferenceableAndAlignedPointer with an alignment of 1&period;
| xref:llvm/isDigit.adoc[`isDigit`] 
| Checks if character `C` is one of the 10 decimal digits&period;
| xref:llvm/isEmbeddedModelEvaluatorValid-0f.adoc[`isEmbeddedModelEvaluatorValid`] 
| `isEmbeddedModelEvaluatorValid` overloads
| xref:llvm/isEscapeSource.adoc[`isEscapeSource`] 
| Returns true if the pointer is one which would have been considered an escape by isNotCapturedBefore&period;
| xref:llvm/isExplicitlyUnknownProfileMetadata.adoc[`isExplicitlyUnknownProfileMetadata`] 
| Check whether `MD` is explicitly&hyphen;unknown profile metadata&period;
| xref:llvm/isFilterPassesEmpty.adoc[`isFilterPassesEmpty`] 
| Returns true if the `&hyphen;filter&hyphen;passes` list is empty&period;
| xref:llvm/isFinite.adoc[`isFinite`] 
| Return true if this loop can be assumed to run for a finite number of iterations&period;
| xref:llvm/isFuncletEHPersonality.adoc[`isFuncletEHPersonality`] 
| Returns true if this is a personality function that invokes handler funclets (which must return to it)&period;
| xref:llvm/isFunctionInPrintList.adoc[`isFunctionInPrintList`] 
| Returns true if IR for `FunctionName` should be printed&period;
| xref:llvm/isGPUProfTarget.adoc[`isGPUProfTarget`] 
| Return true if `M` targets a GPU eligible for PGO instrumentation&period;
| xref:llvm/isGuaranteedNotToBePoison-0d.adoc[`isGuaranteedNotToBePoison`] 
| `isGuaranteedNotToBePoison` overloads
| xref:llvm/isGuaranteedNotToBeUndef-0a.adoc[`isGuaranteedNotToBeUndef`] 
| `isGuaranteedNotToBeUndef` overloads
| xref:llvm/isGuaranteedNotToBeUndefOrPoison-02.adoc[`isGuaranteedNotToBeUndefOrPoison`] 
| `isGuaranteedNotToBeUndefOrPoison` overloads
| xref:llvm/isGuaranteedToExecuteForEveryIteration.adoc[`isGuaranteedToExecuteForEveryIteration`] 
| Return true if this function can prove that the instruction I is executed for every iteration of the loop L&period;
| xref:llvm/isGuaranteedToTransferExecutionToSuccessor-03.adoc[`isGuaranteedToTransferExecutionToSuccessor`] 
| `isGuaranteedToTransferExecutionToSuccessor` overloads
| xref:llvm/isGuard.adoc[`isGuard`] 
| Returns true iff `U` has semantics of a guard expressed in a form of call of llvm&period;experimental&period;guard intrinsic&period;
| xref:llvm/isGuardAsWidenableBranch.adoc[`isGuardAsWidenableBranch`] 
| Returns true iff `U` has semantics of a guard expressed in a form of a widenable conditional branch to deopt block&period;
| xref:llvm/isHeuristicInlineCostFeature.adoc[`isHeuristicInlineCostFeature`] 
| Return true if `Feature` contributes to the heuristic inline cost&period;
| xref:llvm/isHexDigit.adoc[`isHexDigit`] 
| Checks if character `C` is a hexadecimal numeric character&period;
| xref:llvm/isIRPGOFlagSet.adoc[`isIRPGOFlagSet`] 
| Return true if INSTR&lowbar;PROF&lowbar;RAW&lowbar;VERSION&lowbar;VAR is defined in `M&period;`
| xref:llvm/isIRPrintingPass.adoc[`isIRPrintingPass`] 
| Return true if a pass is for IR printing&period;
| xref:llvm/isIdentifiedFunctionLocal.adoc[`isIdentifiedFunctionLocal`] 
| Return true if V is unambiguously identified at the function level&period;
| xref:llvm/isIdentifiedObject.adoc[`isIdentifiedObject`] 
| Return true if this pointer refers to a distinct and identifiable object&period;
| xref:llvm/isImpliedByDomCondition-0fb.adoc[`isImpliedByDomCondition`] 
| `isImpliedByDomCondition` overloads
| xref:llvm/isImpliedCondition-0e.adoc[`isImpliedCondition`] 
| `isImpliedCondition` overloads
| xref:llvm/isInTailCallPosition.adoc[`isInTailCallPosition`] 
| Test whether an instruction is in a position for tail&hyphen;call optimization&period;
| xref:llvm/isInlineViable.adoc[`isInlineViable`] 
| Check if it is mechanically possible to inline the function `Callee,` based on the contents of the function&period;
| xref:llvm/isInstructionTriviallyDead.adoc[`isInstructionTriviallyDead`] 
| Return true if an unused instruction is trivially dead&period;
| xref:llvm/isInt.adoc[`isInt`] 
| Checks if an integer fits into the given bit width&period;
| xref:llvm/isIntN.adoc[`isIntN`] 
| Checks if an signed integer fits into the given (dynamic) bit width&period;
| xref:llvm/isIntOrFPConstant.adoc[`isIntOrFPConstant`] 
| Return true if `V` is either a integer or FP constant&period;
| xref:llvm/isIntrinsicReturningPointerAliasingArgumentWithoutCapturing.adoc[`isIntrinsicReturningPointerAliasingArgumentWithoutCapturing`] 
| Return true if `Call` is an intrinsic that returns a pointer aliasing an argument without capturing it otherwise&period;
| xref:llvm/isKnownIntegral.adoc[`isKnownIntegral`] 
| Return true if the floating&hyphen;point value `V` is known to be an integer value&period;
| xref:llvm/isKnownInversion.adoc[`isKnownInversion`] 
| Return true iff&colon; 1&period; X is poison implies Y is poison&period; 2&period; X is true implies Y is false&period; 3&period; X is false implies Y is true&period; Otherwise, return false&period;
| xref:llvm/isKnownNegation.adoc[`isKnownNegation`] 
| Return true if the two given values are negation&period;
| xref:llvm/isKnownNegative.adoc[`isKnownNegative`] 
| Returns true if the given value is known be negative (i&period;e&period; non&hyphen;positive and non&hyphen;zero)&period;
| xref:llvm/isKnownNegativeInLoop.adoc[`isKnownNegativeInLoop`] 
| Returns true if we can prove that `S` is defined and always negative in loop `L&period;`
| xref:llvm/isKnownNeverInfOrNaN.adoc[`isKnownNeverInfOrNaN`] 
| Return true if the floating&hyphen;point value can never contain a NaN or infinity&period;
| xref:llvm/isKnownNeverInfinity.adoc[`isKnownNeverInfinity`] 
| Return true if the floating&hyphen;point scalar value is not an infinity or if the floating&hyphen;point vector value has no infinities&period;
| xref:llvm/isKnownNeverNaN.adoc[`isKnownNeverNaN`] 
| Return true if the floating&hyphen;point scalar value is not a NaN or if the floating&hyphen;point vector value has no NaN elements&period;
| xref:llvm/isKnownNonEqual.adoc[`isKnownNonEqual`] 
| Return true if the given values are known to be non&hyphen;equal when defined&period; Supports scalar integer types only&period;
| xref:llvm/isKnownNonNegative.adoc[`isKnownNonNegative`] 
| Returns true if the give value is known to be non&hyphen;negative&period;
| xref:llvm/isKnownNonNegativeInLoop.adoc[`isKnownNonNegativeInLoop`] 
| Returns true if we can prove that `S` is defined and always non&hyphen;negative in loop `L&period;`
| xref:llvm/isKnownNonPositiveInLoop.adoc[`isKnownNonPositiveInLoop`] 
| Returns true if we can prove that `S` is defined and always non&hyphen;positive in loop `L&period;`
| xref:llvm/isKnownNonZero.adoc[`isKnownNonZero`] 
| Return true if the given value is known to be non&hyphen;zero when defined&period;
| xref:llvm/isKnownPositive.adoc[`isKnownPositive`] 
| Returns true if the given value is known be positive (i&period;e&period; non&hyphen;negative and non&hyphen;zero)&period;
| xref:llvm/isKnownPositiveInLoop.adoc[`isKnownPositiveInLoop`] 
| Returns true if we can prove that `S` is defined and always positive in loop `L&period;`
| xref:llvm/isKnownToBeAPowerOfTwo-01.adoc[`isKnownToBeAPowerOfTwo`] 
| `isKnownToBeAPowerOfTwo` overloads
| xref:llvm/isLegalToPromote.adoc[`isLegalToPromote`] 
| Return true if the given indirect call site can be made to call `Callee&period;`
| xref:llvm/isLegalUTF8Sequence.adoc[`isLegalUTF8Sequence`] 
| Returns true if the UTF&hyphen;8 sequence starting at `source` is well&hyphen;formed&period;
| xref:llvm/isLegalUTF8String.adoc[`isLegalUTF8String`] 
| Returns true if the UTF&hyphen;8 string between `&ast;source` and `sourceEnd` is legal&period;
| xref:llvm/isLibFreeFunction.adoc[`isLibFreeFunction`] 
| isLibFreeFunction &hyphen; Returns true if the function is a builtin free()
| xref:llvm/isLibFuncEmittable-0c.adoc[`isLibFuncEmittable`] 
| `isLibFuncEmittable` overloads
| xref:llvm/isLower.adoc[`isLower`] 
| Checks if character `C` is a lowercase letter as classified by &quot;C&quot; locale&period;
| xref:llvm/isManyPotentiallyReachableFromMany.adoc[`isManyPotentiallyReachableFromMany`] 
| Determine whether any block in `Worklist` can reach any block in `StopSet&period;`
| xref:llvm/isMask_32.adoc[`isMask&lowbar;32`] 
| Return true if the argument is a non&hyphen;empty low&hyphen;bit ones mask (32&hyphen;bit)&period;
| xref:llvm/isMask_64.adoc[`isMask&lowbar;64`] 
| Return true if the argument is a non&hyphen;empty sequence of ones starting at the least significant bit with the remainder zero (64 bit version)&period;
| xref:llvm/isMaskedSlidePair.adoc[`isMaskedSlidePair`] 
| Return true if `Mask` is one slide or a masked pair of slides&period;
| xref:llvm/isMathLibCallNoop.adoc[`isMathLibCallNoop`] 
| Check whether the given call has no side&hyphen;effects&period; Specifically checks for math routimes which sometimes set errno&period;
| xref:llvm/isMinSignedConstant.adoc[`isMinSignedConstant`] 
| Returns true if `V` is a constant min signed integer value&period;
| xref:llvm/isModAndRefSet.adoc[`isModAndRefSet`] 
| Return true if `MRI` indicates both modification and reference&period;
| xref:llvm/isModOrRefSet.adoc[`isModOrRefSet`] 
| Return true if `MRI` indicates any memory modification or reference&period;
| xref:llvm/isModSet.adoc[`isModSet`] 
| Return whether `MRI` includes a possible memory modification&period;
| xref:llvm/isMustProgress.adoc[`isMustProgress`] 
| Return true if this loop can be assumed to make progress&period; (i&period;e&period; can&apos;t be infinite without side effects without also being undefined)
| xref:llvm/isNoAliasCall.adoc[`isNoAliasCall`] 
| Return true if this pointer is returned by a noalias function&period;
| xref:llvm/isNoModRef.adoc[`isNoModRef`] 
| Return whether `MRI` indicates neither modification nor reference&period;
| xref:llvm/isNoOpWithoutInvoke.adoc[`isNoOpWithoutInvoke`] 
| Return true if this personality may be safely removed if there are no invoke instructions remaining in the current function&period;
| xref:llvm/isNonDataDep.adoc[`isNonDataDep`] 
| Returns true if `Dep` is a non&hyphen;null non&hyphen;data dependency&period;
| xref:llvm/isNotCrossLaneOperation.adoc[`isNotCrossLaneOperation`] 
| Return true if the instruction doesn&apos;t potentially cross vector lanes&period;
| xref:llvm/isNotVisibleOnUnwind.adoc[`isNotVisibleOnUnwind`] 
| Return true if Object memory is not visible after an unwind&period;
| xref:llvm/isNullConstant.adoc[`isNullConstant`] 
| Returns true if `V` is a constant integer zero&period;
| xref:llvm/isNullConstantOrUndef.adoc[`isNullConstantOrUndef`] 
| Returns true if `V` is a constant integer zero or an UNDEF node&period;
| xref:llvm/isNullFPConstant.adoc[`isNullFPConstant`] 
| Returns true if `V` is an FP constant with a value of positive zero&period;
| xref:llvm/isNullOrNullSplat-0a.adoc[`isNullOrNullSplat`] 
| Return true if the value is a constant 0 integer or a null splat&period;
| xref:llvm/isOneConstant.adoc[`isOneConstant`] 
| Returns true if `V` is a constant integer one&period;
| xref:llvm/isOneOrOneSplat.adoc[`isOneOrOneSplat`] 
| Return true if the value is a constant 1 integer or a one splat&period;
| xref:llvm/isOneOrOneSplatFP.adoc[`isOneOrOneSplatFP`] 
| Return true if the value is an FP 1&period;0 constant or splat&period;
| xref:llvm/isOnesOrOnesSplat.adoc[`isOnesOrOnesSplat`] 
| Return true if the value is a constant 1 integer or splat without truncation&period;
| xref:llvm/isOnlyUsedInZeroComparison.adoc[`isOnlyUsedInZeroComparison`] 
| Return true if `CxtI` is only used in comparisons against zero&period;
| xref:llvm/isOnlyUsedInZeroEqualityComparison.adoc[`isOnlyUsedInZeroEqualityComparison`] 
| Return true if `CxtI` is only used in equality comparisons against zero&period;
| xref:llvm/isOverflowIntrinsicNoWrap.adoc[`isOverflowIntrinsicNoWrap`] 
| Returns true if the arithmetic part of the `WO` &apos;s result is used only along no&hyphen;overflow paths&period;
| xref:llvm/isPassInPrintList.adoc[`isPassInPrintList`] 
| Returns true if `&hyphen;filter&hyphen;passes` is empty or contains `PassName&period;`
| xref:llvm/isPhysRegUsedAfter.adoc[`isPhysRegUsedAfter`] 
| Check if physical register `Reg` is used after `MBI&period;`
| xref:llvm/isPotentiallyReachable-0d.adoc[`isPotentiallyReachable`] 
| `isPotentiallyReachable` overloads
| xref:llvm/isPotentiallyReachableFromMany.adoc[`isPotentiallyReachableFromMany`] 
| Determine whether any block in `Worklist` can reach `StopBB&period;`
| xref:llvm/isPowerOf2_32.adoc[`isPowerOf2&lowbar;32`] 
| Return true if the argument is a power of two &gt; 0&period; Ex&period; isPowerOf2&lowbar;32(0x00100000U) &equals;&equals; true (32 bit edition&period;)
| xref:llvm/isPowerOf2_64.adoc[`isPowerOf2&lowbar;64`] 
| Return true if the argument is a power of two &gt; 0 (64 bit edition&period;)
| xref:llvm/isPreISelGenericFloatingPointOpcode.adoc[`isPreISelGenericFloatingPointOpcode`] 
| Returns whether opcode `Opc` is a pre&hyphen;isel generic floating&hyphen;point opcode, having only floating&hyphen;point operands&period;
| xref:llvm/isPreISelGenericOpcode.adoc[`isPreISelGenericOpcode`] 
| Check whether the given Opcode is a generic opcode that is not supposed to appear after ISel&period;
| xref:llvm/isPreISelGenericOptimizationHint.adoc[`isPreISelGenericOptimizationHint`] 
| Check whether the given Opcode is an optimization hint that is not supposed to appear after ISel&period;
| xref:llvm/isPrefixedHexStyle.adoc[`isPrefixedHexStyle`] 
| Return true if a hex print style includes a radix prefix&period;
| xref:llvm/isPresplitCoroSuspendExitEdge.adoc[`isPresplitCoroSuspendExitEdge`] 
| Return true if `Src` to `Dest` is a presplit coroutine suspend exit edge&period;
| xref:llvm/isPrint.adoc[`isPrint`] 
| Checks whether character `C` is printable&period;
| xref:llvm/isPunct.adoc[`isPunct`] 
| Checks whether character `C` is a punctuation character&period;
| xref:llvm/isRangeRelaxable.adoc[`isRangeRelaxable`] 
| Return true if the distance between `Begin` and `End` may change at link time&period;
| xref:llvm/isRawBitcode.adoc[`isRawBitcode`] 
| isRawBitcode &hyphen; Return true if the given bytes are the magic bytes for raw LLVM IR bitcode (without a wrapper)&period;
| xref:llvm/isReachedBefore.adoc[`isReachedBefore`] 
| Return true if `I0` is reached before `I1` in the control flow&period;
| xref:llvm/isReadOnlyLoop.adoc[`isReadOnlyLoop`] 
| Returns true if the loop contains read&hyphen;only memory accesses and doesn&apos;t throw&period; Puts loads that may fault into `NonDereferenceableAndAlignedLoads&period;`
| xref:llvm/isReallocLikeFn.adoc[`isReallocLikeFn`] 
| Tests if a function is a call or invoke to a library function that reallocates memory (e&period;g&period;, realloc)&period;
| xref:llvm/isRefSet.adoc[`isRefSet`] 
| Return whether `MRI` includes a possible memory reference&period;
| xref:llvm/isReleaseModelValid-039.adoc[`isReleaseModelValid`] 
| Check whether a release&hyphen;mode ML advisor has a valid model to execute&period;
| xref:llvm/isReleaseOrStronger.adoc[`isReleaseOrStronger`] 
| Return true if `AO` is `Release` or stronger in the atomic ordering lattice&period;
| xref:llvm/isRemovableAlloc.adoc[`isRemovableAlloc`] 
| Return true if this is a call to a removable allocation function&period;
| xref:llvm/isSafeToDestroyConstant.adoc[`isSafeToDestroyConstant`] 
| Return true if it is safe to destroy constant `C&period;`
| xref:llvm/isSafeToLoadUnconditionally-04.adoc[`isSafeToLoadUnconditionally`] 
| Return true if we know that executing a load from this value cannot trap&period;
| xref:llvm/isSafeToMoveBefore-02.adoc[`isSafeToMoveBefore`] 
| `isSafeToMoveBefore` overloads
| xref:llvm/isSafeToSpeculativelyExecute-00.adoc[`isSafeToSpeculativelyExecute`] 
| `isSafeToSpeculativelyExecute` overloads
| xref:llvm/isSafeToSpeculativelyExecuteWithOpcode.adoc[`isSafeToSpeculativelyExecuteWithOpcode`] 
| Like isSafeToSpeculativelyExecute, but with `Opcode` overriding Inst&period;
| xref:llvm/isSafeToSpeculativelyExecuteWithVariableReplaced.adoc[`isSafeToSpeculativelyExecuteWithVariableReplaced`] 
| Don&apos;t use information from its non&hyphen;constant operands&period; This helper is used when its operands are going to be replaced&period;
| xref:llvm/isSafeToUnrollAndJam.adoc[`isSafeToUnrollAndJam`] 
| Return true if it is safe to unroll&hyphen;and&hyphen;jam loop `L&period;`
| xref:llvm/isScopedEHPersonality.adoc[`isScopedEHPersonality`] 
| Returns true if this personality uses scope&hyphen;style EH IR instructions&colon; catchswitch, catchpad&sol;ret, and cleanuppad&sol;ret&period;
| xref:llvm/isShiftedInt.adoc[`isShiftedInt`] 
| Checks if a signed integer is an N bit number shifted left by S&period;
| xref:llvm/isShiftedMask_32-05.adoc[`isShiftedMask&lowbar;32`] 
| `isShiftedMask&lowbar;32` overloads
| xref:llvm/isShiftedMask_64-0b.adoc[`isShiftedMask&lowbar;64`] 
| `isShiftedMask&lowbar;64` overloads
| xref:llvm/isShiftedUInt.adoc[`isShiftedUInt`] 
| Checks if a unsigned integer is an N bit number shifted left by S&period;
| xref:llvm/isSignBitCheck.adoc[`isSignBitCheck`] 
| Given an exploded icmp instruction, return true if the comparison only checks the sign bit&period;
| xref:llvm/isSpace.adoc[`isSpace`] 
| Checks whether character `C` is whitespace in the &quot;C&quot; locale&period;
| xref:llvm/isSpecialPass.adoc[`isSpecialPass`] 
| Return whether `PassID` names a special pass ending with a suffix in `Specials&period;`
| xref:llvm/isSplatValue.adoc[`isSplatValue`] 
| Return true if each element of `V` is poisoned or equal to the others&period;
| xref:llvm/isStatepointDirectiveAttr.adoc[`isStatepointDirectiveAttr`] 
| Return `true` if the `Attr` is an attribute that is a statepoint directive&period;
| xref:llvm/isStrongerThan.adoc[`isStrongerThan`] 
| Returns true if ao is stronger than other as defined by the AtomicOrdering lattice, which is based on C&plus;&plus;&apos;s definition&period;
| xref:llvm/isStrongerThanMonotonic.adoc[`isStrongerThanMonotonic`] 
| Return true if `AO` is strictly stronger than `Monotonic&period;`
| xref:llvm/isStrongerThanUnordered.adoc[`isStrongerThanUnordered`] 
| Return true if `AO` is strictly stronger than `Unordered&period;`
| xref:llvm/isTargetSpecificOpcode.adoc[`isTargetSpecificOpcode`] 
| Check whether the given Opcode is a target&hyphen;specific opcode&period;
| xref:llvm/isTheSameCluster.adoc[`isTheSameCluster`] 
| Return whether the input cluster ID&apos;s are the same and valid&period;
| xref:llvm/isTimeTraceVerbose.adoc[`isTimeTraceVerbose`] 
| Return true if the current thread&apos;s profiler is capturing verbose details&period;
| xref:llvm/isTriviallyDead.adoc[`isTriviallyDead`] 
| Check whether an instruction `MI` is dead&colon; it only defines dead virtual registers, and doesn&apos;t have other side effects&period;
| xref:llvm/isTriviallyScalarizable.adoc[`isTriviallyScalarizable`] 
| Identify if the intrinsic is trivially scalarizable&period;
| xref:llvm/isTriviallyVectorizable.adoc[`isTriviallyVectorizable`] 
| Identify if the intrinsic is trivially vectorizable&period;
| xref:llvm/isUInt.adoc[`isUInt`] 
| Checks if an unsigned integer fits into the given bit width&period;
| xref:llvm/isUIntN.adoc[`isUIntN`] 
| Checks if an unsigned integer fits into the given (dynamic) bit width&period;
| xref:llvm/isUnpackedStructLiteral.adoc[`isUnpackedStructLiteral`] 
| Returns true if `StructTy` is an unpacked (non&hyphen;packed) literal struct&period;
| xref:llvm/isUpper.adoc[`isUpper`] 
| Checks if character `C` is a uppercase letter as classified by &quot;C&quot; locale&period;
| xref:llvm/isValidAsAccessGroup.adoc[`isValidAsAccessGroup`] 
| Return whether an MDNode might represent an access group&period;
| xref:llvm/isValidAssumeForContext-01.adoc[`isValidAssumeForContext`] 
| `isValidAssumeForContext` overloads
| xref:llvm/isValidAtomicOrdering.adoc[`isValidAtomicOrdering`] 
| Return true if `I` is a valid `AtomicOrdering` enumerator value&period;
| xref:llvm/isValidAtomicOrderingCABI.adoc[`isValidAtomicOrderingCABI`] 
| Return true if `I` is a valid `AtomicOrderingCABI` enumerator value&period;
| xref:llvm/isValueProfileMD.adoc[`isValueProfileMD`] 
| Checks if an MDNode contains value profiling Metadata
| xref:llvm/isVectorIntrinsicWithOverloadTypeAtArg.adoc[`isVectorIntrinsicWithOverloadTypeAtArg`] 
| Identify if a vector intrinsic is overloaded on an operand or return type&period;
| xref:llvm/isVectorIntrinsicWithScalarOpAtArg.adoc[`isVectorIntrinsicWithScalarOpAtArg`] 
| Identify if the vector form of an intrinsic has a scalar operand&period;
| xref:llvm/isVectorIntrinsicWithStructReturnOverloadAtField.adoc[`isVectorIntrinsicWithStructReturnOverloadAtField`] 
| Identify if a struct&hyphen;returning vector intrinsic is overloaded at a field&period;
| xref:llvm/isVectorizedStructTy.adoc[`isVectorizedStructTy`] 
| Returns true if `StructTy` is an unpacked literal struct where all elements are vectors of matching element count&period; This does not include empty structs&period;
| xref:llvm/isVectorizedTy.adoc[`isVectorizedTy`] 
| Returns true if `Ty` is a vector type or a struct of vector types where all vector types share the same VF&period;
| xref:llvm/isWidenableBranch.adoc[`isWidenableBranch`] 
| Returns true iff `U` is a widenable branch (that is, extractWidenableCondition returns widenable condition)&period;
| xref:llvm/isWidenableCondition.adoc[`isWidenableCondition`] 
| Returns true iff `V` has semantics of llvm&period;experimental&period;widenable&period;condition call&period;
| xref:llvm/isWritableObject.adoc[`isWritableObject`] 
| Return true if Object is writable without trapping&period;
| xref:llvm/isZeroOrZeroSplat.adoc[`isZeroOrZeroSplat`] 
| Return true if the value is a constant 0 integer or splat&period;
| xref:llvm/isZeroOrZeroSplatFP.adoc[`isZeroOrZeroSplatFP`] 
| Return true if the value is a (&plus;&sol;&hyphen;)0&period;0 FP constant or splat&period;
| xref:llvm/is_contained-05.adoc[`is&lowbar;contained`] 
| `is&lowbar;contained` overloads
| xref:llvm/is_sorted-01.adoc[`is&lowbar;sorted`] 
| `is&lowbar;sorted` overloads
| xref:llvm/is_sorted_constexpr-04.adoc[`is&lowbar;sorted&lowbar;constexpr`] 
| `is&lowbar;sorted&lowbar;constexpr` overloads
| xref:llvm/isa.adoc[`isa`] 
| isa&lt;X&gt; &hyphen; Return true if the parameter to the template is an instance of one of the template type arguments&period; Used like this&colon;
| xref:llvm/isa_and_nonnull.adoc[`isa&lowbar;and&lowbar;nonnull`] 
| Return true if `Val` is present and matches any of `X&period;`
| xref:llvm/isa_and_present.adoc[`isa&lowbar;and&lowbar;present`] 
| isa&lowbar;and&lowbar;present&lt;X&gt; &hyphen; Functionally identical to isa, except that a null value is accepted&period;
| xref:llvm/itaniumDemangle.adoc[`itaniumDemangle`] 
| Demangle an Itanium ABI mangled name&period;
| xref:llvm/itostr.adoc[`itostr`] 
| Convert a signed integer to a decimal string&period;
| xref:llvm/jitLinkForORC.adoc[`jitLinkForORC`] 
| Asynchronously link `O` for ORC using RuntimeDyld&period;
| xref:llvm/jitTargetAddressToFunction.adoc[`jitTargetAddressToFunction`] 
| Convert a JITTargetAddress to a callable function pointer&period;
| xref:llvm/jitTargetAddressToPointer.adoc[`jitTargetAddressToPointer`] 
| Convert a JITTargetAddress to a pointer&period;
| xref:llvm/jobserver_concurrency.adoc[`jobserver&lowbar;concurrency`] 
| Coordinate with a GNU Make jobserver when one is present&period;
| xref:llvm/join-08.adoc[`join`] 
| `join` overloads
| xref:llvm/joinErrors.adoc[`joinErrors`] 
| Concatenate errors from `E1` followed by those from `E2&period;`
| xref:llvm/join_items.adoc[`join&lowbar;items`] 
| Join the strings in `Items,` inserting `Separator` between them&period;
| xref:llvm/lcm.adoc[`lcm`] 
| Returns the least common multiple of `A` and `B&period;`
| xref:llvm/left_justify.adoc[`left&lowbar;justify`] 
| left&lowbar;justify &hyphen; append spaces after string so total output is `Width` characters&period; If `Str` is larger that `Width,` full string is written with no padding&period;
| xref:llvm/legalizeMachineFunction.adoc[`legalizeMachineFunction`] 
| Legalize generic instructions in `MF` according to `LI&period;`
| xref:llvm/libDriverMain.adoc[`libDriverMain`] 
| Entry point for the lib&period;exe&hyphen;compatible driver used by llvm&hyphen;lib and lld&hyphen;link &sol;lib&period;
| xref:llvm/linkAllBuiltinGCs.adoc[`linkAllBuiltinGCs`] 
| Ensure the definition of the builtin GCs gets linked in
| xref:llvm/linkErlangGCPrinter.adoc[`linkErlangGCPrinter`] 
| Creates an erlang&hyphen;compatible metadata printer&period;
| xref:llvm/linkOcamlGCPrinter.adoc[`linkOcamlGCPrinter`] 
| Creates an ocaml&hyphen;compatible metadata printer&period;
| xref:llvm/lintFunction.adoc[`lintFunction`] 
| Lint a function&period;
| xref:llvm/lintModule.adoc[`lintModule`] 
| Lint a module&period;
| xref:llvm/llvm_execute_on_thread_impl.adoc[`llvm&lowbar;execute&lowbar;on&lowbar;thread&lowbar;impl`] 
| Creates a native thread running `ThreadFunc(Arg)` with optional stack size&period;
| xref:llvm/llvm_is_multithreaded.adoc[`llvm&lowbar;is&lowbar;multithreaded`] 
| Returns true if LLVM is compiled with support for multi&hyphen;threading, and false otherwise&period;
| xref:llvm/llvm_shutdown.adoc[`llvm&lowbar;shutdown`] 
| llvm&lowbar;shutdown &hyphen; Deallocate and destroy all ManagedStatic variables&period;
| xref:llvm/llvm_thread_detach_impl.adoc[`llvm&lowbar;thread&lowbar;detach&lowbar;impl`] 
| Detaches the native thread `Thread` so it runs independently&period;
| xref:llvm/llvm_thread_get_current_id_impl.adoc[`llvm&lowbar;thread&lowbar;get&lowbar;current&lowbar;id&lowbar;impl`] 
| Returns the id of the calling thread&period;
| xref:llvm/llvm_thread_get_id_impl.adoc[`llvm&lowbar;thread&lowbar;get&lowbar;id&lowbar;impl`] 
| Returns the thread id corresponding to native handle `Thread&period;`
| xref:llvm/llvm_thread_join_impl.adoc[`llvm&lowbar;thread&lowbar;join&lowbar;impl`] 
| Blocks until the native thread `Thread` completes&period;
| xref:llvm/llvm_unreachable_internal.adoc[`llvm&lowbar;unreachable&lowbar;internal`]  [.small]#[noreturn]#
| Abort with an optional message printed to stderr&period;
| xref:llvm/localCache.adoc[`localCache`] 
| Create a local file system cache which uses the given cache name, temporary file prefix, cache directory and file callback&period;
| xref:llvm/logAllUnhandledErrors.adoc[`logAllUnhandledErrors`] 
| Log all errors in `E` to `OS,` optionally prefixed by `ErrorBanner&period;`
| xref:llvm/longestCommonSequence.adoc[`longestCommonSequence`] 
| Compute the longest common sequence of two anchor lists using Myers&apos; diff&period;
| xref:llvm/lowerAtomicCmpXchgInst.adoc[`lowerAtomicCmpXchgInst`] 
| Convert the given Cmpxchg into primitive load and compare&period;
| xref:llvm/lowerAtomicRMWInst.adoc[`lowerAtomicRMWInst`] 
| Convert the given RMWI into primitive load and stores, assuming that doing so is legal&period; Return true if the lowering succeeds&period;
| xref:llvm/lowerConstantIntrinsics.adoc[`lowerConstantIntrinsics`] 
| Lower remaining objectsize and is&period;constant intrinsic calls in a function&period;
| xref:llvm/lowerGlobalIFuncUsersAsGlobalCtor.adoc[`lowerGlobalIFuncUsersAsGlobalCtor`] 
| Lower ifunc calls via a global table initialized by a constructor&period;
| xref:llvm/lowerObjectSizeCall-02.adoc[`lowerObjectSizeCall`] 
| Try to turn a call to @llvm&period;objectsize into an integer value&period;
| xref:llvm/lowerUnaryVectorIntrinsicAsLoop.adoc[`lowerUnaryVectorIntrinsicAsLoop`] 
| Lower `CI` as a loop&period; `CI` is a unary intrinsic with a vector argument and is deleted and replaced with a loop&period;
| xref:llvm/lower_bound-0f.adoc[`lower&lowbar;bound`] 
| `lower&lowbar;bound` overloads
| xref:llvm/machineFunctionIsIllegal.adoc[`machineFunctionIsIllegal`] 
| Return an illegal instruction in `MF,` or nullptr if MIR is fully legal&period;
| xref:llvm/machineToStr.adoc[`machineToStr`] 
| Return a user&hyphen;readable string for a COFF machine type&period;
| xref:llvm/makeFollowupLoopID.adoc[`makeFollowupLoopID`] 
| Create a new loop identifier for a loop created from a loop transformation&period;
| xref:llvm/makeGuardControlFlowExplicit.adoc[`makeGuardControlFlowExplicit`] 
| Splits control flow at `Guard` into an explicit branch with a deopt path&period;
| xref:llvm/makeIntrusiveRefCnt.adoc[`makeIntrusiveRefCnt`] 
| Factory function for creating intrusive ref counted pointers&period;
| xref:llvm/makePostTransformationMetadata.adoc[`makePostTransformationMetadata`] 
| Create a new LoopID after the loop has been transformed&period;
| xref:llvm/makeSampler-0c4.adoc[`makeSampler`] 
| `makeSampler` overloads
| xref:llvm/makeVisitor.adoc[`makeVisitor`] 
| Returns an opaquely&hyphen;typed Callable object whose operator() overload set is the sum of the operator() overload sets of each CallableT in CallableTs&period;
| xref:llvm/make_early_inc_range.adoc[`make&lowbar;early&lowbar;inc&lowbar;range`] 
| Make a range that does early increment to allow mutation of the underlying range without disrupting iteration&period;
| xref:llvm/make_error.adoc[`make&lowbar;error`] 
| Make a Error instance representing failure using the given error info type&period;
| xref:llvm/make_error_code-05.adoc[`make&lowbar;error&lowbar;code`] 
| `make&lowbar;error&lowbar;code` overloads
| xref:llvm/make_fallible_end.adoc[`make&lowbar;fallible&lowbar;end`] 
| Convenience wrapper to make a fallible&lowbar;iterator end value from an instance of an underlying iterator&period;
| xref:llvm/make_fallible_itr.adoc[`make&lowbar;fallible&lowbar;itr`] 
| Convenience wrapper to make a fallible&lowbar;iterator value from an instance of an underlying iterator and an Error reference&period;
| xref:llvm/make_fallible_range.adoc[`make&lowbar;fallible&lowbar;range`] 
| Build an iterator range whose increments report failure through `Err&period;`
| xref:llvm/make_filter_range.adoc[`make&lowbar;filter&lowbar;range`] 
| Convenience function that takes a range of elements and a predicate, and return a new filter&lowbar;iterator range&period;
| xref:llvm/make_first_range.adoc[`make&lowbar;first&lowbar;range`] 
| Return a range over the first elements of pairs in `c&period;`
| xref:llvm/make_pointee_range-00.adoc[`make&lowbar;pointee&lowbar;range`] 
| Return a range that iterates over the pointees of `Range&period;`
| xref:llvm/make_pointer_range.adoc[`make&lowbar;pointer&lowbar;range`] 
| Return a range whose iterators expose addresses of elements in `Range&period;`
| xref:llvm/make_range-01.adoc[`make&lowbar;range`] 
| `make&lowbar;range` overloads
| xref:llvm/make_second_range.adoc[`make&lowbar;second&lowbar;range`] 
| Return a range over the second elements of pairs in `c&period;`
| xref:llvm/mapAtomInstance.adoc[`mapAtomInstance`] 
| Mark a cloned instruction as a new instance so that its source loc can be updated when remapped&period;
| xref:llvm/mapLastWindowsError.adoc[`mapLastWindowsError`] 
| Map the last Windows error to a portable `std&colon;&colon;error&lowbar;code&period;`
| xref:llvm/mapWindowsError.adoc[`mapWindowsError`] 
| Map a Windows error value to a portable `std&colon;&colon;error&lowbar;code&period;`
| xref:llvm/map_iterator.adoc[`map&lowbar;iterator`] 
| Create a mapped iterator over `I` using `F&period;`
| xref:llvm/map_range.adoc[`map&lowbar;range`] 
| Return a range that applies `F` to the elements of `C&period;`
| xref:llvm/map_to_vector-06.adoc[`map&lowbar;to&lowbar;vector`] 
| Map a range to a SmallVector with element types deduced from the mapping&period; `F` can be a function, lambda, or member pointer&period;
| xref:llvm/markRegisterParameterAttributes.adoc[`markRegisterParameterAttributes`] 
| Apply &hyphen;mregparm&hyphen;style register parameter attributes to a function&period;
| xref:llvm/maskContainsAllOneOrUndef.adoc[`maskContainsAllOneOrUndef`] 
| Return true if any lane of an i1 mask is known true or undef&period;
| xref:llvm/maskLeadingOnes.adoc[`maskLeadingOnes`] 
| Create a bitmask with the N left&hyphen;most bits set to 1, and all other bits set to 0&period; Only unsigned types are allowed&period;
| xref:llvm/maskLeadingZeros.adoc[`maskLeadingZeros`] 
| Create a bitmask with the N left&hyphen;most bits set to 0, and all other bits set to 1&period; Only unsigned types are allowed&period;
| xref:llvm/maskTrailingOnes.adoc[`maskTrailingOnes`] 
| Create a bitmask with the N right&hyphen;most bits set to 1, and all other bits set to 0&period; Only unsigned types are allowed&period;
| xref:llvm/maskTrailingZeros.adoc[`maskTrailingZeros`] 
| Create a bitmask with the N right&hyphen;most bits set to 0, and all other bits set to 1&period; Only unsigned types are allowed&period;
| xref:llvm/matchDecomposedSelectPattern.adoc[`matchDecomposedSelectPattern`] 
| Determine the pattern that a select with the given compare as its predicate and given values as its true&sol;false operands would match&period;
| xref:llvm/matchSelectPattern-06.adoc[`matchSelectPattern`] 
| `matchSelectPattern` overloads
| xref:llvm/matchSimpleBinaryIntrinsicRecurrence.adoc[`matchSimpleBinaryIntrinsicRecurrence`] 
| Match a simple binary&hyphen;intrinsic value&hyphen;accumulating recurrence&period;
| xref:llvm/matchSimpleRecurrence-06.adoc[`matchSimpleRecurrence`] 
| `matchSimpleRecurrence` overloads
| xref:llvm/matchSimpleTernaryIntrinsicRecurrence.adoc[`matchSimpleTernaryIntrinsicRecurrence`] 
| Match a simple ternary&hyphen;intrinsic value&hyphen;accumulating recurrence&period;
| xref:llvm/matchUnaryPredicate.adoc[`matchUnaryPredicate`] 
| Match a unary predicate against a scalar&sol;splat constant or build vector&period;
| xref:llvm/maxIntN.adoc[`maxIntN`] 
| Gets the maximum value for a N&hyphen;bit signed integer&period;
| xref:llvm/maxUIntN.adoc[`maxUIntN`] 
| Gets the maximum value for a N&hyphen;bit unsigned integer&period;
| xref:llvm/max_element-0e.adoc[`max&lowbar;element`] 
| `max&lowbar;element` overloads
| xref:llvm/maximum.adoc[`maximum`] 
| Implements IEEE 754&hyphen;2019 maximum semantics&period; Returns the larger of 2 arguments, returning a quiet NaN if an argument is a NaN and treating &hyphen;0 as less than &plus;0&period;
| xref:llvm/maximumnum.adoc[`maximumnum`] 
| Implements IEEE 754&hyphen;2019 maximumNumber semantics&period; Returns the larger of 2 arguments, not propagating NaNs and treating &hyphen;0 as less than &plus;0&period;
| xref:llvm/maxnum.adoc[`maxnum`] 
| IEEE&hyphen;754&hyphen;2008 maxNum&colon; return the larger of two values&period;
| xref:llvm/mayBeOldLoopAttachmentTag.adoc[`mayBeOldLoopAttachmentTag`] 
| Check whether a string looks like an old loop attachment tag&period;
| xref:llvm/mayContainIrreducibleControl.adoc[`mayContainIrreducibleControl`] 
| Return true if `F` may contain irreducible control flow&period;
| xref:llvm/mayHaveMemprofSummary.adoc[`mayHaveMemprofSummary`] 
| Returns true if the instruction could have memprof metadata, used to ensure consistency between summary analysis and the ThinLTO backend processing&period;
| xref:llvm/mayHaveNonDefUseDependency.adoc[`mayHaveNonDefUseDependency`] 
| Returns true if the result or effects of the given instructions `I` depend values not reachable through the def use graph&period;
| xref:llvm/maybeMarkSanitizerLibraryCallNoBuiltin.adoc[`maybeMarkSanitizerLibraryCallNoBuiltin`] 
| Mark known string library calls with NoBuiltin for sanitizer interception&period;
| xref:llvm/mergeSampleProfErrors.adoc[`mergeSampleProfErrors`] 
| Merge `Result` into `Accumulator,` preferring the first error&period;
| xref:llvm/mi_bundle_ops.adoc[`mi&lowbar;bundle&lowbar;ops`] 
| Return a range over all operands in the bundle containing `MI&period;`
| xref:llvm/microsoftDemangle.adoc[`microsoftDemangle`] 
| Demangle a Microsoft mangled symbol name&period;
| xref:llvm/minIntN.adoc[`minIntN`] 
| Gets the minimum value for a N&hyphen;bit signed integer&period;
| xref:llvm/min_element-09.adoc[`min&lowbar;element`] 
| `min&lowbar;element` overloads
| xref:llvm/minimum.adoc[`minimum`] 
| Implements IEEE 754&hyphen;2019 minimum semantics&period; Returns the smaller of 2 arguments, returning a quiet NaN if an argument is a NaN and treating &hyphen;0 as less than &plus;0&period;
| xref:llvm/minimumnum.adoc[`minimumnum`] 
| Implements IEEE 754&hyphen;2019 minimumNumber semantics&period; Returns the smaller of 2 arguments, not propagating NaNs and treating &hyphen;0 as less than &plus;0&period;
| xref:llvm/minnum.adoc[`minnum`] 
| IEEE&hyphen;754&hyphen;2008 minNum&colon; return the smaller of two values&period;
| xref:llvm/mismatch.adoc[`mismatch`] 
| Return iterators to the first mismatching elements of two ranges&period;
| xref:llvm/mod-06.adoc[`mod`] 
| `mod` overloads
| xref:llvm/move.adoc[`move`] 
| Move the elements of `Range` into the output range starting at `Out&period;`
| xref:llvm/moveInstructionsToTheBeginning.adoc[`moveInstructionsToTheBeginning`] 
| Move instructions, in an order&hyphen;preserving manner, from `FromBB` to the beginning of `ToBB` when proven safe&period;
| xref:llvm/moveInstructionsToTheEnd.adoc[`moveInstructionsToTheEnd`] 
| Move instructions, in an order&hyphen;preserving manner, from `FromBB` to the end of `ToBB` when proven safe&period;
| xref:llvm/mustExecuteUBIfPoisonOnPathTo.adoc[`mustExecuteUBIfPoisonOnPathTo`] 
| Return true if poison from Root would force UB on the path to OnPathTo&period;
| xref:llvm/mustSuppressSpeculation.adoc[`mustSuppressSpeculation`] 
| Return true if load speculation must be suppressed for sanitizers&period;
| xref:llvm/mustTriggerUB.adoc[`mustTriggerUB`] 
| Return true if `I` must trigger UB when any of `KnownPoison` is poison&period;
| xref:llvm/nameUnamedGlobals.adoc[`nameUnamedGlobals`] 
| Rename all the anon globals in the module using a hash computed from the list of public globals in the module&period;
| xref:llvm/narrowShuffleMaskElts.adoc[`narrowShuffleMaskElts`] 
| Replace each shuffle mask index with scaled indices for narrower elements&period;
| xref:llvm/needConversion.adoc[`needConversion`] 
| Query whether a file needs conversion to the UTF&hyphen;8 codepage&period;
| xref:llvm/needsComdatForCounter.adoc[`needsComdatForCounter`] 
| Return true if profile counters for `GV` should use Comdat&period;
| xref:llvm/needsParamAccessSummary.adoc[`needsParamAccessSummary`] 
| Return true if `M` needs a parameter access summary for stack safety&period;
| xref:llvm/neg.adoc[`neg`] 
| Returns the negated value of the argument&period;
| xref:llvm/next_nodbg.adoc[`next&lowbar;nodbg`] 
| Move to the next non&hyphen;debug instruction after `It&period;`
| xref:llvm/nodes.adoc[`nodes`] 
| Return a range over all nodes of graph `G&period;`
| xref:llvm/nonMicrosoftDemangle.adoc[`nonMicrosoftDemangle`] 
| Demangle a non&hyphen;Microsoft mangled name into `Result&period;`
| xref:llvm/nonStrictlyPostDominate.adoc[`nonStrictlyPostDominate`] 
| Return true if `ThisBlock` is reached after `OtherBlock` in the CFG&period;
| xref:llvm/none_of.adoc[`none&lowbar;of`] 
| Return true if `P` is false for every element of `Range&period;`
| xref:llvm/normalizeForPostIncUse.adoc[`normalizeForPostIncUse`] 
| Normalize `S` to be post&hyphen;increment for all loops present in `Loops&period;`
| xref:llvm/normalizeForPostIncUseIf.adoc[`normalizeForPostIncUseIf`] 
| Normalize `S` for all add recurrence sub&hyphen;expressions for which `Pred` returns true&period;
| xref:llvm/not_equal_to.adoc[`not&lowbar;equal&lowbar;to`] 
| Build a unary predicate that tests inequality to `Arg&period;`
| xref:llvm/nulls.adoc[`nulls`] 
| This returns a reference to a raw&lowbar;ostream which simply discards output&period;
| xref:llvm/offsetToAlignedAddr.adoc[`offsetToAlignedAddr`] 
| Returns the necessary adjustment for aligning `Addr` to `Alignment` bytes, rounding up&period;
| xref:llvm/offsetToAlignment.adoc[`offsetToAlignment`] 
| Returns the offset to the next integer (mod 2&ast;&ast;64) that is greater than or equal to `Value` and is a multiple of `Align&period;`
| xref:llvm/onlyUsedByLifetimeMarkers.adoc[`onlyUsedByLifetimeMarkers`] 
| Return true if the only users of this pointer are lifetime markers&period;
| xref:llvm/onlyUsedByLifetimeMarkersOrDroppableInsts.adoc[`onlyUsedByLifetimeMarkersOrDroppableInsts`] 
| Return true if the only users of this pointer are lifetime markers or droppable instructions&period;
| xref:llvm/operator_mod-06.adoc[`operator%`] 
| Returns the remainder of `A` divided by `B&period;`
| xref:llvm/operator_mod_eq.adoc[`operator%&equals;`] 
| Stores the remainder of `A` divided by `B` in `A&period;`
| xref:llvm/operator_bitand-0d.adoc[`operator&amp;`] 
| Bitwise conjunction operators
| xref:llvm/operator_and_eq-03.adoc[`operator&amp;&equals;`] 
| Bitwise conjunction assignment operators
| xref:llvm/operator_star-0c2.adoc[`operator&ast;`] 
| Multiplication operators
| xref:llvm/operator_star_eq.adoc[`operator&ast;&equals;`] 
| Multiplies `A` by `B` in place&period;
| xref:llvm/operator_plus-0e8.adoc[`operator&plus;`] 
| Addition operators
| xref:llvm/operator_plus_eq-07.adoc[`operator&plus;&equals;`] 
| Addition assignment operators
| xref:llvm/operator_minus-0e.adoc[`operator&hyphen;`] 
| Unary minus operators
| xref:llvm/operator_minus_eq.adoc[`operator&hyphen;&equals;`] 
| Subtracts `B` from `A` in place&period;
| xref:llvm/operator_slash-0f.adoc[`operator&sol;`] 
| Division operators
| xref:llvm/operator_slash_eq.adoc[`operator&sol;&equals;`] 
| Divides `A` by `B` in place&period;
| xref:llvm/operator_rshift-0b6.adoc[`operator&gt;&gt;`] 
| Return `L` shifted right by `Shift` places&period;
| xref:llvm/operator_xor-03.adoc[`operator&circ;`] 
| Bitwise exclusive&hyphen;or operators
| xref:llvm/operator_bitor-0b.adoc[`operator&verbar;`] 
| Bitwise disjunction operators
| xref:llvm/operator_or_eq-0e.adoc[`operator&verbar;&equals;`] 
| Bitwise disjunction assignment operators
| xref:llvm/operator_bitnot-0d.adoc[`operator&#126;`] 
| Unary bitwise complement operator&period;
| xref:llvm/optimal_concurrency.adoc[`optimal&lowbar;concurrency`] 
| Limit threads to about `TaskCount` so small jobs avoid oversubscription&period;
| xref:llvm/optimizeGlobalCtorsList.adoc[`optimizeGlobalCtorsList`] 
| Call &quot;ShouldRemove&quot; for every entry in M&apos;s global&lowbar;ctor list and remove the entries for which it returns true&period;
| xref:llvm/optimized_def_chain.adoc[`optimized&lowbar;def&lowbar;chain`] 
| Return a range walking the optimized clobbering&hyphen;access chain from `MA&period;`
| xref:llvm/orderedStrictlyGreater.adoc[`orderedStrictlyGreater`] 
| Return all FP classes strictly greater than every value in `Mask&period;`
| xref:llvm/orderedStrictlyLess.adoc[`orderedStrictlyLess`] 
| Return all FP classes strictly less than every value in `Mask&period;`
| xref:llvm/outs.adoc[`outs`] 
| This returns a reference to a raw&lowbar;fd&lowbar;ostream for standard output&period; Use it like&colon; outs() &lt;&lt; &quot;foo&quot; &lt;&lt; &quot;bar&quot;&semi;
| xref:llvm/overwriteULEB128.adoc[`overwriteULEB128`] 
| Overwrite a ULEB128 value and keep the original length&period;
| xref:llvm/parallelFor.adoc[`parallelFor`] 
| Invoke `Fn` for each index in &lsqb;&rsqb;`Begin,` `End),` possibly in parallel&period;
| xref:llvm/parallelForEach-02.adoc[`parallelForEach`] 
| `parallelForEach` overloads
| xref:llvm/parallelForEachError.adoc[`parallelForEachError`] 
| Apply `Fn` to each element of `R` in parallel and join any returned Errors&period;
| xref:llvm/parallelSort-0d.adoc[`parallelSort`] 
| `parallelSort` overloads
| xref:llvm/parallelTransformReduce-06.adoc[`parallelTransformReduce`] 
| `parallelTransformReduce` overloads
| xref:llvm/parseAnalysisUtilityPasses.adoc[`parseAnalysisUtilityPasses`] 
| Add require&lt;&gt; or invalidate&lt;&gt; utility passes for an analysis&period;
| xref:llvm/parseAndVerify.adoc[`parseAndVerify`] 
| Try to parse module and verify it&period; May output verification errors to the errs()&period;
| xref:llvm/parseAssembly.adoc[`parseAssembly`] 
| Parse LLVM Assembly from a MemoryBuffer&period;
| xref:llvm/parseAssemblyFile.adoc[`parseAssemblyFile`] 
| Parse LLVM Assembly from a file&period;
| xref:llvm/parseAssemblyFileWithIndex.adoc[`parseAssemblyFileWithIndex`] 
| Parse LLVM Assembly and its module summary from a file&period;
| xref:llvm/parseAssemblyFileWithIndexNoUpgradeDebugInfo.adoc[`parseAssemblyFileWithIndexNoUpgradeDebugInfo`] 
| Parse an assembly file with index without upgrading debug info&period;
| xref:llvm/parseAssemblyInto.adoc[`parseAssemblyInto`] 
| Parse LLVM Assembly into an existing Module or ModuleSummaryIndex&period;
| xref:llvm/parseAssemblyString.adoc[`parseAssemblyString`] 
| Parse LLVM Assembly from a string&period;
| xref:llvm/parseAssemblyWithIndex.adoc[`parseAssemblyWithIndex`] 
| Parse LLVM Assembly including the summary index from a MemoryBuffer&period;
| xref:llvm/parseAtomicScopeIRString.adoc[`parseAtomicScopeIRString`] 
| Parses a target syncscope string into its abstract scope&period;
| xref:llvm/parseBitcodeFile.adoc[`parseBitcodeFile`] 
| Read the specified bitcode file, returning the module&period;
| xref:llvm/parseCachePruningPolicy.adoc[`parseCachePruningPolicy`] 
| Parse the given string as a cache pruning policy&period;
| xref:llvm/parseCommandLineOptions.adoc[`parseCommandLineOptions`] 
| A convenience function that calls cl&colon;&colon;ParseCommandLineOptions on the given set of options&period;
| xref:llvm/parseConstantValue.adoc[`parseConstantValue`] 
| Parse a type and a constant value in the given string&period;
| xref:llvm/parseDIExpressionBodyAtBeginning.adoc[`parseDIExpressionBodyAtBeginning`] 
| Parse a DIExpression body at the beginning of the given string&period;
| xref:llvm/parseDenormalFPAttribute.adoc[`parseDenormalFPAttribute`] 
| Returns the denormal mode to use for inputs and outputs&period;
| xref:llvm/parseDenormalFPAttributeComponent.adoc[`parseDenormalFPAttributeComponent`] 
| Parse the expected names from the denormal&hyphen;fp&hyphen;math attribute&period;
| xref:llvm/parseFuzzerCLOpts.adoc[`parseFuzzerCLOpts`] 
| Parse cl&colon;&colon;opts from a fuzz target commandline&period;
| xref:llvm/parseIR.adoc[`parseIR`] 
| If the given MemoryBuffer holds a bitcode image, return a Module for it&period; Otherwise, attempt to parse it as LLVM Assembly and return a Module for it&period;
| xref:llvm/parseIRFile.adoc[`parseIRFile`] 
| If the given file holds a bitcode image, return a Module for it&period; Otherwise, attempt to parse it as LLVM Assembly and return a Module for it&period;
| xref:llvm/parseInfoSectionUnitHeader.adoc[`parseInfoSectionUnitHeader`] 
| Parse the unit header at the start of a &period;debug&lowbar;info(&period;dwo) section&period;
| xref:llvm/parseKCFIHashAlgorithm.adoc[`parseKCFIHashAlgorithm`] 
| Parse a KCFI hash algorithm name&period; Returns xxHash64 if the name is not recognized&period;
| xref:llvm/parseLongDoubleFormat.adoc[`parseLongDoubleFormat`] 
| Parses an IR floating&hyphen;point type name into a LongDoubleFormat, returning std&colon;&colon;nullopt if it does not name a supported long double format&period;
| xref:llvm/parseMBBReference.adoc[`parseMBBReference`] 
| Parse a machine basic block reference from `Src&period;`
| xref:llvm/parseMDNode.adoc[`parseMDNode`] 
| Parse a metadata node reference from `Src&period;`
| xref:llvm/parseMachineBasicBlockDefinitions.adoc[`parseMachineBasicBlockDefinitions`] 
| Parse the machine basic block definitions, and skip the machine instructions&period;
| xref:llvm/parseMachineInstructions.adoc[`parseMachineInstructions`] 
| Parse the machine instructions&period;
| xref:llvm/parseMachineMetadata.adoc[`parseMachineMetadata`] 
| Parse a machine metadata definition from `Src&period;`
| xref:llvm/parseModule.adoc[`parseModule`] 
| Fuzzer friendly interface for the llvm bitcode parser&period;
| xref:llvm/parseNamedRegisterReference.adoc[`parseNamedRegisterReference`] 
| Parse a named physical register reference from `Src&period;`
| xref:llvm/parsePrefetchTarget.adoc[`parsePrefetchTarget`] 
| Parse a prefetch target (BBID and callsite index) from `Src&period;`
| xref:llvm/parseRegisterReference.adoc[`parseRegisterReference`] 
| Parse a register reference from `Src&period;`
| xref:llvm/parseStackObjectReference.adoc[`parseStackObjectReference`] 
| Parse a stack object reference from `Src&period;`
| xref:llvm/parseStatepointDirectivesFromAttrs.adoc[`parseStatepointDirectivesFromAttrs`] 
| Parse out statepoint directives from the function attributes present in `AS&period;`
| xref:llvm/parseSummaryIndexAssembly.adoc[`parseSummaryIndexAssembly`] 
| Parse LLVM Assembly for summary index from a MemoryBuffer&period;
| xref:llvm/parseSummaryIndexAssemblyFile.adoc[`parseSummaryIndexAssemblyFile`] 
| Parse a module summary index from an LLVM Assembly file&period;
| xref:llvm/parseSummaryIndexAssemblyString.adoc[`parseSummaryIndexAssemblyString`] 
| Parse a module summary index from an LLVM Assembly string&period;
| xref:llvm/parseType.adoc[`parseType`] 
| Parse a type in the given string&period;
| xref:llvm/parseTypeAtBeginning.adoc[`parseTypeAtBeginning`] 
| Parse a type at the beginning of the given string&period;
| xref:llvm/parseVirtualRegisterReference.adoc[`parseVirtualRegisterReference`] 
| Parse a virtual register reference from `Src&period;`
| xref:llvm/parseWidenableBranch-01.adoc[`parseWidenableBranch`] 
| `parseWidenableBranch` overloads
| xref:llvm/parseWidenableGuard.adoc[`parseWidenableGuard`] 
| Collects the individual checks from a widenable guard&apos;s condition&period;
| xref:llvm/partition.adoc[`partition`] 
| Partition `Range` so elements satisfying `P` precede the rest&period;
| xref:llvm/partition_point.adoc[`partition&lowbar;point`] 
| Return the partition point of `Range` under predicate `P&period;`
| xref:llvm/patchReplacementInstruction.adoc[`patchReplacementInstruction`] 
| Relax a replacement so it is no more restrictive than the original&period;
| xref:llvm/peekThroughBitcasts.adoc[`peekThroughBitcasts`] 
| Return the non&hyphen;bitcasted source operand of `V` if it exists&period; If `V` is not a bitcasted value, it is returned as&hyphen;is&period;
| xref:llvm/peekThroughExtractSubvectors.adoc[`peekThroughExtractSubvectors`] 
| Return the non&hyphen;extracted vector source operand of `V` if it exists&period; If `V` is not an extracted subvector, it is returned as&hyphen;is&period;
| xref:llvm/peekThroughFreeze.adoc[`peekThroughFreeze`] 
| Return the non&hyphen;frozen source operand of `V` if it exists&period; If `V` is not a freeze, it is returned as&hyphen;is&period;
| xref:llvm/peekThroughInsertVectorElt.adoc[`peekThroughInsertVectorElt`] 
| Recursively peek through INSERT&lowbar;VECTOR&lowbar;ELT nodes&period;
| xref:llvm/peekThroughOneUseBitcasts.adoc[`peekThroughOneUseBitcasts`] 
| Return the non&hyphen;bitcasted and one&hyphen;use source operand of `V` if it exists&period; If `V` is not a bitcasted one&hyphen;use value, it is returned as&hyphen;is&period;
| xref:llvm/peekThroughOneUseFreeze.adoc[`peekThroughOneUseFreeze`] 
| Return the non&hyphen;frozen one&hyphen;use source operand of `V` if it exists&period;
| xref:llvm/peekThroughTruncates.adoc[`peekThroughTruncates`] 
| Return the non&hyphen;truncated source operand of `V` if it exists&period; If `V` is not a truncation, it is returned as&hyphen;is&period;
| xref:llvm/peelLoop.adoc[`peelLoop`] 
| Peel off `PeelCount` iterations from loop `L&period;`
| xref:llvm/performOptimizedStructLayout.adoc[`performOptimizedStructLayout`] 
| Compute a layout for a struct containing the given fields, making a best&hyphen;effort attempt to minimize the amount of space required&period;
| xref:llvm/phys_regs_and_masks.adoc[`phys&lowbar;regs&lowbar;and&lowbar;masks`] 
| Returns an iterator range over all physical register and mask operands for `MI` and bundled instructions&period; This also skips any debug operands&period;
| xref:llvm/pointerToJITTargetAddress.adoc[`pointerToJITTargetAddress`] 
| Convert a pointer to a JITTargetAddress&period;
| xref:llvm/popcount.adoc[`popcount`] 
| Count the number of set bits in a value&period; Ex&period; popcount(0xF000F000) &equals; 8 Returns 0 if Value is zero&period;
| xref:llvm/possiblyDemandedEltsInMask.adoc[`possiblyDemandedEltsInMask`] 
| Return an APInt of active lanes for a `&lt;Y x i1&gt;` mask&period;
| xref:llvm/post_order.adoc[`post&lowbar;order`] 
| Post&hyphen;order traversal of a graph&period; Note&colon; this returns a PostOrderTraversal, not an iterator range&semi;
| xref:llvm/post_order_ext.adoc[`post&lowbar;order&lowbar;ext`] 
| Post&hyphen;order traversal of `G` that records visited nodes in external set `S&period;`
| xref:llvm/pred_begin-06.adoc[`pred&lowbar;begin`] 
| `pred&lowbar;begin` overloads
| xref:llvm/pred_empty.adoc[`pred&lowbar;empty`] 
| Return true if `BB` has no predecessors&period;
| xref:llvm/pred_end-0bf.adoc[`pred&lowbar;end`] 
| `pred&lowbar;end` overloads
| xref:llvm/pred_size-01b.adoc[`pred&lowbar;size`] 
| `pred&lowbar;size` overloads
| xref:llvm/predecessors-01.adoc[`predecessors`] 
| `predecessors` overloads
| xref:llvm/predicatesFoldable.adoc[`predicatesFoldable`] 
| Return true if both predicates match sign or if at least one of them is an equality comparison (which is signless)&period;
| xref:llvm/prepareForDynamicDebugging.adoc[`prepareForDynamicDebugging`] 
| Prepare a module for dynamic debugging before running optimizations&period;
| xref:llvm/prepareTempFiles.adoc[`prepareTempFiles`] 
| Ensures temporary files exist, creating or re&hyphen;using them&period;
| xref:llvm/prettyPrintRegisterOp.adoc[`prettyPrintRegisterOp`] 
| Pretty print a register opcode and operands&period;
| xref:llvm/prev_nodbg.adoc[`prev&lowbar;nodbg`] 
| Move to the previous non&hyphen;debug instruction before `It&period;`
| xref:llvm/printAfterPasses.adoc[`printAfterPasses`] 
| Returns the names of passes whose IR should be printed after they run&period;
| xref:llvm/printBasicBlock.adoc[`printBasicBlock`] 
| Print BasicBlock `BB` as an operand or print &quot;&lt;nullptr&gt;&quot; if `BB` is a nullptr&period;
| xref:llvm/printBeforePasses.adoc[`printBeforePasses`] 
| Returns the names of passes whose IR should be printed before they run&period;
| xref:llvm/printBlockFreq-0e2c.adoc[`printBlockFreq`] 
| `printBlockFreq` overloads
| xref:llvm/printDebugLog.adoc[`printDebugLog`] 
| If EnableDebugBuffering is true, this flushes the debug stream with the banner displayed, the same way it is printed automatically on program termination&period;
| xref:llvm/printDwarfExpression.adoc[`printDwarfExpression`] 
| Print a DWARF expression&period;
| xref:llvm/printDwarfExpressionCompact.adoc[`printDwarfExpressionCompact`] 
| Print a DWARF expression in a compact, user&hyphen;oriented format&period;
| xref:llvm/printEscapedString.adoc[`printEscapedString`] 
| Print each character of the specified string, escaping it if it is not printable or if it is an escape char&period;
| xref:llvm/printFormattedPipelinePasses.adoc[`printFormattedPipelinePasses`] 
| Print `Pipeline` to `OS` using the requested `Format&period;`
| xref:llvm/printGraphForFunction.adoc[`printGraphForFunction`] 
| Write an analysis graph for a function to a DOT file&period;
| xref:llvm/printHTMLEscaped.adoc[`printHTMLEscaped`] 
| Print each character of the specified string, escaping HTML special characters&period;
| xref:llvm/printIRUnitNameForStackTrace-07.adoc[`printIRUnitNameForStackTrace`] 
| `printIRUnitNameForStackTrace` overloads
| xref:llvm/printJumpTableEntryReference.adoc[`printJumpTableEntryReference`] 
| Prints a jump table entry reference&period;
| xref:llvm/printLLVMNameWithoutPrefix.adoc[`printLLVMNameWithoutPrefix`] 
| Print out a name of an LLVM value without any prefixes&period;
| xref:llvm/printLoop.adoc[`printLoop`] 
| Function to print a loop&apos;s contents as LLVM&apos;s text IR assembly&period;
| xref:llvm/printLowerCase.adoc[`printLowerCase`] 
| Print each character as lowercase if it is uppercase&period;
| xref:llvm/printMBBReference.adoc[`printMBBReference`] 
| Print a machine basic block reference for use in diagnostics and dumps&period;
| xref:llvm/printMIR-06.adoc[`printMIR`] 
| `printMIR` overloads
| xref:llvm/printPercentEncoded.adoc[`printPercentEncoded`] 
| Print `String` percent&hyphen;encoded for a URL query component (RFC 3986)&period;
| xref:llvm/printReg.adoc[`printReg`] 
| Prints virtual and physical registers with or without a TRI instance&period;
| xref:llvm/printRegClassOrBank.adoc[`printRegClassOrBank`] 
| Create Printable object to print register classes or register banks on a xref:llvm/raw_ostream.adoc[`raw&lowbar;ostream`]&period;
| xref:llvm/printRegUnit.adoc[`printRegUnit`] 
| Create Printable object to print register units on a xref:llvm/raw_ostream.adoc[`raw&lowbar;ostream`]&period;
| xref:llvm/printRelativeBlockFreq.adoc[`printRelativeBlockFreq`] 
| Print `Freq` as a multiple of the entry frequency `EntryFreq&period;`
| xref:llvm/printVRegOrUnit.adoc[`printVRegOrUnit`] 
| Create Printable object to print virtual registers and physical registers on a xref:llvm/raw_ostream.adoc[`raw&lowbar;ostream`]&period;
| xref:llvm/processImportsFiles.adoc[`processImportsFiles`] 
| Call `F` passing each of the files module `ModulePath` will import from&period;
| xref:llvm/processShuffleMasks.adoc[`processShuffleMasks`] 
| Split and process a shuffle mask across real input and output registers&period;
| xref:llvm/product_of.adoc[`product&lowbar;of`] 
| Return the product of values in `Range` starting from `Init&period;`
| xref:llvm/programUndefinedIfPoison.adoc[`programUndefinedIfPoison`] 
| Return true if a poison result from `Inst` implies program undefined behavior&period;
| xref:llvm/programUndefinedIfUndefOrPoison.adoc[`programUndefinedIfUndefOrPoison`] 
| Return true if this function can prove that if Inst is executed and yields a poison value or undef bits, then that will trigger undefined behavior&period;
| xref:llvm/promoteCall.adoc[`promoteCall`] 
| Promote the given indirect call site to unconditionally call `Callee&period;`
| xref:llvm/promoteCallWithIfThenElse-01.adoc[`promoteCallWithIfThenElse`] 
| `promoteCallWithIfThenElse` overloads
| xref:llvm/promoteCallWithVTableCmp.adoc[`promoteCallWithVTableCmp`] 
| This is similar to `promoteCallWithIfThenElse` except that the condition to promote a virtual call is that `VPtr` is the same as any of `AddressPoints&period;`
| xref:llvm/promoteLoopAccessesToScalars.adoc[`promoteLoopAccessesToScalars`] 
| Promote must&hyphen;alias loop memory accesses to scalars via load&sol;store motion&period;
| xref:llvm/propagateIRFlags.adoc[`propagateIRFlags`] 
| Intersect IR flags from scalar ops `VL` onto vector op `I&period;`
| xref:llvm/propagateMetadata.adoc[`propagateMetadata`] 
| Propagate common metadata from `VL` onto instruction `I&period;`
| xref:llvm/propagatesPoison.adoc[`propagatesPoison`] 
| Return true if `PoisonOp&apos;s` user yields poison or raises UB if its operand `PoisonOp` is poison&period;
| xref:llvm/pruneCache.adoc[`pruneCache`] 
| Perform pruning using the supplied policy, returns true if pruning occurred, i&period;e&period; if Policy&period;Interval was expired&period;
| xref:llvm/range_size.adoc[`range&lowbar;size`] 
| Return the number of elements in `Range&period;`
| xref:llvm/readAbbrevAttribute.adoc[`readAbbrevAttribute`] 
| Read the next attribute&sol;form spec from an abbreviation declaration&period;
| xref:llvm/readAndDecodeStrings.adoc[`readAndDecodeStrings`] 
| Decode concatenated PGO name strings and invoke a callback for each name&period;
| xref:llvm/readModuleSummaryIndex.adoc[`readModuleSummaryIndex`] 
| Parse the specified bitcode buffer and merge the index into CombinedIndex&period;
| xref:llvm/readWideAPInt.adoc[`readWideAPInt`] 
| Decode a wide APInt from a sequence of 64&hyphen;bit words&period;
| xref:llvm/recognizeBSwapOrBitReverseIdiom.adoc[`recognizeBSwapOrBitReverseIdiom`] 
| Match a bswap or bitreverse idiom and replace it with an intrinsic&period;
| xref:llvm/recomputeLTOCacheKey.adoc[`recomputeLTOCacheKey`] 
| Recompute an LTO cache key with an extra identifier&period;
| xref:llvm/recomputeLivenessFlags.adoc[`recomputeLivenessFlags`] 
| Recomputes dead and kill flags in `MBB&period;`
| xref:llvm/registerCodeGenCallback.adoc[`registerCodeGenCallback`] 
| Register codegen&hyphen;related pass instrumentation callbacks&period;
| xref:llvm/remapDebugVariable.adoc[`remapDebugVariable`] 
| Remap operands of debug records attached to an instruction&period;
| xref:llvm/remapInstructionsInBlocks.adoc[`remapInstructionsInBlocks`] 
| Remaps instructions in `Blocks` using the mapping in `VMap&period;`
| xref:llvm/removeASanIncompatibleFnAttributes.adoc[`removeASanIncompatibleFnAttributes`] 
| Remove memory attributes incompatible with ASan&sol;HWASan instrumentation&period;
| xref:llvm/removeAllNonTerminatorAndEHPadInstructions.adoc[`removeAllNonTerminatorAndEHPadInstructions`] 
| Remove all non&hyphen;terminator, non&hyphen;EH&hyphen;pad instructions from a block&period;
| xref:llvm/removeFromUsedLists.adoc[`removeFromUsedLists`] 
| Removes selected entries from llvm&period;used and llvm&period;compiler&period;used&period;
| xref:llvm/removeUnreachableBlocks.adoc[`removeUnreachableBlocks`] 
| Remove blocks unreachable from a function&apos;s entry&period;
| xref:llvm/removeUnwindEdge.adoc[`removeUnwindEdge`] 
| Replace a terminator so it no longer has an unwind successor&period;
| xref:llvm/remove_bad_alloc_error_handler.adoc[`remove&lowbar;bad&lowbar;alloc&lowbar;error&lowbar;handler`] 
| Restores default bad alloc error handling behavior&period;
| xref:llvm/remove_fatal_error_handler.adoc[`remove&lowbar;fatal&lowbar;error&lowbar;handler`] 
| Restores default error handling behaviour&period;
| xref:llvm/remove_if.adoc[`remove&lowbar;if`] 
| Remove elements of `Range` for which `P` is true&period;
| xref:llvm/renameModuleForThinLTO.adoc[`renameModuleForThinLTO`] 
| Perform in&hyphen;place global value handling on the given Module for exported local functions renamed and promoted for ThinLTO&period;
| xref:llvm/replace-0c.adoc[`replace`] 
| `replace` overloads
| xref:llvm/replaceAllDbgUsesWith.adoc[`replaceAllDbgUsesWith`] 
| Retarget or salvage debug users when replacing a value that will be deleted&period;
| xref:llvm/replaceAndRecursivelySimplify.adoc[`replaceAndRecursivelySimplify`] 
| Replace all uses of &apos;I&apos; with &apos;SimpleV&apos; and simplify the uses recursively&period;
| xref:llvm/replaceDbgDeclare.adoc[`replaceDbgDeclare`] 
| Replace a dbg&period;declare when its address is replaced&period;
| xref:llvm/replaceDbgValueForAlloca.adoc[`replaceDbgValueForAlloca`] 
| Replace dbg&period;value records when an alloca address is replaced&period;
| xref:llvm/replaceDominatedUsesWith-05.adoc[`replaceDominatedUsesWith`] 
| `replaceDominatedUsesWith` overloads
| xref:llvm/replaceDominatedUsesWithIf-05.adoc[`replaceDominatedUsesWithIf`] 
| `replaceDominatedUsesWithIf` overloads
| xref:llvm/replaceNonLocalUsesWith.adoc[`replaceNonLocalUsesWith`] 
| Replace non&hyphen;local uses of an instruction with another value&period;
| xref:llvm/replaceRelativePointerUsersWithZero.adoc[`replaceRelativePointerUsersWithZero`] 
| Finds the same &quot;relative pointer&quot; pattern as described above, where the target is `C`, and replaces the entire pattern with a constant zero&period;
| xref:llvm/replaceSymbolicStrideSCEV.adoc[`replaceSymbolicStrideSCEV`] 
| Return the SCEV corresponding to a pointer with the symbolic stride replaced with constant one, assuming the SCEV predicate associated with `PSE` is true&period;
| xref:llvm/replace_copy.adoc[`replace&lowbar;copy`] 
| Copy `Range` to `Out,` replacing `OldValue` with `NewValue&period;`
| xref:llvm/replace_copy_if.adoc[`replace&lowbar;copy&lowbar;if`] 
| Copy `Range` to `Out,` replacing elements for which `P` is true&period;
| xref:llvm/reportAndResetTimings.adoc[`reportAndResetTimings`] 
| Report collected pass timings immediately and reset the timers to zero&period;
| xref:llvm/reportChangedIR.adoc[`reportChangedIR`] 
| Reports a `&hyphen;print&hyphen;changed` dump for one pass over one IR unit&period;
| xref:llvm/reportFatalInternalError-09.adoc[`reportFatalInternalError`]  [.small]#[noreturn]#
| `reportFatalInternalError` overloads
| xref:llvm/reportFatalUsageError-09.adoc[`reportFatalUsageError`]  [.small]#[noreturn]#
| `reportFatalUsageError` overloads
| xref:llvm/reportGISelFailure-07.adoc[`reportGISelFailure`] 
| `reportGISelFailure` overloads
| xref:llvm/reportGISelWarning.adoc[`reportGISelWarning`] 
| Report an ISel warning as a missed optimization remark to the LLVMContext&apos;s diagnostic stream&period;
| xref:llvm/report_bad_alloc_error.adoc[`report&lowbar;bad&lowbar;alloc&lowbar;error`]  [.small]#[noreturn]#
| Report a bad allocation error via the installed handler&period;
| xref:llvm/report_fatal_error-09.adoc[`report&lowbar;fatal&lowbar;error`]  [.small]#[noreturn]#
| `report&lowbar;fatal&lowbar;error` overloads
| xref:llvm/resolveTypes.adoc[`resolveTypes`] 
| Find a common type that T1 and T2 convert to&period; Return 0 if no such type exists&period;
| xref:llvm/restoreStdHandleAutoConversion.adoc[`restoreStdHandleAutoConversion`] 
| Restore the previously saved auto&hyphen;conversion mode for a standard handle&period;
| xref:llvm/returnTypeIsEligibleForTailCall.adoc[`returnTypeIsEligibleForTailCall`] 
| Test if given that the input instruction is in the tail call position if the return type or any attributes of the function will inhibit tail call optimization&period;
| xref:llvm/reverse.adoc[`reverse`] 
| Return a reverse view over `C` without mutating it&period;
| xref:llvm/reverseBits.adoc[`reverseBits`] 
| Reverse the bits in `Val&period;`
| xref:llvm/reverse_conditionally.adoc[`reverse&lowbar;conditionally`] 
| Return a range that conditionally reverses `C&period;`
| xref:llvm/rewriteLoopExitValues.adoc[`rewriteLoopExitValues`] 
| Rewrite computable loop exit values into users outside the loop&period;
| xref:llvm/right_justify.adoc[`right&lowbar;justify`] 
| right&lowbar;justify &hyphen; add spaces before string so total output is `Width` characters&period; If `Str` is larger that `Width,` full string is written with no padding&period;
| xref:llvm/rotl.adoc[`rotl`] 
| Rotate `V` left by `R` bit positions&period;
| xref:llvm/rotr.adoc[`rotr`] 
| Rotate `V` right by `R` bit positions&period;
| xref:llvm/runFuzzerOnInputs.adoc[`runFuzzerOnInputs`] 
| Runs a fuzz target on the inputs specified on the command line&period;
| xref:llvm/runOnNewStack-0d.adoc[`runOnNewStack`] 
| `runOnNewStack` overloads
| xref:llvm/runWholeProgramDevirtOnIndex.adoc[`runWholeProgramDevirtOnIndex`] 
| Perform index&hyphen;based whole&hyphen;program devirtualization on `Summary&period;`
| xref:llvm/rustDemangle.adoc[`rustDemangle`] 
| Demangle a Rust v0 mangled symbol&period;
| xref:llvm/safe_calloc.adoc[`safe&lowbar;calloc`] 
| Allocate and zero `Count` elements of `Sz` bytes, aborting on failure&period;
| xref:llvm/safe_malloc.adoc[`safe&lowbar;malloc`] 
| Allocate `Sz` bytes with malloc, aborting on failure&period;
| xref:llvm/safe_realloc.adoc[`safe&lowbar;realloc`] 
| Reallocate `Ptr` to `Sz` bytes, aborting on failure&period;
| xref:llvm/salvageDebugInfo-09.adoc[`salvageDebugInfo`] 
| `salvageDebugInfo` overloads
| xref:llvm/salvageDebugInfoForDbgValue.adoc[`salvageDebugInfoForDbgValue`] 
| Assuming the instruction `MI` is going to be deleted, attempt to salvage debug users of `MI` by writing the effect of `MI` in a DIExpression&period;
| xref:llvm/salvageDebugInfoForDbgValues.adoc[`salvageDebugInfoForDbgValues`] 
| Salvage a specific set of debug records that use an instruction&period;
| xref:llvm/salvageDebugInfoImpl.adoc[`salvageDebugInfoImpl`] 
| Append an instruction&apos;s effect to a salvaged DIExpression operand list&period;
| xref:llvm/salvageKnowledge.adoc[`salvageKnowledge`] 
| Insert an llvm&period;assume before an instruction to salvage its derived knowledge&period;
| xref:llvm/sampleprof_category.adoc[`sampleprof&lowbar;category`] 
| Return the error category for sampleprof&lowbar;error&period;
| xref:llvm/saveUsesAndErase.adoc[`saveUsesAndErase`] 
| Record uses of `MI` and erase it, appending newly dead users to the chain&period;
| xref:llvm/scalbn.adoc[`scalbn`] 
| Returns&colon; X &ast; 2&circ;Exp for integral exponents&period;
| xref:llvm/scaleBranchCount.adoc[`scaleBranchCount`] 
| Scale an individual branch count&period;
| xref:llvm/scaleProfData.adoc[`scaleProfData`] 
| Scaling the profile data attached to &apos;I&apos; using the ratio of S&sol;T&period;
| xref:llvm/scaleShuffleMaskElts.adoc[`scaleShuffleMaskElts`] 
| Scale a shuffle mask to a target element count&period;
| xref:llvm/scavengeFrameVirtualRegs.adoc[`scavengeFrameVirtualRegs`] 
| Replaces all frame index virtual registers with physical registers&period; Uses the register scavenger to find an appropriate register to use&period;
| xref:llvm/scc_begin.adoc[`scc&lowbar;begin`] 
| Construct the begin iterator for a deduced graph type T&period;
| xref:llvm/scc_end.adoc[`scc&lowbar;end`] 
| Construct the end iterator for a deduced graph type T&period;
| xref:llvm/search-06.adoc[`search`] 
| `search` overloads
| xref:llvm/seq-09.adoc[`seq`] 
| `seq` overloads
| xref:llvm/seq_inclusive.adoc[`seq&lowbar;inclusive`] 
| Return an inclusive sequence of integral values from `Begin` to `End&period;`
| xref:llvm/serializeSectionKind.adoc[`serializeSectionKind`] 
| Convert the internal value for a section kind to an on&hyphen;disk value&period;
| xref:llvm/setAtomicSyncScopeID.adoc[`setAtomicSyncScopeID`] 
| Set the sync scope of atomic instruction `I&period;`
| xref:llvm/setBranchProbability.adoc[`setBranchProbability`] 
| Set branch weights on `B` from probability `P` for one successor&period;
| xref:llvm/setBranchWeights.adoc[`setBranchWeights`] 
| Create a new `branch&lowbar;weights` metadata node and add or overwrite a `prof` metadata reference to instruction `I`&period;
| xref:llvm/setBugReportMsg.adoc[`setBugReportMsg`] 
| Replaces the generic bug report message that is output upon a crash&period;
| xref:llvm/setCurrentDebugType.adoc[`setCurrentDebugType`] 
| Set the current debug type as if &hyphen;debug&hyphen;only&equals;`Type` were specified&period;
| xref:llvm/setCurrentDebugTypes.adoc[`setCurrentDebugTypes`] 
| Set the current debug types as if &hyphen;debug&hyphen;only&equals;X,Y,Z were specified&period;
| xref:llvm/setDefaultDebuginfodUrls.adoc[`setDefaultDebuginfodUrls`] 
| Sets the list of debuginfod server URLs to query&period; This overrides the environment variable DEBUGINFOD&lowbar;URLS&period;
| xref:llvm/setExplicitlyUnknownBranchWeights.adoc[`setExplicitlyUnknownBranchWeights`] 
| Specify that this terminator&apos;s branch weights are unknown at compile time&period;
| xref:llvm/setExplicitlyUnknownBranchWeightsIfProfiled.adoc[`setExplicitlyUnknownBranchWeightsIfProfiled`] 
| Set unknown branch weights only if the parent function has an entry count&period;
| xref:llvm/setExplicitlyUnknownFunctionEntryCount.adoc[`setExplicitlyUnknownFunctionEntryCount`] 
| Analogous to setExplicitlyUnknownBranchWeights, but for functions and their entry counts&period;
| xref:llvm/setFileTag.adoc[`setFileTag`] 
| Set the tag information for a file descriptor&period;
| xref:llvm/setFittedBranchWeights.adoc[`setFittedBranchWeights`] 
| Variant of `setBranchWeights` where the `Weights` will be fit first to uint32&lowbar;t by shifting right&period;
| xref:llvm/setGlobalVariableLargeSection.adoc[`setGlobalVariableLargeSection`] 
| Place `GV` in a large section on x86&hyphen;64 ELF to ease relocation pressure&period;
| xref:llvm/setInlineRemark.adoc[`setInlineRemark`] 
| Set the inline&hyphen;remark attribute on call site `CB&period;`
| xref:llvm/setIrrLoopHeaderMetadata.adoc[`setIrrLoopHeaderMetadata`] 
| Attach irreducible&hyphen;loop header weight metadata to an instruction&period;
| xref:llvm/setKCFIType.adoc[`setKCFIType`] 
| Sets the KCFI type for the function&period;
| xref:llvm/setLoadStoreAlignment.adoc[`setLoadStoreAlignment`] 
| Set the alignment of load or store instruction `I&period;`
| xref:llvm/setLoopEstimatedTripCount.adoc[`setLoopEstimatedTripCount`] 
| Set the estimated trip count metadata (and optional latch weights) for `L&period;`
| xref:llvm/setLoopProbability.adoc[`setLoopProbability`] 
| Set latch branch weights of `L` from continuation probability `P&period;`
| xref:llvm/setProbeDistributionFactor.adoc[`setProbeDistributionFactor`] 
| Set the distribution factor of the pseudo probe on `Inst&period;`
| xref:llvm/setProfMetadata.adoc[`setProfMetadata`] 
| Attach branch&hyphen;weight profile metadata to a terminator or select&period;
| xref:llvm/setUnwindEdgeTo.adoc[`setUnwindEdgeTo`] 
| Sets the unwind edge of an instruction to a particular successor&period;
| xref:llvm/setWidenableBranchCond.adoc[`setWidenableBranchCond`] 
| Sets a widenable branch&apos;s condition to `Cond` while keeping it widenable&period;
| xref:llvm/set_difference.adoc[`set&lowbar;difference`] 
| set&lowbar;difference(A, B) &hyphen; Return A &hyphen; B
| xref:llvm/set_intersect.adoc[`set&lowbar;intersect`] 
| Compute the intersection of `S1` and `S2,` updating `S1` in place&period;
| xref:llvm/set_intersection.adoc[`set&lowbar;intersection`] 
| set&lowbar;intersection(A, B) &hyphen; Return A &circ; B
| xref:llvm/set_intersection_impl.adoc[`set&lowbar;intersection&lowbar;impl`] 
| Build a new set containing the elements present in both `S1` and `S2&period;`
| xref:llvm/set_intersects.adoc[`set&lowbar;intersects`] 
| set&lowbar;intersects(A, B) &hyphen; Return true iff A &circ; B is non empty
| xref:llvm/set_is_subset.adoc[`set&lowbar;is&lowbar;subset`] 
| set&lowbar;is&lowbar;subset(A, B) &hyphen; Return true iff A in B
| xref:llvm/set_subtract-09.adoc[`set&lowbar;subtract`] 
| `set&lowbar;subtract` overloads
| xref:llvm/set_thread_name.adoc[`set&lowbar;thread&lowbar;name`] 
| Set the name of the current thread&period;
| xref:llvm/set_thread_priority.adoc[`set&lowbar;thread&lowbar;priority`] 
| Set the calling thread&apos;s priority to `Priority&period;`
| xref:llvm/set_union.adoc[`set&lowbar;union`] 
| set&lowbar;union(A, B) &hyphen; Compute A &colon;&equals; A u B, return whether A changed&period;
| xref:llvm/setupLLVMOptimizationRemarks-0b.adoc[`setupLLVMOptimizationRemarks`] 
| `setupLLVMOptimizationRemarks` overloads
| xref:llvm/setupMachineFunctionAsmPrinter.adoc[`setupMachineFunctionAsmPrinter`] 
| Configure `AsmPrinter` for machine&hyphen;function emission of `MF&period;`
| xref:llvm/setupModuleAsmPrinter.adoc[`setupModuleAsmPrinter`] 
| Configure `AsmPrinter` for module&hyphen;level emission of `M&period;`
| xref:llvm/shouldFuncOptimizeForSizeImpl.adoc[`shouldFuncOptimizeForSizeImpl`] 
| Returns true if function `F` is suggested to be size&hyphen;optimized based on the profile&period;
| xref:llvm/shouldInline.adoc[`shouldInline`] 
| Return the inline cost when the inliner should attempt `CB,` else nullopt&period;
| xref:llvm/shouldOptimizeForSize-00.adoc[`shouldOptimizeForSize`] 
| `shouldOptimizeForSize` overloads
| xref:llvm/shouldOptimizeForSizeImpl.adoc[`shouldOptimizeForSizeImpl`] 
| Returns true if a basic block (or its frequency) is suggested to be size&hyphen;optimized based on the profile&period;
| xref:llvm/shouldPrintAfterAll.adoc[`shouldPrintAfterAll`] 
| Returns true if IR should be printed after every pass&period;
| xref:llvm/shouldPrintAfterPass.adoc[`shouldPrintAfterPass`] 
| Returns true if IR should be printed after the pass named `PassID&period;`
| xref:llvm/shouldPrintAfterSomePass.adoc[`shouldPrintAfterSomePass`] 
| Returns true if printing IR after at least one pass is enabled&period;
| xref:llvm/shouldPrintBeforeAll.adoc[`shouldPrintBeforeAll`] 
| Returns true if IR should be printed before every pass&period;
| xref:llvm/shouldPrintBeforePass.adoc[`shouldPrintBeforePass`] 
| Returns true if IR should be printed before the pass named `PassID&period;`
| xref:llvm/shouldPrintBeforeSomePass.adoc[`shouldPrintBeforeSomePass`] 
| Returns true if printing IR before at least one pass is enabled&period;
| xref:llvm/shouldReverseIterate.adoc[`shouldReverseIterate`] 
| Return true if containers of `T` should iterate in reverse order&period;
| xref:llvm/shuffle.adoc[`shuffle`] 
| Randomly shuffle the elements in &lsqb;&rsqb;`first,` `last)` using generator `g&period;`
| xref:llvm/simplifyAShrInst.adoc[`simplifyAShrInst`] 
| Given operands for a AShr, fold the result or return nulll&period;
| xref:llvm/simplifyAddInst.adoc[`simplifyAddInst`] 
| Given operands for an Add, fold the result or return null&period;
| xref:llvm/simplifyAndInst.adoc[`simplifyAndInst`] 
| Given operands for an And, fold the result or return null&period;
| xref:llvm/simplifyBinOp-06.adoc[`simplifyBinOp`] 
| `simplifyBinOp` overloads
| xref:llvm/simplifyCFG.adoc[`simplifyCFG`] 
| Simplify the CFG around a basic block with peephole optimizations&period;
| xref:llvm/simplifyCall.adoc[`simplifyCall`] 
| Given a callsite, callee, and arguments, fold the result or return null&period;
| xref:llvm/simplifyCastInst.adoc[`simplifyCastInst`] 
| Given operands for a CastInst, fold the result or return null&period;
| xref:llvm/simplifyCmpInst.adoc[`simplifyCmpInst`] 
| Given operands for a CmpInst, fold the result or return null&period;
| xref:llvm/simplifyConstrainedFPCall.adoc[`simplifyConstrainedFPCall`] 
| Given a constrained FP intrinsic call, tries to compute its simplified version&period;
| xref:llvm/simplifyExtractElementInst.adoc[`simplifyExtractElementInst`] 
| Given operands for an ExtractElementInst, fold the result or return null&period;
| xref:llvm/simplifyExtractValueInst.adoc[`simplifyExtractValueInst`] 
| Given operands for an ExtractValueInst, fold the result or return null&period;
| xref:llvm/simplifyFAddInst.adoc[`simplifyFAddInst`] 
| Given operands for an FAdd, fold the result or return null&period;
| xref:llvm/simplifyFCmpInst.adoc[`simplifyFCmpInst`] 
| Given operands for an FCmpInst, fold the result or return null&period;
| xref:llvm/simplifyFDivInst.adoc[`simplifyFDivInst`] 
| Given operands for an FDiv, fold the result or return null&period;
| xref:llvm/simplifyFMAFMul.adoc[`simplifyFMAFMul`] 
| Given operands for the multiplication of a FMA, fold the result or return null&period;
| xref:llvm/simplifyFMulInst.adoc[`simplifyFMulInst`] 
| Given operands for an FMul, fold the result or return null&period;
| xref:llvm/simplifyFNegInst.adoc[`simplifyFNegInst`] 
| Given operand for an FNeg, fold the result or return null&period;
| xref:llvm/simplifyFRemInst.adoc[`simplifyFRemInst`] 
| Given operands for an FRem, fold the result or return null&period;
| xref:llvm/simplifyFSubInst.adoc[`simplifyFSubInst`] 
| Given operands for an FSub, fold the result or return null&period;
| xref:llvm/simplifyFreezeInst.adoc[`simplifyFreezeInst`] 
| Given an operand for a Freeze, see if we can fold the result&period;
| xref:llvm/simplifyGEPInst.adoc[`simplifyGEPInst`] 
| Given operands for a GetElementPtrInst, fold the result or return null&period;
| xref:llvm/simplifyICmpInst.adoc[`simplifyICmpInst`] 
| Given operands for an ICmpInst, fold the result or return null&period;
| xref:llvm/simplifyInsertElementInst.adoc[`simplifyInsertElementInst`] 
| Given operands for an InsertElement, fold the result or return null&period;
| xref:llvm/simplifyInsertValueInst.adoc[`simplifyInsertValueInst`] 
| Given operands for an InsertValueInst, fold the result or return null&period;
| xref:llvm/simplifyInstruction.adoc[`simplifyInstruction`] 
| See if we can compute a simplified version of this instruction&period;
| xref:llvm/simplifyInstructionWithOperands.adoc[`simplifyInstructionWithOperands`] 
| Like `simplifyInstruction` but the operands of `I` are replaced with `NewOps&period;`
| xref:llvm/simplifyIntrinsic.adoc[`simplifyIntrinsic`] 
| Given operands for an intrinsic, fold the result or return null&period;
| xref:llvm/simplifyLShrInst.adoc[`simplifyLShrInst`] 
| Given operands for a LShr, fold the result or return null&period;
| xref:llvm/simplifyLoadInst.adoc[`simplifyLoadInst`] 
| Given a load instruction and its pointer operand, fold the result or return null&period;
| xref:llvm/simplifyLoop.adoc[`simplifyLoop`] 
| Simplify each loop in a loop nest recursively&period;
| xref:llvm/simplifyLoopAfterUnroll.adoc[`simplifyLoopAfterUnroll`] 
| Clean up and simplify a loop after unrolling&period;
| xref:llvm/simplifyLoopIVs.adoc[`simplifyLoopIVs`] 
| Simplify users of induction variables within this loop&period;
| xref:llvm/simplifyMulInst.adoc[`simplifyMulInst`] 
| Given operands for a Mul, fold the result or return null&period;
| xref:llvm/simplifyOrInst.adoc[`simplifyOrInst`] 
| Given operands for an Or, fold the result or return null&period;
| xref:llvm/simplifySDivInst.adoc[`simplifySDivInst`] 
| Given operands for an SDiv, fold the result or return null&period;
| xref:llvm/simplifySRemInst.adoc[`simplifySRemInst`] 
| Given operands for an SRem, fold the result or return null&period;
| xref:llvm/simplifySelectInst.adoc[`simplifySelectInst`] 
| Given operands for a SelectInst, fold the result or return null&period;
| xref:llvm/simplifyShlInst.adoc[`simplifyShlInst`] 
| Given operands for a Shl, fold the result or return null&period;
| xref:llvm/simplifyShuffleVectorInst.adoc[`simplifyShuffleVectorInst`] 
| Given operands for a ShuffleVectorInst, fold the result or return null&period;
| xref:llvm/simplifySubInst.adoc[`simplifySubInst`] 
| Given operands for a Sub, fold the result or return null&period;
| xref:llvm/simplifyUDivInst.adoc[`simplifyUDivInst`] 
| Given operands for a UDiv, fold the result or return null&period;
| xref:llvm/simplifyURemInst.adoc[`simplifyURemInst`] 
| Given operands for a URem, fold the result or return null&period;
| xref:llvm/simplifyUnOp-02.adoc[`simplifyUnOp`] 
| `simplifyUnOp` overloads
| xref:llvm/simplifyUsersOfIV.adoc[`simplifyUsersOfIV`] 
| Simplify instructions that use this induction variable&period;
| xref:llvm/simplifyWithOpReplaced.adoc[`simplifyWithOpReplaced`] 
| See if V simplifies when its operand Op is replaced with RepOp&period;
| xref:llvm/simplifyXorInst.adoc[`simplifyXorInst`] 
| Given operands for an Xor, fold the result or return null&period;
| xref:llvm/sinkRegion.adoc[`sinkRegion`] 
| Sink invariant instructions out of a loop region in reverse DFS order&period;
| xref:llvm/sinkRegionForLoopNest.adoc[`sinkRegionForLoopNest`] 
| Sink invariant instructions for every loop in a nest, inner to outer&period;
| xref:llvm/size.adoc[`size`] 
| Return the size of `Range` when distance is O(1)&period;
| xref:llvm/skipDebugInstructionsBackward.adoc[`skipDebugInstructionsBackward`] 
| Retreat `It` past debug (and optionally pseudo&hyphen;probe) instructions&period;
| xref:llvm/skipDebugInstructionsForward.adoc[`skipDebugInstructionsForward`] 
| Advance `It` past debug (and optionally pseudo&hyphen;probe) instructions&period;
| xref:llvm/skipDebugIntrinsics.adoc[`skipDebugIntrinsics`] 
| Advance `It` while it points to a debug instruction and return the result&period;
| xref:llvm/sort-049.adoc[`sort`] 
| `sort` overloads
| xref:llvm/sortBasicBlocksAndUpdateBranches.adoc[`sortBasicBlocksAndUpdateBranches`] 
| Sort the machine basic blocks of `MF` and update branches after the reorder&period;
| xref:llvm/sortPtrAccesses.adoc[`sortPtrAccesses`] 
| Attempt to sort the pointers in `VL` and return the sorted indices in `SortedIndices,` if reordering is required&period;
| xref:llvm/spell.adoc[`spell`] 
| Returns text representation of the given rounding mode&period;
| xref:llvm/spliceBB-0f.adoc[`spliceBB`] 
| `spliceBB` overloads
| xref:llvm/split-04.adoc[`split`] 
| `split` overloads
| xref:llvm/splitBB-04b2.adoc[`splitBB`] 
| `splitBB` overloads
| xref:llvm/splitBBWithSuffix.adoc[`splitBBWithSuffix`] 
| Split a block and suffix the current block name for the new successor&period;
| xref:llvm/splitBlockBefore-00.adoc[`splitBlockBefore`] 
| `splitBlockBefore` overloads
| xref:llvm/splitModuleTransitiveFromEntryPoints.adoc[`splitModuleTransitiveFromEntryPoints`] 
| Splits a module into parts by transitive reachability from entry points&period;
| xref:llvm/stableHashValue-032.adoc[`stableHashValue`] 
| `stableHashValue` overloads
| xref:llvm/stable_hash_combine-05.adoc[`stable&lowbar;hash&lowbar;combine`] 
| `stable&lowbar;hash&lowbar;combine` overloads
| xref:llvm/stable_hash_name.adoc[`stable&lowbar;hash&lowbar;name`] 
| Hash `Name` after normalizing it with get&lowbar;stable&lowbar;name()&period;
| xref:llvm/stable_sort-03.adoc[`stable&lowbar;sort`] 
| `stable&lowbar;sort` overloads
| xref:llvm/streamFile.adoc[`streamFile`] 
| Sets the response to stream the file at FilePath, if available, and otherwise an HTTP 404 error response&period;
| xref:llvm/stringifyKCFIHashAlgorithm.adoc[`stringifyKCFIHashAlgorithm`] 
| Convert a KCFI hash algorithm enum to its string representation&period;
| xref:llvm/stripDebugInfo-0a.adoc[`stripDebugInfo`] 
| Strip debug info from a single function&period;
| xref:llvm/stripDebugifyMetadata.adoc[`stripDebugifyMetadata`] 
| Strip out all of the metadata and debug info inserted by debugify&period;
| xref:llvm/stripNonLineTableDebugInfo.adoc[`stripNonLineTableDebugInfo`] 
| Downgrade the debug info in a module to contain only line table information&period;
| xref:llvm/stripNullTest-0a.adoc[`stripNullTest`] 
| `stripNullTest` overloads
| xref:llvm/succ_begin-0f7.adoc[`succ&lowbar;begin`] 
| `succ&lowbar;begin` overloads
| xref:llvm/succ_empty-04.adoc[`succ&lowbar;empty`] 
| `succ&lowbar;empty` overloads
| xref:llvm/succ_end-05.adoc[`succ&lowbar;end`] 
| `succ&lowbar;end` overloads
| xref:llvm/succ_size-05.adoc[`succ&lowbar;size`] 
| `succ&lowbar;size` overloads
| xref:llvm/succeeded.adoc[`succeeded`] 
| Utility function that returns true if the provided LogicalResult corresponds to a success value&period;
| xref:llvm/success-08.adoc[`success`] 
| `success` overloads
| xref:llvm/successors-02.adoc[`successors`] 
| `successors` overloads
| xref:llvm/sum_of.adoc[`sum&lowbar;of`] 
| Return the sum of values in `Range` starting from `Init&period;`
| xref:llvm/swap-048.adoc[`swap`] 
| `swap` overloads
| xref:llvm/tensorValueToString.adoc[`tensorValueToString`] 
| Format a tensor buffer as a string for debugging&period;
| xref:llvm/thinLTOFinalizeInModule.adoc[`thinLTOFinalizeInModule`] 
| Apply ThinLTO summary linkage, visibility, and optional attribute updates&period;
| xref:llvm/thinLTOInternalizeAndPromoteInIndex.adoc[`thinLTOInternalizeAndPromoteInIndex`] 
| Mark exported values external and non&hyphen;exported values internal in the index&period;
| xref:llvm/thinLTOInternalizeModule.adoc[`thinLTOInternalizeModule`] 
| Internalize `TheModule` based on the information recorded in the summaries during global summary&hyphen;based analysis&period;
| xref:llvm/thinLTOPropagateFunctionAttrs.adoc[`thinLTOPropagateFunctionAttrs`] 
| Propagate function attributes for function summaries along the index&apos;s callgraph during thinlink
| xref:llvm/thinLTOResolvePrevailingInIndex.adoc[`thinLTOResolvePrevailingInIndex`] 
| Resolve linkage for prevailing symbols in the index&period;
| xref:llvm/timeTraceAddInstantEvent.adoc[`timeTraceAddInstantEvent`] 
| Record an instant event with the given name and lazily computed detail&period;
| xref:llvm/timeTraceAsyncProfilerBegin.adoc[`timeTraceAsyncProfilerBegin`] 
| Manually begin an asynchronous time section with the given name and detail&period;
| xref:llvm/timeTraceProfilerBegin-09.adoc[`timeTraceProfilerBegin`] 
| `timeTraceProfilerBegin` overloads
| xref:llvm/timeTraceProfilerCleanup.adoc[`timeTraceProfilerCleanup`] 
| Cleanup the time trace profiler, if it was initialized&period;
| xref:llvm/timeTraceProfilerEnabled.adoc[`timeTraceProfilerEnabled`] 
| Is the time trace profiler enabled, i&period;e&period; initialized?
| xref:llvm/timeTraceProfilerEnd-02.adoc[`timeTraceProfilerEnd`] 
| `timeTraceProfilerEnd` overloads
| xref:llvm/timeTraceProfilerFinishThread.adoc[`timeTraceProfilerFinishThread`] 
| Finish a time trace profiler running on a worker thread&period;
| xref:llvm/timeTraceProfilerInitialize.adoc[`timeTraceProfilerInitialize`] 
| Initialize the time trace profiler&period;
| xref:llvm/timeTraceProfilerWrite-04.adoc[`timeTraceProfilerWrite`] 
| `timeTraceProfilerWrite` overloads
| xref:llvm/toCABI.adoc[`toCABI`] 
| Map LLVM `AO` to the corresponding C11&sol;C&plus;&plus;11 ABI memory&hyphen;order encoding&period;
| xref:llvm/toHex-05.adoc[`toHex`] 
| `toHex` overloads
| xref:llvm/toIRString.adoc[`toIRString`] 
| String used by LLVM IR to represent atomic ordering&period;
| xref:llvm/toLower.adoc[`toLower`] 
| Returns the corresponding lowercase character if `x` is uppercase&period;
| xref:llvm/toScalarizedStructTy.adoc[`toScalarizedStructTy`] 
| Convert a struct of vector types to a struct of scalar types&period;
| xref:llvm/toScalarizedTy.adoc[`toScalarizedTy`] 
| Convert a vectorized type to its scalarized (non&hyphen;vector) form&period;
| xref:llvm/toString-09.adoc[`toString`] 
| `toString` overloads
| xref:llvm/toStringRef-009.adoc[`toStringRef`] 
| `toStringRef` overloads
| xref:llvm/toStringRefArray.adoc[`toStringRefArray`] 
| Construct a vector of StringRefs from a null&hyphen;terminated C&hyphen;string array&period;
| xref:llvm/toStringWithoutConsuming.adoc[`toStringWithoutConsuming`] 
| Like toString(), but does not consume the error&period; This can be used to print a warning while retaining the original error object&period;
| xref:llvm/toUpper.adoc[`toUpper`] 
| Returns the corresponding uppercase character if `x` is lowercase&period;
| xref:llvm/toVectorTy-0e2.adoc[`toVectorTy`] 
| `toVectorTy` overloads
| xref:llvm/toVectorizedStructTy.adoc[`toVectorizedStructTy`] 
| Convert a struct of scalar types to a struct of vector types&period;
| xref:llvm/toVectorizedTy.adoc[`toVectorizedTy`] 
| Convert a scalar or struct type to its vectorized form&period;
| xref:llvm/to_address-09.adoc[`to&lowbar;address`] 
| `to&lowbar;address` overloads
| xref:llvm/to_float-06.adoc[`to&lowbar;float`] 
| `to&lowbar;float` overloads
| xref:llvm/to_integer.adoc[`to&lowbar;integer`] 
| Convert string `S` to an integer of type `N` using radix `Base&period;`
| xref:llvm/to_string-0dd.adoc[`to&lowbar;string`] 
| `to&lowbar;string` overloads
| xref:llvm/to_underlying.adoc[`to&lowbar;underlying`] 
| Returns the underlying integer value of an enum&period;
| xref:llvm/to_vector-06.adoc[`to&lowbar;vector`] 
| `to&lowbar;vector` overloads
| xref:llvm/to_vector_of-02.adoc[`to&lowbar;vector&lowbar;of`] 
| `to&lowbar;vector&lowbar;of` overloads
| xref:llvm/transform.adoc[`transform`] 
| Apply `F` to each element of `Range` and store results at `d&lowbar;first&period;`
| xref:llvm/transformGlobalCtors.adoc[`transformGlobalCtors`] 
| Apply `Fn` to the list of global constructors of module `M&period;`
| xref:llvm/transformGlobalDtors.adoc[`transformGlobalDtors`] 
| Apply `Fn` to the list of global destructors of module `M&period;`
| xref:llvm/transformOptional.adoc[`transformOptional`] 
| Apply `F` to the contained value of `O` if present&period;
| xref:llvm/tryBiasPhysRegs.adoc[`tryBiasPhysRegs`] 
| Bias candidate selection toward physreg copies near their users&period;
| xref:llvm/tryEnforceAlignment.adoc[`tryEnforceAlignment`] 
| Try to raise a controlled object&apos;s alignment to a preferred value&period;
| xref:llvm/tryGetFromHex.adoc[`tryGetFromHex`] 
| Convert a hexadecimal string to binary bytes&period;
| xref:llvm/tryGetHexFromNibbles.adoc[`tryGetHexFromNibbles`] 
| Decode two hex digit characters into a byte&period;
| xref:llvm/tryGreater.adoc[`tryGreater`] 
| Prefer `TryCand` when `TryVal` is greater than `CandVal&period;`
| xref:llvm/tryLatency.adoc[`tryLatency`] 
| Apply latency heuristics between `TryCand` and `Cand` in `Zone&period;`
| xref:llvm/tryLess.adoc[`tryLess`] 
| Prefer `TryCand` when `TryVal` is less than `CandVal&period;`
| xref:llvm/tryPressure.adoc[`tryPressure`] 
| Apply register&hyphen;pressure heuristics between `TryP` and `CandP&period;`
| xref:llvm/tryPromoteCall.adoc[`tryPromoteCall`] 
| Try to promote (devirtualize) a virtual call on an Alloca&period; Return true on success&period;
| xref:llvm/uniform-08.adoc[`uniform`] 
| `uniform` overloads
| xref:llvm/uninitialized_copy.adoc[`uninitialized&lowbar;copy`] 
| Copy range `Src` into uninitialized memory at `Dst&period;`
| xref:llvm/unique-001.adoc[`unique`] 
| `unique` overloads
| xref:llvm/unique_dyn_cast-04.adoc[`unique&lowbar;dyn&lowbar;cast`] 
| `unique&lowbar;dyn&lowbar;cast` overloads
| xref:llvm/unique_dyn_cast_or_null-05.adoc[`unique&lowbar;dyn&lowbar;cast&lowbar;or&lowbar;null`] 
| `unique&lowbar;dyn&lowbar;cast&lowbar;or&lowbar;null` overloads
| xref:llvm/uniteAccessGroups.adoc[`uniteAccessGroups`] 
| Compute the union of two access&hyphen;group lists&period;
| xref:llvm/unknown_sign.adoc[`unknown&lowbar;sign`] 
| Return the test mask which returns true if the value could have the same set of classes, but with a different sign&period;
| xref:llvm/unwrap-0fa3.adoc[`unwrap`] 
| `unwrap` overloads
| xref:llvm/updateCGAndAnalysisManagerForCGSCCPass.adoc[`updateCGAndAnalysisManagerForCGSCCPass`] 
| Helper to update the call graph after running a CGSCC pass&period;
| xref:llvm/updateCGAndAnalysisManagerForFunctionPass.adoc[`updateCGAndAnalysisManagerForFunctionPass`] 
| Helper to update the call graph after running a function pass&period;
| xref:llvm/updateCompilerUsed.adoc[`updateCompilerUsed`] 
| Create or update the magic &quot;llvm&period;compiler&lowbar;used&quot; global in a module&period;
| xref:llvm/updateDbgValueForSpill.adoc[`updateDbgValueForSpill`] 
| Update a DBG&lowbar;VALUE whose value has been spilled to FrameIndex&period; Useful when modifying an instruction in place while iterating over a basic block&period;
| xref:llvm/updateIndexWPDForExports.adoc[`updateIndexWPDForExports`] 
| Update recorded single&hyphen;impl WPD target names after cross&hyphen;module importing&period;
| xref:llvm/updateIndirectCalls.adoc[`updateIndirectCalls`] 
| Update SamplePGO indirect call edges to local functions when needed&period;
| xref:llvm/updateLoopMetadataDebugLocations.adoc[`updateLoopMetadataDebugLocations`] 
| Update debug locations in any MD&lowbar;loop metadata attached to `I&period;`
| xref:llvm/updatePhiNodes.adoc[`updatePhiNodes`] 
| Replace OldPred with NewPred in PHI nodes of a destination block&period;
| xref:llvm/updateProfileCallee.adoc[`updateProfileCallee`] 
| Update callee profile counts after cloning or inlining&period;
| xref:llvm/updatePublicTypeTestCalls.adoc[`updatePublicTypeTestCalls`] 
| Update public type&hyphen;test calls according to whole&hyphen;program visibility&period;
| xref:llvm/updateVCallVisibilityInIndex.adoc[`updateVCallVisibilityInIndex`] 
| Update virtual&hyphen;call visibility in the module summary index&period;
| xref:llvm/updateVCallVisibilityInModule.adoc[`updateVCallVisibilityInModule`] 
| Update virtual&hyphen;call visibility metadata on vtables in `M&period;`
| xref:llvm/upgradeInstructionLoopAttachment.adoc[`upgradeInstructionLoopAttachment`] 
| Upgrade the loop attachment metadata node&period;
| xref:llvm/upper_bound-0f.adoc[`upper&lowbar;bound`] 
| `upper&lowbar;bound` overloads
| xref:llvm/upward_defs.adoc[`upward&lowbar;defs`] 
| Return a range walking upward defs from `Pair` with phi translation&period;
| xref:llvm/upward_defs_begin.adoc[`upward&lowbar;defs&lowbar;begin`] 
| Return the begin iterator for an upward defs walk of `Pair&period;`
| xref:llvm/upward_defs_end.adoc[`upward&lowbar;defs&lowbar;end`] 
| Return the end iterator for an upward defs walk&period;
| xref:llvm/utohexstr.adoc[`utohexstr`] 
| Convert `X` to a hexadecimal string&period;
| xref:llvm/utostr.adoc[`utostr`] 
| Convert an unsigned integer to a decimal string&period;
| xref:llvm/validateDelinearizationResult.adoc[`validateDelinearizationResult`] 
| Check that each subscript in `Subscripts` is within the corresponding size in `Sizes&period;` For the outermost dimension, the subscript being negative is allowed&period;
| xref:llvm/verifyFunction.adoc[`verifyFunction`] 
| Check a function for errors, useful for use when debugging a pass&period;
| xref:llvm/verifyMachineFunction.adoc[`verifyMachineFunction`] 
| Run the machine code verifier on `MF,` reporting problems under `Banner&period;`
| xref:llvm/verifyModule.adoc[`verifyModule`] 
| Check a module for errors&period;
| xref:llvm/verifySafepointIR.adoc[`verifySafepointIR`] 
| Run the safepoint verifier over a single function&period; Crashes on failure&period;
| xref:llvm/versionCallSite.adoc[`versionCallSite`] 
| Predicate and clone the given call site&period;
| xref:llvm/viewGraphForFunction.adoc[`viewGraphForFunction`] 
| Open a Graphviz viewer for a function&apos;s analysis graph&period;
| xref:llvm/viewRegion-03.adoc[`viewRegion`] 
| `viewRegion` overloads
| xref:llvm/viewRegionOnly-07.adoc[`viewRegionOnly`] 
| `viewRegionOnly` overloads
| xref:llvm/visitAll.adoc[`visitAll`] 
| Use SCEVTraversal to visit all nodes in the given expression tree&period;
| xref:llvm/visitErrors.adoc[`visitErrors`] 
| Visit all the ErrorInfo(s) contained in E by passing them to the respective handler, without consuming the error&period;
| xref:llvm/warnToStderr.adoc[`warnToStderr`] 
| Log `Err` to stderr as a warning&period;
| xref:llvm/widenShuffleMaskElts-00.adoc[`widenShuffleMaskElts`] 
| `widenShuffleMaskElts` overloads
| xref:llvm/widenWidenableBranch.adoc[`widenWidenableBranch`] 
| Widens a widenable branch so that `NewCond` also holds on the taken path&period;
| xref:llvm/willNotFreeBetween.adoc[`willNotFreeBetween`] 
| Returns true, if no instruction between `Assume` and `CtxI` may free (including through synchronization)&period;
| xref:llvm/wouldInstructionBeTriviallyDead.adoc[`wouldInstructionBeTriviallyDead`] 
| Return true if an instruction would be trivially dead with no uses&period;
| xref:llvm/wrap-003e.adoc[`wrap`] 
| `wrap` overloads
| xref:llvm/write.adoc[`write`] 
| Merge split DWARF inputs into `Out,` optionally writing the package&period;
| xref:llvm/writeArchive.adoc[`writeArchive`] 
| Write an archive to the file named `ArcName&period;`
| xref:llvm/writeArchiveToBuffer.adoc[`writeArchiveToBuffer`] 
| Write an archive into a memory buffer&period;
| xref:llvm/writeArchiveToStream.adoc[`writeArchiveToStream`] 
| Write an archive directly to an output stream&period;
| xref:llvm/writeIndexToFile.adoc[`writeIndexToFile`] 
| Write a module summary index to `Out` as a new bitcode block&period;
| xref:llvm/writeMemProf.adoc[`writeMemProf`] 
| Write MemProf profile data to `OS` in the requested indexed format version&period;
| xref:llvm/writeModule.adoc[`writeModule`] 
| Fuzzer friendly interface for the llvm bitcode printer&period;
| xref:llvm/writeThinLinkBitcodeToFile.adoc[`writeThinLinkBitcodeToFile`] 
| Write a minimized thin&hyphen;link bitcode file to `Out&period;`
| xref:llvm/writeToOutput.adoc[`writeToOutput`] 
| Create an output stream for `OutputFileName` and pass it to `Write&period;`
| xref:llvm/write_double.adoc[`write&lowbar;double`] 
| Write a floating&hyphen;point value to a stream&period;
| xref:llvm/write_hex.adoc[`write&lowbar;hex`] 
| Write a hexadecimal value to a stream&period;
| xref:llvm/write_integer-04.adoc[`write&lowbar;integer`] 
| `write&lowbar;integer` overloads
| xref:llvm/xxh3_128bits-08.adoc[`xxh3&lowbar;128bits`] 
| `xxh3&lowbar;128bits` overloads
| xref:llvm/xxh3_64bits-07.adoc[`xxh3&lowbar;64bits`] 
| `xxh3&lowbar;64bits` overloads
| xref:llvm/zip.adoc[`zip`] 
| Zip two or more ranges, stopping at the shortest&period;
| xref:llvm/zip_equal.adoc[`zip&lowbar;equal`] 
| Zip ranges that are required to have equal length&period;
| xref:llvm/zip_first.adoc[`zip&lowbar;first`] 
| Zip ranges assuming the first is the shortest&period;
| xref:llvm/zip_longest.adoc[`zip&lowbar;longest`] 
| Zip ranges until every iteratee has been exhausted&period;
| xref:llvm/operator_lshift-071.adoc[`operator&lt;&lt;`] 
| Left shift operators
| xref:llvm/operator_eq-0280.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:llvm/operator_not_eq-04d.adoc[`operator!&equals;`] 
| Inequality operators
| xref:llvm/operator_lt-058.adoc[`operator&lt;`] 
| Less&hyphen;than operators
| xref:llvm/operator_le-0f01.adoc[`operator&lt;&equals;`] 
| Less&hyphen;than&hyphen;or&hyphen;equal operators
| xref:llvm/operator_gt-007.adoc[`operator&gt;`] 
| Greater&hyphen;than operators
| xref:llvm/operator_ge-055.adoc[`operator&gt;&equals;`] 
| Greater&hyphen;than&hyphen;or&hyphen;equal operators
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:llvm/AsmRewritePrecedence.adoc[`AsmRewritePrecedence`] 
| Precedence for each `AsmRewriteKind` when applying rewrites&period;
| xref:llvm/AssumptionAttrKey.adoc[`AssumptionAttrKey`] 
| The key we use for assumption attributes&period;
| xref:llvm/AtomicExpandID.adoc[`AtomicExpandID`] 
| AtomicExpandID &hyphen;&hyphen; Lowers atomic operations in terms of either cmpxchg load&hyphen;linked&sol;store&hyphen;conditional loops&period;
| xref:llvm/BBSectionsColdTextPrefix.adoc[`BBSectionsColdTextPrefix`] 
| Command&hyphen;line option for the text section prefix of cold basic block clusters&period;
| xref:llvm/BitWidth.adoc[`BitWidth`] 
| Number of bits needed to represent the largest enumerator of bitmask enum `E&period;`
| xref:llvm/BranchFolderPassID.adoc[`BranchFolderPassID`] 
| Pass ID for CFG optimizations that fold machine branches&period;
| xref:llvm/BranchRelaxationPassID.adoc[`BranchRelaxationPassID`] 
| BranchRelaxation &hyphen; This pass replaces branches that need to jump further than is supported by a branch instruction&period;
| xref:llvm/BreakCriticalEdgesID.adoc[`BreakCriticalEdgesID`] 
| Pass ID for the BreakCriticalEdges pass&period;
| xref:llvm/CastIfPresentTo.adoc[`CastIfPresentTo`] 
| Function object that applies `cast&lowbar;if&lowbar;present&lt;To&gt;` in generic algorithms&period;
| xref:llvm/CastTo.adoc[`CastTo`] 
| Function object that applies `cast&lt;To&gt;` in generic algorithms&period;
| xref:llvm/CheckBFIUnknownBlockQueries.adoc[`CheckBFIUnknownBlockQueries`] 
| When true, treat queries for unknown blocks as errors for debugging&period;
| xref:llvm/DeadMachineInstructionElimID.adoc[`DeadMachineInstructionElimID`] 
| DeadMachineInstructionElim &hyphen; This pass removes dead machine instructions&period;
| xref:llvm/DebugFlag.adoc[`DebugFlag`] 
| True when the &apos;&hyphen;debug&apos; command line option is specified&period;
| xref:llvm/DecisionName.adoc[`DecisionName`] 
| Tensor name for the ML model&apos;s inlining decision output&period;
| xref:llvm/DefMaxInstsToScan.adoc[`DefMaxInstsToScan`] 
| The default number of maximum instructions to scan in the block, used by FindAvailableLoadedValue()&period;
| xref:llvm/DefaultAllocTokenMode.adoc[`DefaultAllocTokenMode`] 
| The default allocation token mode&period;
| xref:llvm/DefaultDecisionName.adoc[`DefaultDecisionName`] 
| Tensor name for the default (heuristic) inlining decision&period;
| xref:llvm/DefaultDecisionSpec.adoc[`DefaultDecisionSpec`] 
| Spec for the default (heuristic) inlining decision tensor&period;
| xref:llvm/DetectDeadLanesID.adoc[`DetectDeadLanesID`] 
| This pass adds dead&sol;undef flags after analyzing subregister lanes&period;
| xref:llvm/DisableGISelLegalityCheck.adoc[`DisableGISelLegalityCheck`] 
| Command&hyphen;line option that disables GlobalISel legality verification checks&period;
| xref:llvm/DoInstrProfNameCompression.adoc[`DoInstrProfNameCompression`] 
| Whether to compress function names in profiles and filenames in coverage&period;
| xref:llvm/DynCastIfPresentTo.adoc[`DynCastIfPresentTo`] 
| Function object that applies `dyn&lowbar;cast&lowbar;if&lowbar;present&lt;To&gt;` in generic algorithms&period;
| xref:llvm/DynCastTo.adoc[`DynCastTo`] 
| Function object that applies `dyn&lowbar;cast&lt;To&gt;` in generic algorithms&period;
| xref:llvm/EarlyIfConverterLegacyID.adoc[`EarlyIfConverterLegacyID`] 
| EarlyIfConverter &hyphen; This pass performs if&hyphen;conversion on SSA form by inserting cmov instructions&period;
| xref:llvm/EarlyIfPredicatorID.adoc[`EarlyIfPredicatorID`] 
| EarlyIfPredicator &hyphen; This pass performs if&hyphen;conversion on SSA form by predicating if&sol;else block and insert select at the join point&period;
| xref:llvm/EarlyMachineLICMID.adoc[`EarlyMachineLICMID`] 
| This pass performs loop invariant code motion on machine instructions&period; This variant works before register allocation&period;
| xref:llvm/EarlyTailDuplicateLegacyID.adoc[`EarlyTailDuplicateLegacyID`] 
| Duplicate blocks with unconditional branches into tails of their predecessors&period; Variant that works before register allocation&period;
| xref:llvm/EdgeBundlesWrapperLegacyID.adoc[`EdgeBundlesWrapperLegacyID`] 
| EdgeBundles analysis &hyphen; Bundle machine CFG edges&period;
| xref:llvm/EmitLongStrLiterals.adoc[`EmitLongStrLiterals`] 
| Controls emitting large character arrays as strings or character arrays&period; Typically set to false when building with MSVC&period;
| xref:llvm/EnableDebugBuffering.adoc[`EnableDebugBuffering`] 
| When true, the debug stream installs signal handlers to dump buffered output&period;
| xref:llvm/EnableFSDiscriminator.adoc[`EnableFSDiscriminator`] 
| Command&hyphen;line flag enabling flow&hyphen;sensitive discriminators&period;
| xref:llvm/EnableKnowledgeRetention.adoc[`EnableKnowledgeRetention`] 
| Enable preservation of attributes throughout code transformation&period;
| xref:llvm/EnableLTOInternalization.adoc[`EnableLTOInternalization`] 
| Enable global value internalization in LTO&period;
| xref:llvm/EnableLoopInterleaving.adoc[`EnableLoopInterleaving`] 
| Command&hyphen;line option that enables automatic loop interleaving&period;
| xref:llvm/EnableLoopVectorization.adoc[`EnableLoopVectorization`] 
| Command&hyphen;line option that enables automatic loop vectorization&period;
| xref:llvm/EnablePGSO.adoc[`EnablePGSO`] 
| Enable the profile&hyphen;guided size optimizations&period;
| xref:llvm/ErrorsPrinted.adoc[`ErrorsPrinted`] 
| Count of error diagnostics printed so far&period;
| xref:llvm/ExpandPostRAPseudosID.adoc[`ExpandPostRAPseudosID`] 
| ExpandPostRAPseudos &hyphen; This pass expands pseudo instructions after register allocation&period;
| xref:llvm/FEntryInserterID.adoc[`FEntryInserterID`] 
| This pass inserts FEntry calls
| xref:llvm/FinalizeISelID.adoc[`FinalizeISelID`] 
| This pass expands pseudo&hyphen;instructions, reserves registers and adjusts machine frame information&period;
| xref:llvm/FixupStatepointCallerSavedID.adoc[`FixupStatepointCallerSavedID`] 
| The pass fixups statepoint machine instruction to replace usage of caller saved registers with stack slots&period;
| xref:llvm/ForcePGSO.adoc[`ForcePGSO`] 
| Force the profile&hyphen;guided size optimizations regardless of profile data&period;
| xref:llvm/ForgetSCEVInLoopUnroll.adoc[`ForgetSCEVInLoopUnroll`] 
| Command&hyphen;line option to forget all SCEV loops when unrolling&period;
| xref:llvm/FuncletLayoutID.adoc[`FuncletLayoutID`] 
| This pass lays out funclets contiguously&period;
| xref:llvm/GCLoweringID.adoc[`GCLoweringID`] 
| GCLowering Pass &hyphen; Used by gc&period;root to perform its default lowering operations&period;
| xref:llvm/GCMachineCodeAnalysisID.adoc[`GCMachineCodeAnalysisID`] 
| Pass ID for marking GC safe points in machine code&period;
| xref:llvm/GlobalIdentifierDelimiter.adoc[`GlobalIdentifierDelimiter`] 
| Delimiter used when constructing a global identifier from name and filename&period;
| xref:llvm/GraphHasNodeNumbers.adoc[`GraphHasNodeNumbers`] 
| Indicate whether a GraphTraits&lt;NodeT&gt;&colon;&colon;getNumber() is supported&period;
| xref:llvm/HybridPatchableTargetSuffix.adoc[`HybridPatchableTargetSuffix`] 
| Suffix appended to ARM64EC hybrid&hyphen;patchable names for the x64 thunk&period;
| xref:llvm/HybridPatchableTargetSuffixArr.adoc[`HybridPatchableTargetSuffixArr`] 
| Character array holding the ARM64EC hybrid&hyphen;patchable target suffix&period;
| xref:llvm/IfConverterID.adoc[`IfConverterID`] 
| IfConverter &hyphen; This pass performs machine code if conversion&period;
| xref:llvm/IgnoreBundleTag.adoc[`IgnoreBundleTag`] 
| Tag in operand bundle indicating that this bundle should be ignored&period;
| xref:llvm/ImplicitNullChecksID.adoc[`ImplicitNullChecksID`] 
| ImplicitNullChecks &hyphen; This pass folds null pointer checks into nearby memory operations&period;
| xref:llvm/ImprovedFSDiscriminator.adoc[`ImprovedFSDiscriminator`] 
| Command&hyphen;line option enabling the improved MIR flow&hyphen;sensitive discriminator encoding&period;
| xref:llvm/IndexedCodeGenDataLazyLoading.adoc[`IndexedCodeGenDataLazyLoading`] 
| Command&hyphen;line option enabling lazy loading of indexed codegen data&period;
| xref:llvm/InferAddressSpacesID.adoc[`InferAddressSpacesID`] 
| Pass ID for the InferAddressSpaces pass&period;
| xref:llvm/InitUndefID.adoc[`InitUndefID`] 
| Pass ID for defining undef values with a pseudo instruction&period;
| xref:llvm/InlineDecisionSpec.adoc[`InlineDecisionSpec`] 
| Spec for the ML model&apos;s inlining decision output tensor&period;
| xref:llvm/InvalidClusterId.adoc[`InvalidClusterId`] 
| Sentinel cluster id meaning &quot;not in a cluster&quot;&period;
| xref:llvm/IsNullable.adoc[`IsNullable`] 
| True if `T` is a pointer or constructible from `nullptr&period;`
| xref:llvm/IsaAndPresentPred.adoc[`IsaAndPresentPred`] 
| Function object that applies `isa&lowbar;and&lowbar;present&lt;Types&period;&period;&period;&gt;` in algorithms&period;
| xref:llvm/IsaPred.adoc[`IsaPred`] 
| Function object that applies `isa&lt;Types&period;&period;&period;&gt;` in generic algorithms&period;
| xref:llvm/IterativeBFIMaxIterationsPerBlock.adoc[`IterativeBFIMaxIterationsPerBlock`] 
| Max iterative&hyphen;inference updates allowed per reachable block&period;
| xref:llvm/IterativeBFIPrecision.adoc[`IterativeBFIPrecision`] 
| Convergence epsilon for iterative block&hyphen;frequency inference&period;
| xref:llvm/LCSSAID.adoc[`LCSSAID`] 
| Pass ID for the LCSSA pass&period;
| xref:llvm/LLVMLoopEstimatedTripCount.adoc[`LLVMLoopEstimatedTripCount`] 
| Profile&hyphen;based loop metadata that should be accessed only by using `llvm&colon;&colon;getLoopEstimatedTripCount` and `llvm&colon;&colon;setLoopEstimatedTripCount&period;`
| xref:llvm/LLVMLoopUnrollFollowupAll.adoc[`LLVMLoopUnrollFollowupAll`] 
| @&lcub; Metadata attribute names
| xref:llvm/LLVMLoopUnrollFollowupRemainder.adoc[`LLVMLoopUnrollFollowupRemainder`] 
| Metadata attribute name for follow&hyphen;up attributes on the remainder loop&period;
| xref:llvm/LLVMLoopUnrollFollowupUnrolled.adoc[`LLVMLoopUnrollFollowupUnrolled`] 
| Metadata attribute name for follow&hyphen;up attributes on the unrolled loop&period;
| xref:llvm/LiveDebugValuesID.adoc[`LiveDebugValuesID`] 
| LiveDebugValues pass
| xref:llvm/LiveIntervalsID.adoc[`LiveIntervalsID`] 
| LiveIntervals &hyphen; This analysis keeps track of the live ranges of virtual and physical registers&period;
| xref:llvm/LiveRangeShrinkID.adoc[`LiveRangeShrinkID`] 
| LiveRangeShrink pass&period; Move instruction close to its definition to shrink the definition&apos;s live range&period;
| xref:llvm/LiveStacksID.adoc[`LiveStacksID`] 
| LiveStacks pass&period; An analysis keeping track of the liveness of stack slots&period;
| xref:llvm/LiveVariablesID.adoc[`LiveVariablesID`] 
| LiveVariables pass &hyphen; This pass computes the set of blocks in which each variable is life and sets machine operand kill flags&period;
| xref:llvm/LocalStackSlotAllocationID.adoc[`LocalStackSlotAllocationID`] 
| Pass ID for allocating local stack slots relative to each other&period;
| xref:llvm/LoopSimplifyID.adoc[`LoopSimplifyID`] 
| Pass ID for the LoopSimplify pass&period;
| xref:llvm/LowerInvokePassID.adoc[`LowerInvokePassID`] 
| Pass ID for the LowerInvoke pass&period;
| xref:llvm/LowerSwitchID.adoc[`LowerSwitchID`] 
| Pass ID for the LowerSwitch pass&period;
| xref:llvm/MAX_SUBTARGET_FEATURES.adoc[`MAX&lowbar;SUBTARGET&lowbar;FEATURES`] 
| Maximum number of subtarget feature bits (MAX&lowbar;SUBTARGET&lowbar;WORDS &ast; 64)&period;
| xref:llvm/MAX_SUBTARGET_WORDS.adoc[`MAX&lowbar;SUBTARGET&lowbar;WORDS`] 
| Number of 64&hyphen;bit words used to store subtarget feature bits&period;
| xref:llvm/MCScheduleOptions.adoc[`MCScheduleOptions`] 
| Option category for machine&hyphen;model scheduling command&hyphen;line flags&period;
| xref:llvm/MIRAddFSDiscriminatorsID.adoc[`MIRAddFSDiscriminatorsID`] 
| This pass adds flow sensitive discriminators&period;
| xref:llvm/MIRCanonicalizerID.adoc[`MIRCanonicalizerID`] 
| MIRCanonicalizer &hyphen; This pass canonicalizes MIR by renaming vregs according to the semantics of the instruction as well as hoists code&period;
| xref:llvm/MIRPrintingPassID.adoc[`MIRPrintingPassID`] 
| MIRPrintingPass &hyphen; this pass prints out the LLVM IR using the MIR serialization format&period;
| xref:llvm/MIRProfileLoaderPassID.adoc[`MIRProfileLoaderPassID`] 
| This pass reads flow sensitive profile&period;
| xref:llvm/MachineBlockPlacementID.adoc[`MachineBlockPlacementID`] 
| MachineBlockPlacement &hyphen; This pass places basic blocks based on branch probabilities&period;
| xref:llvm/MachineBlockPlacementStatsID.adoc[`MachineBlockPlacementStatsID`] 
| MachineBlockPlacementStats &hyphen; This pass collects statistics about the basic block placement using branch probabilities and block frequency information&period;
| xref:llvm/MachineCFGPrinterID.adoc[`MachineCFGPrinterID`] 
| MachineCFGPrinter pass&period;
| xref:llvm/MachineCSELegacyID.adoc[`MachineCSELegacyID`] 
| MachineCSE &hyphen; This pass performs global CSE on machine instructions&period;
| xref:llvm/MachineCombinerID.adoc[`MachineCombinerID`] 
| This pass performs instruction combining using trace metrics to estimate critical&hyphen;path and resource depth&period;
| xref:llvm/MachineCopyPropagationID.adoc[`MachineCopyPropagationID`] 
| MachineCopyPropagation &hyphen; This pass performs copy propagation on machine instructions&period;
| xref:llvm/MachineDominanceFrontierID.adoc[`MachineDominanceFrontierID`] 
| MachineDominanaceFrontier &hyphen; This pass is a machine dominators analysis&period;
| xref:llvm/MachineDominatorsID.adoc[`MachineDominatorsID`] 
| MachineDominators &hyphen; This pass is a machine dominators analysis pass&period;
| xref:llvm/MachineFunctionPrinterPassID.adoc[`MachineFunctionPrinterPassID`] 
| MachineFunctionPrinterPass &hyphen; This pass prints out MachineInstr&apos;s&period;
| xref:llvm/MachineLICMID.adoc[`MachineLICMID`] 
| This pass performs loop invariant code motion on machine instructions&period;
| xref:llvm/MachineLateInstrsCleanupID.adoc[`MachineLateInstrsCleanupID`] 
| MachineLateInstrsCleanup &hyphen; This pass removes redundant identical instructions after register allocation and rematerialization&period;
| xref:llvm/MachineLoopInfoID.adoc[`MachineLoopInfoID`] 
| MachineLoopInfo &hyphen; This pass is a loop analysis pass&period;
| xref:llvm/MachinePipelinerID.adoc[`MachinePipelinerID`] 
| This pass performs software pipelining on machine instructions&period;
| xref:llvm/MachineRegionInfoPassID.adoc[`MachineRegionInfoPassID`] 
| MachineRegionInfo &hyphen; This pass computes SESE regions for machine functions&period;
| xref:llvm/MachineSanitizerBinaryMetadataID.adoc[`MachineSanitizerBinaryMetadataID`] 
| Pass ID for finalizing sanitizer binary metadata in machine IR&period;
| xref:llvm/MachineSchedulerID.adoc[`MachineSchedulerID`] 
| MachineScheduler &hyphen; This pass schedules machine instructions&period;
| xref:llvm/MachineSinkingLegacyID.adoc[`MachineSinkingLegacyID`] 
| MachineSinking &hyphen; This pass performs sinking on machine instructions&period;
| xref:llvm/MachineTraceMetricsID.adoc[`MachineTraceMetricsID`] 
| MachineTraceMetrics &hyphen; This pass computes critical path and CPU resource usage in an ensemble of traces&period;
| xref:llvm/MaxAnalysisRecursionDepth.adoc[`MaxAnalysisRecursionDepth`] 
| Maximum recursion depth for analysis queries in this header&period;
| xref:llvm/MaxInitializationChainLength.adoc[`MaxInitializationChainLength`] 
| The value passed to the line option that defines the maximal initialization chain length&period;
| xref:llvm/MaxLookupSearchDepth.adoc[`MaxLookupSearchDepth`] 
| The max limit of the search depth in DecomposeGEPExpression() and getUnderlyingObject()&period;
| xref:llvm/NOMORE_ICP_MAGICNUM.adoc[`NOMORE&lowbar;ICP&lowbar;MAGICNUM`] 
| Magic number in the value profile metadata showing a target has been promoted for the instruction and shouldn&apos;t be promoted again&period;
| xref:llvm/NoKernelInfoEndLTO.adoc[`NoKernelInfoEndLTO`] 
| Remove the kernel&hyphen;info pass at the end of the full LTO pipeline when set&period;
| xref:llvm/NoWarnSampleUnused.adoc[`NoWarnSampleUnused`] 
| Command&hyphen;line option that suppresses warnings about unused sample profiles&period;
| xref:llvm/OldBooleanLoopTags.adoc[`OldBooleanLoopTags`] 
| Table mapping removed two&hyphen;operand loop enable tags to replacement tags&period;
| xref:llvm/OptimizePHIsLegacyID.adoc[`OptimizePHIsLegacyID`] 
| OptimizePHIs &hyphen; This pass optimizes machine instruction PHIs to take advantage of opportunities created during DAG legalization&period;
| xref:llvm/PGSOColdCodeOnly.adoc[`PGSOColdCodeOnly`] 
| Apply the profile&hyphen;guided size optimizations only to cold code&period;
| xref:llvm/PGSOColdCodeOnlyForInstrPGO.adoc[`PGSOColdCodeOnlyForInstrPGO`] 
| Apply PGSO only to cold code under instrumentation PGO&period;
| xref:llvm/PGSOColdCodeOnlyForPartialSamplePGO.adoc[`PGSOColdCodeOnlyForPartialSamplePGO`] 
| Apply PGSO only to cold code under partial&hyphen;profile sample PGO&period;
| xref:llvm/PGSOColdCodeOnlyForSamplePGO.adoc[`PGSOColdCodeOnlyForSamplePGO`] 
| Apply PGSO only to cold code under sample PGO&period;
| xref:llvm/PGSOLargeWorkingSetSizeOnly.adoc[`PGSOLargeWorkingSetSizeOnly`] 
| Apply PGSO only when the working set size is large (except for cold code)&period;
| xref:llvm/PHIEliminationID.adoc[`PHIEliminationID`] 
| Pass ID for eliminating machine PHI nodes with copies&period;
| xref:llvm/PartialUnrollingThreshold.adoc[`PartialUnrollingThreshold`] 
| Threshold controlling partial loop unrolling in BasicTTIImplBase&period;
| xref:llvm/PatchableFunctionID.adoc[`PatchableFunctionID`] 
| This pass implements the &quot;patchable&hyphen;function&quot; attribute&period;
| xref:llvm/PeepholeOptimizerLegacyID.adoc[`PeepholeOptimizerLegacyID`] 
| PeepholeOptimizer &hyphen; This pass performs peephole optimizations &hyphen; like extension and comparison eliminations&period;
| xref:llvm/PgsoCutoffInstrProf.adoc[`PgsoCutoffInstrProf`] 
| Profile summary cutoff for PGSO with instrumentation profiles&period;
| xref:llvm/PgsoCutoffSampleProf.adoc[`PgsoCutoffSampleProf`] 
| Profile summary cutoff for PGSO with sample profiles&period;
| xref:llvm/PoisonMaskElem.adoc[`PoisonMaskElem`] 
| Shuffle mask element value indicating a poison result element&period; Shuffle mask element value that marks the corresponding result lane as poison&period;
| xref:llvm/PostMachineSchedulerID.adoc[`PostMachineSchedulerID`] 
| PostMachineScheduler &hyphen; This pass schedules machine instructions postRA&period;
| xref:llvm/PostRAHazardRecognizerID.adoc[`PostRAHazardRecognizerID`] 
| PostRAHazardRecognizer &hyphen; This pass runs the post&hyphen;ra hazard recognizer&period;
| xref:llvm/PostRAMachineSinkingID.adoc[`PostRAMachineSinkingID`] 
| This pass perform post&hyphen;ra machine sink for COPY instructions&period;
| xref:llvm/PostRASchedulerID.adoc[`PostRASchedulerID`] 
| PostRAScheduler &hyphen; This pass performs post register allocation scheduling&period;
| xref:llvm/PreRADirection.adoc[`PreRADirection`] 
| Command&hyphen;line override for pre&hyphen;RA scheduling direction&period;
| xref:llvm/PrintChanged.adoc[`PrintChanged`] 
| Storage for the `&hyphen;print&hyphen;changed` command&hyphen;line option&period;
| xref:llvm/PrintDAGs.adoc[`PrintDAGs`] 
| When true, print each MISched DAG to the debug stream&period;
| xref:llvm/PrintPipelinePasses.adoc[`PrintPipelinePasses`] 
| Common option used by multiple tools to print pipeline passes
| xref:llvm/ProcessImplicitDefsID.adoc[`ProcessImplicitDefsID`] 
| ProcessImpicitDefs pass &hyphen; This pass removes IMPLICIT&lowbar;DEFs&period;
| xref:llvm/ProfcheckDisableMetadataFixes.adoc[`ProfcheckDisableMetadataFixes`] 
| Command&hyphen;line option that disables profile&hyphen;metadata propagation fixes&period;
| xref:llvm/ProfileInlineGrowthLimit.adoc[`ProfileInlineGrowthLimit`] 
| Size growth ratio limit for priority&hyphen;based sample profile loader inlining&period;
| xref:llvm/ProfileInlineLimitMax.adoc[`ProfileInlineLimitMax`] 
| Upper bound of size growth limit for priority&hyphen;based sample profile inlining&period;
| xref:llvm/ProfileInlineLimitMin.adoc[`ProfileInlineLimitMin`] 
| Lower bound of size growth limit for priority&hyphen;based sample profile inlining&period;
| xref:llvm/ProfileSummaryColdCount.adoc[`ProfileSummaryColdCount`] 
| Fixed cold count that overrides the threshold derived from ProfileSummaryCutoffCold&period;
| xref:llvm/ProfileSummaryCutoffCold.adoc[`ProfileSummaryCutoffCold`] 
| Percentile cutoff (scaled by ProfileSummary&colon;&colon;Scale) used to derive the cold count threshold&period;
| xref:llvm/ProfileSummaryCutoffHot.adoc[`ProfileSummaryCutoffHot`] 
| Percentile cutoff (scaled by ProfileSummary&colon;&colon;Scale) used to derive the hot count threshold&period;
| xref:llvm/ProfileSummaryHotCount.adoc[`ProfileSummaryHotCount`] 
| Fixed hot count that overrides the threshold derived from ProfileSummaryCutoffHot&period;
| xref:llvm/ProfileSummaryHugeWorkingSetSizeThreshold.adoc[`ProfileSummaryHugeWorkingSetSizeThreshold`] 
| Block&hyphen;count threshold above which the hot working set is considered huge&period;
| xref:llvm/ProfileSummaryLargeWorkingSetSizeThreshold.adoc[`ProfileSummaryLargeWorkingSetSizeThreshold`] 
| Block&hyphen;count threshold above which the hot working set is considered large&period;
| xref:llvm/PrologEpilogCodeInserterID.adoc[`PrologEpilogCodeInserterID`] 
| PrologEpilogCodeInserter &hyphen; This pass inserts prolog and epilog code, and eliminates abstract frame references&period;
| xref:llvm/PseudoProbeDescMetadataName.adoc[`PseudoProbeDescMetadataName`] 
| Metadata name for the module&hyphen;level pseudo probe descriptor&period;
| xref:llvm/RABasicID.adoc[`RABasicID`] 
| Basic register allocator&period;
| xref:llvm/RAGreedyLegacyID.adoc[`RAGreedyLegacyID`] 
| Greedy register allocator&period;
| xref:llvm/RegisterCoalescerID.adoc[`RegisterCoalescerID`] 
| RegisterCoalescer &hyphen; This pass merges live ranges to eliminate copies&period;
| xref:llvm/RemoveLoadsIntoFakeUsesID.adoc[`RemoveLoadsIntoFakeUsesID`] 
| RemoveLoadsIntoFakeUses pass&period;
| xref:llvm/RemoveRedundantDebugValuesID.adoc[`RemoveRedundantDebugValuesID`] 
| RemoveRedundantDebugValues pass&period;
| xref:llvm/RenameIndependentSubregsID.adoc[`RenameIndependentSubregsID`] 
| This pass detects subregister lanes in a virtual register that are used independently of other lanes and splits them into separate virtual registers&period;
| xref:llvm/RequireAndPreserveDomTree.adoc[`RequireAndPreserveDomTree`] 
| When true, SimplifyCFG requires a dominator tree and preserves it&period;
| xref:llvm/RewardName.adoc[`RewardName`] 
| Tensor name for the training reward (IR size delta)&period;
| xref:llvm/SCEVCheapExpansionBudget.adoc[`SCEVCheapExpansionBudget`] 
| Command&hyphen;line option for the budget used to decide if a SCEV expansion is cheap&period;
| xref:llvm/SSAUpdaterPhiSearchLimit.adoc[`SSAUpdaterPhiSearchLimit`] 
| Maximum number of PHI nodes searched when looking for a matching duplicate&period;
| xref:llvm/SampleColdCallSiteThreshold.adoc[`SampleColdCallSiteThreshold`] 
| Threshold for inlining cold callsites under sample profile loading&period;
| xref:llvm/SampleHotCallSiteThreshold.adoc[`SampleHotCallSiteThreshold`] 
| Hot callsite threshold for priority&hyphen;based sample profile loader inlining&period;
| xref:llvm/SampleProfileMaxPropagateIterations.adoc[`SampleProfileMaxPropagateIterations`] 
| Command&hyphen;line option for the maximum number of weight&hyphen;propagation iterations&period;
| xref:llvm/SampleProfileRecordCoverage.adoc[`SampleProfileRecordCoverage`] 
| Command&hyphen;line option for the minimum matched&hyphen;record coverage percentage&period;
| xref:llvm/SampleProfileSampleCoverage.adoc[`SampleProfileSampleCoverage`] 
| Command&hyphen;line option for the minimum matched&hyphen;sample coverage percentage&period;
| xref:llvm/SampleProfileUseProfi.adoc[`SampleProfileUseProfi`] 
| Command&hyphen;line flag selecting flow&hyphen;based (profi) weight inference&period;
| xref:llvm/SetLicmMssaNoAccForPromotionCap.adoc[`SetLicmMssaNoAccForPromotionCap`] 
| Caps loop memory accesses before LICM disables MemorySSA promotion&period;
| xref:llvm/SetLicmMssaOptCap.adoc[`SetLicmMssaOptCap`] 
| Caps MemorySSA clobbering&hyphen;call queries in LICM for compile&hyphen;time&period;
| xref:llvm/ShadowStackGCLoweringID.adoc[`ShadowStackGCLoweringID`] 
| ShadowStackGCLowering &hyphen; Implements the custom lowering mechanism used by the shadow stack GC&period;
| xref:llvm/ShrinkWrapID.adoc[`ShrinkWrapID`] 
| ShrinkWrap pass&period; Look for the best place to insert save and restore
| xref:llvm/SortProfiledSCC.adoc[`SortProfiledSCC`] 
| Sort profiled recursion SCC members by edge weights&period;
| xref:llvm/SpillPlacementID.adoc[`SpillPlacementID`] 
| SpillPlacement analysis&period; Suggest optimal placement of spill code between basic blocks&period;
| xref:llvm/SrcMgr.adoc[`SrcMgr`] 
| Global SourceMgr used for TableGen diagnostics&period;
| xref:llvm/StackColoringLegacyID.adoc[`StackColoringLegacyID`] 
| StackSlotColoring &hyphen; This pass performs stack coloring and merging&period; It merges disjoint allocas to reduce the stack size&period;
| xref:llvm/StackFrameLayoutAnalysisPassID.adoc[`StackFrameLayoutAnalysisPassID`] 
| StackFramePrinter &hyphen; This pass prints the stack frame layout and variable mappings&period;
| xref:llvm/StackMapLivenessID.adoc[`StackMapLivenessID`] 
| Pass ID for attaching live&hyphen;out register info to stackmaps&period;
| xref:llvm/StackSlotColoringID.adoc[`StackSlotColoringID`] 
| StackSlotColoring &hyphen; This pass performs stack slot coloring&period;
| xref:llvm/StaticCastTo.adoc[`StaticCastTo`] 
| Function objects corresponding to the Cast types defined above&period;
| xref:llvm/SwpEnableCopyToPhi.adoc[`SwpEnableCopyToPhi`] 
| Enable the CopyToPhi DAG mutation during swing modulo scheduling&period;
| xref:llvm/SwpForceIssueWidth.adoc[`SwpForceIssueWidth`] 
| Force a specific issue width for SMS resource modeling&semi; &lt;&equals; 0 keeps the model default&period;
| xref:llvm/TailDuplicateLegacyID.adoc[`TailDuplicateLegacyID`] 
| TailDuplicate &hyphen; Duplicate blocks with unconditional branches into tails of their predecessors&period;
| xref:llvm/TimePassesIsEnabled.adoc[`TimePassesIsEnabled`] 
| True when the &hyphen;time&hyphen;passes command&hyphen;line option is enabled&period;
| xref:llvm/TimePassesPerRun.adoc[`TimePassesPerRun`] 
| True when each pass invocation is timed and reported separately&period;
| xref:llvm/TwoAddressInstructionPassID.adoc[`TwoAddressInstructionPassID`] 
| TwoAddressInstruction &hyphen; This pass reduces two&hyphen;address instructions to use two operands&period; This destroys SSA information but it is desired by register allocators&period;
| xref:llvm/UnpackMachineBundlesID.adoc[`UnpackMachineBundlesID`] 
| UnpackMachineBundles &hyphen; This pass unpack machine instruction bundles&period;
| xref:llvm/UnreachableMachineBlockElimID.adoc[`UnreachableMachineBlockElimID`] 
| UnreachableMachineBlockElimination &hyphen; This pass removes unreachable machine basic blocks&period;
| xref:llvm/UseContextLessSummary.adoc[`UseContextLessSummary`] 
| Merge context&hyphen;sensitive profiles before calculating summary thresholds&period;
| xref:llvm/UseIterativeBFIInference.adoc[`UseIterativeBFIInference`] 
| When true, run iterative inference to refine irreducible&hyphen;loop frequencies&period;
| xref:llvm/UseSegmentSetForPhysRegs.adoc[`UseSegmentSetForPhysRegs`] 
| Command&hyphen;line option to use segment sets when computing physreg unit ranges&period;
| xref:llvm/VerifyDomInfo.adoc[`VerifyDomInfo`] 
| Enables verification of dominator trees&period;
| xref:llvm/VerifyLoopInfo.adoc[`VerifyLoopInfo`] 
| Enable verification of loop info&period;
| xref:llvm/VerifyMemorySSA.adoc[`VerifyMemorySSA`] 
| Enables verification of MemorySSA&period;
| xref:llvm/VerifySCEV.adoc[`VerifySCEV`] 
| If true, verify ScalarEvolution after each transformation that uses it&period;
| xref:llvm/VerifyScheduling.adoc[`VerifyScheduling`] 
| When true, verify the schedule after each region is scheduled&period;
| xref:llvm/ViewMISchedDAGs.adoc[`ViewMISchedDAGs`] 
| When true, open a Graphviz view of each MISched DAG&period;
| xref:llvm/VirtRegRewriterID.adoc[`VirtRegRewriterID`] 
| VirtRegRewriter pass&period; Rewrite virtual registers to physical registers as assigned in VirtRegMap&period;
| xref:llvm/XRayInstrumentationID.adoc[`XRayInstrumentationID`] 
| This pass inserts the XRay instrumentation sleds if they are supported by the target platform&period;
| xref:llvm/all_types_equal_v.adoc[`all&lowbar;types&lowbar;equal&lowbar;v`] 
| True if `T` and every type in `Ts` are the same&period;
| xref:llvm/force_iteration_on_noniterable_enum.adoc[`force&lowbar;iteration&lowbar;on&lowbar;noniterable&lowbar;enum`] 
| Tag value passed to enum&lowbar;seq helpers to force iteration on unsafe enums&period;
| xref:llvm/from_range.adoc[`from&lowbar;range`] 
| Tag value used to select range&hyphen;based constructors&period;
| xref:llvm/has_equality_comparison_v.adoc[`has&lowbar;equality&lowbar;comparison&lowbar;v`] 
| Detects when type `const T` can be compared for equality with `const U`&period;
| xref:llvm/huge_valf.adoc[`huge&lowbar;valf`] 
| Use this rather than HUGE&lowbar;VALF&semi; the latter causes warnings on MSVC&period;
| xref:llvm/is_incomplete_v.adoc[`is&lowbar;incomplete&lowbar;v`] 
| Detects when type `T` is incomplete&period; This is true for forward declarations and false for types with a full definition&period;
| xref:llvm/kSanitizerBinaryMetadataAtomics.adoc[`kSanitizerBinaryMetadataAtomics`] 
| Feature mask bit indicating the function contains atomic operations&period;
| xref:llvm/kSanitizerBinaryMetadataAtomicsBit.adoc[`kSanitizerBinaryMetadataAtomicsBit`] 
| Bit position of the atomics feature flag in the covered&hyphen;function feature mask&period;
| xref:llvm/kSanitizerBinaryMetadataAtomicsSection.adoc[`kSanitizerBinaryMetadataAtomicsSection`] 
| ELF section name for atomic&hyphen;operation sanitizer metadata&period;
| xref:llvm/kSanitizerBinaryMetadataCoveredSection.adoc[`kSanitizerBinaryMetadataCoveredSection`] 
| ELF section name for covered&hyphen;function sanitizer metadata&period;
| xref:llvm/kSanitizerBinaryMetadataUAR.adoc[`kSanitizerBinaryMetadataUAR`] 
| Feature mask bit indicating the function is subject to use&hyphen;after&hyphen;return checking&period;
| xref:llvm/kSanitizerBinaryMetadataUARBit.adoc[`kSanitizerBinaryMetadataUARBit`] 
| Bit position of the use&hyphen;after&hyphen;return feature flag in the covered&hyphen;function feature mask&period;
| xref:llvm/kSanitizerBinaryMetadataUARHasSize.adoc[`kSanitizerBinaryMetadataUARHasSize`] 
| Feature mask bit indicating UAR metadata includes the stack frame size&period;
| xref:llvm/kSanitizerBinaryMetadataUARHasSizeBit.adoc[`kSanitizerBinaryMetadataUARHasSizeBit`] 
| Bit position of the use&hyphen;after&hyphen;return&hyphen;has&hyphen;size feature flag in the covered&hyphen;function feature mask&period;
|===


== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:llvm/LegalizeAction.adoc[`LegalizeAction`] 
| Convenient alias for LegalizeActions&colon;&colon;LegalizeAction&period;
| xref:llvm/ObjectFile.adoc[`ObjectFile`] 
| Bring `object&colon;&colon;ObjectFile` into this namespace&period;
| xref:llvm/PassManagerBase.adoc[`PassManagerBase`] 
| Alias for the legacy pass manager base class&period;
| xref:llvm/SectionRef.adoc[`SectionRef`] 
| Bring `object&colon;&colon;SectionRef` into this namespace&period;
| xref:llvm/SectionedAddress.adoc[`SectionedAddress`] 
| Bring `object&colon;&colon;SectionedAddress` into this namespace&period;
| xref:llvm/any-0c.adoc[`any`] 
| Bring bitmask enum any&hyphen;bits&hyphen;set test into this namespace for ADL&period;
| xref:llvm/operator_not.adoc[`operator!`] 
| Bring bitmask enum logical&hyphen;not into this namespace for ADL&period;
| xref:llvm/operator_bitand-05.adoc[`operator&amp;`] 
| Bring bitmask enum bitwise AND into this namespace for ADL&period;
| xref:llvm/operator_and_eq-0f.adoc[`operator&amp;&equals;`] 
| Bring bitmask enum in&hyphen;place AND into this namespace for ADL&period;
| xref:llvm/operator_lshift-000b.adoc[`operator&lt;&lt;`] 
| Bring bitmask enum left&hyphen;shift into this namespace for ADL&period;
| xref:llvm/operator_lshift_eq.adoc[`operator&lt;&lt;&equals;`] 
| Bring bitmask enum in&hyphen;place left&hyphen;shift into this namespace for ADL&period;
| xref:llvm/operator_rshift-0bf.adoc[`operator&gt;&gt;`] 
| Bring bitmask enum right&hyphen;shift into this namespace for ADL&period;
| xref:llvm/operator_rshift_eq.adoc[`operator&gt;&gt;&equals;`] 
| Bring bitmask enum in&hyphen;place right&hyphen;shift into this namespace for ADL&period;
| xref:llvm/operator_xor-09d.adoc[`operator&circ;`] 
| Bring bitmask enum bitwise XOR into this namespace for ADL&period;
| xref:llvm/operator_xor_eq.adoc[`operator&circ;&equals;`] 
| Bring bitmask enum in&hyphen;place XOR into this namespace for ADL&period;
| xref:llvm/operator_bitor-058.adoc[`operator&verbar;`] 
| Bring bitmask enum bitwise OR into this namespace for ADL&period;
| xref:llvm/operator_or_eq-0b.adoc[`operator&verbar;&equals;`] 
| Bring bitmask enum in&hyphen;place OR into this namespace for ADL&period;
| xref:llvm/operator_bitnot-08.adoc[`operator&#126;`] 
| Bring bitmask enum bitwise NOT into this namespace for ADL&period;
|===


== Using Namespace Directives

[cols="1,4"]
|===
| Name| Description
| xref:llvm/sampleprof.adoc[`sampleprof`] 
| Sample profile data structures and helpers&period;
| xref:llvm/sampleprofutil.adoc[`sampleprofutil`] 
| Utilities shared by sample profile loader implementations&period;
|===



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