[#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`] 
| 
| xref:llvm/AArch64BuildAttributes.adoc[`AArch64BuildAttributes`] 
| 
| xref:llvm/AMDGPU.adoc[`AMDGPU`] 
| AMDGPU&hyphen;specific address&hyphen;space helpers and DWARF mappings&period;
| xref:llvm/AMDGPUAS.adoc[`AMDGPUAS`] 
| OpenCL uses address spaces to differentiate between various memory regions on the hardware&period; On the CPU all of the address spaces point to the same memory, however on the GPU, each address space points to a separate piece of memory that is unique from other memory locations&period;
| xref:llvm/APIntOps.adoc[`APIntOps`] 
| Additional APInt utility operations&period;
| xref:llvm/ARM.adoc[`ARM`] 
| 
| xref:llvm/ARMBuildAttrs.adoc[`ARMBuildAttrs`] 
| 
| xref:llvm/AVR.adoc[`AVR`] 
| 
| xref:llvm/ArchYAML.adoc[`ArchYAML`] 
| 
| xref:llvm/AttributeFuncs.adoc[`AttributeFuncs`] 
| 
| xref:llvm/BBAddrMapYAML.adoc[`BBAddrMapYAML`] 
| 
| xref:llvm/BTF.adoc[`BTF`] 
| 
| xref:llvm/BitmaskEnumDetail.adoc[`BitmaskEnumDetail`] 
| Implementation details and operator overloads for bitmask enumerations&period;
| xref:llvm/COFF.adoc[`COFF`] 
| 
| xref:llvm/COFFYAML.adoc[`COFFYAML`] 
| 
| xref:llvm/CSKY.adoc[`CSKY`] 
| 
| xref:llvm/CSKYAttrs.adoc[`CSKYAttrs`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/ConverterEBCDIC.adoc[`ConverterEBCDIC`] 
| 
| xref:llvm/DOT.adoc[`DOT`] 
| 
| xref:llvm/DWARFYAML.adoc[`DWARFYAML`] 
| 
| xref:llvm/DXContainerYAML.adoc[`DXContainerYAML`] 
| 
| xref:llvm/DomTreeBuilder.adoc[`DomTreeBuilder`] 
| 
| xref:llvm/ELF.adoc[`ELF`] 
| 
| xref:llvm/ELFAttrs.adoc[`ELFAttrs`] 
| 
| xref:llvm/ELFYAML.adoc[`ELFYAML`] 
| 
| xref:llvm/EngineKind.adoc[`EngineKind`] 
| 
| xref:llvm/FPOpFusion.adoc[`FPOpFusion`] 
| 
| xref:llvm/FloatABI.adoc[`FloatABI`] 
| Floating&hyphen;point ABI selection&period;
| xref:llvm/GCOV.adoc[`GCOV`] 
| 
| xref:llvm/GISelAddressing.adoc[`GISelAddressing`] 
| 
| xref:llvm/GOFF.adoc[`GOFF`] 
| 
| xref:llvm/GOFFYAML.adoc[`GOFFYAML`] 
| 
| xref:llvm/GVNExpression.adoc[`GVNExpression`] 
| 
| xref:llvm/GraphProgram.adoc[`GraphProgram`] 
| 
| xref:llvm/HWASanAccessInfo.adoc[`HWASanAccessInfo`] 
| 
| xref:llvm/HexStyle.adoc[`HexStyle`] 
| 
| xref:llvm/HexagonAttrs.adoc[`HexagonAttrs`] 
| 
| xref:llvm/IDFCalculatorDetail.adoc[`IDFCalculatorDetail`] 
| 
| 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`] 
| 
| xref:llvm/IndexedInstrProf.adoc[`IndexedInstrProf`] 
| 
| xref:llvm/InlineConstants.adoc[`InlineConstants`] 
| 
| xref:llvm/IntegerInclusiveIntervalUtils.adoc[`IntegerInclusiveIntervalUtils`] 
| 
| 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`] 
| This namespace contains an enum with a value for every intrinsic&sol;builtin function known by LLVM&period; The enum values are returned by Function&colon;&colon;getIntrinsicID()&period;
| xref:llvm/JumpTable.adoc[`JumpTable`] 
| 
| xref:llvm/LCOMM.adoc[`LCOMM`] 
| 
| xref:llvm/LegalityPredicates.adoc[`LegalityPredicates`] 
| 
| xref:llvm/LegalizeActions.adoc[`LegalizeActions`] 
| 
| xref:llvm/LegalizeMutations.adoc[`LegalizeMutations`] 
| 
| xref:llvm/LoongArch.adoc[`LoongArch`] 
| 
| xref:llvm/MCD.adoc[`MCD`] 
| 
| xref:llvm/MCID.adoc[`MCID`] 
| 
| xref:llvm/MCOI.adoc[`MCOI`] 
| 
| xref:llvm/MCParserUtils.adoc[`MCParserUtils`] 
| 
| xref:llvm/MIPatternMatch.adoc[`MIPatternMatch`] 
| 
| xref:llvm/MISched.adoc[`MISched`] 
| 
| xref:llvm/MSP430Attrs.adoc[`MSP430Attrs`] 
| 
| xref:llvm/MSSAHelpers.adoc[`MSSAHelpers`] 
| 
| xref:llvm/MachO.adoc[`MachO`] 
| 
| xref:llvm/MachOYAML.adoc[`MachOYAML`] 
| 
| xref:llvm/MinidumpYAML.adoc[`MinidumpYAML`] 
| 
| xref:llvm/Mips.adoc[`Mips`] 
| 
| xref:llvm/NVPTX.adoc[`NVPTX`] 
| 
| xref:llvm/NVPTXAS.adoc[`NVPTXAS`] 
| 
| xref:llvm/NVVMAttr.adoc[`NVVMAttr`] 
| 
| xref:llvm/OMF.adoc[`OMF`] 
| 
| xref:llvm/OffloadYAML.adoc[`OffloadYAML`] 
| 
| xref:llvm/PBQP.adoc[`PBQP`] 
| 
| 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`] 
| 
| xref:llvm/PatternMatch.adoc[`PatternMatch`] 
| 
| xref:llvm/PatternMatchHelpers.adoc[`PatternMatchHelpers`] 
| 
| xref:llvm/RISCV.adoc[`RISCV`] 
| 
| xref:llvm/RISCVAttrs.adoc[`RISCVAttrs`] 
| 
| xref:llvm/RISCVCFI.adoc[`RISCVCFI`] 
| 
| xref:llvm/RISCVISAUtils.adoc[`RISCVISAUtils`] 
| 
| xref:llvm/RISCVVType.adoc[`RISCVVType`] 
| 
| xref:llvm/RTLIB.adoc[`RTLIB`] 
| 
| xref:llvm/RawInstrProf.adoc[`RawInstrProf`] 
| 
| xref:llvm/Reloc.adoc[`Reloc`] 
| Relocation model types&period;
| xref:llvm/SCEVPatternMatch.adoc[`SCEVPatternMatch`] 
| 
| xref:llvm/SDPatternMatch.adoc[`SDPatternMatch`] 
| 
| xref:llvm/ScaledNumbers.adoc[`ScaledNumbers`] 
| 
| xref:llvm/Sched.adoc[`Sched`] 
| 
| xref:llvm/SignBitsOps.adoc[`SignBitsOps`] 
| 
| xref:llvm/SwitchCG.adoc[`SwitchCG`] 
| 
| xref:llvm/SymbolRewriter.adoc[`SymbolRewriter`] 
| 
| xref:llvm/SyncScope.adoc[`SyncScope`] 
| 
| xref:llvm/TLSModel.adoc[`TLSModel`] 
| Thread&hyphen;local storage models&period;
| xref:llvm/TableGen.adoc[`TableGen`] 
| 
| xref:llvm/TargetOpcode.adoc[`TargetOpcode`] 
| Invariant opcodes&colon; All instruction sets have these as their low opcodes&period;
| xref:llvm/TargetStackID.adoc[`TargetStackID`] 
| 
| 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`] 
| 
| xref:llvm/VFABI.adoc[`VFABI`] 
| 
| xref:llvm/VNCoercion.adoc[`VNCoercion`] 
| 
| xref:llvm/WasmYAML.adoc[`WasmYAML`] 
| 
| xref:llvm/WebAssembly.adoc[`WebAssembly`] 
| 
| xref:llvm/Win64EH.adoc[`Win64EH`] 
| 
| xref:llvm/WinEH.adoc[`WinEH`] 
| 
| xref:llvm/X86.adoc[`X86`] 
| 
| xref:llvm/X86Disassembler.adoc[`X86Disassembler`] 
| 
| xref:llvm/XCOFF.adoc[`XCOFF`] 
| 
| xref:llvm/XCOFFYAML.adoc[`XCOFFYAML`] 
| 
| xref:llvm/Xtensa.adoc[`Xtensa`] 
| 
| xref:llvm/ZeroCallUsedRegs.adoc[`ZeroCallUsedRegs`] 
| Specify what type of zeroing for callee&hyphen;used registers&period;
| xref:llvm/abi.adoc[`abi`] 
| 
| 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`] 
| 
| xref:llvm/amdhsa.adoc[`amdhsa`] 
| 
| xref:llvm/at.adoc[`at`] 
| Assignment Tracking (at)&period;
| xref:llvm/bfi_detail.adoc[`bfi&lowbar;detail`] 
| 
| xref:llvm/binaryformat.adoc[`binaryformat`] 
| 
| xref:llvm/bitc.adoc[`bitc`] 
| 
| 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`] 
| 
| xref:llvm/cas.adoc[`cas`] 
| Content&hyphen;addressable storage (CAS) APIs&period;
| xref:llvm/cfg.adoc[`cfg`] 
| 
| xref:llvm/cgdata.adoc[`cgdata`] 
| 
| 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`] 
| 
| xref:llvm/codegenoptions.adoc[`codegenoptions`] 
| 
| xref:llvm/codelayout.adoc[`codelayout`] 
| 
| xref:llvm/codeview.adoc[`codeview`] 
| 
| xref:llvm/compression.adoc[`compression`] 
| 
| 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`] 
| 
| xref:llvm/coverage.adoc[`coverage`] 
| 
| xref:llvm/ctx_profile.adoc[`ctx&lowbar;profile`] 
| 
| xref:llvm/densemap-07.adoc[`densemap`] 
| DenseMap&hyphen;specific hashing helpers&period;
| xref:llvm/details.adoc[`details`] 
| 
| xref:llvm/directive-07.adoc[`directive`] 
| 
| xref:llvm/driver.adoc[`driver`] 
| 
| xref:llvm/dwarf.adoc[`dwarf`] 
| Calculates the starting offsets for various sections within the &period;debug&lowbar;names section&period;
| xref:llvm/dwarf_linker.adoc[`dwarf&lowbar;linker`] 
| 
| xref:llvm/dxbc.adoc[`dxbc`] 
| 
| xref:llvm/dxil.adoc[`dxil`] 
| 
| xref:llvm/fp.adoc[`fp`] 
| 
| xref:llvm/fuzzerop.adoc[`fuzzerop`] 
| @&rcub;
| xref:llvm/gsym.adoc[`gsym`] 
| 
| xref:llvm/hashbuilder_detail.adoc[`hashbuilder&lowbar;detail`] 
| 
| xref:llvm/hashing.adoc[`hashing`] 
| Implementation details for hash computation&period;
| xref:llvm/hlsl.adoc[`hlsl`] 
| 
| xref:llvm/ifs.adoc[`ifs`] 
| 
| xref:llvm/ilist_detail.adoc[`ilist&lowbar;detail`] 
| Implementation details for intrusive list node prev&sol;next storage&period;
| xref:llvm/impl.adoc[`impl`] 
| 
| xref:llvm/impl_detail.adoc[`impl&lowbar;detail`] 
| 
| xref:llvm/instrumentor.adoc[`instrumentor`] 
| 
| xref:llvm/ir2vec.adoc[`ir2vec`] 
| 
| xref:llvm/irsymtab.adoc[`irsymtab`] 
| 
| xref:llvm/itanium_demangle.adoc[`itanium&lowbar;demangle`] 
| 
| xref:llvm/jitlink.adoc[`jitlink`] 
| 
| xref:llvm/json.adoc[`json`] 
| 
| 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`] 
| 
| xref:llvm/lltok.adoc[`lltok`] 
| 
| xref:llvm/logicalview.adoc[`logicalview`] 
| 
| xref:llvm/lowertypetests.adoc[`lowertypetests`] 
| 
| xref:llvm/lsp.adoc[`lsp`] 
| 
| xref:llvm/lto.adoc[`lto`] 
| 
| xref:llvm/mc.adoc[`mc`] 
| 
| xref:llvm/mca.adoc[`mca`] 
| 
| xref:llvm/mcdwarf.adoc[`mcdwarf`] 
| 
| xref:llvm/mcdxbc.adoc[`mcdxbc`] 
| 
| xref:llvm/mdconst.adoc[`mdconst`] 
| Transitional API for extracting constants from Metadata&period;
| xref:llvm/memprof.adoc[`memprof`] 
| 
| xref:llvm/memtag.adoc[`memtag`] 
| 
| xref:llvm/minidump.adoc[`minidump`] 
| 
| xref:llvm/mir2vec.adoc[`mir2vec`] 
| 
| xref:llvm/misexpect.adoc[`misexpect`] 
| 
| xref:llvm/ms_demangle.adoc[`ms&lowbar;demangle`] 
| 
| xref:llvm/msf.adoc[`msf`] 
| 
| xref:llvm/msgpack.adoc[`msgpack`] 
| 
| xref:llvm/mustache.adoc[`mustache`] 
| 
| xref:llvm/numbers.adoc[`numbers`] 
| Mathematical constants backported from C&plus;&plus;20 &lt;numbers&gt;&period;
| xref:llvm/nvvm.adoc[`nvvm`] 
| 
| xref:llvm/objcarc.adoc[`objcarc`] 
| 
| xref:llvm/objcopy.adoc[`objcopy`] 
| 
| xref:llvm/object.adoc[`object`] 
| 
| xref:llvm/offloading.adoc[`offloading`] 
| 
| xref:llvm/omp.adoc[`omp`] 
| 
| xref:llvm/opt.adoc[`opt`] 
| 
| xref:llvm/orc.adoc[`orc`] 
| 
| 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`] 
| 
| xref:llvm/parallel.adoc[`parallel`] 
| Helpers for running work across a pool of worker threads&period;
| xref:llvm/pdb.adoc[`pdb`] 
| 
| xref:llvm/pgo.adoc[`pgo`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/sampleprof.adoc[`sampleprof`] 
| 
| xref:llvm/sampleprofutil.adoc[`sampleprofutil`] 
| 
| xref:llvm/sandboxir.adoc[`sandboxir`] 
| 
| xref:llvm/sframe.adoc[`sframe`] 
| 
| 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`] 
| 
| xref:llvm/sys.adoc[`sys`] 
| Host system utilities&period;
| xref:llvm/telemetry.adoc[`telemetry`] 
| 
| xref:llvm/this_thread.adoc[`this&lowbar;thread`] 
| 
| xref:llvm/trailing_objects_internal.adoc[`trailing&lowbar;objects&lowbar;internal`] 
| 
| xref:llvm/vfs.adoc[`vfs`] 
| 
| xref:llvm/wasm.adoc[`wasm`] 
| 
| xref:llvm/wholeprogramdevirt.adoc[`wholeprogramdevirt`] 
| 
| xref:llvm/windows_manifest.adoc[`windows&lowbar;manifest`] 
| 
| xref:llvm/xray.adoc[`xray`] 
| 
| xref:llvm/yaml.adoc[`yaml`] 
| 
|===


== 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`] 
| 
| xref:llvm/AAAssumptionInfo.adoc[`AAAssumptionInfo`] 
| An abstract attribute for getting assumption information&period;
| xref:llvm/AACacheLoc.adoc[`AACacheLoc`] 
| Cache key for BasicAA results&period; It only includes the pointer and size from MemoryLocation, as BasicAA is AATags independent&period; Additionally, it includes the value of MayBeCrossIteration, which may affect 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`] 
| 
| 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`] 
| The data structure for the nodes of a dependency graph
| xref:llvm/AADereferenceable.adoc[`AADereferenceable`] 
| An abstract interface for all dereferenceable attribute&period;
| xref:llvm/AAEvaluator.adoc[`AAEvaluator`] 
| 
| xref:llvm/AAExecutionDomain.adoc[`AAExecutionDomain`] 
| 
| xref:llvm/AAGlobalValueInfo.adoc[`AAGlobalValueInfo`] 
| An abstract interface for llvm&colon;&colon;GlobalValue information interference&period;
| xref:llvm/AAHeapToStack.adoc[`AAHeapToStack`] 
| 
| xref:llvm/AAIndirectCallInfo.adoc[`AAIndirectCallInfo`] 
| An abstract interface for indirect call information interference&period;
| xref:llvm/AAInstanceInfo.adoc[`AAInstanceInfo`] 
| An abstract interface to track if a value leaves it&apos;s 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`] 
| 
| 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`] 
| 
| xref:llvm/AANoUndef.adoc[`AANoUndef`] 
| An abstract interface for all noundef attributes&period;
| xref:llvm/AANoUnwind.adoc[`AANoUnwind`] 
| Abstract attribute for the no&hyphen;unwind function attribute&period; Abstract Attribute Classes &hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;&hyphen;
| 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 struct information&period;
| xref:llvm/AAPotentialConstantValues.adoc[`AAPotentialConstantValues`] 
| An abstract interface for potential values analysis&period;
| xref:llvm/AAPotentialValues.adoc[`AAPotentialValues`] 
| 
| xref:llvm/AAPrivatizablePtr.adoc[`AAPrivatizablePtr`] 
| An abstract interface for privatizability&period;
| xref:llvm/AAQueryInfo.adoc[`AAQueryInfo`] 
| This class stores info we want to provide to or retain within an alias query&period; By default, the root query is stateless and starts with a freshly constructed info object&period; Specific alias analyses can use this query info to store per&hyphen;query state that is important for recursive or nested queries to avoid recomputing&period; To enable preserving this state across multiple queries where safe (due to the IR not changing), use a `BatchAAResults` wrapper&period; The information stored in an `AAQueryInfo` is currently limitted to the caches used by BasicAA, but can further be extended to fit other AA needs&period;
| xref:llvm/AAResultBase.adoc[`AAResultBase`] 
| A base class to help implement the function alias analysis results concept&period;
| xref:llvm/AAResults.adoc[`AAResults`] 
| 
| 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`] 
| 
| xref:llvm/AArch64BuildAttrSubsections.adoc[`AArch64BuildAttrSubsections`] 
| 
| xref:llvm/ADCEPass.adoc[`ADCEPass`] 
| A DCE pass that assumes instructions are dead until proven otherwise&period;
| xref:llvm/APFixedPoint.adoc[`APFixedPoint`] 
| The APFixedPoint class works similarly to APInt&sol;APSInt in that it is a functional replacement for a scaled integer&period; It supports a wide range of semantics including the one used by fixed point types proposed in ISO&sol;IEC JTC1 SC22 WG14 N1169&period; The class carries the value and semantics of a fixed point, and provides different operations that would normally be performed on fixed point types&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`] 
| 
| 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`] 
| 
| xref:llvm/ASanAccessInfo.adoc[`ASanAccessInfo`] 
| 
| xref:llvm/ASanStackFrameLayout.adoc[`ASanStackFrameLayout`] 
| 
| xref:llvm/ASanStackVariableDescription.adoc[`ASanStackVariableDescription`] 
| 
| xref:llvm/AShrOperator.adoc[`AShrOperator`] 
| 
| 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`] 
| This abstract builder class defines a set of high&hyphen;level steps for creating DDG&hyphen;like graphs&period; The client code is expected to inherit from this class and define concrete implementation for each of the pure virtual functions used in the high&hyphen;level algorithm&period;
| xref:llvm/AbstractLatticeFunction.adoc[`AbstractLatticeFunction`] 
| AbstractLatticeFunction &hyphen; This class is implemented by the dataflow instance to specify what the lattice values are and how they handle merges etc&period; This gives the client the power to compute lattice values from instructions, constants, etc&period; The current requirement is that lattice values must be copyable&period; At the moment, nothing tries to avoid copying&period; Additionally, lattice keys must be able to be used as keys of a mapping data structure&period; Internally, the generic solver currently uses a DenseMap to map lattice keys to lattice values&period; If the lattice key is a non&hyphen;standard type, a specialization of DenseMapInfo must be provided&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`] 
| This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buckets, each bucket containint a sequence of HashData entries&period; The class is parameterized by the type of entries it holds&period; The type template parameter also defines the hash function to use for hashing names&period;
| xref:llvm/AccelTableBase.adoc[`AccelTableBase`] 
| A base class holding non&hyphen;template&hyphen;dependant functionality of the AccelTable class&period; Clients should not use this class directly but rather instantiate AccelTable with a type derived from AccelTableData&period;
| xref:llvm/AccelTableData.adoc[`AccelTableData`] 
| Interface which the different types of accelerator table data have to conform&period; It serves as a base class for different values of the template argument of the AccelTable class template&period;
| xref:llvm/ActiveBlocksOption.adoc[`ActiveBlocksOption`] 
| 
| xref:llvm/AddDiscriminatorsPass.adoc[`AddDiscriminatorsPass`] 
| 
| xref:llvm/AddOperator.adoc[`AddOperator`] 
| 
| xref:llvm/AddrLabelMap.adoc[`AddrLabelMap`] 
| 
| xref:llvm/AddrSpaceCastInst.adoc[`AddrSpaceCastInst`] 
| This class represents a conversion between pointers from one address space to another&period;
| xref:llvm/AddrSpaceCastOperator.adoc[`AddrSpaceCastOperator`] 
| 
| xref:llvm/AddrSpaceCastSDNode.adoc[`AddrSpaceCastSDNode`] 
| 
| xref:llvm/AddressProbesMap.adoc[`AddressProbesMap`] 
| 
| 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`] 
| The AddressRanges class helps normalize address range collections&period; This class keeps a sorted vector of AddressRange objects and can perform insertions and searches efficiently&period; Intersecting(&lsqb;100,200), &lsqb;150,300))&rsqb;&rsqb; and adjacent(&lsqb;100,200), &lsqb;200,300)) address ranges are combined during&rsqb;&rsqb; insertion&period;
| xref:llvm/AddressRangesBase-05.adoc[`AddressRangesBase`] 
| The AddressRangesBase class presents the base functionality for the normalized address ranges collection&period; This class keeps a sorted vector of AddressRange&hyphen;like objects and can perform searches efficiently&period; The address ranges are always sorted and never contain any invalid, empty or intersected address ranges&period;
| xref:llvm/AddressRangesMap.adoc[`AddressRangesMap`] 
| AddressRangesMap class maps values to the address ranges&period; It keeps normalized address ranges and corresponding values&period; This class keeps a sorted vector of AddressRangeValuePair objects and can perform insertions and searches efficiently&period; Intersecting(&lsqb;100,200), &lsqb;150,300)) ranges splitted into non&hyphen;conflicting&rsqb;&rsqb; parts(&lsqb;100,200), &lsqb;200,300))&period; Adjacent(&lsqb;100,200), &lsqb;200,300)) address&rsqb;&rsqb;&rsqb;&rsqb; ranges are not combined during insertion&period;
| xref:llvm/AddressSanitizerOptions.adoc[`AddressSanitizerOptions`] 
| 
| 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; Implementations of this interface may allow multiple threads&sol;processes to acquire the ownership of the lock simultaneously&period; Typically, threads&sol;processes waiting for the lock to be unlocked will validate that the computation was performed by the expected thread&sol;process and re&hyphen;run the computation if not&period;
| xref:llvm/AggregationData.adoc[`AggregationData`] 
| 
| xref:llvm/AggressiveInstCombinePass.adoc[`AggressiveInstCombinePass`] 
| 
| 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`] 
| 
| xref:llvm/AliasResult.adoc[`AliasResult`] 
| The possible results of an alias query&period;
| xref:llvm/AliasScopeNode.adoc[`AliasScopeNode`] 
| This is a simple wrapper around an MDNode which provides a higher&hyphen;level interface by hiding the details of how alias analysis information is encoded in its operands&period;
| xref:llvm/AliasSet.adoc[`AliasSet`] 
| 
| xref:llvm/AliasSetTracker.adoc[`AliasSetTracker`] 
| 
| xref:llvm/AliasSetsPrinterPass.adoc[`AliasSetsPrinterPass`] 
| 
| 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`] 
| 
| xref:llvm/AllAnalysesOn-0a.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`] 
| 
| 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`] 
| 
| xref:llvm/AllocationOrder.adoc[`AllocationOrder`] 
| 
| 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&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`] 
| A container for analyses that lazily runs them and caches their results&period;
| xref:llvm/AnalysisResolver.adoc[`AnalysisResolver`] 
| AnalysisResolver &hyphen; Simple interface used by Pass objects to pull all analysis information out of pass manager that is responsible to manage the pass&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`] 
| Represent the analysis usage information of a pass&period; This tracks analyses that the pass REQUIRES (must be available when the pass runs), REQUIRES TRANSITIVE (must be available throughout the lifetime of the pass), and analyses that the pass PRESERVES (the pass does not invalidate the results of these analyses)&period; This information is provided by a pass to the Pass infrastructure through the getAnalysisUsage virtual function&period;
| xref:llvm/Annotation2MetadataPass.adoc[`Annotation2MetadataPass`] 
| Pass to convert llvm&period;global&period;annotations to !annotation metadata&period;
| xref:llvm/AnnotationRemarksPass.adoc[`AnnotationRemarksPass`] 
| 
| xref:llvm/AnonNamespaceEmitter.adoc[`AnonNamespaceEmitter`] 
| 
| xref:llvm/AnonymousNameInit.adoc[`AnonymousNameInit`] 
| &quot;anonymous&lowbar;n&quot; &hyphen; Represent an anonymous record name
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| This class represents any memset intrinsic
| xref:llvm/AnyMemTransferInst.adoc[`AnyMemTransferInst`] 
| 
| 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`] 
| A base class for different implementations of Data classes for Apple Accelerator Tables&period; The columns in the table are defined by the static Atoms variable defined on the subclasses&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; A formal argument, since it is formal&apos;&apos;, does not contain an actual value but instead represents the type, argument number, and attributes of an argument for a specific function&period; When used in the body of said function, the argument of course represents the value of the actual argument that the function was called with&period;
| xref:llvm/ArgumentInit.adoc[`ArgumentInit`] 
| 
| 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`] 
| Represent a constant reference to an array (0 or more elements consecutively in memory), i&period;e&period; a start pointer and a length&period; It allows various APIs to take consecutive elements easily and conveniently&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`] 
| 
| xref:llvm/AsmLexer.adoc[`AsmLexer`] 
| 
| 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`] 
| 
| xref:llvm/AsmPrinterHandler.adoc[`AsmPrinterHandler`] 
| Collects and handles AsmPrinter objects required to build debug or EH information&period;
| xref:llvm/AsmRewrite.adoc[`AsmRewrite`] 
| 
| xref:llvm/AsmToken.adoc[`AsmToken`] 
| Target independent representation for an assembler token&period;
| xref:llvm/AsmTypeInfo.adoc[`AsmTypeInfo`] 
| 
| xref:llvm/AssemblerConstantPools.adoc[`AssemblerConstantPools`] 
| 
| xref:llvm/AssemblyAnnotationWriter.adoc[`AssemblyAnnotationWriter`] 
| 
| xref:llvm/AssertAlignSDNode.adoc[`AssertAlignSDNode`] 
| An SDNode that records if a register contains a value that is guaranteed to be aligned accordingly&period;
| xref:llvm/AssertingVH.adoc[`AssertingVH`] 
| Value handle that asserts if the Value is deleted&period;
| xref:llvm/AssignGUIDPass.adoc[`AssignGUIDPass`] 
| 
| xref:llvm/AssignmentTrackingAnalysis.adoc[`AssignmentTrackingAnalysis`] 
| 
| xref:llvm/AssignmentTrackingPass.adoc[`AssignmentTrackingPass`] 
| Convert llvm&period;dbg&period;declare intrinsics into sets of llvm&period;dbg&period;assign intrinsics by treating stores to the dbg&period;declare&apos;d address as assignments to the variable&period; Not all kinds of variables are supported yet&semi; those will be left with their dbg&period;declare intrinsics&period; The pass sets the debug&hyphen;info&hyphen;assignment&hyphen;tracking module flag to true to indicate assignment tracking has been enabled&period;
| xref:llvm/AssumeAlignInfo.adoc[`AssumeAlignInfo`] 
| 
| 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`] 
| 
| xref:llvm/AssumeInst.adoc[`AssumeInst`] 
| This represents the llvm&period;assume intrinsic&period;
| xref:llvm/AssumeNoUndefInfo.adoc[`AssumeNoUndefInfo`] 
| 
| xref:llvm/AssumeNonNullInfo.adoc[`AssumeNonNullInfo`] 
| 
| xref:llvm/AssumeSeparateStorageInfo.adoc[`AssumeSeparateStorageInfo`] 
| 
| 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 instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there&period; The value returned by this instruction is a pair containing the original value as first element, and an i1 indicating success (true) or failure (false) as second element&period;
| xref:llvm/AtomicExpandPass.adoc[`AtomicExpandPass`] 
| 
| xref:llvm/AtomicInfo.adoc[`AtomicInfo`] 
| 
| xref:llvm/AtomicRMWInst.adoc[`AtomicRMWInst`] 
| an instruction that atomically reads a memory location, combines it with another value, and then stores the result back&period; Returns the old value&period;
| xref:llvm/AtomicSDNode.adoc[`AtomicSDNode`] 
| This is an SDNode representing atomic operations&period;
| xref:llvm/AttrBuilder.adoc[`AttrBuilder`] 
| This class is used in conjunction with the Attribute&colon;&colon;get method to create an Attribute object&period; The object itself is uniquified&period; The Builder&apos;s value, however, is not&period; So this can be used as a quick way to test for equality, presence of attributes, etc&period;
| xref:llvm/Attribute.adoc[`Attribute`] 
| Functions, function parameters, and return types can have attributes to indicate how they should be treated by optimizations and code generation&period; This class represents one of those attributes&period; It&apos;s light&hyphen;weight and should be passed around by&hyphen;value&period;
| xref:llvm/AttributeImpl.adoc[`AttributeImpl`] 
| 
| xref:llvm/AttributeList.adoc[`AttributeList`] 
| This class holds the attributes for a function, its return value, and its parameters&period; You access the attributes for each of them via an index into the AttributeList object&period; The function attributes are at index &grave;AttributeList&colon;&colon;FunctionIndex&apos;, the return value is at index &grave;AttributeList&colon;&colon;ReturnIndex&apos;, and the attributes for the parameters start at index &grave;AttributeList&colon;&colon;FirstArgIndex&apos;&period;
| xref:llvm/AttributeListImpl.adoc[`AttributeListImpl`] 
| 
| 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`] 
| This class holds the attributes for a particular argument, parameter, function, or return value&period; It is an immutable value type that is cheap to copy&period; Adding and removing enum attributes is intended to be fast, but adding and removing string or integer attributes involves a FoldingSet lookup&period;
| xref:llvm/AttributeSetNode.adoc[`AttributeSetNode`] 
| 
| xref:llvm/Attributor.adoc[`Attributor`] 
| The fixpoint analysis framework that orchestrates the attribute deduction&period;
| xref:llvm/AttributorCGSCCPass.adoc[`AttributorCGSCCPass`] 
| 
| xref:llvm/AttributorCallGraph.adoc[`AttributorCallGraph`] 
| 
| xref:llvm/AttributorConfig.adoc[`AttributorConfig`] 
| Configuration for the Attributor&period;
| xref:llvm/AttributorLightCGSCCPass.adoc[`AttributorLightCGSCCPass`] 
| A more lightweight version of the Attributor which only runs attribute inference but no simplifications&period;
| xref:llvm/AttributorLightPass.adoc[`AttributorLightPass`] 
| A more lightweight version of the Attributor which only runs attribute inference but no simplifications&period;
| xref:llvm/AttributorPass.adoc[`AttributorPass`] 
| Module pass that runs the attributor analysis&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`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/BFIDOTGraphTraitsBase.adoc[`BFIDOTGraphTraitsBase`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/BTFParser.adoc[`BTFParser`] 
| 
| xref:llvm/BalancedPartitioning.adoc[`BalancedPartitioning`] 
| 
| 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`] 
| 
| xref:llvm/BalancedPartitioningTest_Large_Test.adoc[`BalancedPartitioningTest&lowbar;Large&lowbar;Test`] 
| 
| xref:llvm/BalancedPartitioningTest_MoveGain_Test.adoc[`BalancedPartitioningTest&lowbar;MoveGain&lowbar;Test`] 
| 
| xref:llvm/BaseIndexOffset.adoc[`BaseIndexOffset`] 
| Helper struct to parse and store a memory address as base &plus; index &plus; offset&period; We ignore sign extensions when it is safe to do so&period; The following two expressions are not equivalent&period; To differentiate we need to store whether there was a sign extension involved in the index computation&period; (load (i64 add (i64 copyfromreg %c) (i64 signextend (add (i8 load %index) (i8 1)))) vs
| xref:llvm/BaseRecord.adoc[`BaseRecord`] 
| 
| xref:llvm/BasicAA.adoc[`BasicAA`] 
| Analysis pass providing a never&hyphen;invalidated alias analysis result&period;
| xref:llvm/BasicAAResult.adoc[`BasicAAResult`] 
| This is the AA result object for the basic, local, and stateless alias analysis&period; It implements the AA query interface in an entirely stateless manner&period; As one consequence, it is never invalidated due to IR changes&period; While it does retain some storage, that is used as an optimization and not to preserve information from query to query&period; However it does retain handles to various other analyses and must be recomputed when those analyses are&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`] 
| 
| xref:llvm/BasicBlockMatchingAndInference.adoc[`BasicBlockMatchingAndInference`] 
| 
| xref:llvm/BasicBlockSDNode.adoc[`BasicBlockSDNode`] 
| 
| xref:llvm/BasicBlockSectionsProfileReader.adoc[`BasicBlockSectionsProfileReader`] 
| 
| xref:llvm/BasicBlockSectionsProfileReaderAnalysis.adoc[`BasicBlockSectionsProfileReaderAnalysis`] 
| Analysis pass providing the `BasicBlockSectionsProfileReader&period;`
| xref:llvm/BasicBlockSectionsProfileReaderWrapperPass.adoc[`BasicBlockSectionsProfileReaderWrapperPass`] 
| 
| xref:llvm/BasicDIEUnit.adoc[`BasicDIEUnit`] 
| 
| xref:llvm/BasicSubtargetFeatureKV.adoc[`BasicSubtargetFeatureKV`] 
| 
| 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`] 
| This class is a wrapper over an AAResults, and it is intended to be used only when there are no IR changes inbetween queries&period; BatchAAResults is reusing the same `AAQueryInfo` to preserve the state across queries, esentially making AA work in &quot;batch mode&quot;&period; The internal state cannot be cleared, so to go &quot;out&hyphen;of&hyphen;batch&hyphen;mode&quot;, the user must either use AAResults, or create a new BatchAAResults&period;
| xref:llvm/BinOpInit.adoc[`BinOpInit`] 
| !op (X, Y) &hyphen; Combine two inits&period;
| xref:llvm/BinaryByteStream.adoc[`BinaryByteStream`] 
| An implementation of BinaryStream which holds its entire data set in a single contiguous buffer&period; BinaryByteStream guarantees that no read operation will ever incur a copy&period; Note that BinaryByteStream does not own the underlying buffer&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`] 
| BinaryItemStream represents a sequence of objects stored in some kind of external container but for which it is useful to view as a stream of contiguous bytes&period; An example of this might be if you have a collection of records and you serialize each one into a buffer, and store these serialized records in a container&period; The pointers themselves are not laid out contiguously in memory, but we may wish to read from or write to these records as if they were&period;
| xref:llvm/BinaryItemTraits-05.adoc[`BinaryItemTraits`] 
| 
| 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`] 
| 
| xref:llvm/BinaryStream.adoc[`BinaryStream`] 
| An interface for accessing data in a stream&hyphen;like format, but which discourages copying&period; Instead of specifying a buffer in which to copy data on a read, the API returns an ArrayRef to data owned by the stream&apos;s implementation&period; Since implementations may not necessarily store data in a single contiguous buffer (or even in memory at all), in such cases a it may be necessary for an implementation to cache such a buffer so that it can return it&period;
| xref:llvm/BinaryStreamError.adoc[`BinaryStreamError`] 
| Base class for errors originating when parsing raw PDB files
| xref:llvm/BinaryStreamReader.adoc[`BinaryStreamReader`] 
| Provides read only access to a subclass of `BinaryStream`&period; Provides bounds checking and helpers for writing certain common data types such as null&hyphen;terminated strings, integers in various flavors of endianness, etc&period; Can be subclassed to provide reading of custom datatypes, although no are overridable&period;
| xref:llvm/BinaryStreamRef.adoc[`BinaryStreamRef`] 
| BinaryStreamRef is to BinaryStream what ArrayRef is to an Array&period; It provides copy&hyphen;semantics and read only access to a &quot;window&quot; of the underlying BinaryStream&period; Note that BinaryStreamRef is _not_ a BinaryStream&period; That is to say, it does not inherit and override the methods of BinaryStream&period; In general, you should not pass around pointers or references to BinaryStreams and use inheritance to achieve polymorphism&period; Instead, you should pass around BinaryStreamRefs by value and achieve polymorphism that way&period;
| xref:llvm/BinaryStreamRefBase-0f.adoc[`BinaryStreamRefBase`] 
| Common stuff for mutable and immutable StreamRefs&period;
| xref:llvm/BinaryStreamWriter.adoc[`BinaryStreamWriter`] 
| Provides write only access to a subclass of `WritableBinaryStream`&period; Provides bounds checking and helpers for writing certain common data types such as null&hyphen;terminated strings, integers in various flavors of endianness, etc&period; Can be subclassed to provide reading and writing of custom datatypes, although no methods are overridable&period;
| xref:llvm/BinarySubstreamRef.adoc[`BinarySubstreamRef`] 
| 
| xref:llvm/BitCastInst.adoc[`BitCastInst`] 
| This class represents a no&hyphen;op cast from one type to another&period;
| xref:llvm/BitCastOperator.adoc[`BitCastOperator`] 
| 
| xref:llvm/BitCodeAbbrev.adoc[`BitCodeAbbrev`] 
| BitCodeAbbrev &hyphen; This class represents an abbreviation record&period; An abbreviation allows a complex record that has redundancy to be stored in a specialized format instead of the fully&hyphen;general, fully&hyphen;vbr, format&period;
| xref:llvm/BitCodeAbbrevOp.adoc[`BitCodeAbbrevOp`] 
| BitCodeAbbrevOp &hyphen; This describes one or more operands in an abbreviation&period; This is actually a union of two different things&colon; 1&period; It could be a literal integer value (&quot;the operand is always 17&quot;)&period; 2&period; It could be an encoding specification (&quot;this operand encoded like so&quot;)&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`] 
| This class encapuslates the logic to iterate over bitmask returned by the various RegClass related APIs&period; E&period;g&period;, this class can be used to iterate over the subclasses provided by TargetRegisterClass&colon;&colon;getSubClassMask or SuperRegClassIterator&colon;&colon;getMask&period;
| xref:llvm/BitRecTy.adoc[`BitRecTy`] 
| &apos;bit&apos; &hyphen; Represent a single bit
| xref:llvm/BitVector.adoc[`BitVector`] 
| 
| xref:llvm/BitcodeAnalyzer.adoc[`BitcodeAnalyzer`] 
| 
| xref:llvm/BitcodeFileContents.adoc[`BitcodeFileContents`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/BlendedBlockHash.adoc[`BlendedBlockHash`] 
| An object wrapping several components of a basic block hash&period; The combined (blended) hash is represented and stored as one uint64&lowbar;t, while individual components are of smaller size (e&period;g&period;, uint16&lowbar;t or uint8&lowbar;t)&period;
| xref:llvm/BlockAddress.adoc[`BlockAddress`] 
| The address of a basic block&period;
| xref:llvm/BlockAddressSDNode.adoc[`BlockAddressSDNode`] 
| 
| xref:llvm/BlockCoverageInference.adoc[`BlockCoverageInference`] 
| 
| xref:llvm/BlockDataT-01.adoc[`BlockDataT`] 
| 
| xref:llvm/BlockExtractorPass.adoc[`BlockExtractorPass`] 
| 
| xref:llvm/BlockFrequency.adoc[`BlockFrequency`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/BranchProbability.adoc[`BranchProbability`] 
| 
| xref:llvm/BranchProbabilityAnalysis.adoc[`BranchProbabilityAnalysis`] 
| Analysis pass which computes `BranchProbabilityInfo&period;`
| xref:llvm/BranchProbabilityInfo.adoc[`BranchProbabilityInfo`] 
| Analysis providing branch probability information&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`] 
| 
| xref:llvm/BreakCriticalEdgesPass.adoc[`BreakCriticalEdgesPass`] 
| 
| xref:llvm/BreakFalseDepsPass.adoc[`BreakFalseDepsPass`] 
| 
| xref:llvm/BuildAttributeItem.adoc[`BuildAttributeItem`] 
| 
| xref:llvm/BuildAttributeSubSection.adoc[`BuildAttributeSubSection`] 
| 
| 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 known origin of an individual byte in combine pattern&period; The value of the byte is either constant zero, or comes from memory &sol; some other productive instruction (e&period;g&period; arithmetic instructions)&period; Bit manipulation instructions like shifts are not ByteProviders, rather are used to extract Bytes&period;
| xref:llvm/ByteType.adoc[`ByteType`] 
| Class to represent byte types&period;
| xref:llvm/CCState.adoc[`CCState`] 
| CCState &hyphen; This class holds information needed while lowering arguments and return values&period; It captures which registers are already assigned and which stack slots are used&period; It provides accessors to allocate these values&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`] 
| 
| xref:llvm/CFGOnlyViewerPass.adoc[`CFGOnlyViewerPass`] 
| 
| xref:llvm/CFGPrinterPass.adoc[`CFGPrinterPass`] 
| 
| xref:llvm/CFGProfile.adoc[`CFGProfile`] 
| 
| xref:llvm/CFGSCCPrinterPass.adoc[`CFGSCCPrinterPass`] 
| 
| xref:llvm/CFGViewerPass.adoc[`CFGViewerPass`] 
| 
| xref:llvm/CFGuardPass.adoc[`CFGuardPass`] 
| 
| xref:llvm/CFIFixupLegacy.adoc[`CFIFixupLegacy`] 
| 
| xref:llvm/CFIFixupPass.adoc[`CFIFixupPass`] 
| 
| xref:llvm/CFIFunctionFrameAnalyzer.adoc[`CFIFunctionFrameAnalyzer`] 
| This class implements the `CFIFunctionFrameReceiver` interface to validate Call Frame Information in a stream of function frames&period; For validation, it instantiates a `DWARFCFIAnalysis` for each frame&period; The errors&sol;warnings are emitted through the `MCContext` instance to the constructor&period; If a frame finishes without being started or if all the frames are not finished before this classes is destructed, the program fails through an assertion&period;
| xref:llvm/CFIFunctionFrameReceiver.adoc[`CFIFunctionFrameReceiver`] 
| This abstract base class is an interface for receiving DWARF function frames Call Frame Information&period; `DWARFCFIFunctionFrameStreamer` channels the function frames information gathered from an `MCStreamer` using a pointer to an instance of this class for the whole program&period;
| xref:llvm/CFIFunctionFrameStreamer.adoc[`CFIFunctionFrameStreamer`] 
| This class is an `MCStreamer` implementation that watches for machine instructions and CFI directives&period; It cuts the stream into function frames and channels them to `CFIFunctionFrameReceiver`&period; A function frame is the machine instructions and CFI directives that are between `&period;cfi&lowbar;startproc` and `&period;cfi&lowbar;endproc` directives&period;
| xref:llvm/CFIInstBuilder.adoc[`CFIInstBuilder`] 
| Helper class for creating CFI instructions and inserting them into MIR&period;
| xref:llvm/CFIInstrInserterPass.adoc[`CFIInstrInserterPass`] 
| 
| xref:llvm/CGDataError.adoc[`CGDataError`] 
| 
| 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`] 
| 
| xref:llvm/CGProfilePass.adoc[`CGProfilePass`] 
| 
| 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`] 
| 
| xref:llvm/CHERIoTCapabilityFormat.adoc[`CHERIoTCapabilityFormat`] 
| 
| xref:llvm/CRCTable.adoc[`CRCTable`] 
| A custom std&colon;&colon;array with 256 entries, that also has a print function&period;
| xref:llvm/CSEConfigBase.adoc[`CSEConfigBase`] 
| 
| xref:llvm/CSEConfigConstantOnly.adoc[`CSEConfigConstantOnly`] 
| 
| xref:llvm/CSEConfigFull.adoc[`CSEConfigFull`] 
| 
| xref:llvm/CSEMIRBuilder.adoc[`CSEMIRBuilder`] 
| Defines a builder that does CSE of MachineInstructions using GISelCSEInfo&period; Eg usage&period;
| xref:llvm/CSKYAttributeParser.adoc[`CSKYAttributeParser`] 
| 
| xref:llvm/CacheCost.adoc[`CacheCost`] 
| `CacheCost` represents the estimated cost of a inner loop as the number of cache lines used by the memory references it contains&period; The &apos;cache cost&apos; of a loop &apos;L&apos; in a loop nest &apos;LN&apos; is computed as the sum of the cache costs of all of its reference groups when the loop is considered to be in the innermost position in the nest&period; A reference group represents memory references that fall into the same cache line&period; Each reference group is analysed with respect to the innermost loop in a loop nest&period; The cost of a reference is defined as follow&colon; &hyphen; one if it is loop invariant w&period;r&period;t the innermost loop, &hyphen; equal to the loop trip count divided by the cache line times the reference stride if the reference stride is less than the cache line size (CLS), and the coefficient of this loop&apos;s index variable used in all other subscripts is zero (e&period;g&period; RefCost &equals; TripCount&sol;(CLS&sol;RefStride)) &hyphen; equal to the innermost loop trip count if the reference stride is greater or equal to the cache line size CLS&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; Most clients should just be able to return an instance of this base class from the stream callback, but if a client needs to perform some action after the stream is written to, that can be done by deriving from this class and overriding the destructor or the commit() method&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`] 
| CallBr instruction, tracking function calls that may not return control but instead transfer it to a third location&period; The SubclassData field is used to hold the calling convention of the call&period;
| xref:llvm/CallEntryPseudoSourceValue.adoc[`CallEntryPseudoSourceValue`] 
| 
| 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`] 
| 
| 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`] 
| This class represents a function call, abstracting a target machine&apos;s calling convention&period; This class uses low bit of the SubClassData field to indicate whether or not this is a tail call&period; The rest of the bits hold the calling convention of the call&period;
| xref:llvm/CallLowering.adoc[`CallLowering`] 
| 
| xref:llvm/CallSiteFormat.adoc[`CallSiteFormat`] 
| 
| xref:llvm/CallSiteSplittingPass.adoc[`CallSiteSplittingPass`] 
| 
| xref:llvm/CallbackVH.adoc[`CallbackVH`] 
| Value handle with callbacks on RAUW and destruction&period;
| xref:llvm/CalledValuePropagationPass.adoc[`CalledValuePropagationPass`] 
| 
| xref:llvm/CalleeInfo.adoc[`CalleeInfo`] 
| Class to accumulate and hold information about a callee&period;
| xref:llvm/CalleeSavedInfo.adoc[`CalleeSavedInfo`] 
| The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in the current frame&period; Callee saved reg can also be saved to a different register rather than on the stack by setting DstReg instead of FrameIdx&period;
| xref:llvm/CallsiteID.adoc[`CallsiteID`] 
| 
| xref:llvm/CallsiteInfo.adoc[`CallsiteInfo`] 
| Summary of memprof callsite metadata&period;
| xref:llvm/CanonicalLoopInfo.adoc[`CanonicalLoopInfo`] 
| Class to represented 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`] 
| This callback is used in conjunction with PointerMayBeCaptured&period; In addition to the interface here, you&apos;ll need to provide your own getters to see whether anything was captured&period;
| xref:llvm/CastInfo-01.adoc[`CastInfo`] 
| This struct provides a method for customizing the way a cast is performed&period; It inherits from CastIsPossible, to support the case of declaring many CastIsPossible specializations without having to specialize the full CastInfo&period;
| xref:llvm/CastInst.adoc[`CastInst`] 
| This is the base class for all instructions that perform data casts&period; It is simply provided so that instruction category testing can be performed with code like&colon;
| xref:llvm/CastIsPossible-05.adoc[`CastIsPossible`] 
| This struct provides a way to check if a given cast is possible&period; It provides a static function called isPossible that is used to check if a cast can be performed&period; It should be overridden like this&colon;
| xref:llvm/CatchPadInst.adoc[`CatchPadInst`] 
| 
| xref:llvm/CatchReturnInst.adoc[`CatchReturnInst`] 
| 
| xref:llvm/CatchSwitchInst.adoc[`CatchSwitchInst`] 
| 
| xref:llvm/CfiFunctionIndex.adoc[`CfiFunctionIndex`] 
| Encapsulate the names of CFI target functions&period; It interfaces with ThinLTO to determine efficiently which of the names need to be exported for a particular module&period;
| xref:llvm/ChangeReporter-00.adoc[`ChangeReporter`] 
| 
| xref:llvm/CheckDebugMachineModulePass.adoc[`CheckDebugMachineModulePass`] 
| 
| xref:llvm/Clause.adoc[`Clause`] 
| 
| xref:llvm/CleanupInstaller.adoc[`CleanupInstaller`] 
| 
| xref:llvm/CleanupPadInst.adoc[`CleanupPadInst`] 
| 
| xref:llvm/CleanupReturnInst.adoc[`CleanupReturnInst`] 
| 
| 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`] 
| 
| xref:llvm/CmpInst.adoc[`CmpInst`] 
| This class is the base class for the comparison instructions&period; 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 floating&hyphen;point predicate, and a pack of an integer predicate with samesign information&period; Some functions in ICmpInst construct and return this type in place of a Predicate&period;
| xref:llvm/CoalescerPair.adoc[`CoalescerPair`] 
| 
| 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 for the CodeExtractor analysis&period; The operation xref:llvm/CodeExtractor/extractCodeRegion-06.adoc[`CodeExtractor&colon;&colon;extractCodeRegion`] is guaranteed not to invalidate this object&period; This object should conservatively be considered invalid if any other mutating operations on the IR occur&period;
| xref:llvm/CodeGenCoverage.adoc[`CodeGenCoverage`] 
| 
| xref:llvm/CodeGenData.adoc[`CodeGenData`] 
| 
| xref:llvm/CodeGenDataReader.adoc[`CodeGenDataReader`] 
| 
| xref:llvm/CodeGenDataWriter.adoc[`CodeGenDataWriter`] 
| 
| xref:llvm/CodeGenPassBuilder.adoc[`CodeGenPassBuilder`] 
| This class provides access to building LLVM&apos;s passes&period;
| xref:llvm/CodeGenPreparePass.adoc[`CodeGenPreparePass`] 
| 
| xref:llvm/CodeGenTargetMachineImpl.adoc[`CodeGenTargetMachineImpl`] 
| implements a set of functionality in the `TargetMachine` class for targets that make use of the independent code generator (CodeGen) library&period; Must not be used directly in code unless to inherit its implementation&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`] 
| 
| xref:llvm/CombinerInfo.adoc[`CombinerInfo`] 
| 
| xref:llvm/Comdat.adoc[`Comdat`] 
| 
| xref:llvm/CompileUnitIdentifiers.adoc[`CompileUnitIdentifiers`] 
| 
| xref:llvm/ComplexDeinterleavingPass.adoc[`ComplexDeinterleavingPass`] 
| 
| 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`] 
| 
| xref:llvm/CondContext.adoc[`CondContext`] 
| Evaluate query assuming this condition holds&period;
| xref:llvm/CondOpInit.adoc[`CondOpInit`] 
| !cond(condition&lowbar;1&colon; value1, &period;&period;&period; , condition&lowbar;n&colon; value) Selects the first value for which condition is true&period; Otherwise reports an error&period;
| xref:llvm/ConnectedVNInfoEqClasses.adoc[`ConnectedVNInfoEqClasses`] 
| ConnectedVNInfoEqClasses &hyphen; Helper class that can divide VNInfos in a LiveInterval into equivalence clases of connected components&period; A LiveInterval that has multiple connected components can be broken into multiple LiveIntervals&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`] 
| Provides a cast trait that strips `const` from types to make it easier to implement a const&hyphen;version of a non&hyphen;const cast&period; It just removes boilerplate and reduces the amount of code you as the user need to implement&period; You can use it like this&colon;
| xref:llvm/Constant.adoc[`Constant`] 
| This is an important base class in LLVM&period; It provides the common facilities of all constant values in an LLVM program&period; A constant is a value that is immutable at runtime&period; Functions are constants because their address is immutable&period; Same with global variables&period;
| xref:llvm/ConstantAggrKeyType.adoc[`ConstantAggrKeyType`] 
| 
| xref:llvm/ConstantAggregate.adoc[`ConstantAggregate`] 
| Base class for aggregate constants (with operands)&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`] 
| 
| xref:llvm/ConstantByte.adoc[`ConstantByte`] 
| Class for constant bytes&period;
| xref:llvm/ConstantData.adoc[`ConstantData`] 
| Base class for constants with no operands&period;
| xref:llvm/ConstantDataArray.adoc[`ConstantDataArray`] 
| An array constant whose element type is a simple 1&sol;2&sol;4&sol;8&hyphen;byte integer, bytes or float&sol;double, and whose elements are just simple data values (i&period;e&period; ConstantInt&sol;ConstantFP)&period; This Constant node has no operands because it stores all of the elements of the constant as densely packed data, instead of as Value&ast;&apos;s&period;
| xref:llvm/ConstantDataArraySlice.adoc[`ConstantDataArraySlice`] 
| Represents offset&plus;length into a ConstantDataArray&period;
| xref:llvm/ConstantDataSequential.adoc[`ConstantDataSequential`] 
| ConstantDataSequential &hyphen; A vector or array constant whose element type is a simple 1&sol;2&sol;4&sol;8&hyphen;byte integer&sol;byte or half&sol;bfloat&sol;float&sol;double, and whose elements are just simple data values (i&period;e&period; ConstantInt&sol;ConstantByte&sol; ConstantFP)&period; This Constant node has no operands because it stores all of the elements of the constant as densely packed data, instead of as Value&ast;&apos;s&period;
| xref:llvm/ConstantDataVector.adoc[`ConstantDataVector`] 
| A vector constant whose element type is a simple 1&sol;2&sol;4&sol;8&hyphen;byte integer or float&sol;double, and whose elements are just simple data values (i&period;e&period; ConstantInt&sol;ConstantFP)&period; This Constant node has no operands because it stores all of the elements of the constant as densely packed data, instead of as Value&ast;&apos;s&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`] 
| 
| 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`] 
| 
| xref:llvm/ConstantFolder.adoc[`ConstantFolder`] 
| ConstantFolder &hyphen; Create constants with minimum, target independent, folding&period;
| xref:llvm/ConstantHoistingPass.adoc[`ConstantHoistingPass`] 
| 
| 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`] 
| 
| xref:llvm/ConstantPoolEntry.adoc[`ConstantPoolEntry`] 
| 
| xref:llvm/ConstantPoolSDNode.adoc[`ConstantPoolSDNode`] 
| 
| xref:llvm/ConstantPtrAuth.adoc[`ConstantPtrAuth`] 
| A signed pointer, in the ptrauth sense&period;
| xref:llvm/ConstantPtrAuthKeyType.adoc[`ConstantPtrAuthKeyType`] 
| 
| xref:llvm/ConstantRange.adoc[`ConstantRange`] 
| This class represents a range of values&period;
| xref:llvm/ConstantRangeList.adoc[`ConstantRangeList`] 
| This class represents a list of constant ranges&period;
| xref:llvm/ConstantSDNode.adoc[`ConstantSDNode`] 
| 
| xref:llvm/ConstantStruct.adoc[`ConstantStruct`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/ConstraintSystem.adoc[`ConstraintSystem`] 
| 
| xref:llvm/ContextAndReplaceableUses.adoc[`ContextAndReplaceableUses`] 
| Pointer to the context, with optional RAUW support&period;
| xref:llvm/ContextTotalSize.adoc[`ContextTotalSize`] 
| 
| xref:llvm/ContextTrieNode.adoc[`ContextTrieNode`] 
| 
| 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`] 
| 
| xref:llvm/ConvergenceControlInst.adoc[`ConvergenceControlInst`] 
| Represents calls to the llvm&period;experimintal&period;convergence&period;&ast; intrinsics&period;
| xref:llvm/ConvergingVLIWScheduler.adoc[`ConvergingVLIWScheduler`] 
| 
| xref:llvm/CopyProfPass.adoc[`CopyProfPass`] 
| 
| xref:llvm/CopyProfStoresPass.adoc[`CopyProfStoresPass`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/CoroConditionalWrapper.adoc[`CoroConditionalWrapper`] 
| 
| xref:llvm/CoroDeadInst.adoc[`CoroDeadInst`] 
| This represents the llvm&period;coro&period;dead instruction&period;
| xref:llvm/CoroEarlyPass.adoc[`CoroEarlyPass`] 
| 
| xref:llvm/CoroElidePass.adoc[`CoroElidePass`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/CostBenefitPair.adoc[`CostBenefitPair`] 
| 
| 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`] 
| 
| xref:llvm/CountVisitsPass.adoc[`CountVisitsPass`] 
| 
| 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`] 
| 
| xref:llvm/CtxProfAnalysis.adoc[`CtxProfAnalysis`] 
| 
| xref:llvm/CtxProfAnalysisPrinterPass.adoc[`CtxProfAnalysisPrinterPass`] 
| 
| xref:llvm/CxxUnwindMapEntry.adoc[`CxxUnwindMapEntry`] 
| 
| xref:llvm/CycleAnalysis.adoc[`CycleAnalysis`] 
| Analysis pass which computes a xref:llvm/CycleInfo.adoc[`CycleInfo`]&period;
| xref:llvm/CycleInfo.adoc[`CycleInfo`] 
| 
| xref:llvm/CycleInfoPrinterPass.adoc[`CycleInfoPrinterPass`] 
| 
| xref:llvm/CycleInfoVerifierPass.adoc[`CycleInfoVerifierPass`] 
| 
| 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 that wraps the cycle&apos;s preorder index&period; Handles remain valid as long as the cycle forest is not recomputed&semi; addBlockToCycle() adds a block but never adds, removes, or reorders cycles, so it leaves every handle valid&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`] 
| 
| 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`] 
| Concrete implementation of a pure data dependence graph builder&period; This class provides custom implementation for the pure&hyphen;virtual functions used in the generic dependence graph build algorithm&period;
| xref:llvm/DDGDotPrinterPass.adoc[`DDGDotPrinterPass`] 
| 
| xref:llvm/DDGEdge.adoc[`DDGEdge`] 
| Data Dependency Graph Edge&period; An edge in the DDG can represent a def&hyphen;use relationship or a memory dependence based on the result of DependenceAnalysis&period; A rooted edge connects the root node to one of the components of the graph&period;
| xref:llvm/DDGNode.adoc[`DDGNode`] 
| Data Dependence Graph Node The graph can represent the following types of nodes&colon; 1&period; Single instruction node containing just one instruction&period; 2&period; Multiple instruction node where two or more instructions from the same basic block are merged into one node&period; 3&period; Pi&hyphen;block node which is a group of other DDG nodes that are part of a strongly&hyphen;connected component of the graph&period; A pi&hyphen;block node contains more than one single or multiple instruction nodes&period; The root node cannot be part of a pi&hyphen;block&period; 4&period; Root node is a special node that connects to all components such that there is always a path from it to any node in the graph&period;
| xref:llvm/DFAJumpThreadingPass.adoc[`DFAJumpThreadingPass`] 
| 
| xref:llvm/DFAPacketizer.adoc[`DFAPacketizer`] 
| 
| xref:llvm/DFCalculateWorkObject.adoc[`DFCalculateWorkObject`] 
| 
| 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&period; Used to link stores (as an attachment) and dbg&period;assigns (as an operand)&period; DIAssignID metadata is never uniqued as we compare instances using referential equality (the instance&sol;address is the ID)&period;
| xref:llvm/DIBasicType.adoc[`DIBasicType`] 
| Basic type, like &apos;int&apos; or &apos;float&apos;&period;
| xref:llvm/DIBuilder.adoc[`DIBuilder`] 
| 
| 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`] 
| 
| 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`] 
| A BaseTypeRef DIE&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`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/DILexicalBlockFile.adoc[`DILexicalBlockFile`] 
| 
| 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`] 
| 
| 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 lexical block&period;
| xref:llvm/DINode.adoc[`DINode`] 
| Tagged DWARF&hyphen;like metadata node&period;
| xref:llvm/DIObjCProperty.adoc[`DIObjCProperty`] 
| 
| 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`] 
| 
| xref:llvm/DITemplateValueParameter.adoc[`DITemplateValueParameter`] 
| 
| 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`] 
| 
| xref:llvm/DOTGraphTraits-077.adoc[`DOTGraphTraits`] 
| DOTGraphTraits &hyphen; Template class that can be specialized to customize how graphs are converted to &apos;dot&apos; graphs&period; When specializing, you may inherit from DefaultDOTGraphTraits if you don&apos;t need to override everything&period;
| xref:llvm/DOTGraphTraitsModulePrinterWrapperPass.adoc[`DOTGraphTraitsModulePrinterWrapperPass`] 
| 
| xref:llvm/DOTGraphTraitsModuleViewerWrapperPass.adoc[`DOTGraphTraitsModuleViewerWrapperPass`] 
| 
| xref:llvm/DOTGraphTraitsPrinter-097.adoc[`DOTGraphTraitsPrinter`] 
| 
| xref:llvm/DOTGraphTraitsPrinterWrapperPass.adoc[`DOTGraphTraitsPrinterWrapperPass`] 
| 
| xref:llvm/DOTGraphTraitsViewer-03.adoc[`DOTGraphTraitsViewer`] 
| 
| xref:llvm/DOTGraphTraitsViewerWrapperPass.adoc[`DOTGraphTraitsViewerWrapperPass`] 
| 
| xref:llvm/DOTMachineFuncInfo.adoc[`DOTMachineFuncInfo`] 
| 
| 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`] 
| Wrapper for a function that represents a value that functionally represents the original function&period; This can be a function, global alias to a function, or an ifunc&period;
| xref:llvm/DWARF5AccelTable.adoc[`DWARF5AccelTable`] 
| 
| xref:llvm/DWARF5AccelTableData.adoc[`DWARF5AccelTableData`] 
| The Data class implementation for DWARF v5 accelerator table&period; Unlike the Apple Data classes, this class is just a DIE wrapper, and does not know to serialize itself&period; The complete serialization logic is in the emitDWARF5AccelTable function&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`] 
| The accelerator tables are designed to allow efficient random access (using a symbol name as a key) into debug info by providing an index of the debug info DIEs&period; This class implements the common functionality of Apple and DWARF 5 accelerator tables&period; TODO&colon; Generalize the rest of the AppleAcceleratorTable interface and move it to this class&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`] 
| `DWARFCFIAnalysis` validates the DWARF Call Frame Information one machine instruction at a time&period; This class maintains an internal CFI state initialized with the prologue directives and updated with each instruction&apos;s associated directives&period; In each update, it checks if the machine instruction changes the CFI state in a way that matches the changes from the CFI directives&period; This checking may results in errors and warnings&period;
| xref:llvm/DWARFCFIState.adoc[`DWARFCFIState`] 
| This class is used to maintain a CFI state, referred to as an unwinding row, during CFI analysis&period; The only way to modify the state is by updating it with a CFI directive&period;
| xref:llvm/DWARFCompileUnit-05.adoc[`DWARFCompileUnit`] 
| 
| 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`] 
| 
| xref:llvm/DWARFDebugAbbrev.adoc[`DWARFDebugAbbrev`] 
| 
| 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`] 
| 
| xref:llvm/DWARFDebugAranges.adoc[`DWARFDebugAranges`] 
| 
| 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`] 
| 
| xref:llvm/DWARFDebugLoc.adoc[`DWARFDebugLoc`] 
| 
| xref:llvm/DWARFDebugLoclists.adoc[`DWARFDebugLoclists`] 
| 
| xref:llvm/DWARFDebugMacro.adoc[`DWARFDebugMacro`] 
| 
| xref:llvm/DWARFDebugNames.adoc[`DWARFDebugNames`] 
| &period;debug&lowbar;names section consists of one or more units&period; Each unit starts with a header, which is followed by a list of compilation units, local and foreign type units&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`] 
| 
| 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`] 
| 
| xref:llvm/DWARFFormValue.adoc[`DWARFFormValue`] 
| 
| xref:llvm/DWARFGdbIndex.adoc[`DWARFGdbIndex`] 
| 
| 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 table of lists as specified in the DWARF v5 standard for location lists and range lists&period; The table consists of a header followed by an array of offsets into a DWARF section, followed by zero or more list entries&period; The list entries are kept in a map where the keys are the lists&apos; section offsets&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`] 
| An abstract base class for various kinds of location tables (&period;debug&lowbar;loc, &period;debug&lowbar;loclists, and their dwo variants)&period;
| xref:llvm/DWARFObject.adoc[`DWARFObject`] 
| 
| xref:llvm/DWARFSection.adoc[`DWARFSection`] 
| 
| xref:llvm/DWARFTypePrinter.adoc[`DWARFTypePrinter`] 
| 
| xref:llvm/DWARFTypeUnit-07.adoc[`DWARFTypeUnit`] 
| 
| 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 &quot;unit&period;&quot; Some information is specific to certain unit types&period; We separate this class out so we can parse the header before deciding what specific kind of unit to construct&period;
| xref:llvm/DWARFUnitIndex.adoc[`DWARFUnitIndex`] 
| 
| 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`] 
| 
| xref:llvm/DWPStringPool.adoc[`DWPStringPool`] 
| 
| xref:llvm/DWPWriter.adoc[`DWPWriter`] 
| Direct ELF writer for DWP output&period;
| xref:llvm/DXContainerObjectWriter.adoc[`DXContainerObjectWriter`] 
| 
| xref:llvm/DXILMetadataAnalysis.adoc[`DXILMetadataAnalysis`] 
| 
| xref:llvm/DXILMetadataAnalysisPrinterPass.adoc[`DXILMetadataAnalysisPrinterPass`] 
| Printer pass for the `DXILMetadataAnalysis` results&period;
| xref:llvm/DXILMetadataAnalysisWrapperPass.adoc[`DXILMetadataAnalysisWrapperPass`] 
| Legacy pass
| xref:llvm/DXILResourceAnalysis.adoc[`DXILResourceAnalysis`] 
| 
| xref:llvm/DXILResourceBindingAnalysis.adoc[`DXILResourceBindingAnalysis`] 
| 
| xref:llvm/DXILResourceBindingInfo.adoc[`DXILResourceBindingInfo`] 
| 
| xref:llvm/DXILResourceBindingWrapperPass.adoc[`DXILResourceBindingWrapperPass`] 
| 
| xref:llvm/DXILResourceMap.adoc[`DXILResourceMap`] 
| 
| xref:llvm/DXILResourcePrinterPass.adoc[`DXILResourcePrinterPass`] 
| Printer pass for the `DXILResourceAnalysis` results&period;
| xref:llvm/DXILResourceTypeAnalysis.adoc[`DXILResourceTypeAnalysis`] 
| 
| xref:llvm/DXILResourceTypeMap.adoc[`DXILResourceTypeMap`] 
| 
| xref:llvm/DXILResourceTypeWrapperPass.adoc[`DXILResourceTypeWrapperPass`] 
| 
| xref:llvm/DXILResourceWrapperPass.adoc[`DXILResourceWrapperPass`] 
| 
| xref:llvm/DXILUpgradePass.adoc[`DXILUpgradePass`] 
| Upgrade DXIL&hyphen;style metadata into their LLVM representations
| xref:llvm/DagInit.adoc[`DagInit`] 
| (v a, b) &hyphen; Represent a DAG tree value&period; DAG inits are required to have at least one value then a (possibly empty) list of arguments&period; Each argument can have a name associated with it&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`] 
| 
| xref:llvm/DataFlowSanitizerPass.adoc[`DataFlowSanitizerPass`] 
| 
| 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`] 
| This is the common base class for debug info intrinsics&period;
| xref:llvm/DbgLabelInst.adoc[`DbgLabelInst`] 
| This represents the llvm&period;dbg&period;label instruction&period;
| xref:llvm/DbgLabelInstrMap.adoc[`DbgLabelInstrMap`] 
| For each inlined instance of a source&hyphen;level label, keep the corresponding DBG&lowbar;LABEL instruction&period; The DBG&lowbar;LABEL instruction could be used to generate a temporary (assembler) label before it&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 record of debug&hyphen;info&period; If an Instruction is the position of some debugging information, it points at a DbgMarker storing that info&period; Each marker points back at the instruction that owns it&period; Various utilities are provided for manipulating the DbgRecords contained within this marker&period;
| xref:llvm/DbgRangeEntry.adoc[`DbgRangeEntry`] 
| 
| xref:llvm/DbgRecord.adoc[`DbgRecord`] 
| Base class for non&hyphen;instruction debug metadata records that have positions within IR&period; Features various methods copied across from the Instruction class to aid ease&hyphen;of&hyphen;use&period; DbgRecords should always be linked into a DbgMarker&apos;s StoredDbgRecords list&period; The marker connects a DbgRecord back to its position in the BasicBlock&period;
| xref:llvm/DbgRecordParamRef-0a.adoc[`DbgRecordParamRef`] 
| A typed tracking MDNode reference that does not require a definition for its parameter type&period; Necessary to avoid including DebugInfoMetadata&period;h, which has a significant impact on compile times if included in this file&period;
| xref:llvm/DbgSSABlock.adoc[`DbgSSABlock`] 
| 
| 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`] 
| &sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;
| 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`] 
| 
| 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`] 
| 
| xref:llvm/DeadArgumentEliminationPass.adoc[`DeadArgumentEliminationPass`] 
| Eliminate dead arguments (and return values) from functions&period;
| xref:llvm/DeadLaneDetector.adoc[`DeadLaneDetector`] 
| 
| xref:llvm/DeadMachineInstructionElimPass.adoc[`DeadMachineInstructionElimPass`] 
| 
| xref:llvm/DeadOnReturnInfo.adoc[`DeadOnReturnInfo`] 
| 
| xref:llvm/DebugAssignmentTrackingAnalysis.adoc[`DebugAssignmentTrackingAnalysis`] 
| 
| xref:llvm/DebugAssignmentTrackingPrinterPass.adoc[`DebugAssignmentTrackingPrinterPass`] 
| 
| xref:llvm/DebugCounter.adoc[`DebugCounter`] 
| 
| 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`] 
| 
| 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`] 
| DebugifyCustomPassManager wraps each pass with the debugify passes if needed&period; NOTE&colon; We support legacy custom pass manager only&period; TODO&colon; Add New PM support for custom pass manager&period;
| xref:llvm/DebugifyEachInstrumentation.adoc[`DebugifyEachInstrumentation`] 
| 
| xref:llvm/DebuginfodCollection.adoc[`DebuginfodCollection`] 
| Tracks a collection of debuginfod artifacts on the local filesystem&period;
| xref:llvm/DebuginfodFetcher.adoc[`DebuginfodFetcher`] 
| 
| xref:llvm/DebuginfodLog.adoc[`DebuginfodLog`] 
| 
| xref:llvm/DebuginfodLogEntry.adoc[`DebuginfodLogEntry`] 
| 
| xref:llvm/DebuginfodServer.adoc[`DebuginfodServer`] 
| 
| 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`] 
| 
| 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`] 
| DefaultDOTGraphTraits &hyphen; This class provides the default implementations of all of the DOTGraphTraits methods&period; If a specialization does not need to override all methods here it should inherit so that it can get the default implementations&period;
| xref:llvm/DefaultDoCastIfPossible.adoc[`DefaultDoCastIfPossible`] 
| This cast trait just provides the default implementation of doCastIfPossible to make CastInfo specializations more declarative&period; The `Derived` template parameter _must_ be provided for forwarding castFailed and doCast&period;
| xref:llvm/DefaultEvictionAdvisor.adoc[`DefaultEvictionAdvisor`] 
| 
| xref:llvm/DefaultFoldingSetTrait-0847.adoc[`DefaultFoldingSetTrait`] 
| This class provides default implementations for FoldingSetTrait implementations&period;
| xref:llvm/DefaultInlineAdvice.adoc[`DefaultInlineAdvice`] 
| 
| xref:llvm/DefaultInlineAdvisor.adoc[`DefaultInlineAdvisor`] 
| The default (manual heuristics) implementation of the InlineAdvisor&period; This implementation does not need to keep state between inliner pass runs, and is reusable as&hyphen;is for inliner pass test scenarios, as well as for regular use&period;
| xref:llvm/DefaultPriorityAdvisor.adoc[`DefaultPriorityAdvisor`] 
| 
| xref:llvm/DefaultVLIWScheduler.adoc[`DefaultVLIWScheduler`] 
| 
| 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`] 
| 
| xref:llvm/DelinearizationPrinterPass.adoc[`DelinearizationPrinterPass`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/DenormalMode.adoc[`DenormalMode`] 
| Represent subnormal handling kind for floating point instruction inputs and outputs&period;
| xref:llvm/DenseMap-0c.adoc[`DenseMap`] 
| 
| xref:llvm/DenseMapBase-0d8.adoc[`DenseMapBase`] 
| 
| xref:llvm/DenseMapInfo-034d.adoc[`DenseMapInfo`] 
| An information struct used to provide DenseMap with the various necessary components for a given value type `T`&period; `Enable` is an optional additional parameter that is used to support SFINAE (generally using std&colon;&colon;enable&lowbar;if&lowbar;t) in derived DenseMapInfo specializations&semi; in non&hyphen;SFINAE use cases this should just be `void`&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`] 
| Dependence &hyphen; This class represents a dependence between two memory memory references in a function&period; It contains minimal information and is used in the very common situation where the compiler is unable to determine anything beyond the existence of a dependence&semi; that is, it represents a confused dependence (see also FullDependence)&period; In most cases (for output, flow, and anti dependences), the dependence implies an ordering, where the source must precede the destination&semi; in contrast, input dependences are unordered&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
| xref:llvm/DerivedUser.adoc[`DerivedUser`] 
| Extension point for the Value hierarchy&period; All classes outside of lib&sol;IR that wish to inherit from User should instead inherit from DerivedUser instead&period; Inheriting from this class is discouraged&period;
| xref:llvm/DestSourcePair.adoc[`DestSourcePair`] 
| 
| xref:llvm/DetectDeadLanesPass.adoc[`DetectDeadLanesPass`] 
| 
| 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; The handleDiagnostics method must be overriden by the subclasses to handle diagnostic&period; The &ast;RemarkEnabled methods can be overriden to control which remarks are enabled&period;
| xref:llvm/DiagnosticInfo.adoc[`DiagnosticInfo`] 
| This is the base abstract class for diagnostic reporting in the backend&period; The print method must be overloaded by the subclasses to print a user&hyphen;friendly message in the client of the backend (let us call it a frontend)&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`] 
| 
| xref:llvm/DiagnosticInfoGeneric.adoc[`DiagnosticInfoGeneric`] 
| 
| xref:llvm/DiagnosticInfoGenericWithLoc.adoc[`DiagnosticInfoGenericWithLoc`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/DiagnosticPredicate.adoc[`DiagnosticPredicate`] 
| 
| 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`] 
| 
| xref:llvm/DirectedGraph-0d.adoc[`DirectedGraph`] 
| Directed graph
| xref:llvm/Directive-02.adoc[`Directive`] 
| 
| xref:llvm/DirectiveLanguage.adoc[`DirectiveLanguage`] 
| 
| 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`] 
| 
| 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`] 
| A MemorySSAWalker that does no alias queries, or anything else&period; It simply returns the links as they were constructed by the builder&period;
| xref:llvm/DomConditionCache.adoc[`DomConditionCache`] 
| 
| xref:llvm/DomOnlyPrinter.adoc[`DomOnlyPrinter`] 
| 
| xref:llvm/DomOnlyViewer.adoc[`DomOnlyViewer`] 
| 
| xref:llvm/DomPrinter.adoc[`DomPrinter`] 
| 
| xref:llvm/DomTreeGraphTraitsBase-0e.adoc[`DomTreeGraphTraitsBase`] 
| 
| 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`] 
| 
| xref:llvm/DomViewer.adoc[`DomViewer`] 
| 
| 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`] 
| 
| xref:llvm/DominanceFrontierAnalysis.adoc[`DominanceFrontierAnalysis`] 
| Analysis pass which computes a `DominanceFrontier&period;`
| xref:llvm/DominanceFrontierBase-06.adoc[`DominanceFrontierBase`] 
| DominanceFrontierBase &hyphen; Common base class for computing forward and inverse dominance frontiers for a function&period;
| xref:llvm/DominanceFrontierPrinterPass.adoc[`DominanceFrontierPrinterPass`] 
| Printer pass for the `DominanceFrontier&period;`
| xref:llvm/DominanceFrontierWrapperPass.adoc[`DominanceFrontierWrapperPass`] 
| 
| 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`] 
| 
| xref:llvm/DotFuncBCIInfo.adoc[`DotFuncBCIInfo`] 
| 
| xref:llvm/DropTypeTestsPass.adoc[`DropTypeTestsPass`] 
| 
| xref:llvm/DropUnnecessaryAssumesPass.adoc[`DropUnnecessaryAssumesPass`] 
| 
| xref:llvm/DroppedVariableStats.adoc[`DroppedVariableStats`] 
| A base class to collect and print dropped debug information variable statistics&period;
| xref:llvm/DroppedVariableStatsIR.adoc[`DroppedVariableStatsIR`] 
| A class to collect and print dropped debug information due to LLVM IR optimization passes&period; After every LLVM IR pass is run, it will print how many &num;dbg&lowbar;values were dropped due to that pass&period;
| xref:llvm/DroppedVariableStatsMIR.adoc[`DroppedVariableStatsMIR`] 
| A class to collect and print dropped debug information due to MIR optimization passes&period; After every MIR pass is run, it will print how many &num;DBG&lowbar;VALUEs were dropped due to that pass&period;
| xref:llvm/DstOp.adoc[`DstOp`] 
| 
| 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`] 
| 
| xref:llvm/DwarfDebug.adoc[`DwarfDebug`] 
| 
| xref:llvm/DwarfEHPreparePass.adoc[`DwarfEHPreparePass`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/EHStreamer.adoc[`EHStreamer`] 
| 
| xref:llvm/ELFAttributeParser.adoc[`ELFAttributeParser`] 
| 
| xref:llvm/ELFCompactAttrParser.adoc[`ELFCompactAttrParser`] 
| 
| xref:llvm/ELFExtendedAttrParser.adoc[`ELFExtendedAttrParser`] 
| 
| xref:llvm/ELFObjectWriter.adoc[`ELFObjectWriter`] 
| 
| xref:llvm/ELFRelocationEntry.adoc[`ELFRelocationEntry`] 
| 
| xref:llvm/ETMDecoder.adoc[`ETMDecoder`] 
| 
| 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 provider, which computes and caches the earliest common dominator closure of all captures&period; It provides a good approximation to a precise &quot;captures before&quot; analysis&period;
| xref:llvm/EarlyCSEPass.adoc[`EarlyCSEPass`] 
| A simple and fast domtree&hyphen;based CSE pass&period;
| xref:llvm/EarlyIfConverterPass.adoc[`EarlyIfConverterPass`] 
| 
| xref:llvm/EarlyMachineLICMPass.adoc[`EarlyMachineLICMPass`] 
| 
| xref:llvm/EarlyTailDuplicatePass.adoc[`EarlyTailDuplicatePass`] 
| 
| xref:llvm/EdgeBundles.adoc[`EdgeBundles`] 
| 
| xref:llvm/EdgeBundlesAnalysis.adoc[`EdgeBundlesAnalysis`] 
| 
| xref:llvm/EdgeBundlesWrapperLegacy.adoc[`EdgeBundlesWrapperLegacy`] 
| 
| xref:llvm/ElementCount.adoc[`ElementCount`] 
| 
| xref:llvm/EliminateAvailableExternallyPass.adoc[`EliminateAvailableExternallyPass`] 
| A pass that transforms external global definitions into declarations&period;
| xref:llvm/EmbedBitcodeOptions.adoc[`EmbedBitcodeOptions`] 
| 
| 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`] 
| ReleaseModeModelRunner &hyphen; production mode implementation of the MLModelRunner&period; It uses an AOT&hyphen;compiled SavedModel for efficient execution&period;
| xref:llvm/EmitCModelRunner.adoc[`EmitCModelRunner`] 
| 
| xref:llvm/EmptyData.adoc[`EmptyData`] 
| 
| 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`] 
| 
| xref:llvm/EntryExitInstrumenterPass.adoc[`EntryExitInstrumenterPass`] 
| 
| 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; Only use for constexpr variables passed to BUILD&lowbar;ENUM&lowbar;STRINGS, do NOT access the created variable directly in code! The idea is that this is only used at compile&hyphen;time to build a more compact and relocation&hyphen;free representation in the binary&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`] 
| 
| xref:llvm/EnumeratedArray.adoc[`EnumeratedArray`] 
| Fixed&hyphen;size array indexed by values of a scoped enumeration&period;
| xref:llvm/EphemeralValuesAnalysis.adoc[`EphemeralValuesAnalysis`] 
| 
| 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 for the sole purpose of identifying the success path in the type system&period; This allows to catch invalid conversion to Expected&lt;T&gt; at compile time&period;
| xref:llvm/EscapeEnumerator.adoc[`EscapeEnumerator`] 
| EscapeEnumerator &hyphen; This is a little algorithm to find all escape points from a function so that &quot;finally&quot;&hyphen;style code can be inserted&period; In addition to finding the existing return and unwind instructions, it also (if necessary) transforms any call instructions into invokes and sends them to a landing pad&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`] 
| 
| 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`] 
| 
| xref:llvm/ExpandMemCmpPass.adoc[`ExpandMemCmpPass`] 
| 
| xref:llvm/ExpandPostRAPseudosPass.adoc[`ExpandPostRAPseudosPass`] 
| 
| xref:llvm/ExpandReductionsPass.adoc[`ExpandReductionsPass`] 
| 
| xref:llvm/ExpandVariadicsPass.adoc[`ExpandVariadicsPass`] 
| 
| 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`] 
| Used to describe addressing mode similar to ExtAddrMode in CodeGenPrepare&period; It holds the register values, the scale value and the displacement&period; It also holds a descriptor for the expression used to calculate the address from the operands&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`] 
| 
| xref:llvm/ExtraFunctionPassManager.adoc[`ExtraFunctionPassManager`] 
| A pass manager to run a set of extra function passes if the ShouldRunExtraPasses marker analysis is present&period; This allows passes to request additional transformations on demand&period; An example is extra simplifications after loop&hyphen;vectorization, if runtime checks have been added&period;
| xref:llvm/ExtraLoopPassManager.adoc[`ExtraLoopPassManager`] 
| A pass manager to run a set of extra loop passes if the MarkerTy analysis is present&period; This allows passes to request additional transformations on demand&period; An example is doing additional runs of SimpleLoopUnswitch&period;
| xref:llvm/ExtractElementInst.adoc[`ExtractElementInst`] 
| This instruction extracts a single (scalar) element from a VectorType value
| xref:llvm/ExtractGVPass.adoc[`ExtractGVPass`] 
| 
| xref:llvm/ExtractValueInst.adoc[`ExtractValueInst`] 
| This instruction extracts a struct member or array element value 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`] 
| This instruction compares its operands according to the predicate given to the constructor&period; It only operates on floating point values or packed vectors of floating point values&period; The operands must be identical types&period; Represents a floating point comparison operator&period;
| xref:llvm/FEntryInserterPass.adoc[`FEntryInserterPass`] 
| 
| 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 operators support fast&hyphen;math flags, users should not use this class directly, BinaryOperator can create instructions with correct type automatically&period;
| xref:llvm/FPExtInst.adoc[`FPExtInst`] 
| This class represents an extension of floating point types&period;
| xref:llvm/FPMathOperator.adoc[`FPMathOperator`] 
| Utility class for floating point operations which can have information about relaxed accuracy requirements attached to them&period;
| xref:llvm/FPPassManager.adoc[`FPPassManager`] 
| FPPassManager manages BBPassManagers and FunctionPasses&period; It batches all function passes and basic block pass managers together and sequence them to process one function at a time before processing next function&period;
| xref:llvm/FPStateAccessSDNode.adoc[`FPStateAccessSDNode`] 
| 
| xref:llvm/FPToSIInst.adoc[`FPToSIInst`] 
| This class represents a cast from floating point to signed integer&period;
| xref:llvm/FPToUIInst.adoc[`FPToUIInst`] 
| This class represents a cast from floating point to unsigned integer
| xref:llvm/FPTruncInst.adoc[`FPTruncInst`] 
| This class represents a truncation of floating point types&period;
| xref:llvm/FPUnaryOperator.adoc[`FPUnaryOperator`] 
| Unary operators support fast&hyphen;math flags, users should not use this class directly, Unary can create instructions with correct type automatically&period;
| xref:llvm/FPValueAndVReg.adoc[`FPValueAndVReg`] 
| 
| xref:llvm/FailureOr.adoc[`FailureOr`] 
| This class provides support for representing a failure result, or a valid value of type `T`&period; This allows for integrating with LogicalResult, while also providing a value on the success path&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`] 
| 
| xref:llvm/FaultMapParser.adoc[`FaultMapParser`] 
| A parser for the &lowbar;&lowbar;llvm&lowbar;faultmaps section generated by the FaultMaps class declared in llvm&sol;CodeGen&sol;FaultMaps&period;h&period; This parser is version locked with with the &lowbar;&lowbar;llvm&lowbar;faultmaps section generated by the version of LLVM that includes it&period; No guarantees are made with respect to forward or backward compatibility&period;
| xref:llvm/FaultMaps.adoc[`FaultMaps`] 
| 
| 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; 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/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; It encapsulates a caching function and the directory path where the cache is stored&period; To request an item from the cache, pass a unique string as the Key&period; For hits, the cached file will be added to the link and this function will return AddStreamFn()&period; For misses, the cache will return a stream callback which must be called at most once to produce content for the stream&period; The file stream produced by the stream callback will add the file to the link after the stream is written to&period; ModuleName is the unique module identifier for the bitcode module the cache is being checked for&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`] 
| 
| xref:llvm/FileCheckRequest.adoc[`FileCheckRequest`] 
| Contains info about various FileCheck options&period;
| xref:llvm/FileCheckString.adoc[`FileCheckString`] 
| 
| 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`] 
| 
| xref:llvm/FileCollectorFileSystem.adoc[`FileCollectorFileSystem`] 
| 
| 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`] 
| FileOutputBuffer &hyphen; This interface provides simple way to create an in&hyphen;memory buffer which will be written to a file&period; During the lifetime of these objects, the content or existence of the specified file is undefined&period; That is, creating an OutputBuffer for a file may immediately remove the file&period; If the FileOutputBuffer is committed, the target file&apos;s content will become the buffer content at the time of the commit&period; If the FileOutputBuffer is not committed, the file will be deleted in the FileOutputBuffer destructor&period;
| xref:llvm/FilePermissionsApplier.adoc[`FilePermissionsApplier`] 
| FilePermssionsApplier helps to copy permissions from an input file to an output one&period; It memorizes the status of the input file and can apply permissions and dates to the output file&period;
| xref:llvm/FileRemover.adoc[`FileRemover`] 
| FileRemover &hyphen; This class is a simple object meant to be stack allocated&period; If an exception is thrown from a region, the object removes the filename specified (if deleteIt is true)&period;
| xref:llvm/FinalizeBundleTestPass.adoc[`FinalizeBundleTestPass`] 
| 
| xref:llvm/FinalizeISelPass.adoc[`FinalizeISelPass`] 
| 
| 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`] 
| 
| xref:llvm/FixedNumOperandTraits-09b87.adoc[`FixedNumOperandTraits`] 
| FixedNumOperandTraits &hyphen; determine the allocation regime of the Use array when it is a prefix to the User object, and the number of Use objects is known at compile time&period;
| xref:llvm/FixedPointBuilder.adoc[`FixedPointBuilder`] 
| 
| xref:llvm/FixedPointSemantics.adoc[`FixedPointSemantics`] 
| The fixed point semantics work similarly to fltSemantics&period; The width specifies the whole bit width of the underlying scaled integer (with padding if any)&period; The scale represents the number of fractional bits in this type&period; When HasUnsignedPadding is true and this type is unsigned, the first bit in the value this represents is treated as padding&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`] 
| FixedStreamArray is similar to VarStreamArray, except with each record having a fixed&hyphen;length&period; As with VarStreamArray, there is no upfront cost associated with building or copying a FixedStreamArray, as the memory for each element is not read from the backing stream until that element is iterated&period;
| xref:llvm/FixedStreamArrayIterator.adoc[`FixedStreamArrayIterator`] 
| 
| xref:llvm/FixedVectorType.adoc[`FixedVectorType`] 
| Class to represent fixed width SIMD vectors
| xref:llvm/FixupStatepointCallerSavedPass.adoc[`FixupStatepointCallerSavedPass`] 
| 
| xref:llvm/FlagEntry.adoc[`FlagEntry`] 
| 
| xref:llvm/FlatIt.adoc[`FlatIt`] 
| Marker class to iterate over the elements of a Region in flat mode&period;
| xref:llvm/FlattenCFGPass.adoc[`FlattenCFGPass`] 
| 
| xref:llvm/Float2IntPass.adoc[`Float2IntPass`] 
| 
| 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`] 
| This class describes a reference to an interned FoldingSetNodeID, which can be a useful to store node id data rather than using plain FoldingSetNodeIDs, since the 32&hyphen;element SmallVector is often much larger than necessary, and the possibility of heap allocation means it requires a non&hyphen;trivial destructor call&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`] 
| This trait class is used to define behavior of how to &quot;profile&quot; (in the FoldingSet parlance) an object of a given type&period; The default behavior is to invoke a &apos;Profile&apos; method on an object, but through template specialization the behavior can be tailored for specific types&period; Combined with the FoldingSetNodeWrapper class, one can add objects to FoldingSets that were not originally designed to have that behavior&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`] 
| 
| xref:llvm/FormattedBytes.adoc[`FormattedBytes`] 
| 
| 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`] 
| Provides a cast trait that uses a defined pointer to pointer cast as a base for reference&hyphen;to&hyphen;reference casts&period; Note that it does not provide castFailed and doCastIfPossible because a pointer&hyphen;to&hyphen;pointer cast would likely just return `nullptr` which could cause nullptr dereference&period; You can use it like this&colon;
| 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`] 
| 
| xref:llvm/FreeDeleter.adoc[`FreeDeleter`] 
| Deleter that calls `free` on a pointer allocated with `malloc&period;`
| xref:llvm/FreeMachineFunctionPass.adoc[`FreeMachineFunctionPass`] 
| 
| xref:llvm/FreezeInst.adoc[`FreezeInst`] 
| This class represents a freeze function that returns random concrete value if an operand is either a poison value or an undef value
| xref:llvm/FullDependence.adoc[`FullDependence`] 
| FullDependence &hyphen; This class represents a dependence between two memory references in a function&period; It contains detailed information about the dependence (direction vectors, etc&period;) and is used when the compiler is able to accurately analyze the interaction of the references&semi; that is, it is not a confused dependence (see Dependence)&period; In most cases (for output, flow, and anti dependences), the dependence implies an ordering, where the source must precede the destination&semi; in contrast, input dependences are unordered&period;
| xref:llvm/FuncDataT-0a.adoc[`FuncDataT`] 
| 
| xref:llvm/FuncletLayoutPass.adoc[`FuncletLayoutPass`] 
| 
| xref:llvm/FuncletPadInst.adoc[`FuncletPadInst`] 
| 
| xref:llvm/Function.adoc[`Function`] 
| 
| xref:llvm/FunctionAnalysisManagerCGSCCProxy.adoc[`FunctionAnalysisManagerCGSCCProxy`] 
| A proxy from a `FunctionAnalysisManager` to an `SCC&period;`
| xref:llvm/FunctionAnalysisManagerMachineFunctionProxy.adoc[`FunctionAnalysisManagerMachineFunctionProxy`] 
| 
| xref:llvm/FunctionCallee.adoc[`FunctionCallee`] 
| A handy container for a FunctionType&plus;Callee&hyphen;pointer pair, which can be passed around as a single entity&period; This assists in replacing the use of PointerType&colon;&colon;getElementType() to access the function&apos;s type, since that&apos;s slated for removal as part of the &lsqb;opaque pointer types&rsqb;project&period;
| xref:llvm/FunctionComparator.adoc[`FunctionComparator`] 
| FunctionComparator &hyphen; Compares two functions to determine whether or not&period;
| xref:llvm/FunctionHashInfo.adoc[`FunctionHashInfo`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/FunctionPropertiesInfo.adoc[`FunctionPropertiesInfo`] 
| 
| 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`] 
| Correctly update FunctionPropertiesInfo post&hyphen;inlining&period; A FunctionPropertiesUpdater keeps the state necessary for tracking the changes llvm&colon;&colon;InlineFunction makes&period; The idea is that inlining will at most modify a few BBs of the Caller (maybe the entry BB and definitely the callsite BB) and potentially affect exception handling BBs in the case of invoke inlining&period;
| xref:llvm/FunctionSpecializer.adoc[`FunctionSpecializer`] 
| 
| 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`] 
| 
| xref:llvm/FunctionType.adoc[`FunctionType`] 
| Class to represent function types
| xref:llvm/FunctionVarLocs.adoc[`FunctionVarLocs`] 
| Data structure describing the variable locations in a function&period; Used as the result of the AssignmentTrackingAnalysis pass&period; Essentially read&hyphen;only outside of AssignmentTrackingAnalysis where it is built&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; Only carry&hyphen;out&colon; G&lowbar;UADDO, G&lowbar;SADDO, G&lowbar;USUBO, G&lowbar;SSUBO, G&lowbar;UMULO, G&lowbar;SMULO Carry&hyphen;in and carry&hyphen;out&colon; G&lowbar;UADDE, G&lowbar;SADDE, G&lowbar;USUBE, G&lowbar;SSUBE
| 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`] 
| 
| xref:llvm/GCFunctionAnalysis.adoc[`GCFunctionAnalysis`] 
| An analysis pass which caches information about the Function&period; Records the function level information used by GCRoots&period; This pass depends on `CollectorMetadataAnalysis`&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`] 
| LowerIntrinsics &hyphen; This pass rewrites calls to the llvm&period;gcread or llvm&period;gcwrite intrinsics, replacing them with simple loads and stores as directed by the GCStrategy&period; It also performs automatic root initialization and custom intrinsic lowering&period;
| xref:llvm/GCMetadataPrinter.adoc[`GCMetadataPrinter`] 
| GCMetadataPrinter &hyphen; Emits GC metadata as assembly code&period; Instances are created, managed, and owned by the AsmPrinter&period;
| xref:llvm/GCModuleInfo.adoc[`GCModuleInfo`] 
| An analysis pass which caches information about the entire Module&period; Records both the function level information used by GCRoots and a cache of the &apos;active&apos; gc strategy objects for the current Module&period;
| xref:llvm/GCOVArc.adoc[`GCOVArc`] 
| 
| 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`] 
| 
| 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`] 
| GCStrategy describes a garbage collector algorithm&apos;s code generation requirements, and provides overridable hooks for those needs which cannot be abstractly described&period; GCStrategy objects must be looked up through the Function&period; The objects themselves are owned by the Context and must be immutable&period;
| xref:llvm/GCStrategyMap.adoc[`GCStrategyMap`] 
| 
| 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 flags for the getelementptr instruction&sol;expression&period; The following flags are supported&colon; &ast; inbounds (implies nusw) &ast; nusw (no unsigned signed wrap) &ast; nuw (no unsigned wrap) See LangRef for a description of their semantics&period;
| xref:llvm/GEPOperator.adoc[`GEPOperator`] 
| 
| 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`] 
| Provides the logic to execute GlobalISel match tables, which are used by the instruction selector and instruction combiners as their engine to match and apply MIR patterns&period;
| xref:llvm/GISelCSEAnalysis.adoc[`GISelCSEAnalysis`] 
| 
| xref:llvm/GISelCSEAnalysisWrapper.adoc[`GISelCSEAnalysisWrapper`] 
| Simple wrapper that does the following&period; 1) Lazily evaluate the MachineFunction to compute CSEable instructions&period; 2) Allows configuration of which instructions are CSEd through CSEConfig object&period; Provides a method called get which takes a CSEConfig object&period;
| xref:llvm/GISelCSEAnalysisWrapperPass.adoc[`GISelCSEAnalysisWrapperPass`] 
| The actual analysis pass wrapper&period;
| xref:llvm/GISelCSEInfo.adoc[`GISelCSEInfo`] 
| The CSE Analysis object&period; This installs itself as a delegate to the MachineFunction to track new instructions as well as deletions&period; It however will not be able to track instruction mutations&period; In such cases, recordNewInstruction should be called (for eg inside MachineIRBuilder&colon;&colon;recordInsertion)&period; Also because of how just the instruction can be inserted without adding any operands to the instruction, instructions are uniqued and inserted lazily&period; CSEInfo should assert when trying to enter an incomplete instruction into the CSEMap&period; There is Opcode level granularity on which instructions can be CSE&apos;d and for now, only Generic instructions are CSEable&period;
| xref:llvm/GISelChangeObserver.adoc[`GISelChangeObserver`] 
| Abstract class that contains various methods for clients to notify about changes&period; This should be the preferred way for APIs to notify changes&period; Typically calling erasingInstr&sol;createdInstr multiple times should not affect the result&period; The observer would likely need to check if it was already notified earlier (consider using GISelWorkList)&period;
| xref:llvm/GISelInstProfileBuilder.adoc[`GISelInstProfileBuilder`] 
| 
| xref:llvm/GISelObserverWrapper.adoc[`GISelObserverWrapper`] 
| Simple wrapper observer that takes several observers, and calls each one for each event&period; If there are multiple observers (say CSE, Legalizer, Combiner), it&apos;s sufficient to register this to the machine function as the delegate&period;
| xref:llvm/GISelValueTracking.adoc[`GISelValueTracking`] 
| 
| xref:llvm/GISelValueTrackingAnalysis.adoc[`GISelValueTrackingAnalysis`] 
| 
| xref:llvm/GISelValueTrackingAnalysisLegacy.adoc[`GISelValueTrackingAnalysisLegacy`] 
| Eventually add other features such as caching&sol;ser&sol;deserializing to MIR etc&period; Those implementations can derive from GISelValueTracking and override computeKnownBitsImpl&period;
| xref:llvm/GISelValueTrackingPrinterPass.adoc[`GISelValueTrackingPrinterPass`] 
| 
| xref:llvm/GISelWorkList.adoc[`GISelWorkList`] 
| 
| 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; These are different enough from regular loads that they get their own class&period; Including them in GAnyLoad would probably make a footgun for someone&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`] 
| 
| xref:llvm/GOFFRelocationEntry.adoc[`GOFFRelocationEntry`] 
| 
| 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`] 
| 
| xref:llvm/GUnmerge.adoc[`GUnmerge`] 
| Represents a G&lowbar;UNMERGE&lowbar;VALUES&period;
| xref:llvm/GVMaterializer.adoc[`GVMaterializer`] 
| 
| xref:llvm/GVNHoist.adoc[`GVNHoist`] 
| 
| 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`] 
| 
| xref:llvm/GVNOptions.adoc[`GVNOptions`] 
| true &hyphen; enabling the transformation&period; false &hyphen; disabling the transformation&period; None &hyphen; relying on a global default&period; Intended use is to create a default object, modify parameters with additional setters and then pass it to GVN&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`] 
| 
| 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`] 
| 
| xref:llvm/GenericFloatingPointPredicateUtils.adoc[`GenericFloatingPointPredicateUtils`] 
| 
| 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&period; This class maintains information about scheduling candidates based on TargetSchedModel making it easy to implement heuristics for either preRA or postRA scheduling&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-023.adoc[`GenericUniformityInfo`] 
| Computes which values and terminators are uniform vs divergent in a function&period;
| xref:llvm/GenericValue.adoc[`GenericValue`] 
| 
| 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`] 
| This class implements a glob pattern matcher similar to the one found in bash, but with some key differences&period; Namely, that `&ast;` matches all characters and does not exclude path separators&period;
| xref:llvm/GlobalAddressSDNode.adoc[`GlobalAddressSDNode`] 
| 
| xref:llvm/GlobalAlias.adoc[`GlobalAlias`] 
| 
| xref:llvm/GlobalDCEPass.adoc[`GlobalDCEPass`] 
| Pass to remove unused function declarations&period;
| xref:llvm/GlobalIFunc.adoc[`GlobalIFunc`] 
| 
| xref:llvm/GlobalMergeFunc.adoc[`GlobalMergeFunc`] 
| GlobalMergeFunc is a ModulePass that implements a function merging mechanism using stable function hashes&period; It identifies and merges functions with matching hashes across modules to optimize binary size&period;
| xref:llvm/GlobalMergeFuncPass.adoc[`GlobalMergeFuncPass`] 
| Global function merging pass for new pass manager&period;
| xref:llvm/GlobalMergeOptions.adoc[`GlobalMergeOptions`] 
| 
| xref:llvm/GlobalMergePass.adoc[`GlobalMergePass`] 
| 
| xref:llvm/GlobalNumberState.adoc[`GlobalNumberState`] 
| GlobalNumberState assigns an integer to each global value in the program, which is used by the comparison routine to order references to globals&period; This state must be preserved throughout the pass, because Functions and other globals need to maintain their relative order&period; Globals are assigned a number when they are first visited&period; This order is deterministic, and so the assigned numbers are as well&period; When two functions are merged, neither number is updated&period; If the symbols are weak, this would be incorrect&period; If they are strong, then one will be replaced at all references to the other, and so direct callsites will now see one or the other symbol, and no update is necessary&period; Note that if we were guaranteed unique names, we could just compare those, but this would not work for stripped bitcodes or for those few symbols without a name&period;
| xref:llvm/GlobalObject.adoc[`GlobalObject`] 
| 
| 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`] 
| As we analyze each global or thread&hyphen;local variable, keep track of some information about it&period; If we find out that the address of the global is taken, none of this info will be accurate&period;
| xref:llvm/GlobalValue.adoc[`GlobalValue`] 
| 
| 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`] 
| 
| xref:llvm/GlobalValueSummaryMap.adoc[`GlobalValueSummaryMap`] 
| Map from global value GUID to corresponding summary structures&period; Use a DenseMap for O(1) lookup and a std&colon;&colon;deque for storage&period; std&colon;&colon;deque guarantees that pointers to elements are not invalidated by push&lowbar;back, which is required because ValueInfo stores a raw pointer to elements of this container&period;
| xref:llvm/GlobalVarSummary.adoc[`GlobalVarSummary`] 
| Global variable summary information to aid decisions and implementation of importing&period;
| xref:llvm/GlobalVariable.adoc[`GlobalVariable`] 
| 
| 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`] 
| 
| xref:llvm/GraphTraits-061.adoc[`GraphTraits`] 
| Traits for traversing a graph type without copying it&period;
| xref:llvm/GraphWriter.adoc[`GraphWriter`] 
| 
| xref:llvm/GraphWriterBase.adoc[`GraphWriterBase`] 
| 
| xref:llvm/GuardWideningPass.adoc[`GuardWideningPass`] 
| 
| 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`] 
| 
| xref:llvm/HTTPResponseHandler.adoc[`HTTPResponseHandler`] 
| A handler for state updates occurring while an HTTPRequest is performed&period; Can trigger the client to abort the request by returning an Error from any of its methods&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`] 
| 
| xref:llvm/HTTPServerRequest.adoc[`HTTPServerRequest`] 
| 
| xref:llvm/HWAddressSanitizerOptions.adoc[`HWAddressSanitizerOptions`] 
| 
| xref:llvm/HWAddressSanitizerPass.adoc[`HWAddressSanitizerPass`] 
| This is a public interface to the hardware address sanitizer&period;
| xref:llvm/HandleSDNode.adoc[`HandleSDNode`] 
| This class is used to form a handle around another node that is persistent and is updated across invocations of replaceAllUsesWith on its operand&period; This node should be directly created by end&hyphen;users and not added to the AllNodes list&period;
| xref:llvm/HardwareLoopInfo.adoc[`HardwareLoopInfo`] 
| Attributes of a target dependent hardware loop&period;
| xref:llvm/HardwareLoopOptions.adoc[`HardwareLoopOptions`] 
| 
| xref:llvm/HardwareLoopsPass.adoc[`HardwareLoopsPass`] 
| 
| 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`] 
| A HashNode is an entry in an OutlinedHashTree, holding a hash value and a collection of Successors (other HashNodes)&period; If a HashNode has a positive terminal value (Terminals &gt; 0), it signifies the end of a hash sequence with that occurrence count&period;
| xref:llvm/HashNodeStable.adoc[`HashNodeStable`] 
| HashNodeStable is the serialized, stable, and compact representation of a HashNode&period;
| xref:llvm/HashRecognize.adoc[`HashRecognize`] 
| The analysis&period;
| xref:llvm/HashRecognizePrinterPass.adoc[`HashRecognizePrinterPass`] 
| 
| xref:llvm/HelloWorldPass.adoc[`HelloWorldPass`] 
| 
| xref:llvm/HexNumber.adoc[`HexNumber`] 
| 
| xref:llvm/HexagonAttributeParser.adoc[`HexagonAttributeParser`] 
| 
| xref:llvm/HipStdParAcceleratorCodeSelectionPass.adoc[`HipStdParAcceleratorCodeSelectionPass`] 
| 
| xref:llvm/HipStdParAllocationInterpositionPass.adoc[`HipStdParAllocationInterpositionPass`] 
| 
| xref:llvm/HipStdParMathFixupPass.adoc[`HipStdParMathFixupPass`] 
| 
| xref:llvm/HistogramInfo.adoc[`HistogramInfo`] 
| This holds details about a histogram operation &hyphen;&hyphen; a load &hyphen;&gt; update &hyphen;&gt; store sequence where each lane in a vector might be updating the same element as another lane&period;
| xref:llvm/HotColdSplitting.adoc[`HotColdSplitting`] 
| 
| 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`] 
| This implementation of LoopSafetyInfo use ImplicitControlFlowTracking to give precise answers on &quot;may throw&quot; queries&period; This implementation uses cache that should be invalidated by calling the methods insertInstructionTo and removeInstruction whenever we modify a basic block&apos;s contents by adding or removing instructions&period;
| xref:llvm/ICallPromotionAnalysis.adoc[`ICallPromotionAnalysis`] 
| 
| xref:llvm/ICmpInst.adoc[`ICmpInst`] 
| This instruction compares its operands according to the predicate given to the constructor&period; It only operates on integers or pointers&period; The operands must be identical types&period; Represent an integer comparison operator&period;
| xref:llvm/IDFCalculator.adoc[`IDFCalculator`] 
| 
| 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`] 
| This analysis provides the vocabulary for IR2Vec&period; The vocabulary provides a mapping between an entity of the IR (like opcode, type, argument, etc&period;) and its corresponding embedding&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`] 
| This provides a uniform API for creating instructions and inserting them into a basic block&colon; either at the end of a BasicBlock, or at a specific iterator location in a block&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`] 
| This provides the default implementation of the IRBuilder &apos;InsertHelper&apos; method that is called whenever an instruction is created by IRBuilder and needs to be inserted&period;
| xref:llvm/IRBuilderFolder.adoc[`IRBuilderFolder`] 
| IRBuilderFolder &hyphen; Interface for constant folding in IRBuilder&period;
| xref:llvm/IRCEPass.adoc[`IRCEPass`] 
| 
| xref:llvm/IRChangedPrinter.adoc[`IRChangedPrinter`] 
| 
| xref:llvm/IRChangedTester.adoc[`IRChangedTester`] 
| 
| xref:llvm/IRComparer-0a.adoc[`IRComparer`] 
| 
| xref:llvm/IRDataT-01.adoc[`IRDataT`] 
| 
| xref:llvm/IRMover.adoc[`IRMover`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/IRTranslatorLegacy.adoc[`IRTranslatorLegacy`] 
| 
| xref:llvm/IRTranslatorPass.adoc[`IRTranslatorPass`] 
| 
| 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`] 
| IVStrideUse &hyphen; Keep track of one use of a strided induction variable&period; The Expr member keeps track of the expression, User is the actual user instruction of the operand, and &apos;OperandValToReplace&apos; is the operand of the User that is the use&period;
| xref:llvm/IVUsers.adoc[`IVUsers`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/IfDefGuardEmitter.adoc[`IfDefGuardEmitter`] 
| 
| xref:llvm/IfGuardEmitter.adoc[`IfGuardEmitter`] 
| 
| xref:llvm/IfGuardEmitterBase.adoc[`IfGuardEmitterBase`] 
| 
| xref:llvm/IfNDefGuardEmitter.adoc[`IfNDefGuardEmitter`] 
| 
| xref:llvm/ImmutableList.adoc[`ImmutableList`] 
| This class represents an immutable (functional) list&period; It is implemented as a smart pointer (wraps ImmutableListImpl), so it is intended to always be copied by value as if it were a pointer&period; This interface matches ImmutableSet and ImmutableMap&period; ImmutableList objects should almost never be created directly, and instead should be created by ImmutableListFactory objects that manage the lifetime of a group of lists&period; When the factory object is reclaimed, all lists created by that factory are released as well&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`] 
| This class allows to keep track on instructions with implicit control flow&period; These are instructions that may not pass execution to their successors&period; For example, throwing calls and guards do not always do this&period; If we need to know for sure that some instruction is guaranteed to execute if the given block is reached, then we need to make sure that there is no implicit control flow instruction (ICFI) preceding it&period; For example, this check is required if we perform PRE moving non&hyphen;speculable instruction to other place&period;
| xref:llvm/ImplicitNullChecksPass.adoc[`ImplicitNullChecksPass`] 
| 
| xref:llvm/ImportedFunctionsInliningStatistics.adoc[`ImportedFunctionsInliningStatistics`] 
| Calculate and dump ThinLTO specific inliner stats&period; The main statistics are&colon; (1) Number of inlined imported functions, (2) Number of imported functions inlined into importing module (indirect), (3) Number of non imported functions inlined into importing module (indirect)&period; The difference between first and the second is that first stat counts all performed inlines on imported functions, but the second one only the functions that have been eventually inlined to a function in the importing module (by a chain of inlines)&period; Because llvm uses bottom&hyphen;up inliner, it is possible to e&period;g&period; import function `A`, `B` and then inline `B` to `A`, and after this `A` might be too big to be inlined into some other function that calls it&period; It calculates this statistic by building graph, where the nodes are functions, and edges are performed inlines and then by marking the edges starting from not imported function&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`] 
| Generic definition of comparison operations for elements of immutable containers that defaults to using std&colon;&colon;equal&lowbar;to&lt;&gt; and std&colon;&colon;less&lt;&gt; to perform comparison of elements&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; While both the first and second elements in a pair are used to generate profile information, only the first element (the key) is used by isEqual and isLess&period;
| xref:llvm/ImutProfileInfo-01a.adoc[`ImutProfileInfo`] 
| Generic profile template&period; The default behavior is to invoke the profile method of an object&period; Specializations for primitive integers and generic handling of pointers is done below&period;
| xref:llvm/ImutProfileInteger-0a1.adoc[`ImutProfileInteger`] 
| Profile traits for integers&period;
| xref:llvm/InLineChangePrinter.adoc[`InLineChangePrinter`] 
| 
| 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`] 
| 
| xref:llvm/IndVarSimplifyPass.adoc[`IndVarSimplifyPass`] 
| 
| xref:llvm/IndexListEntry.adoc[`IndexListEntry`] 
| This class represents an entry in the slot index list held in the SlotIndexes pass&period; It should not be used directly&period; See the SlotIndex &amp; SlotIndexes classes for the public interface to this information&period;
| xref:llvm/IndexedCodeGenDataReader.adoc[`IndexedCodeGenDataReader`] 
| 
| xref:llvm/IndexedInstrProfReader.adoc[`IndexedInstrProfReader`] 
| Reader for the indexed binary instrprof format&period;
| xref:llvm/IndexedLoadStoreMatchInfo.adoc[`IndexedLoadStoreMatchInfo`] 
| 
| 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`] 
| 
| xref:llvm/IndexedReference.adoc[`IndexedReference`] 
| Represents a memory reference as a base pointer and a set of indexing operations&period; For example given the array reference A&lsqb;i&rsqb;&lsqb;2j&plus;1&rsqb;&lsqb;3k&plus;2&rsqb;in a 3&hyphen;dim loop nest&colon; for(i&equals;0&semi;i&lt;n&semi;&plus;&plus;i) for(j&equals;0&semi;j&lt;m&semi;&plus;&plus;j) for(k&equals;0&semi;k&lt;o&semi;&plus;&plus;k) &period;&period;&period; A&lsqb;i&rsqb;&lsqb;2j&plus;1&rsqb;&lsqb;3k&plus;2&rsqb;&period;&period;&period; We expect&colon; BasePointer &hyphen;&gt; A Subscripts &hyphen;&gt; &lsqb;&lcub;0,&plus;,1&rcub;&lt;%for&period;i&gt;&rsqb;&lsqb;&lcub;1,&plus;,2&rcub;&lt;%for&period;j&gt;&rsqb;&lsqb;&lcub;2,&plus;,3&rcub;&lt;%for&period;k&gt;&rsqb; Sizes &hyphen;&gt; &lsqb;m&rsqb;&lsqb;o&rsqb;&lsqb;4&rsqb;
| xref:llvm/IndirectBrExpandPass.adoc[`IndirectBrExpandPass`] 
| 
| 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`] 
| 
| xref:llvm/InferAlignmentPass.adoc[`InferAlignmentPass`] 
| 
| 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`] 
| 
| xref:llvm/InformationCache.adoc[`InformationCache`] 
| Data structure to hold cached (LLVM&hyphen;IR) information&period;
| xref:llvm/Init.adoc[`Init`] 
| 
| xref:llvm/InitLLVM.adoc[`InitLLVM`] 
| 
| xref:llvm/InitUndefPass.adoc[`InitUndefPass`] 
| 
| xref:llvm/InjectTLIMappings.adoc[`InjectTLIMappings`] 
| 
| xref:llvm/InjectorIRStrategy.adoc[`InjectorIRStrategy`] 
| Strategy that injects operations into the function&period;
| xref:llvm/InlineAdvice.adoc[`InlineAdvice`] 
| Capture state between an inlining decision having had been made, and its impact being observable&period; When collecting model training data, this allows recording features&sol;decisions&sol;partial reward data sets&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`] 
| 
| xref:llvm/InlineAsmIdentifierInfo.adoc[`InlineAsmIdentifierInfo`] 
| 
| xref:llvm/InlineAsmKeyType.adoc[`InlineAsmKeyType`] 
| 
| xref:llvm/InlineAsmLowering.adoc[`InlineAsmLowering`] 
| 
| xref:llvm/InlineAsmPreparePass.adoc[`InlineAsmPreparePass`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/InlineParams.adoc[`InlineParams`] 
| Thresholds to tune inline cost analysis&period; The inline cost analysis decides the condition to apply a threshold and applies it&period; Otherwise, DefaultThreshold is used&period; If a threshold is Optional, it is applied only when it has a valid value&period; Typically, users of inline cost analysis obtain an InlineParams object through one of the `getInlineParams` methods and pass it to `getInlineCost&period;` Some specialized versions of inliner (such as the pre&hyphen;inliner) might have custom logic to compute `InlineParams` object&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`] 
| An analysis over an &quot;outer&quot; IR unit that provides access to an analysis manager over an &quot;inner&quot; IR unit&period; The inner unit must be contained in the outer 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`] 
| This instruction inserts a single (scalar) element into a VectorType value
| 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`] 
| 
| xref:llvm/InsertValueInst.adoc[`InsertValueInst`] 
| This instruction inserts a struct field of array element value into an aggregate value&period;
| xref:llvm/InstCombineOptions.adoc[`InstCombineOptions`] 
| 
| xref:llvm/InstCombinePass.adoc[`InstCombinePass`] 
| 
| xref:llvm/InstCombiner.adoc[`InstCombiner`] 
| The core instruction combiner logic&period;
| xref:llvm/InstCostVisitor.adoc[`InstCostVisitor`] 
| 
| xref:llvm/InstCountPass.adoc[`InstCountPass`] 
| 
| xref:llvm/InstDeleterIRStrategy.adoc[`InstDeleterIRStrategy`] 
| Strategy that deletes instructions when the Module is too large&period;
| xref:llvm/InstIterator.adoc[`InstIterator`] 
| 
| xref:llvm/InstModificationIRStrategy.adoc[`InstModificationIRStrategy`] 
| Strategy that modifies instruction attributes and operands&period;
| xref:llvm/InstSimplifyFolder.adoc[`InstSimplifyFolder`] 
| InstSimplifyFolder &hyphen; Use InstructionSimplify to fold operations to existing values&period; Also applies target&hyphen;specific constant folding when not using 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`] 
| !instances&lt;type&gt;(&lsqb;regex&rsqb;) &hyphen; Produces a list of records whose type is `type`&period; If `regex` is provided, only records whose name matches the regular expression `regex` will be included&period;
| xref:llvm/InstrInfoQuery.adoc[`InstrInfoQuery`] 
| InstrInfoQuery provides an interface to query additional information for instructions like metadata or keywords like nsw, which provides conservative results if the users specified it is safe to use&period;
| xref:llvm/InstrItinerary.adoc[`InstrItinerary`] 
| An itinerary represents the scheduling information for an instruction&period; This includes a set of stages occupied by the instruction and the pipeline cycle in which operands are read and written&period;
| xref:llvm/InstrItineraryData.adoc[`InstrItineraryData`] 
| Itinerary data supplied by a subtarget to be used by a target&period;
| xref:llvm/InstrProfCallsite.adoc[`InstrProfCallsite`] 
| This represents the llvm&period;instrprof&period;callsite intrinsic&period; It is structurally like the increment or step counters, hence the inheritance relationship, albeit somewhat tenuous (it&apos;s not &apos;counting&apos; per se)
| 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`] 
| 
| 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`] 
| 
| xref:llvm/InstrProfReaderIndexBase.adoc[`InstrProfReaderIndexBase`] 
| 
| xref:llvm/InstrProfReaderItaniumRemapper.adoc[`InstrProfReaderItaniumRemapper`] 
| 
| 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`] 
| Writer for instrumentation based profile data&period;
| xref:llvm/InstrProfSummaryBuilder.adoc[`InstrProfSummaryBuilder`] 
| 
| xref:llvm/InstrProfSymtab.adoc[`InstrProfSymtab`] 
| A symbol table used for function &lsqb;IR&rsqb;PGO name look&hyphen;up with keys (such as pointers, md5hash values) to the function&period; A function&apos;s &lsqb;IR&rsqb;PGO name or name&apos;s md5hash are used in retrieving the profile data of the function&period; See `getIRPGOFuncName()` and `getPGOFuncName` methods for details how &lsqb;IR&rsqb;PGO name is formed&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`] 
| 
| xref:llvm/InstrProfWriter.adoc[`InstrProfWriter`] 
| 
| 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`] 
| These values represent a non&hyphen;pipelined step in the execution of an instruction&period; Cycles represents the number of discrete time slots needed to complete the stage&period; Units represent the choice of functional units that can be used to complete the stage&period; Eg&period; IntUnit1, IntUnit2&period; NextCycles indicates how many cycles should elapse from the start of this stage to the start of the next stage in the itinerary&period; A value of &hyphen;1 indicates that the next stage should start immediately after the current one&period; For example&colon;
| xref:llvm/Instruction.adoc[`Instruction`] 
| 
| xref:llvm/InstructionBuildSteps.adoc[`InstructionBuildSteps`] 
| 
| xref:llvm/InstructionCombiningPass.adoc[`InstructionCombiningPass`] 
| The legacy pass manager&apos;s instcombine pass&period;
| xref:llvm/InstructionCost.adoc[`InstructionCost`] 
| 
| xref:llvm/InstructionNamerPass.adoc[`InstructionNamerPass`] 
| 
| xref:llvm/InstructionOrdering.adoc[`InstructionOrdering`] 
| Record instruction ordering so we can query their relative positions within a function&period; Meta instructions are given the same ordinal as the preceding non&hyphen;meta instruction&period; Class state is invalid if MF is modified after calling initialize&period;
| xref:llvm/InstructionPrecedenceTracking.adoc[`InstructionPrecedenceTracking`] 
| 
| xref:llvm/InstructionSelectImpl.adoc[`InstructionSelectImpl`] 
| 
| xref:llvm/InstructionSelectLegacy.adoc[`InstructionSelectLegacy`] 
| This pass is responsible for selecting generic machine instructions to target&hyphen;specific instructions&period; It relies on the InstructionSelector provided by the target&period; Selection is done by examining blocks in post&hyphen;order, and instructions in reverse order&period;
| xref:llvm/InstructionSelectPass.adoc[`InstructionSelectPass`] 
| 
| xref:llvm/InstructionSelector.adoc[`InstructionSelector`] 
| 
| xref:llvm/InstructionStepsMatchInfo.adoc[`InstructionStepsMatchInfo`] 
| 
| 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`] 
| 
| 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`] 
| This class represents a cast from 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; Note that this class is also used to represent the built&hyphen;in integer types&colon; Int1Ty, Int8Ty, Int16Ty, Int32Ty and Int64Ty&period; Integer representation type
| xref:llvm/IntelExpr.adoc[`IntelExpr`] 
| 
| xref:llvm/IntelJITEventsWrapper.adoc[`IntelJITEventsWrapper`] 
| 
| xref:llvm/InteractiveModelRunner.adoc[`InteractiveModelRunner`] 
| A MLModelRunner that asks for advice from an external agent, or host&period; It uses 2 files &hyphen; ideally named pipes &hyphen; one to send data to that agent, and one to receive advice&period; The data exchange uses the training logger (Utils&sol;TrainingLogger&period;h) format&period; Specifically, the compiler will send the log header, set the context, and send observations&semi; the host is expected to reply with a tensor value after each observation as a binary buffer that&apos;s conforming to the shape of the advice&period; Interleaved, the data closely resembles the training log for a log where we don&apos;t capture the reward signal&period;
| xref:llvm/InterestingMemoryOperand.adoc[`InterestingMemoryOperand`] 
| 
| 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`] 
| 
| xref:llvm/InterleavedLoadCombinePass.adoc[`InterleavedLoadCombinePass`] 
| 
| xref:llvm/InterleavedRange.adoc[`InterleavedRange`] 
| Format object class for interleaved ranges&period; Supports specifying the separator and, optionally, the prefix and suffix to be printed surrounding the range&period; Uses the operator &apos;&lt;&lt;&apos; of the range element type for printing&period; The range type itself does not have to have an &apos;&lt;&lt;&apos; operator defined&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`] 
| An interval data composed by a _Left_ and _Right_ points and an associated _Value&period;_ _PointT_ corresponds to the interval endpoints type&period; _ValueT_ corresponds to the interval value type&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`] 
| IntervalMapOverlaps &hyphen; Iterate over the overlaps of mapped intervals in two IntervalMaps&period; The maps may be different, but the KeyT and Traits types should be the same&period;
| xref:llvm/IntervalPressure.adoc[`IntervalPressure`] 
| RegisterPressure computed within a region of instructions delimited by TopIdx and BottomIdx&period; During pressure computation, the maximum pressure per register pressure set is increased&period; Once pressure within a region is fully computed, the live&hyphen;in and live&hyphen;out sets are recorded&period;
| xref:llvm/IntervalTree-08.adoc[`IntervalTree`] 
| Interval tree that stores closed intervals and answers point queries&period;
| xref:llvm/IntrinsicCostAttributes.adoc[`IntrinsicCostAttributes`] 
| 
| 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`] 
| 
| xref:llvm/IntrusiveBackList-0bf.adoc[`IntrusiveBackList`] 
| 
| xref:llvm/IntrusiveBackListBase.adoc[`IntrusiveBackListBase`] 
| 
| xref:llvm/IntrusiveBackListNode.adoc[`IntrusiveBackListNode`] 
| 
| 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`] 
| Invoke instruction&period; The SubclassData field is used to hold the calling convention of the call&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`] 
| &quot;Partial&quot; demangler&period; This supports demangling a string into an AST (typically an intermediate stage in itaniumDemangle) and querying certain properties or partially printing the demangled name&period;
| xref:llvm/JITEvaluatedSymbol.adoc[`JITEvaluatedSymbol`] 
| Represents a symbol that has been evaluated to an address already&period;
| xref:llvm/JITEventListener.adoc[`JITEventListener`] 
| JITEventListener &hyphen; Abstract interface for use by the JIT to notify clients about significant events during compilation&period; For example, to notify profilers and debuggers that need to know where functions have been emitted&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`] 
| 
| xref:llvm/JSONScopedPrinter.adoc[`JSONScopedPrinter`] 
| 
| xref:llvm/JamCRC.adoc[`JamCRC`] 
| 
| 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`] 
| 
| xref:llvm/JumpTableSDNode.adoc[`JumpTableSDNode`] 
| 
| xref:llvm/JumpTableToSwitchPass.adoc[`JumpTableToSwitchPass`] 
| 
| xref:llvm/JumpThreadingPass.adoc[`JumpThreadingPass`] 
| This pass performs &apos;jump threading&apos;, which looks at blocks that have multiple predecessors and multiple successors&period; If one or more of the predecessors of the block can be proven to always jump to one of the successors, we forward the edge from the predecessor to the successor by duplicating the contents of this block&period;
| xref:llvm/KCFIPass.adoc[`KCFIPass`] 
| 
| xref:llvm/KernelInfoPrinter.adoc[`KernelInfoPrinter`] 
| 
| 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`] 
| 
| xref:llvm/KnownFPClass.adoc[`KnownFPClass`] 
| 
| xref:llvm/LCSSAPass.adoc[`LCSSAPass`] 
| Converts loops into loop&hyphen;closed SSA form&period;
| xref:llvm/LCSSAVerificationPass.adoc[`LCSSAVerificationPass`] 
| 
| xref:llvm/LICMOptions.adoc[`LICMOptions`] 
| 
| xref:llvm/LICMPass.adoc[`LICMPass`] 
| Performs Loop Invariant Code Motion Pass&period;
| xref:llvm/LLLexer.adoc[`LLLexer`] 
| 
| xref:llvm/LLParser.adoc[`LLParser`] 
| 
| xref:llvm/LLT.adoc[`LLT`] 
| 
| 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`] 
| 
| xref:llvm/LLVMRemarkFileHandle.adoc[`LLVMRemarkFileHandle`] 
| RAII handle that manages the lifetime of the ToolOutputFile used to output remarks&period; On destruction (or when calling releaseFile()), this handle ensures that the optimization remarks are finalized and the RemarkStreamer is correctly deregistered from the LLVMContext&period;
| xref:llvm/LLVMRemarkSetupErrorInfo-00.adoc[`LLVMRemarkSetupErrorInfo`] 
| 
| xref:llvm/LLVMRemarkSetupFileError.adoc[`LLVMRemarkSetupFileError`] 
| 
| xref:llvm/LLVMRemarkSetupFormatError.adoc[`LLVMRemarkSetupFormatError`] 
| 
| xref:llvm/LLVMRemarkSetupPatternError.adoc[`LLVMRemarkSetupPatternError`] 
| 
| xref:llvm/LLVMRemarkStreamer.adoc[`LLVMRemarkStreamer`] 
| Streamer for LLVM remarks which has logic for dealing with DiagnosticInfo objects&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`] 
| 
| xref:llvm/LSBaseSDNode.adoc[`LSBaseSDNode`] 
| Base class for LoadSDNode and StoreSDNode
| xref:llvm/LShrOperator.adoc[`LShrOperator`] 
| 
| 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`] 
| 
| xref:llvm/LandingPadInfo.adoc[`LandingPadInfo`] 
| This structure is used to retain landing pad info for the current function&period;
| xref:llvm/LandingPadInst.adoc[`LandingPadInst`] 
| The landingpad instruction holds all of the information necessary to generate correct exception handling&period; The landingpad instruction cannot be moved from the top of a landing pad block, which itself is accessible only from the &apos;unwind&apos; edge of an invoke&period; This uses the SubclassData field in Value to store whether or not the landingpad is a cleanup&period;
| xref:llvm/LaneBitmask.adoc[`LaneBitmask`] 
| 
| xref:llvm/LastRunTrackingAnalysis.adoc[`LastRunTrackingAnalysis`] 
| A function&sol;module analysis which provides an empty `LastRunTrackingInfo&period;`
| xref:llvm/LastRunTrackingInfo.adoc[`LastRunTrackingInfo`] 
| This class is used to track the last run of a set of module&sol;function passes&period; Invalidation are conservatively handled by the pass manager if a pass doesn&apos;t explicitly preserve the result&period; If we want to skip a pass, we should define a unique ID `PassID` to identify the pass, which is usually a pointer to a static member&period; If a pass has parameters, they should be stored in a struct `OptionT` with a method bool isCompatibleWith(const OptionT&amp; LastOpt) const to check compatibility&period;
| xref:llvm/LatencyPriorityQueue.adoc[`LatencyPriorityQueue`] 
| 
| 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`] 
| Atomic pointer that&apos;s lock&hyphen;free, but that can coordinate concurrent writes from a lazy generator&period; Should be reserved for cases where concurrent uses of a generator for the same storage is unlikely&period;
| xref:llvm/LazyBlockFrequencyInfo.adoc[`LazyBlockFrequencyInfo`] 
| Wraps a BFI to allow lazy computation of the block frequencies&period;
| xref:llvm/LazyBlockFrequencyInfoPass.adoc[`LazyBlockFrequencyInfoPass`] 
| This is an alternative analysis pass to BlockFrequencyInfoWrapperPass&period; The difference is that with this pass the block frequencies are not computed when the analysis pass is executed but rather when the BFI result is explicitly requested by the analysis client&period;
| xref:llvm/LazyBranchProbabilityInfoPass.adoc[`LazyBranchProbabilityInfoPass`] 
| This is an alternative analysis pass to BranchProbabilityInfoWrapperPass&period; The difference is that with this pass the branch probabilities are not computed when the analysis pass is executed but rather when the BPI results is explicitly requested by the analysis client&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`] 
| This is an alternative analysis pass to MachineBlockFrequencyInfo&period; The difference is that with this pass, the block frequencies are not computed when the analysis pass is executed but rather when the BFI result is explicitly requested by the analysis client&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`] 
| 
| 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`] 
| The LegalityQuery object bundles together all the information that&apos;s needed to decide whether a given operation is legal or not&period; For efficiency, it doesn&apos;t make a copy of Types so care must be taken not to free it before using the query&period;
| xref:llvm/LegalizationArtifactCombiner.adoc[`LegalizationArtifactCombiner`] 
| 
| 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; The specified action is chosen when the predicate is true&period; Where appropriate for the action (e&period;g&period; for WidenScalar) the new type is selected using the given mutator&period;
| xref:llvm/LegalizeRuleSet.adoc[`LegalizeRuleSet`] 
| 
| xref:llvm/LegalizerHelper.adoc[`LegalizerHelper`] 
| 
| xref:llvm/LegalizerInfo.adoc[`LegalizerInfo`] 
| 
| xref:llvm/LegalizerLegacy.adoc[`LegalizerLegacy`] 
| 
| xref:llvm/LegalizerMFResult.adoc[`LegalizerMFResult`] 
| 
| xref:llvm/LegalizerPass.adoc[`LegalizerPass`] 
| 
| xref:llvm/LessRecord.adoc[`LessRecord`] 
| Sorting predicate to sort record pointers by name&period;
| xref:llvm/LessRecordByID.adoc[`LessRecordByID`] 
| Sorting predicate to sort record pointers by their unique ID&period; If you just need a deterministic order, use this, since it just compares two `unsigned`&semi; the other sorting predicates require string manipulation&period;
| xref:llvm/LessRecordFieldName.adoc[`LessRecordFieldName`] 
| Sorting predicate to sort record pointers by their Name field&period;
| xref:llvm/LessRecordRegister.adoc[`LessRecordRegister`] 
| 
| 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`] 
| LibCallSimplifier &hyphen; This class implements a collection of optimizations that replace well formed calls to library functions with a more optimal form&period; For example, replacing &apos;printf(&quot;Hello!&quot;)&apos; with &apos;puts(&quot;Hello!&quot;)&apos;&period;
| xref:llvm/LibCallsShrinkWrapPass.adoc[`LibCallsShrinkWrapPass`] 
| 
| xref:llvm/LibcallLoweringInfo.adoc[`LibcallLoweringInfo`] 
| Tracks which library functions to use for a particular subtarget or function&period;
| xref:llvm/LibcallLoweringInfoWrapper.adoc[`LibcallLoweringInfoWrapper`] 
| 
| xref:llvm/LibcallLoweringModuleAnalysis.adoc[`LibcallLoweringModuleAnalysis`] 
| 
| 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`] 
| 
| xref:llvm/LinearExpression.adoc[`LinearExpression`] 
| Linear expression BasePtr &plus; Index &ast; Scale &plus; Offset&period; Index, Scale and Offset all have the same bit width, which matches the pointer index size of BasePtr&period; Index may be nullptr if Scale is 0&period;
| xref:llvm/Linker.adoc[`Linker`] 
| This class provides the core functionality of linking in LLVM&period; It keeps a pointer to the merged module so far&period; It doesn&apos;t take ownership of the module since it is assumed that the user of this class will want to do something with it after the linking&period;
| xref:llvm/LintPass.adoc[`LintPass`] 
| 
| xref:llvm/ListInit.adoc[`ListInit`] 
| &lsqb;AL, AH, CL&rsqb;&hyphen; Represent a list of defs
| 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`] 
| 
| xref:llvm/ListSeparator.adoc[`ListSeparator`] 
| A helper class to return the specified delimiter string after the first invocation of operator StringRef()&period; Used to generate a comma&hyphen;separated list from a loop like so&colon;
| xref:llvm/ListeningSocket.adoc[`ListeningSocket`] 
| Manages a passive (i&period;e&period;, listening) UNIX domain socket
| xref:llvm/LiveDebugValuesPass.adoc[`LiveDebugValuesPass`] 
| 
| xref:llvm/LiveDebugVariables.adoc[`LiveDebugVariables`] 
| 
| xref:llvm/LiveDebugVariablesAnalysis.adoc[`LiveDebugVariablesAnalysis`] 
| 
| xref:llvm/LiveDebugVariablesPrinterPass.adoc[`LiveDebugVariablesPrinterPass`] 
| 
| xref:llvm/LiveDebugVariablesWrapperLegacy.adoc[`LiveDebugVariablesWrapperLegacy`] 
| 
| xref:llvm/LiveInterval.adoc[`LiveInterval`] 
| LiveInterval &hyphen; This class represents the liveness of a register, or stack slot&period;
| xref:llvm/LiveIntervalCalc.adoc[`LiveIntervalCalc`] 
| 
| xref:llvm/LiveIntervalUnion.adoc[`LiveIntervalUnion`] 
| Union of live intervals that are strong candidates for coalescing into a single register (either physical or virtual depending on the context)&period; We expect the constituent live intervals to be disjoint, although we may eventually make exceptions to handle value&hyphen;based interference&period;
| xref:llvm/LiveIntervals.adoc[`LiveIntervals`] 
| 
| xref:llvm/LiveIntervalsAnalysis.adoc[`LiveIntervalsAnalysis`] 
| 
| xref:llvm/LiveIntervalsPrinterPass.adoc[`LiveIntervalsPrinterPass`] 
| 
| xref:llvm/LiveIntervalsWrapperPass.adoc[`LiveIntervalsWrapperPass`] 
| 
| 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 a LiveRange query&period; This class hides the implementation details of live ranges, and it should be used as the primary interface for examining live ranges around instructions&period;
| xref:llvm/LiveRange.adoc[`LiveRange`] 
| This class represents the liveness of a register, stack slot, etc&period; It manages an ordered list of Segment objects&period; The Segments are organized in a static single assignment form&colon; At places where a new value is defined or different values reach a CFG join a new segment with a new value number is used&period;
| xref:llvm/LiveRangeCalc.adoc[`LiveRangeCalc`] 
| 
| xref:llvm/LiveRangeEdit.adoc[`LiveRangeEdit`] 
| 
| xref:llvm/LiveRangeUpdater.adoc[`LiveRangeUpdater`] 
| Helper class for performant LiveRange bulk updates&period;
| xref:llvm/LiveRegMatrix.adoc[`LiveRegMatrix`] 
| 
| xref:llvm/LiveRegMatrixAnalysis.adoc[`LiveRegMatrixAnalysis`] 
| 
| xref:llvm/LiveRegMatrixWrapperLegacy.adoc[`LiveRegMatrixWrapperLegacy`] 
| 
| xref:llvm/LiveRegSet.adoc[`LiveRegSet`] 
| A set of live virtual registers and physical register units&period;
| xref:llvm/LiveRegUnit.adoc[`LiveRegUnit`] 
| 
| xref:llvm/LiveRegUnits.adoc[`LiveRegUnits`] 
| A set of register units used to track register liveness&period;
| xref:llvm/LiveStacks.adoc[`LiveStacks`] 
| 
| xref:llvm/LiveStacksAnalysis.adoc[`LiveStacksAnalysis`] 
| 
| xref:llvm/LiveStacksPrinterPass.adoc[`LiveStacksPrinterPass`] 
| 
| xref:llvm/LiveStacksWrapperLegacy.adoc[`LiveStacksWrapperLegacy`] 
| 
| xref:llvm/LiveVariables.adoc[`LiveVariables`] 
| 
| xref:llvm/LiveVariablesAnalysis.adoc[`LiveVariablesAnalysis`] 
| 
| xref:llvm/LiveVariablesPrinterPass.adoc[`LiveVariablesPrinterPass`] 
| 
| xref:llvm/LiveVariablesWrapperPass.adoc[`LiveVariablesWrapperPass`] 
| 
| 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`] 
| 
| xref:llvm/LoadStoreOptPass.adoc[`LoadStoreOptPass`] 
| 
| xref:llvm/LoadStoreVectorizerPass.adoc[`LoadStoreVectorizerPass`] 
| 
| 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`] 
| 
| xref:llvm/LocalStackSlotAllocationPass.adoc[`LocalStackSlotAllocationPass`] 
| 
| xref:llvm/LocalizerLegacy.adoc[`LocalizerLegacy`] 
| This pass implements the localization mechanism described at the top of this file&period; One specificity of the implementation is that it will materialize one and only one instance of a constant per basic block, thus enabling reuse of that constant within that block&period; Moreover, it only materializes constants in blocks where they are used&period; PHI uses are considered happening at the end of the related predecessor&period;
| xref:llvm/LocalizerPass.adoc[`LocalizerPass`] 
| 
| xref:llvm/LocationSize.adoc[`LocationSize`] 
| 
| 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 through instructions in a set of blocks in reverse order from the first non&hyphen;terminator&period; For example (assume all blocks have size n)&colon; LockstepReverseIterator I(&lsqb;B1, B2, B3&rsqb;)&semi; &ast;I&hyphen;&hyphen; &equals; &lsqb;B1&lsqb;n&rsqb;, B2&lsqb;n&rsqb;, B3&lsqb;n&rsqb;&rsqb;&semi; &ast;I&hyphen;&hyphen; &equals; &lsqb;B1&lsqb;n&hyphen;1&rsqb;, B2&lsqb;n&hyphen;1&rsqb;, B3&lsqb;n&hyphen;1&rsqb;&rsqb;&semi; &ast;I&hyphen;&hyphen; &equals; &lsqb;B1&lsqb;n&hyphen;2&rsqb;, B2&lsqb;n&hyphen;2&rsqb;, B3&lsqb;n&hyphen;2&rsqb;&rsqb;&semi; &period;&period;&period;
| xref:llvm/Logger.adoc[`Logger`] 
| Logging utility &hyphen; given an ordered specification of features, and assuming a scalar reward, allow logging feature values and rewards&period; The assumption is that, for an event to be logged (i&period;e&period; a set of feature values and a reward), the user calls the log&ast; API for each feature exactly once, providing the index matching the position in the feature spec list provided at construction&period; The example assumes the first feature&apos;s element type is float, the second is int64, and the reward is float&colon;
| xref:llvm/LogicalResult.adoc[`LogicalResult`] 
| This class represents an efficient way to signal success or failure&period; It should be preferred over the use of `bool` when appropriate, as it avoids all of the ambiguity that arises in interpreting a boolean result&period; This class is marked as NODISCARD to ensure that the result is processed&period; Users may explicitly discard a result by using `(void)`, e&period;g&period; `(void)functionThatReturnsALogicalResult()&semi;`&period; Given the intended nature of this class, it generally shouldn&apos;t be used as the result of functions that very frequently have the result ignored&period; This class is intended to be used in conjunction with the utility functions below&period;
| xref:llvm/LogicalSROAPass.adoc[`LogicalSROAPass`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| Represents loop&hyphen;carried dependencies&period; Because SwingSchedulerDAG doesn&apos;t assume cycle dependencies as the name suggests, such dependencies must be handled separately&period; After DAG construction is finished, these dependencies are added to SwingSchedulerDDG&period; TODO&colon; Also handle output&hyphen;dependencies introduced by physical registers&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`] 
| 
| xref:llvm/LoopDistributePass.adoc[`LoopDistributePass`] 
| 
| xref:llvm/LoopFlattenPass.adoc[`LoopFlattenPass`] 
| 
| xref:llvm/LoopFullUnrollPass.adoc[`LoopFullUnrollPass`] 
| Loop unroll pass that only does full loop unrolling and peeling&period;
| xref:llvm/LoopFusePass.adoc[`LoopFusePass`] 
| 
| xref:llvm/LoopIdiomRecognizePass.adoc[`LoopIdiomRecognizePass`] 
| Performs Loop Idiom Recognize Pass&period;
| xref:llvm/LoopIdiomVectorizePass.adoc[`LoopIdiomVectorizePass`] 
| 
| xref:llvm/LoopInfo.adoc[`LoopInfo`] 
| 
| xref:llvm/LoopInfoBase-00.adoc[`LoopInfoBase`] 
| This class builds and contains all of the top&hyphen;level loop structures in the specified 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`] 
| 
| 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`] 
| 
| 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 loop safety information&period; It keep information for loop blocks may throw exception or otherwise exit abnormally on any iteration of the loop which might actually execute at runtime&period; The primary way to consume this information is via isGuaranteedToExecute below, but some callers bailout or fallback to alternate reasoning if a loop contains any implicit control flow&period; NOTE&colon; LoopSafetyInfo contains cached information regarding loops and their particular blocks&period; This information is only dropped on invocation of computeLoopSafetyInfo&period; If the loop or any of its block is deleted, or if any thrower instructions have been added or removed from them, or if the control flow has changed, or in case of other meaningful modifications, the LoopSafetyInfo needs to be recomputed&period; If a meaningful modifications to the loop were made and the info wasn&apos;t recomputed properly, the behavior of all methods except for computeLoopSafetyInfo is undefined&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`] 
| The adaptor from a function pass to a loop pass computes these analyses and makes them available to the loop passes &quot;for free&quot;&period; Each loop pass is expected to update these analyses if necessary to ensure they&apos;re valid after it runs&period;
| xref:llvm/LoopStrengthReducePass.adoc[`LoopStrengthReducePass`] 
| Performs Loop Strength Reduce Pass&period;
| xref:llvm/LoopStructure.adoc[`LoopStructure`] 
| 
| xref:llvm/LoopTermFoldPass.adoc[`LoopTermFoldPass`] 
| 
| xref:llvm/LoopTraversal.adoc[`LoopTraversal`] 
| This class provides the basic blocks traversal order used by passes like ReachingDefAnalysis and ExecutionDomainFix&period; It identifies basic blocks that are part of loops and should to be visited twice and returns efficient traversal order for all the blocks&period;
| xref:llvm/LoopUnrollAndJamPass.adoc[`LoopUnrollAndJamPass`] 
| A simple loop rotation transformation&period;
| xref:llvm/LoopUnrollOptions.adoc[`LoopUnrollOptions`] 
| A set of parameters used to control various transforms performed by the LoopUnroll pass&period; Each of the boolean parameters can be set to&colon; true &hyphen; enabling the transformation&period; false &hyphen; disabling the transformation&period; None &hyphen; relying on a global default&period;
| xref:llvm/LoopUnrollPass.adoc[`LoopUnrollPass`] 
| Loop unroll pass that will support both full and partial unrolling&period; It is a function pass to have access to function and module analyses&period; It will also put loops into canonical form (simplified and LCSSA)&period;
| xref:llvm/LoopVectorizationLegality.adoc[`LoopVectorizationLegality`] 
| LoopVectorizationLegality checks if it is legal to vectorize a loop, and to what vectorization factor&period; This class does not look at the profitability of vectorization, only the legality&period; This class has two main kinds of checks&colon; &ast; Memory checks &hyphen; The code in canVectorizeMemory checks if vectorization will change the order of memory accesses in a way that will change the correctness of the program&period; &ast; Scalars checks &hyphen; The code in canVectorizeInstrs and canVectorizeMemory checks for a number of different conditions, such as the availability of a single induction variable, that all types are supported and vectorize&hyphen;able, etc&period; This code reflects the capabilities of InnerLoopVectorizer&period; This class is also used by InnerLoopVectorizer for identifying induction variable and the different reduction variables&period;
| xref:llvm/LoopVectorizationRequirements.adoc[`LoopVectorizationRequirements`] 
| This holds vectorization requirements that must be verified late in the process&period; The requirements are set by legalize and costmodel&period; Once vectorization has been determined to be possible and profitable the requirements can be verified by looking for metadata or compiler options&period; For example, some loops require FP commutativity which is only allowed if vectorization is explicitly specified or if the fast&hyphen;math compiler option has been provided&period; Late evaluation of these requirements allows helpful diagnostics to be composed that tells the user what need to be done to vectorize the loop&period; For example, by specifying &num;pragma clang loop vectorize or &hyphen;ffast&hyphen;math&period; Late evaluation should be used only when diagnostics can generated that can be followed by a non&hyphen;expert user&period;
| xref:llvm/LoopVectorizeHints.adoc[`LoopVectorizeHints`] 
| Utility class for getting and setting loop vectorizer hints in the form of loop metadata&period; This class keeps a number of loop annotations locally (as member variables) and can, upon request, write them back as metadata on the loop&period; It will initially scan the loop for existing metadata, and will update the local values based on information in the loop&period; We cannot write all values to metadata, as the mere presence of some info, for example &apos;force&apos;, means a decision has been made&period; So, we need to be careful NOT to add them if the user hasn&apos;t specifically asked so&period;
| xref:llvm/LoopVectorizeOptions.adoc[`LoopVectorizeOptions`] 
| 
| 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`] 
| 
| xref:llvm/LoopVersioningPass.adoc[`LoopVersioningPass`] 
| Expose LoopVersioning as a pass&period; Currently this is only used for unit&hyphen;testing&period; It adds all memchecks necessary to remove all may&hyphen;aliasing array accesses from the loop&period;
| xref:llvm/LostDebugLocObserver.adoc[`LostDebugLocObserver`] 
| 
| xref:llvm/LowerAllowCheckPass.adoc[`LowerAllowCheckPass`] 
| 
| xref:llvm/LowerAtomicPass.adoc[`LowerAtomicPass`] 
| A pass that lowers atomic intrinsic into non&hyphen;atomic intrinsics&period;
| xref:llvm/LowerCommentStringPass.adoc[`LowerCommentStringPass`] 
| 
| xref:llvm/LowerConstantIntrinsicsPass.adoc[`LowerConstantIntrinsicsPass`] 
| 
| xref:llvm/LowerEmuTLSPass.adoc[`LowerEmuTLSPass`] 
| 
| xref:llvm/LowerExpectIntrinsicPass.adoc[`LowerExpectIntrinsicPass`] 
| 
| xref:llvm/LowerGlobalDtorsPass.adoc[`LowerGlobalDtorsPass`] 
| 
| xref:llvm/LowerGuardIntrinsicPass.adoc[`LowerGuardIntrinsicPass`] 
| 
| xref:llvm/LowerIFuncPass.adoc[`LowerIFuncPass`] 
| Pass to replace calls to ifuncs with indirect calls&period;
| xref:llvm/LowerInvokePass.adoc[`LowerInvokePass`] 
| 
| xref:llvm/LowerMatrixIntrinsicsPass.adoc[`LowerMatrixIntrinsicsPass`] 
| 
| xref:llvm/LowerSwitchPass.adoc[`LowerSwitchPass`] 
| 
| xref:llvm/LowerTypeTestsPass.adoc[`LowerTypeTestsPass`] 
| 
| xref:llvm/LowerWidenableConditionPass.adoc[`LowerWidenableConditionPass`] 
| 
| xref:llvm/LshrOfTruncOfLshr.adoc[`LshrOfTruncOfLshr`] 
| 
| xref:llvm/MBB2NumberFunctor.adoc[`MBB2NumberFunctor`] 
| 
| xref:llvm/MBBReachingDefsInfo.adoc[`MBBReachingDefsInfo`] 
| 
| xref:llvm/MBBSectionID.adoc[`MBBSectionID`] 
| 
| xref:llvm/MBFIWrapper.adoc[`MBFIWrapper`] 
| 
| xref:llvm/MCAsmBackend.adoc[`MCAsmBackend`] 
| Generic interface to target specific assembler backends&period;
| xref:llvm/MCAsmBaseStreamer.adoc[`MCAsmBaseStreamer`] 
| 
| 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`] 
| 
| xref:llvm/MCAsmInfoDarwin.adoc[`MCAsmInfoDarwin`] 
| 
| xref:llvm/MCAsmInfoELF.adoc[`MCAsmInfoELF`] 
| 
| xref:llvm/MCAsmInfoGNUCOFF.adoc[`MCAsmInfoGNUCOFF`] 
| 
| xref:llvm/MCAsmInfoGOFF.adoc[`MCAsmInfoGOFF`] 
| 
| xref:llvm/MCAsmInfoMicrosoft.adoc[`MCAsmInfoMicrosoft`] 
| 
| xref:llvm/MCAsmInfoWasm.adoc[`MCAsmInfoWasm`] 
| 
| xref:llvm/MCAsmInfoXCOFF.adoc[`MCAsmInfoXCOFF`] 
| 
| xref:llvm/MCAsmMacro.adoc[`MCAsmMacro`] 
| 
| xref:llvm/MCAsmMacroParameter.adoc[`MCAsmMacroParameter`] 
| 
| 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`] 
| 
| xref:llvm/MCBinaryExpr.adoc[`MCBinaryExpr`] 
| Binary assembler expressions&period;
| xref:llvm/MCBoundaryAlignFragment.adoc[`MCBoundaryAlignFragment`] 
| Represents required padding such that a particular other set of fragments does not cross a particular power&hyphen;of&hyphen;two boundary&period; The other fragments must follow this one within the same section&period;
| xref:llvm/MCCFIInstruction.adoc[`MCCFIInstruction`] 
| 
| 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 introduced by &period;cv&lowbar;func&lowbar;id or &period;cv&lowbar;inline&lowbar;site&lowbar;id&period; Accumulates information from &period;cv&lowbar;loc directives used with this function&apos;s id or the id of an inlined call site within this 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`] 
| 
| xref:llvm/MCDXContainerPart.adoc[`MCDXContainerPart`] 
| 
| xref:llvm/MCDXContainerStreamer.adoc[`MCDXContainerStreamer`] 
| 
| xref:llvm/MCDXContainerTargetWriter.adoc[`MCDXContainerTargetWriter`] 
| 
| xref:llvm/MCDecodedPseudoProbe.adoc[`MCDecodedPseudoProbe`] 
| 
| xref:llvm/MCDecodedPseudoProbeInlineTree.adoc[`MCDecodedPseudoProbeInlineTree`] 
| 
| 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`] 
| 
| xref:llvm/MCDwarfFile.adoc[`MCDwarfFile`] 
| Instances of this class represent the name of the dwarf &period;file directive and its associated dwarf file number in the MC file&period; MCDwarfFile&apos;s are created and uniqued by the MCContext class&period; In Dwarf 4 file numbers start from 1&semi; i&period;e&period; the entry with file number 1 is the first element in the vector of DwarfFiles and there is no MCDwarfFile with file number 0&period; In Dwarf 5 file numbers start from 0, with the MCDwarfFile with file number 0 being the primary source file, and file numbers correspond to their index in the vector&period;
| xref:llvm/MCDwarfFrameEmitter.adoc[`MCDwarfFrameEmitter`] 
| 
| xref:llvm/MCDwarfFrameInfo.adoc[`MCDwarfFrameInfo`] 
| 
| xref:llvm/MCDwarfLineAddr.adoc[`MCDwarfLineAddr`] 
| 
| xref:llvm/MCDwarfLineEntry.adoc[`MCDwarfLineEntry`] 
| Instances of this class represent the line information for the dwarf line table entries&period; Which is created after a machine instruction is assembled and uses an address from a temporary label created at the current address in the current section and the info from the last &period;loc directive seen as stored in the context&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`] 
| 
| xref:llvm/MCDwarfLineTableHeader.adoc[`MCDwarfLineTableHeader`] 
| 
| xref:llvm/MCDwarfLineTableParams.adoc[`MCDwarfLineTableParams`] 
| 
| xref:llvm/MCDwarfLoc.adoc[`MCDwarfLoc`] 
| Instances of this class represent the information from a dwarf &period;loc directive&period;
| xref:llvm/MCELFObjectTargetWriter.adoc[`MCELFObjectTargetWriter`] 
| 
| xref:llvm/MCELFStreamer.adoc[`MCELFStreamer`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/MCGOFFObjectTargetWriter.adoc[`MCGOFFObjectTargetWriter`] 
| 
| xref:llvm/MCGOFFStreamer.adoc[`MCGOFFStreamer`] 
| 
| xref:llvm/MCGenDwarfInfo.adoc[`MCGenDwarfInfo`] 
| 
| xref:llvm/MCGenDwarfLabelEntry.adoc[`MCGenDwarfLabelEntry`] 
| 
| xref:llvm/MCInst.adoc[`MCInst`] 
| Instances of this class represent a single low&hyphen;level machine instruction&period;
| xref:llvm/MCInstBuilder.adoc[`MCInstBuilder`] 
| 
| 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`] 
| 
| xref:llvm/MCInstrDesc.adoc[`MCInstrDesc`] 
| Describe properties that are true of each instruction in the target description file&period; This captures information about side effects, register use and many other things&period; There is one instance of this struct for each target instruction class, and the MachineInstr class points to this struct directly to describe itself&period;
| xref:llvm/MCInstrInfo.adoc[`MCInstrInfo`] 
| Interface to description of machine instruction set&period;
| xref:llvm/MCJITMemoryManager.adoc[`MCJITMemoryManager`] 
| 
| xref:llvm/MCLFIRewriter.adoc[`MCLFIRewriter`] 
| 
| xref:llvm/MCLOHContainer.adoc[`MCLOHContainer`] 
| 
| xref:llvm/MCLOHDirective.adoc[`MCLOHDirective`] 
| Store Linker Optimization Hint information (LOH)&period;
| xref:llvm/MCLabel.adoc[`MCLabel`] 
| Instances of this class represent a label name in the MC file, and MCLabel are created and uniqued by the MCContext class&period; MCLabel should only be constructed for valid instances in the object file&period;
| xref:llvm/MCLineSection.adoc[`MCLineSection`] 
| Instances of this class represent the line information for a compile unit where machine instructions have been assembled after seeing &period;loc directives&period; This is the information used to build the dwarf line table for a section&period;
| xref:llvm/MCMachObjectTargetWriter.adoc[`MCMachObjectTargetWriter`] 
| 
| xref:llvm/MCNopsFragment.adoc[`MCNopsFragment`] 
| 
| xref:llvm/MCObjectFileInfo.adoc[`MCObjectFileInfo`] 
| 
| 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`] 
| 
| xref:llvm/MCParsedAsmOperand.adoc[`MCParsedAsmOperand`] 
| MCParsedAsmOperand &hyphen; This abstract class represents a source&hyphen;level assembly instruction operand&period; It should be subclassed by target&hyphen;specific code&period; This base class is used by target&hyphen;independent clients and is the interface between parsing an asm instruction and recognizing it&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`] 
| Instances of this class represent a pseudo probe instance for a pseudo probe table entry, which is created during a machine instruction is assembled and uses an address from a temporary label created at the current address in the current section&period;
| xref:llvm/MCPseudoProbeBase.adoc[`MCPseudoProbeBase`] 
| 
| xref:llvm/MCPseudoProbeDecoder.adoc[`MCPseudoProbeDecoder`] 
| 
| xref:llvm/MCPseudoProbeFuncDesc.adoc[`MCPseudoProbeFuncDesc`] 
| 
| xref:llvm/MCPseudoProbeInlineTree.adoc[`MCPseudoProbeInlineTree`] 
| 
| xref:llvm/MCPseudoProbeInlineTreeBase-0a.adoc[`MCPseudoProbeInlineTreeBase`] 
| 
| xref:llvm/MCPseudoProbeSections.adoc[`MCPseudoProbeSections`] 
| Instances of this class represent the pseudo probes inserted into a compile unit&period;
| xref:llvm/MCPseudoProbeTable.adoc[`MCPseudoProbeTable`] 
| 
| xref:llvm/MCReadAdvanceEntry.adoc[`MCReadAdvanceEntry`] 
| Specify the number of cycles allowed after instruction issue before a particular use operand reads its registers&period; This effectively reduces the write&apos;s latency&period; Here we allow negative cycles for corner cases where latency increases&period; This rule only applies when the entry&apos;s WriteResource matches the write&apos;s WriteResource&period;
| xref:llvm/MCRegAliasIterator.adoc[`MCRegAliasIterator`] 
| MCRegAliasIterator enumerates all registers aliasing Reg&period;
| xref:llvm/MCRegUnitIterator.adoc[`MCRegUnitIterator`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/MCRegisterCostEntry.adoc[`MCRegisterCostEntry`] 
| Specify the cost of a register definition in terms of number of physical register allocated at register renaming stage&period; For example, AMD Jaguar&period; natively supports 128&hyphen;bit data types, and operations on 256&hyphen;bit registers (i&period;e&period; YMM registers) are internally split into two COPs (complex operations) and each COP updates a physical register&period; Basically, on Jaguar, a YMM register write effectively consumes two physical registers&period; That means, the cost of a YMM write in the BtVer2 model is 2&period;
| xref:llvm/MCRegisterDesc.adoc[`MCRegisterDesc`] 
| MCRegisterDesc &hyphen; This record contains information about a particular register&period; The SubRegs field is a zero terminated array of registers that are sub&hyphen;registers of the specific register, e&period;g&period; AL, AH are sub&hyphen;registers of AX&period; The SuperRegs field is a zero terminated array of registers that are super&hyphen;registers of the specific register, e&period;g&period; RAX, EAX, are super&hyphen;registers of AX&period;
| xref:llvm/MCRegisterFileDesc.adoc[`MCRegisterFileDesc`] 
| A register file descriptor&period;
| xref:llvm/MCRegisterInfo.adoc[`MCRegisterInfo`] 
| MCRegisterInfo base class &hyphen; We assume that the target defines a static array of MCRegisterDesc objects that represent all of the machine registers that the target has&period; As such, we simply have to track a pointer to this array so that we can turn register number into a register descriptor&period;
| xref:llvm/MCRelocationInfo.adoc[`MCRelocationInfo`] 
| Create MCExprs from relocations found in an object file&period;
| xref:llvm/MCSFrameEmitter.adoc[`MCSFrameEmitter`] 
| 
| xref:llvm/MCSPIRVObjectTargetWriter.adoc[`MCSPIRVObjectTargetWriter`] 
| 
| xref:llvm/MCSPIRVStreamer.adoc[`MCSPIRVStreamer`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/MCSectionWasm.adoc[`MCSectionWasm`] 
| This represents a section on wasm&period;
| xref:llvm/MCSectionXCOFF.adoc[`MCSectionXCOFF`] 
| 
| xref:llvm/MCSpecifierExpr.adoc[`MCSpecifierExpr`] 
| Extension point for target&hyphen;specific MCExpr subclasses with a relocation specifier, serving as a replacement for MCSymbolRefExpr&colon;&colon;VariantKind&period; Limit this to top&hyphen;level use, avoiding its inclusion as 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`] 
| MCSymbol &hyphen; Instances of this class represent a symbol name in the MC file, and MCSymbols are created and uniqued by the MCContext class&period; MCSymbols should only be constructed with valid names for the object file&period;
| xref:llvm/MCSymbolCOFF.adoc[`MCSymbolCOFF`] 
| 
| xref:llvm/MCSymbolELF.adoc[`MCSymbolELF`] 
| 
| xref:llvm/MCSymbolGOFF.adoc[`MCSymbolGOFF`] 
| 
| xref:llvm/MCSymbolIdFragment.adoc[`MCSymbolIdFragment`] 
| Represents a symbol table index fragment&period;
| xref:llvm/MCSymbolMachO.adoc[`MCSymbolMachO`] 
| 
| xref:llvm/MCSymbolRefExpr.adoc[`MCSymbolRefExpr`] 
| Represent a reference to a symbol from inside an expression&period;
| xref:llvm/MCSymbolSDNode.adoc[`MCSymbolSDNode`] 
| 
| xref:llvm/MCSymbolTableValue.adoc[`MCSymbolTableValue`] 
| The value for an entry in the symbol table of an MCContext&period;
| xref:llvm/MCSymbolWasm.adoc[`MCSymbolWasm`] 
| 
| xref:llvm/MCSymbolXCOFF.adoc[`MCSymbolXCOFF`] 
| 
| 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`] 
| Extension point for target&hyphen;specific MCExpr subclasses to implement&period; This can encode a relocation operator, serving as a replacement for MCSymbolRefExpr&colon;&colon;VariantKind&period; Ideally, limit this to top&hyphen;level use, avoiding its inclusion as a subexpression&period;
| xref:llvm/MCTargetOptions.adoc[`MCTargetOptions`] 
| 
| 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`] 
| 
| xref:llvm/MCWasmObjectTargetWriter.adoc[`MCWasmObjectTargetWriter`] 
| 
| xref:llvm/MCWasmStreamer.adoc[`MCWasmStreamer`] 
| 
| xref:llvm/MCWinCOFFObjectTargetWriter.adoc[`MCWinCOFFObjectTargetWriter`] 
| 
| xref:llvm/MCWinCOFFStreamer.adoc[`MCWinCOFFStreamer`] 
| 
| xref:llvm/MCWriteLatencyEntry.adoc[`MCWriteLatencyEntry`] 
| Specify the latency in cpu cycles for a particular scheduling class and def index&period; &hyphen;1 indicates an invalid latency&period; Heuristics would typically consider an instruction with invalid latency to have infinite latency&period; Also identify the WriteResources of this def&period; When the operand expands to a sequence of writes, this ID is the last write in the sequence&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`] 
| 
| xref:llvm/MCXCOFFStreamer.adoc[`MCXCOFFStreamer`] 
| 
| xref:llvm/MD5.adoc[`MD5`] 
| Incremental MD5 message&hyphen;digest computation&period;
| xref:llvm/MDBuilder.adoc[`MDBuilder`] 
| 
| xref:llvm/MDNode.adoc[`MDNode`] 
| Metadata node&period;
| xref:llvm/MDNodeSDNode.adoc[`MDNodeSDNode`] 
| 
| xref:llvm/MDOperand.adoc[`MDOperand`] 
| Tracking metadata reference owned by Metadata&period;
| xref:llvm/MDProfLabels.adoc[`MDProfLabels`] 
| 
| 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`] 
| An RAII based helper class to modify MachineFunctionProperties when running pass&period; Define a MFPropsModifier in PassT&colon;&colon;run to set MachineFunctionProperties properly&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`] 
| MIBundleOperandIteratorBase &hyphen; Iterator that visits all operands in a bundle of MachineInstrs&period; This class is not intended to be used directly, use one of the sub&hyphen;classes instead&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`] 
| MIR2Vec vocabulary provider used by pass managers and standalone tools&period; This class encapsulates the core vocabulary loading logic and can be used independently of the pass manager infrastructure&period; For pass&hyphen;based usage, see MIR2VecVocabLegacyAnalysis&period;
| xref:llvm/MIRAddFSDiscriminators.adoc[`MIRAddFSDiscriminators`] 
| 
| xref:llvm/MIRFormatter.adoc[`MIRFormatter`] 
| MIRFormater &hyphen; Interface to format MIR operand based on target
| 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`] 
| 
| xref:llvm/MIRProfileLoader.adoc[`MIRProfileLoader`] 
| 
| xref:llvm/MIRProfileLoaderPass.adoc[`MIRProfileLoaderPass`] 
| 
| 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`] 
| 
| xref:llvm/MLModelRunner.adoc[`MLModelRunner`] 
| MLModelRunner interface&colon; abstraction of a mechanism for evaluating a ML model&period; More abstractly, evaluating a function that has as tensors as arguments, described via TensorSpecs, and returns a tensor&period; Currently, the latter is assumed to be a scalar, in absence of more elaborate scenarios&period; NOTE&colon; feature indices are expected to be consistent all accross MLModelRunners (pertaining to the same model), and also Loggers (see TFUtils&period;h)
| 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`] 
| 
| xref:llvm/MSVCPError.adoc[`MSVCPError`] 
| 
| xref:llvm/MSVCPExpected.adoc[`MSVCPExpected`] 
| 
| xref:llvm/MVT.adoc[`MVT`] 
| Machine Value Type&period; Every type that is supported natively by some processor targeted by LLVM occurs here&period; This means that any legal value type can be represented by an MVT&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`] 
| 
| xref:llvm/MachineBasicBlock.adoc[`MachineBasicBlock`] 
| 
| xref:llvm/MachineBlockFrequencyAnalysis.adoc[`MachineBlockFrequencyAnalysis`] 
| 
| xref:llvm/MachineBlockFrequencyInfo.adoc[`MachineBlockFrequencyInfo`] 
| MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic block frequencies&period;
| xref:llvm/MachineBlockFrequencyInfoWrapperPass.adoc[`MachineBlockFrequencyInfoWrapperPass`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/MachineBlockPlacementStatsPass.adoc[`MachineBlockPlacementStatsPass`] 
| 
| xref:llvm/MachineBranchProbabilityAnalysis.adoc[`MachineBranchProbabilityAnalysis`] 
| 
| xref:llvm/MachineBranchProbabilityInfo.adoc[`MachineBranchProbabilityInfo`] 
| 
| xref:llvm/MachineBranchProbabilityInfoWrapperPass.adoc[`MachineBranchProbabilityInfoWrapperPass`] 
| 
| xref:llvm/MachineBranchProbabilityPrinterPass.adoc[`MachineBranchProbabilityPrinterPass`] 
| 
| xref:llvm/MachineCFGPrinterPass.adoc[`MachineCFGPrinterPass`] 
| 
| xref:llvm/MachineCSEPass.adoc[`MachineCSEPass`] 
| 
| xref:llvm/MachineCombinerPass.adoc[`MachineCombinerPass`] 
| 
| xref:llvm/MachineConstantPool.adoc[`MachineConstantPool`] 
| The MachineConstantPool class keeps track of constants referenced by a function which must be spilled to memory&period; This is used for constants which are unable to be used directly as operands to instructions, which typically include floating point and large integer constants&period;
| xref:llvm/MachineConstantPoolEntry.adoc[`MachineConstantPoolEntry`] 
| This class is a data container for one entry in a MachineConstantPool&period; It contains a pointer to the value and an offset from the start of the constant pool&period; An entry in a MachineConstantPool
| xref:llvm/MachineConstantPoolValue.adoc[`MachineConstantPoolValue`] 
| Abstract base class for all machine specific constantpool value subclasses&period;
| xref:llvm/MachineCopyPropagationPass.adoc[`MachineCopyPropagationPass`] 
| 
| xref:llvm/MachineCycleAnalysis.adoc[`MachineCycleAnalysis`] 
| 
| xref:llvm/MachineCycleInfo.adoc[`MachineCycleInfo`] 
| 
| xref:llvm/MachineCycleInfoPrinterPass.adoc[`MachineCycleInfoPrinterPass`] 
| 
| xref:llvm/MachineCycleInfoWrapperPass.adoc[`MachineCycleInfoWrapperPass`] 
| Legacy analysis pass which computes a xref:llvm/MachineCycleInfo.adoc[`MachineCycleInfo`]&period;
| xref:llvm/MachineDomTreeGraphTraitsBase-04.adoc[`MachineDomTreeGraphTraitsBase`] 
| DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterators&period;
| xref:llvm/MachineDomTreeUpdater.adoc[`MachineDomTreeUpdater`] 
| 
| xref:llvm/MachineDominanceFrontier.adoc[`MachineDominanceFrontier`] 
| 
| xref:llvm/MachineDominanceFrontierAnalysis.adoc[`MachineDominanceFrontierAnalysis`] 
| 
| xref:llvm/MachineDominanceFrontierWrapperPass.adoc[`MachineDominanceFrontierWrapperPass`] 
| 
| 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`] 
| The MachineFrameInfo class represents an abstract stack frame until prolog&sol;epilog code is inserted&period; This class is key to allowing stack frame representation optimizations, such as frame pointer elimination&period; It also allows more mundane (but still important) optimizations, such as reordering of abstract objects on the stack frame&period;
| xref:llvm/MachineFunction.adoc[`MachineFunction`] 
| 
| 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`] 
| MachineFunctionInfo &hyphen; This class can be derived from and used by targets to hold private target&hyphen;specific information for each MachineFunction&period; Objects of type are accessed&sol;created with MF&colon;&colon;getInfo and destroyed when the MachineFunction is destroyed&period;
| xref:llvm/MachineFunctionPass.adoc[`MachineFunctionPass`] 
| MachineFunctionPass &hyphen; This class adapts the FunctionPass interface to allow convenient creation of passes that operate on the MachineFunction representation&period; Instead of overriding runOnFunction, subclasses override runOnMachineFunction&period;
| xref:llvm/MachineFunctionProperties.adoc[`MachineFunctionProperties`] 
| Properties which a MachineFunction may have at a given point in time&period; Each of these has checking code in the MachineVerifier, and passes can require that a property be set&period;
| xref:llvm/MachineIDFSSAUpdater.adoc[`MachineIDFSSAUpdater`] 
| 
| xref:llvm/MachineIRBuilder.adoc[`MachineIRBuilder`] 
| Helper class to build MachineInstr&period; It keeps internally the insertion point and debug location for all the new instructions we want to create&period; This information can be modified via the related setters&period;
| xref:llvm/MachineIRBuilderState.adoc[`MachineIRBuilderState`] 
| Class which stores all the state required in a MachineIRBuilder&period; Since MachineIRBuilders will only store state in this object, it allows to transfer BuilderState between different kinds of MachineIRBuilders&period;
| xref:llvm/MachineInstr.adoc[`MachineInstr`] 
| Representation of each machine instruction&period;
| xref:llvm/MachineInstrBuilder.adoc[`MachineInstrBuilder`] 
| 
| 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`] 
| 
| xref:llvm/MachineInstrBundleIteratorTraits-010.adoc[`MachineInstrBundleIteratorTraits`] 
| 
| xref:llvm/MachineInstrExpressionTrait.adoc[`MachineInstrExpressionTrait`] 
| Special DenseMapInfo traits to compare MachineInstr&ast; by _value_ of the instruction rather than by pointer value&period; The hashing and equality testing functions ignore definitions so this is useful for CSE, etc&period;
| xref:llvm/MachineInstrSpan.adoc[`MachineInstrSpan`] 
| MachineInstrSpan provides an interface to get an iteration range containing the instruction it was initialized with, along with all those instructions inserted prior to or following that instruction at some point after the MachineInstrSpan is constructed&period;
| xref:llvm/MachineJumpTableEntry.adoc[`MachineJumpTableEntry`] 
| MachineJumpTableEntry &hyphen; One jump table in the jump table info&period;
| xref:llvm/MachineJumpTableInfo.adoc[`MachineJumpTableInfo`] 
| 
| xref:llvm/MachineKCFIPass.adoc[`MachineKCFIPass`] 
| 
| xref:llvm/MachineLICMBasePass-0d.adoc[`MachineLICMBasePass`] 
| 
| xref:llvm/MachineLICMPass.adoc[`MachineLICMPass`] 
| 
| xref:llvm/MachineLateInstrsCleanupPass.adoc[`MachineLateInstrsCleanupPass`] 
| 
| xref:llvm/MachineLocation.adoc[`MachineLocation`] 
| 
| xref:llvm/MachineLoop.adoc[`MachineLoop`] 
| 
| xref:llvm/MachineLoopAnalysis.adoc[`MachineLoopAnalysis`] 
| Analysis pass that exposes the `MachineLoopInfo` for a machine function&period;
| xref:llvm/MachineLoopInfo.adoc[`MachineLoopInfo`] 
| 
| xref:llvm/MachineLoopInfoWrapperPass.adoc[`MachineLoopInfoWrapperPass`] 
| 
| xref:llvm/MachineLoopPrinterPass.adoc[`MachineLoopPrinterPass`] 
| Printer pass for the `LoopAnalysis` results&period;
| xref:llvm/MachineMemOperand.adoc[`MachineMemOperand`] 
| A description of a memory reference used in the backend&period; Instead of holding a StoreInst or LoadInst, this class holds the address Value of the reference along with a byte size and offset&period; This allows it to describe lowered loads and stores&period; Also, the special PseudoSourceValue objects can be used to represent loads and stores to memory locations that aren&apos;t explicit in the regular LLVM IR&period;
| xref:llvm/MachineModuleAnalysis.adoc[`MachineModuleAnalysis`] 
| An analysis that produces `MachineModuleInfo` for a module&period; This does not produce its own MachineModuleInfo because we need a consistent MachineModuleInfo to keep ownership of MachineFunctions regardless of analysis invalidation&sol;clearing&period; So something outside the analysis infrastructure must own the MachineModuleInfo&period;
| xref:llvm/MachineModuleInfo.adoc[`MachineModuleInfo`] 
| This class contains meta information specific to a module&period; Queries can be made by different debugging and exception handling schemes and reformated for specific use&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`] 
| This class can be derived from and used by targets to hold private target&hyphen;specific information for each Module&period; Objects of type are accessed&sol;created with MachineModuleInfo&colon;&colon;getObjFileInfo and destroyed when the MachineModuleInfo is destroyed&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`] 
| 
| xref:llvm/MachineModuleSlotTracker.adoc[`MachineModuleSlotTracker`] 
| 
| 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`] 
| This class contains a discriminated union of information about pointers in memory operands, relating them back to LLVM IR or to virtual locations (such as frame indices) that are exposed during codegen&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`] 
| 
| xref:llvm/MachinePostDominatorTreePrinterPass.adoc[`MachinePostDominatorTreePrinterPass`] 
| 
| xref:llvm/MachinePostDominatorTreeWrapperPass.adoc[`MachinePostDominatorTreeWrapperPass`] 
| 
| xref:llvm/MachineRegion.adoc[`MachineRegion`] 
| 
| xref:llvm/MachineRegionInfo.adoc[`MachineRegionInfo`] 
| 
| xref:llvm/MachineRegionInfoAnalysis.adoc[`MachineRegionInfoAnalysis`] 
| 
| xref:llvm/MachineRegionInfoPass.adoc[`MachineRegionInfoPass`] 
| 
| xref:llvm/MachineRegionInfoPrinterPass.adoc[`MachineRegionInfoPrinterPass`] 
| 
| xref:llvm/MachineRegionNode.adoc[`MachineRegionNode`] 
| 
| xref:llvm/MachineRegisterClassAnalysis.adoc[`MachineRegisterClassAnalysis`] 
| 
| xref:llvm/MachineRegisterClassInfoWrapperPass.adoc[`MachineRegisterClassInfoWrapperPass`] 
| 
| 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`] 
| MachineSSAUpdater &hyphen; This class updates SSA form for a set of virtual registers defined in multiple blocks&period; This is used when code duplication or another unstructured transformation wants to rewrite a set of uses of one vreg with uses of a set of vregs&period;
| xref:llvm/MachineSanitizerBinaryMetadataPass.adoc[`MachineSanitizerBinaryMetadataPass`] 
| 
| xref:llvm/MachineSchedContext.adoc[`MachineSchedContext`] 
| MachineSchedContext provides enough context from the MachineScheduler pass for the target to instantiate a scheduler&period;
| xref:llvm/MachineSchedPolicy.adoc[`MachineSchedPolicy`] 
| Define a generic scheduling policy for targets that don&apos;t provide their own MachineSchedStrategy&period; This can be overriden for each scheduling region before building the DAG&period;
| xref:llvm/MachineSchedRegistry.adoc[`MachineSchedRegistry`] 
| MachineSchedRegistry provides a selection of available machine instruction schedulers&period;
| xref:llvm/MachineSchedStrategy.adoc[`MachineSchedStrategy`] 
| MachineSchedStrategy &hyphen; Interface to the scheduling algorithm used by ScheduleDAGMI&period;
| xref:llvm/MachineSchedulerPass.adoc[`MachineSchedulerPass`] 
| 
| xref:llvm/MachineSinkingPass.adoc[`MachineSinkingPass`] 
| 
| xref:llvm/MachineTraceMetrics.adoc[`MachineTraceMetrics`] 
| 
| xref:llvm/MachineTraceMetricsAnalysis.adoc[`MachineTraceMetricsAnalysis`] 
| 
| xref:llvm/MachineTraceMetricsVerifierPass.adoc[`MachineTraceMetricsVerifierPass`] 
| Verifier pass for `MachineTraceMetrics&period;`
| xref:llvm/MachineTraceMetricsWrapperPass.adoc[`MachineTraceMetricsWrapperPass`] 
| 
| xref:llvm/MachineUniformityAnalysis.adoc[`MachineUniformityAnalysis`] 
| 
| xref:llvm/MachineUniformityAnalysisPass.adoc[`MachineUniformityAnalysisPass`] 
| Legacy analysis pass which computes a xref:llvm/MachineUniformityInfo.adoc[`MachineUniformityInfo`]&period;
| xref:llvm/MachineUniformityPrinterPass.adoc[`MachineUniformityPrinterPass`] 
| 
| xref:llvm/MachineVerifierPass.adoc[`MachineVerifierPass`] 
| 
| xref:llvm/MakeGuardsExplicitPass.adoc[`MakeGuardsExplicitPass`] 
| 
| xref:llvm/MallocAllocator.adoc[`MallocAllocator`] 
| Allocator that obtains memory from malloc&sol;free (or aligned variants)&period;
| xref:llvm/ManagedStatic.adoc[`ManagedStatic`] 
| ManagedStatic &hyphen; This transparently changes the behavior of global statics to be lazily constructed on demand (good for reducing startup times of dynamic libraries that link in LLVM components) and for making destruction be explicit through the llvm&lowbar;shutdown() function call&period;
| xref:llvm/ManagedStaticBase.adoc[`ManagedStaticBase`] 
| ManagedStaticBase &hyphen; Common base class for ManagedStatic instances&period;
| xref:llvm/Mangler.adoc[`Mangler`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/MemDepResult.adoc[`MemDepResult`] 
| A memory dependence query can return one of three different answers&period;
| xref:llvm/MemDerefPrinterPass.adoc[`MemDerefPrinterPass`] 
| 
| xref:llvm/MemIntrinsic.adoc[`MemIntrinsic`] 
| This is the common base class for memset&sol;memcpy&sol;memmove&period;
| xref:llvm/MemIntrinsicBase-0f.adoc[`MemIntrinsicBase`] 
| Common base class for all memory intrinsics&period; Simply provides common methods&period; Written as CRTP to avoid a common base class amongst the three atomicity hierarchies&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`] 
| This SDNode is used for target intrinsics that touch memory and need an associated MachineMemOperand&period; Its opcode may be INTRINSIC&lowbar;VOID, INTRINSIC&lowbar;W&lowbar;CHAIN, PREFETCH, or a target&hyphen;specific memory&hyphen;referencing opcode (see `SelectionDAGTargetInfo&colon;&colon;isTargetMemoryOpcode`)&period;
| xref:llvm/MemMoveInst.adoc[`MemMoveInst`] 
| This class wraps the llvm&period;memmove intrinsic&period;
| xref:llvm/MemOp.adoc[`MemOp`] 
| 
| xref:llvm/MemProfContextDisambiguation.adoc[`MemProfContextDisambiguation`] 
| 
| xref:llvm/MemProfRemoveInfo.adoc[`MemProfRemoveInfo`] 
| Strips MemProf attributes and metadata&period;
| xref:llvm/MemProfUsePass.adoc[`MemProfUsePass`] 
| 
| 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`] 
| This class wraps the llvm&period;experimental&period;memset&period;pattern intrinsic&period; Note that despite the inheritance, this is not part of the MemIntrinsic hierachy in terms of isa&sol;cast&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`] 
| 
| 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`] 
| An implementation of BinaryStream whose data is backed by an llvm MemoryBuffer object&period; MemoryBufferByteStream owns the MemoryBuffer in question&period; As with BinaryByteStream, reading from a MemoryBufferByteStream will never cause a copy&period;
| xref:llvm/MemoryBufferRef.adoc[`MemoryBufferRef`] 
| 
| 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 to determine whether there vectorization is legal or not (and at which vectorization factor)&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`] 
| 
| xref:llvm/MemoryLocation.adoc[`MemoryLocation`] 
| Representation for a specific memory location&period;
| xref:llvm/MemoryOpRemark.adoc[`MemoryOpRemark`] 
| 
| 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`] 
| 
| xref:llvm/MemorySSAUtil.adoc[`MemorySSAUtil`] 
| 
| xref:llvm/MemorySSAVerifierPass.adoc[`MemorySSAVerifierPass`] 
| Verifier pass for `MemorySSA&period;`
| xref:llvm/MemorySSAWalker.adoc[`MemorySSAWalker`] 
| This is the generic walker interface for walkers of MemorySSA&period; Walkers are used to be able to further disambiguate the def&hyphen;use chains MemorySSA gives you, or otherwise produce better info than MemorySSA gives you&period; In particular, while the def&hyphen;use chains provide basic information, and are guaranteed to give, for example, the nearest may&hyphen;aliasing MemoryDef for a MemoryUse as AliasAnalysis considers it, a user mant want better or other information&period; In particular, they may want to use SCEV info to further disambiguate memory accesses, or they may want the nearest dominating may&hyphen;aliasing MemoryDef for a call or a store&period; This API enables a standardized interface to getting and using that info&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`] 
| 
| 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`] 
| Class that has the common methods &plus; fields of memory uses&sol;defs&period; It&apos;s a little awkward to have, but there are many cases where we want either a use or def, and there are many cases where uses are needed (defs aren&apos;t acceptable), and vice&hyphen;versa&period;
| xref:llvm/MemoryWriteTracking.adoc[`MemoryWriteTracking`] 
| 
| xref:llvm/MergeFunctionsPass.adoc[`MergeFunctionsPass`] 
| Merge identical functions&period;
| xref:llvm/MergeICmpsPass.adoc[`MergeICmpsPass`] 
| 
| xref:llvm/MergedLoadStoreMotionOptions.adoc[`MergedLoadStoreMotionOptions`] 
| 
| xref:llvm/MergedLoadStoreMotionPass.adoc[`MergedLoadStoreMotionPass`] 
| 
| xref:llvm/MetaRenamerPass.adoc[`MetaRenamerPass`] 
| 
| 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`] 
| 
| 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`] 
| A Module instance is used to store all the information related to an LLVM module&period; Modules are the top level container of all other LLVM Intermediate Representation (IR) objects&period; Each module directly contains a list of globals variables, a list of functions, a list of libraries (or other modules) this module depends on, a symbol table, and various data about the target&apos;s characteristics&period;
| xref:llvm/ModuleCopyProfPass.adoc[`ModuleCopyProfPass`] 
| 
| xref:llvm/ModuleDebugInfoPrinterPass.adoc[`ModuleDebugInfoPrinterPass`] 
| 
| 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 pass&period; This works in conjunction with the InlineAdvisorAnalysis to facilitate inlining decisions taking into account module&hyphen;wide state, that need to keep track of inter&hyphen;inliner pass runs, for a given module&period; An InlineAdvisor is configured and kept alive for the duration of the ModuleInlinerWrapperPass&colon;&colon;run&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`] 
| ModulePass class &hyphen; This class is used to implement unstructured interprocedural optimizations and analyses&period; ModulePasses may do anything they want to the program&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`] 
| 
| 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`] 
| 
| xref:llvm/MulOperator.adoc[`MulOperator`] 
| 
| xref:llvm/MultiHazardRecognizer.adoc[`MultiHazardRecognizer`] 
| 
| xref:llvm/MustBeExecutedContextExplorer.adoc[`MustBeExecutedContextExplorer`] 
| A &quot;must be executed context&quot; for a given program point PP is the set of instructions, potentially before and after PP, that are executed always when PP is reached&period; The MustBeExecutedContextExplorer an interface to explore &quot;must be executed contexts&quot; in a module through the use of MustBeExecutedIterator&period;
| xref:llvm/MustBeExecutedContextPrinterPass.adoc[`MustBeExecutedContextPrinterPass`] 
| 
| 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`] 
| 
| xref:llvm/MutableArrayRef-02.adoc[`MutableArrayRef`] 
| Represent a mutable reference to an array (0 or more elements consecutively in memory), i&period;e&period; a start pointer and a length&period; It allows various APIs to take and modify consecutive elements easily and conveniently&period;
| xref:llvm/MutableBinaryByteStream.adoc[`MutableBinaryByteStream`] 
| An implementation of BinaryStream which holds its entire data set in a single contiguous buffer&period; As with BinaryByteStream, the mutable version also guarantees that no read operation will ever incur a copy, and similarly it does not own the underlying buffer&period;
| xref:llvm/NameAnonGlobalPass.adoc[`NameAnonGlobalPass`] 
| Simple pass that provides a name to every anonymous globals&period;
| xref:llvm/NamedInstrProfRecord.adoc[`NamedInstrProfRecord`] 
| 
| xref:llvm/NamedMDNode.adoc[`NamedMDNode`] 
| A tuple of MDNodes&period;
| xref:llvm/NamedRegionTimer.adoc[`NamedRegionTimer`] 
| This class is basically a combination of TimeRegion and Timer&period; It allows you to declare a new timer, AND specify the region to time, all in one statement&period; All timers with the same name are merged&period; This is primarily used for debugging and for hunting performance problems&period;
| xref:llvm/NamespaceEmitter.adoc[`NamespaceEmitter`] 
| 
| xref:llvm/NaryReassociatePass.adoc[`NaryReassociatePass`] 
| 
| xref:llvm/NearMissInfo.adoc[`NearMissInfo`] 
| 
| xref:llvm/NewArchiveMember.adoc[`NewArchiveMember`] 
| 
| xref:llvm/NewGVNPass.adoc[`NewGVNPass`] 
| 
| xref:llvm/NfaStatePair.adoc[`NfaStatePair`] 
| Forward define the pair type used by the automata transition info tables&period;
| xref:llvm/NoActiveBlocksOption.adoc[`NoActiveBlocksOption`] 
| 
| xref:llvm/NoAliasScopeDeclInst.adoc[`NoAliasScopeDeclInst`] 
| 
| 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`] 
| 
| 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`] 
| A mock class satisfying the interface expected by ReleaseModeModelRunner for its `TGen` parameter&period; Useful to avoid conditional compilation complexity, as a compile&hyphen;time replacement for a real AOT&hyphen;ed model&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`] 
| This cast trait just provides castFailed for the specified `To` type to make CastInfo specializations more declarative&period; In order to use this, the target result type must be `To` and `To` must be constructible from `nullptr`&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`] 
| 
| xref:llvm/ObjCARCContractPass.adoc[`ObjCARCContractPass`] 
| 
| xref:llvm/ObjCARCExpandPass.adoc[`ObjCARCExpandPass`] 
| 
| xref:llvm/ObjCARCOptPass.adoc[`ObjCARCOptPass`] 
| 
| xref:llvm/ObjCSelectorNames.adoc[`ObjCSelectorNames`] 
| 
| xref:llvm/ObjectCache.adoc[`ObjectCache`] 
| This is the base ObjectCache type which can be provided to an ExecutionEngine for the purpose of avoiding compilation for Modules that have already been compiled and an object file is available&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`] 
| Class that manages information about offload code regions and data
| 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`] 
| 
| 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 operators
| xref:llvm/OpenMPIRBuilder.adoc[`OpenMPIRBuilder`] 
| An interface to create LLVM&hyphen;IR for OpenMP directives&period;
| xref:llvm/OpenMPIRBuilderConfig.adoc[`OpenMPIRBuilderConfig`] 
| Captures attributes that affect generating LLVM&hyphen;IR using the OpenMPIRBuilder and related classes&period; Note that not all attributes are required for all classes or functions&period; In some use cases the configuration is not necessary at all, because because the only functions that are called are ones that are not dependent on the configuration&period;
| xref:llvm/OpenMPOptCGSCCPass.adoc[`OpenMPOptCGSCCPass`] 
| 
| xref:llvm/OpenMPOptPass.adoc[`OpenMPOptPass`] 
| OpenMP optimizations pass&period;
| xref:llvm/OperandBundleDefT.adoc[`OperandBundleDefT`] 
| A container for an operand bundle being viewed as a set of values rather than a set of uses&period;
| xref:llvm/OperandBundleUse.adoc[`OperandBundleUse`] 
| A lightweight accessor for an operand bundle meant to be passed around 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`] 
| This class implements a mechanism to disable passes and individual optimizations at compile time based on two command line options (&hyphen;opt&hyphen;bisect and &hyphen;opt&hyphen;disable) in order to perform a bisecting search for optimization&hyphen;related problems, and&sol;or disable individual passes or combinations thereof&period;
| xref:llvm/OptNoneInstrumentation.adoc[`OptNoneInstrumentation`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| This cast trait provides std&colon;&colon;optional&lt;T&gt; casting&period; This means that if you have a value type, you can cast it to another value type and have dyn&lowbar;cast return an std&colon;&colon;optional&lt;T&gt;&period;
| xref:llvm/OrderedChangedData-01.adoc[`OrderedChangedData`] 
| 
| xref:llvm/OuterAnalysisManagerProxy-06.adoc[`OuterAnalysisManagerProxy`] 
| This proxy doesn&apos;t manage invalidation in any way &hyphen;&hyphen; that is handled by the recursive return path of each layer of the pass manager&period; A consequence of this is the outer analyses may be stale&period; We invalidate the outer analyses only when we&apos;re done running passes over the inner IR units&period;
| xref:llvm/OutlinedHashTree.adoc[`OutlinedHashTree`] 
| 
| xref:llvm/OutlinedHashTreeRecord.adoc[`OutlinedHashTreeRecord`] 
| 
| xref:llvm/OutputCategoryAggregator.adoc[`OutputCategoryAggregator`] 
| 
| xref:llvm/OverflowTracking.adoc[`OverflowTracking`] 
| 
| xref:llvm/OverflowingBinaryOperator.adoc[`OverflowingBinaryOperator`] 
| Utility class for integer operators which may exhibit overflow &hyphen; Add, Sub, Mul, and Shl&period; It does not include SDiv, despite that operator having the potential for overflow&period;
| xref:llvm/OverlapFuncFilters.adoc[`OverlapFuncFilters`] 
| 
| xref:llvm/OverlapStats.adoc[`OverlapStats`] 
| 
| xref:llvm/PAEvalPass.adoc[`PAEvalPass`] 
| 
| 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 node (context) in the loaded contextual profile, suitable for mutation during IPO passes&period; We generally expect a fraction of counters and callsites to be populated&period; We continue to model counters as vectors, but callsites are modeled as a map of a map&period; The expectation is that, typically, there is a small number of indirect targets (usually, 1 for direct calls)&semi; but potentially a large number of callsites, and, as inlining progresses, the callsite count of a caller will grow&period;
| xref:llvm/PGOCtxProfFlatteningPass.adoc[`PGOCtxProfFlatteningPass`] 
| 
| xref:llvm/PGOCtxProfLoweringPass.adoc[`PGOCtxProfLoweringPass`] 
| 
| xref:llvm/PGOCtxProfile.adoc[`PGOCtxProfile`] 
| 
| xref:llvm/PGOCtxProfileReader.adoc[`PGOCtxProfileReader`] 
| 
| xref:llvm/PGOCtxProfileWriter.adoc[`PGOCtxProfileWriter`] 
| Write one or more ContextNodes to the provided raw&lowbar;fd&lowbar;stream&period; The caller must destroy the PGOCtxProfileWriter object before closing the stream&period; The design allows serializing a bunch of contexts embedded in some other file&period; The overall format is&colon;
| xref:llvm/PGOForceFunctionAttrsPass.adoc[`PGOForceFunctionAttrsPass`] 
| 
| xref:llvm/PGOIndirectCallPromotion.adoc[`PGOIndirectCallPromotion`] 
| The indirect function call promotion pass&period;
| xref:llvm/PGOIndirectCallVisitor.adoc[`PGOIndirectCallVisitor`] 
| 
| 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`] 
| 
| xref:llvm/PHINode.adoc[`PHINode`] 
| 
| xref:llvm/PHITransAddr.adoc[`PHITransAddr`] 
| PHITransAddr &hyphen; An address value which tracks and handles phi translation&period; As we walk &quot;up&quot; the CFG through predecessors, we need to ensure that the address we&apos;re tracking is kept up to date&period; For example, if we&apos;re analyzing an address of &quot;&amp;A&lsqb;i&rsqb;&quot; and walk through the definition of &apos;i&apos; which is a PHI node, we _must_ phi translate i to get &quot;&amp;A&lsqb;j&rsqb;&quot; or else we will analyze an incorrect pointer in the predecessor block&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 the given physical or virtual register&period; If Reg is physical, it must be a register unit (from MCRegUnitIterator)&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`] 
| 
| xref:llvm/ParseResult.adoc[`ParseResult`] 
| This class represents success&sol;failure for parsing&hyphen;like operations that find it important to chain together failable operations with `&verbar;&verbar;`&period; This is an extended version of `LogicalResult` that allows for explicit conversion to bool&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`] 
| 
| xref:llvm/PartialInlinerPass.adoc[`PartialInlinerPass`] 
| Pass to remove unused function declarations&period;
| xref:llvm/PartiallyInlineLibCallsPass.adoc[`PartiallyInlineLibCallsPass`] 
| 
| xref:llvm/Pass.adoc[`Pass`] 
| Pass interface &hyphen; Implemented by all &apos;passes&apos;&period; Subclass this if you are an interprocedural optimization or you do not fit into any of the more constrained passes described below&period;
| xref:llvm/PassBuilder.adoc[`PassBuilder`] 
| This class provides access to building LLVM&apos;s passes&period;
| xref:llvm/PassConfigImpl.adoc[`PassConfigImpl`] 
| 
| xref:llvm/PassInfo.adoc[`PassInfo`] 
| PassInfo class &hyphen; An instance of this class exists for every pass known by the system, and can be obtained from a live Pass by calling its getPassInfo() method&period; These objects are set up by the RegisterPass&lt;&gt; template&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-04c.adoc[`PassManager`] 
| Manages 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`] 
| 
| xref:llvm/PassNameParser.adoc[`PassNameParser`] 
| 
| 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`] 
| 
| xref:llvm/PassRegistry.adoc[`PassRegistry`] 
| PassRegistry &hyphen; This class manages the registration and intitialization of the pass subsystem as application startup, and assists the PassManager in resolving pass dependencies&period; NOTE&colon; PassRegistry is NOT thread&hyphen;safe&period; If you want to use LLVM on multiple threads simultaneously, you will need to use a separate PassRegistry on each thread&period;
| xref:llvm/PatchItem.adoc[`PatchItem`] 
| 
| xref:llvm/PatchPointOpers.adoc[`PatchPointOpers`] 
| MI&hyphen;level patchpoint operands&period;
| xref:llvm/PatchableFunctionPass.adoc[`PatchableFunctionPass`] 
| 
| 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`] 
| 
| xref:llvm/PerFunctionMIParsingState.adoc[`PerFunctionMIParsingState`] 
| 
| xref:llvm/PerTargetMIParsingState.adoc[`PerTargetMIParsingState`] 
| 
| 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`] 
| 
| xref:llvm/PhysicalRegisterUsageInfo.adoc[`PhysicalRegisterUsageInfo`] 
| 
| xref:llvm/PhysicalRegisterUsageInfoPrinterPass.adoc[`PhysicalRegisterUsageInfoPrinterPass`] 
| 
| xref:llvm/PhysicalRegisterUsageInfoWrapperLegacy.adoc[`PhysicalRegisterUsageInfoWrapperLegacy`] 
| 
| xref:llvm/PiBlockDDGNode.adoc[`PiBlockDDGNode`] 
| Subclass of DDGNode representing a pi&hyphen;block&period; A pi&hyphen;block represents a group of DDG nodes that are part of a strongly&hyphen;connected component of the graph&period; Replacing all the SCCs with pi&hyphen;blocks results in an acyclic representation of the DDG&period; For example if we have&colon; &lcub;a &hyphen;&gt; b&rcub;, &lcub;b &hyphen;&gt; c, d&rcub;, &lcub;c &hyphen;&gt; a&rcub; the cycle a &hyphen;&gt; b &hyphen;&gt; c &hyphen;&gt; a is abstracted into a pi&hyphen;block &quot;p&quot; as follows&colon; &lcub;p &hyphen;&gt; d&rcub; with &quot;p&quot; containing&colon; &lcub;a &hyphen;&gt; b&rcub;, &lcub;b &hyphen;&gt; c&rcub;, &lcub;c &hyphen;&gt; a&rcub;
| xref:llvm/PipelineTuningOptions.adoc[`PipelineTuningOptions`] 
| Tunable parameters for passes in the default pipelines&period;
| xref:llvm/PlaceSafepointsPass.adoc[`PlaceSafepointsPass`] 
| 
| 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`] 
| 
| xref:llvm/PointerDiffInfo.adoc[`PointerDiffInfo`] 
| 
| xref:llvm/PointerEmbeddedInt.adoc[`PointerEmbeddedInt`] 
| Utility to embed an integer into a pointer&hyphen;like type&period; This is specifically intended to allow embedding integers where fewer bits are required than exist in a pointer, and the integer can participate in abstractions along side other pointer&hyphen;like types&period; For example it can be placed into a `PointerSumType` or `PointerUnion&period;`
| xref:llvm/PointerIntPair-03.adoc[`PointerIntPair`] 
| PointerIntPair &hyphen; This class implements a pair of a pointer and small integer&period; It is designed to represent this in the space required by one pointer by bitmangling the integer into the low part of the pointer&period; This can only be done for small integers&colon; typically up to 3 bits, but it depends on the number of bits available according to PointerLikeTypeTraits for the type&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 compile time pair of an integer tag and the pointer&hyphen;like type which it indexes within a sum type&period; Also allows the user to specify a particular traits class for pointer types with custom behavior such as over&hyphen;aligned allocation&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`] 
| 
| xref:llvm/PoisonValue.adoc[`PoisonValue`] 
| In order to facilitate speculative execution, many instructions do not invoke immediate undefined behavior when provided with illegal operands, and return a poison value instead&period;
| xref:llvm/PoisoningVH.adoc[`PoisoningVH`] 
| Value handle that poisons itself if the Value is deleted&period;
| xref:llvm/PolynomialInfo.adoc[`PolynomialInfo`] 
| The structure that is returned when a polynomial algorithm was recognized by the analysis&period; Currently, only the CRC algorithm is recognized&period;
| xref:llvm/PossiblyDisjointInst.adoc[`PossiblyDisjointInst`] 
| An or instruction, which can be marked as &quot;disjoint&quot;, indicating that the inputs don&apos;t have a 1 in the same bit position&period; Meaning this instruction can also be treated as an add&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`] 
| Instruction that can have a nneg flag (zext&sol;uitofp)&period;
| xref:llvm/PostDomOnlyPrinter.adoc[`PostDomOnlyPrinter`] 
| 
| xref:llvm/PostDomOnlyViewer.adoc[`PostDomOnlyViewer`] 
| 
| xref:llvm/PostDomPrinter.adoc[`PostDomPrinter`] 
| 
| xref:llvm/PostDomViewer.adoc[`PostDomViewer`] 
| 
| 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`] 
| 
| xref:llvm/PostGenericScheduler.adoc[`PostGenericScheduler`] 
| PostGenericScheduler &hyphen; Interface to the scheduling algorithm used by ScheduleDAGMI&period;
| xref:llvm/PostMachineSchedulerPass.adoc[`PostMachineSchedulerPass`] 
| 
| 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`] 
| 
| xref:llvm/PostRAMachineSinkingPass.adoc[`PostRAMachineSinkingPass`] 
| 
| xref:llvm/PostRASchedulerPass.adoc[`PostRASchedulerPass`] 
| 
| xref:llvm/PotentialValuesState-06.adoc[`PotentialValuesState`] 
| A class for a set state&period;
| xref:llvm/PreISelIntrinsicLoweringPass.adoc[`PreISelIntrinsicLoweringPass`] 
| 
| xref:llvm/PredIterator.adoc[`PredIterator`] 
| 
| xref:llvm/PredIteratorCache.adoc[`PredIteratorCache`] 
| PredIteratorCache &hyphen; This class is an extremely trivial cache for predecessor iterator queries&period; This is useful for code that repeatedly wants the predecessor list for the same blocks&period;
| xref:llvm/PredicateAssume.adoc[`PredicateAssume`] 
| 
| xref:llvm/PredicateBase.adoc[`PredicateBase`] 
| 
| xref:llvm/PredicateBranch.adoc[`PredicateBranch`] 
| 
| xref:llvm/PredicateBundleAssume.adoc[`PredicateBundleAssume`] 
| 
| xref:llvm/PredicateConditionAssume.adoc[`PredicateConditionAssume`] 
| 
| 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`] 
| 
| xref:llvm/PredicateInfoBuilder.adoc[`PredicateInfoBuilder`] 
| 
| 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`] 
| 
| xref:llvm/PredicateWithEdge.adoc[`PredicateWithEdge`] 
| 
| xref:llvm/PredicatedScalarEvolution.adoc[`PredicatedScalarEvolution`] 
| An interface layer with SCEV used to manage how we see SCEV expressions for values in the context of existing predicates&period; We can add new predicates, but we cannot remove them&period;
| xref:llvm/PreferredTuple.adoc[`PreferredTuple`] 
| 
| xref:llvm/PrefetchHint.adoc[`PrefetchHint`] 
| 
| 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`] 
| 
| xref:llvm/PreservedCastFlags.adoc[`PreservedCastFlags`] 
| 
| xref:llvm/PressureChange.adoc[`PressureChange`] 
| Capture a change in pressure for a single pressure set&period; UnitInc may be expressed in terms of upward or downward pressure depending on the client and will be dynamically adjusted for current liveness&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`] 
| PrettyStackTraceEntry &hyphen; This class is used to represent a frame of the &quot;pretty&quot; stack trace that is dumped when a program crashes&period; You can define subclasses of this and declare them on the program stack&colon; when they are constructed and destructed, they will add their symbolic frames to a virtual stack trace&period; This gets dumped out if the program crashes&period;
| xref:llvm/PrettyStackTraceFormat.adoc[`PrettyStackTraceFormat`] 
| PrettyStackTraceFormat &hyphen; This object prints a string (which may use printf&hyphen;style formatting but should not contain newlines) to the stream as the stack trace when a crash occurs&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`] 
| 
| 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`] 
| 
| xref:llvm/PrintMIRPreparePass.adoc[`PrintMIRPreparePass`] 
| 
| 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`] 
| 
| xref:llvm/PrintPassOptions.adoc[`PrintPassOptions`] 
| 
| xref:llvm/PrintPipelinePassesFormatParser.adoc[`PrintPipelinePassesFormatParser`] 
| 
| 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`] 
| 
| xref:llvm/ProfOStream.adoc[`ProfOStream`] 
| 
| xref:llvm/ProfiParams.adoc[`ProfiParams`] 
| Various thresholds and options controlling the behavior of the profile inference algorithm&period; Default values are tuned for several large&hyphen;scale applications, and can be modified via corresponding command&hyphen;line flags&period;
| xref:llvm/ProfileAnnotator.adoc[`ProfileAnnotator`] 
| 
| xref:llvm/ProfileAnnotatorImpl.adoc[`ProfileAnnotatorImpl`] 
| Utility that propagates counter values to each basic block and to each edge when a basic block has more than one outgoing edge, using an adaptation of PGOUseFunc&colon;&colon;populateCounters&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`] 
| 
| xref:llvm/ProfileSummaryAnalysis.adoc[`ProfileSummaryAnalysis`] 
| An analysis pass based on the new PM to deliver ProfileSummaryInfo&period;
| xref:llvm/ProfileSummaryBuilder.adoc[`ProfileSummaryBuilder`] 
| 
| xref:llvm/ProfileSummaryEntry.adoc[`ProfileSummaryEntry`] 
| 
| 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`] 
| Checks that MD&lowbar;prof is present on every instruction that supports it&period; Used in conjunction with the ProfileInjectorPass&period; MD&lowbar;prof &quot;unknown&quot; is considered valid (i&period;e&period; !&lcub;!&quot;unknown&quot;&rcub;)
| xref:llvm/PrologEpilogInserterPass.adoc[`PrologEpilogInserterPass`] 
| 
| xref:llvm/PromotePass.adoc[`PromotePass`] 
| 
| xref:llvm/PseudoProbe.adoc[`PseudoProbe`] 
| 
| xref:llvm/PseudoProbeDescriptor.adoc[`PseudoProbeDescriptor`] 
| 
| xref:llvm/PseudoProbeDwarfDiscriminator.adoc[`PseudoProbeDwarfDiscriminator`] 
| 
| xref:llvm/PseudoProbeHandler.adoc[`PseudoProbeHandler`] 
| 
| xref:llvm/PseudoProbeInst.adoc[`PseudoProbeInst`] 
| 
| xref:llvm/PseudoProbeManager.adoc[`PseudoProbeManager`] 
| 
| xref:llvm/PseudoProbeSDNode.adoc[`PseudoProbeSDNode`] 
| This SDNode is used for PSEUDO&lowbar;PROBE values, which are the function guid and the index of the basic block being probed&period; A pseudo probe serves as a place holder and will be removed at the end of compilation&period; It does not have any operand because we do not want the instruction selection to deal with any&period;
| xref:llvm/PseudoProbeUpdatePass.adoc[`PseudoProbeUpdatePass`] 
| 
| xref:llvm/PseudoProbeVerifier.adoc[`PseudoProbeVerifier`] 
| 
| xref:llvm/PseudoSourceValue.adoc[`PseudoSourceValue`] 
| Special value supplied for machine level alias analysis&period; It indicates that a memory access references the functions stack frame (e&period;g&period;, a spill slot), below the stack frame (e&period;g&period;, argument space), or constant pool&period;
| xref:llvm/PseudoSourceValueManager.adoc[`PseudoSourceValueManager`] 
| Manages creation of pseudo source values&period;
| xref:llvm/PtrAddChain.adoc[`PtrAddChain`] 
| 
| xref:llvm/PtrToAddr.adoc[`PtrToAddr`] 
| 
| xref:llvm/PtrToAddrInst.adoc[`PtrToAddrInst`] 
| This class represents a cast from a pointer to an address (non&hyphen;capturing ptrtoint)&period;
| xref:llvm/PtrToAddrOperator.adoc[`PtrToAddrOperator`] 
| 
| xref:llvm/PtrToInt.adoc[`PtrToInt`] 
| 
| xref:llvm/PtrToIntInst.adoc[`PtrToIntInst`] 
| This class represents a cast from a pointer to an integer&period;
| xref:llvm/PtrToIntOperator.adoc[`PtrToIntOperator`] 
| 
| xref:llvm/PtrUseVisitor.adoc[`PtrUseVisitor`] 
| A base class for visitors over the uses of a pointer value&period;
| xref:llvm/RAGreedy.adoc[`RAGreedy`] 
| Interface to the eviction advisor, which is responsible for making a decision as to which live ranges should be evicted (if any)&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`] 
| 
| xref:llvm/RGPassManager.adoc[`RGPassManager`] 
| The pass manager to schedule RegionPasses&period;
| xref:llvm/RISCVAttributeParser.adoc[`RISCVAttributeParser`] 
| 
| xref:llvm/RISCVISAInfo.adoc[`RISCVISAInfo`] 
| 
| xref:llvm/RNSuccIterator-05.adoc[`RNSuccIterator`] 
| Hierarchical RegionNode successor iterator&period;
| xref:llvm/RTDyldMemoryManager.adoc[`RTDyldMemoryManager`] 
| 
| 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`] 
| 
| xref:llvm/RadixTree.adoc[`RadixTree`] 
| A Radix Tree implementation&period;
| xref:llvm/RandomIRBuilder.adoc[`RandomIRBuilder`] 
| 
| 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 &quot;int&quot; used to store reaching definitions, using an encoding that makes it compatible with TinyPtrVector&period; The 0th LSB is forced zero (and will be used for pointer union tagging), The 1st LSB is forced one (to make sure the value is non&hyphen;zero)&period;
| xref:llvm/ReachingDefAnalysis.adoc[`ReachingDefAnalysis`] 
| 
| xref:llvm/ReachingDefInfo.adoc[`ReachingDefInfo`] 
| This class provides the reaching def analysis&period;
| xref:llvm/ReachingDefInfoWrapperPass.adoc[`ReachingDefInfoWrapperPass`] 
| 
| xref:llvm/ReachingDefPrinterPass.adoc[`ReachingDefPrinterPass`] 
| Printer pass for the `ReachingDefInfo` results&period;
| xref:llvm/ReadyQueue.adoc[`ReadyQueue`] 
| ReadyQueue encapsulates vector of &quot;ready&quot; SUnits with basic convenience methods for pushing and removing nodes&period; ReadyQueue&apos;s are uniquely identified by an ID&period; SUnit&colon;&colon;NodeQueueId is a mask of the ReadyQueues the SUnit is in&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`] 
| 
| xref:llvm/RecomputeGlobalsAAPass.adoc[`RecomputeGlobalsAAPass`] 
| 
| xref:llvm/Record.adoc[`Record`] 
| 
| xref:llvm/RecordAccessor.adoc[`RecordAccessor`] 
| 
| xref:llvm/RecordKeeper.adoc[`RecordKeeper`] 
| 
| 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`] 
| 
| xref:llvm/RefCountedBase-0d.adoc[`RefCountedBase`] 
| A CRTP mixin class that adds reference counting to a type&period;
| xref:llvm/RegAllocEvictionAdvisor.adoc[`RegAllocEvictionAdvisor`] 
| 
| xref:llvm/RegAllocEvictionAdvisorAnalysis.adoc[`RegAllocEvictionAdvisorAnalysis`] 
| A MachineFunction analysis for fetching the Eviction Advisor&period; This sets up the Provider lazily and caches it&period; &hyphen; in the ML implementation case, the evaluator is stateless but (especially in the development mode) expensive to set up&period; With a Module Analysis, we `require` it and set it up once&period; &hyphen; in the &apos;development&apos; mode ML case, we want to capture the training log during allocation (this is a log of features encountered and decisions made), and then measure a score, potentially a few steps after allocation completes&period; So we need a Module analysis to keep the logger state around until we can make that measurement&period;
| xref:llvm/RegAllocEvictionAdvisorAnalysisLegacy.adoc[`RegAllocEvictionAdvisorAnalysisLegacy`] 
| ImmutableAnalysis abstraction for fetching the Eviction Advisor&period; We model it as an analysis to decouple the user from the implementation insofar as dependencies on other analyses goes&period; The motivation for it being an immutable pass is twofold&colon; &hyphen; in the ML implementation case, the evaluator is stateless but (especially in the development mode) expensive to set up&period; With an immutable pass, we set it up once&period; &hyphen; in the &apos;development&apos; mode ML case, we want to capture the training log during allocation (this is a log of features encountered and decisions made), and then measure a score, potentially a few steps after allocation completes&period; So we need the properties of an immutable pass to keep the logger state around until we can make that measurement&period;
| xref:llvm/RegAllocEvictionAdvisorProvider.adoc[`RegAllocEvictionAdvisorProvider`] 
| Common provider for legacy and new pass managers&period; This keeps the state for logging, and sets up and holds the provider&period; The legacy pass itself used to keep the logging state and provider, so this extraction helps the NPM analysis to reuse the logic&period; TODO&colon; Coalesce this with the NPM analysis when legacy PM is removed&period;
| xref:llvm/RegAllocFastPass.adoc[`RegAllocFastPass`] 
| 
| xref:llvm/RegAllocPriorityAdvisor.adoc[`RegAllocPriorityAdvisor`] 
| Interface to the priority advisor, which is responsible for prioritizing live ranges&period;
| xref:llvm/RegAllocPriorityAdvisorAnalysis.adoc[`RegAllocPriorityAdvisorAnalysis`] 
| 
| xref:llvm/RegAllocPriorityAdvisorAnalysisLegacy.adoc[`RegAllocPriorityAdvisorAnalysisLegacy`] 
| 
| xref:llvm/RegAllocPriorityAdvisorProvider.adoc[`RegAllocPriorityAdvisorProvider`] 
| Common provider for getting the priority advisor and logging rewards&period; Legacy analysis forwards all calls to this provider&period; New analysis serves the provider as the analysis result&period; Expensive setup is done in the constructor, so that the advisor can be created quickly for every machine function&period; TODO&colon; Remove once legacy PM support is dropped&period;
| xref:llvm/RegAllocTypeParser.adoc[`RegAllocTypeParser`] 
| 
| xref:llvm/RegBankSelectLegacy.adoc[`RegBankSelectLegacy`] 
| This pass implements the reg bank selector pass used in the GlobalISel pipeline&period; At the end of this pass, all register operands have been assigned
| xref:llvm/RegBankSelectPass.adoc[`RegBankSelectPass`] 
| 
| 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`] 
| Used to describe a register and immediate addition&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`] 
| Track the current register pressure at some position in the instruction stream, and remember the high water mark within the region traversed&period; This does not automatically consider live&hyphen;through ranges&period; The client may independently adjust for global liveness&period;
| xref:llvm/RegScavenger.adoc[`RegScavenger`] 
| 
| xref:llvm/RegToMemPass.adoc[`RegToMemPass`] 
| 
| xref:llvm/RegUsageInfoCollectorPass.adoc[`RegUsageInfoCollectorPass`] 
| 
| xref:llvm/RegUsageInfoPropagationPass.adoc[`RegUsageInfoPropagationPass`] 
| 
| xref:llvm/Regex.adoc[`Regex`] 
| 
| xref:llvm/Region.adoc[`Region`] 
| 
| xref:llvm/RegionBase-0e.adoc[`RegionBase`] 
| A single entry single exit Region&period;
| xref:llvm/RegionInfo.adoc[`RegionInfo`] 
| 
| 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&period;
| xref:llvm/RegionInfoPass.adoc[`RegionInfoPass`] 
| 
| 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`] 
| 
| xref:llvm/RegionNodeBase-00.adoc[`RegionNodeBase`] 
| A RegionNode represents a subregion or a BasicBlock that is part of a Region&period;
| xref:llvm/RegionPass.adoc[`RegionPass`] 
| A pass that runs on each Region in a function&period;
| xref:llvm/RegionPressure.adoc[`RegionPressure`] 
| RegisterPressure computed within a region of instructions delimited by TopPos and BottomPos&period; This is a less precise version of IntervalPressure for use when LiveIntervals are unavailable&period;
| xref:llvm/RegionTraits-02.adoc[`RegionTraits`] 
| 
| 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`] 
| 
| xref:llvm/RegisterCoalescerPass.adoc[`RegisterCoalescerPass`] 
| 
| xref:llvm/RegisterImmPair.adoc[`RegisterImmPair`] 
| 
| xref:llvm/RegisterMCAsmBackend.adoc[`RegisterMCAsmBackend`] 
| RegisterMCAsmBackend &hyphen; Helper template for registering a target specific assembler backend&period; Usage&colon;
| xref:llvm/RegisterMCAsmInfo.adoc[`RegisterMCAsmInfo`] 
| RegisterMCAsmInfo &hyphen; Helper template for registering a target assembly info implementation&period; This invokes the static &quot;Create&quot; method on the class to actually do the construction&period; Usage&colon;
| 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`] 
| RegisterMCInstrAnalysis &hyphen; Helper template for registering a target instruction analyzer implementation&period; This invokes the static &quot;Create&quot; method on the class to actually do the construction&period; Usage&colon;
| xref:llvm/RegisterMCInstrAnalysisFn.adoc[`RegisterMCInstrAnalysisFn`] 
| RegisterMCInstrAnalysisFn &hyphen; Helper template for registering a target instruction analyzer implementation&period; This invokes the specified function to do the construction&period; Usage&colon;
| xref:llvm/RegisterMCInstrInfo.adoc[`RegisterMCInstrInfo`] 
| RegisterMCInstrInfo &hyphen; Helper template for registering a target instruction info implementation&period; This invokes the static &quot;Create&quot; method on the class to actually do the construction&period; Usage&colon;
| xref:llvm/RegisterMCInstrInfoFn.adoc[`RegisterMCInstrInfoFn`] 
| RegisterMCInstrInfoFn &hyphen; Helper template for registering a target instruction info implementation&period; This invokes the specified function to do the construction&period; Usage&colon;
| xref:llvm/RegisterMCObjectFileInfo.adoc[`RegisterMCObjectFileInfo`] 
| Helper template for registering a target object file info implementation&period; This invokes the static &quot;Create&quot; method on the class to actually do the construction&period; Usage&colon;
| 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`] 
| RegisterMCRegInfo &hyphen; Helper template for registering a target register info implementation&period; This invokes the static &quot;Create&quot; method on the class to actually do the construction&period; Usage&colon;
| 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`] 
| RegisterMCSubtargetInfo &hyphen; Helper template for registering a target subtarget info implementation&period; This invokes the static &quot;Create&quot; method on the class to actually do the construction&period; Usage&colon;
| xref:llvm/RegisterMCSubtargetInfoFn.adoc[`RegisterMCSubtargetInfoFn`] 
| RegisterMCSubtargetInfoFn &hyphen; Helper template for registering a target subtarget info implementation&period; This invokes the specified function to do the construction&period; Usage&colon;
| xref:llvm/RegisterMaskSDNode.adoc[`RegisterMaskSDNode`] 
| 
| 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`] 
| 
| xref:llvm/RegisterRegAllocBase-04.adoc[`RegisterRegAllocBase`] 
| RegisterRegAllocBase class &hyphen; Track the registration of register allocators&period;
| xref:llvm/RegisterSDNode.adoc[`RegisterSDNode`] 
| 
| xref:llvm/RegisterScheduler.adoc[`RegisterScheduler`] 
| 
| 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`] 
| 
| xref:llvm/Registry-08.adoc[`Registry`] 
| A global registry used in conjunction with static constructors to make pluggable components (like targets or garbage collectors) &quot;just work&quot; when linked with an executable&period;
| xref:llvm/RelLookupTableConverterPass.adoc[`RelLookupTableConverterPass`] 
| 
| xref:llvm/ReleaseModeModelRunner.adoc[`ReleaseModeModelRunner`] 
| 
| 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`] 
| 
| xref:llvm/RemoveRedundantDebugValuesPass.adoc[`RemoveRedundantDebugValuesPass`] 
| 
| xref:llvm/RenameIndependentSubregsPass.adoc[`RenameIndependentSubregsPass`] 
| 
| 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`] 
| 
| xref:llvm/ReplaceWithVeclibLegacy.adoc[`ReplaceWithVeclibLegacy`] 
| 
| xref:llvm/ReplaceableMetadataImpl.adoc[`ReplaceableMetadataImpl`] 
| Shared implementation of use&hyphen;lists for replaceable metadata&period;
| xref:llvm/ReplacementItem.adoc[`ReplacementItem`] 
| 
| 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-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`] 
| 
| xref:llvm/ResourceManager.adoc[`ResourceManager`] 
| 
| xref:llvm/ResourcePriorityQueue.adoc[`ResourcePriorityQueue`] 
| 
| 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`] 
| Represent one information held inside an operand bundle of an llvm&period;assume&period; AttrKind is the property that holds&period; WasOn if not null is that Value for which AttrKind holds&period; ArgValue is optionally an argument of the attribute&period; For example if we know that %P has an alignment of at least four&colon; &hyphen; AttrKind will be Attribute&colon;&colon;Alignment&period; &hyphen; WasOn will be %P&period; &hyphen; ArgValue will be 4&period;
| xref:llvm/ReturnInst.adoc[`ReturnInst`] 
| Return a value (possibly void), from a function&period; Execution does not continue in this function any longer&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`] 
| 
| xref:llvm/RewriteSymbolPass.adoc[`RewriteSymbolPass`] 
| 
| xref:llvm/Rollbacker.adoc[`Rollbacker`] 
| Rematerializer listener with the ability to re&hyphen;create deleted registers and rollback rematerializations&period; Starts recording register deletions and rematerializations as soon as it is attached to the rematerializer&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`] 
| 
| xref:llvm/RuntimeDyldChecker.adoc[`RuntimeDyldChecker`] 
| RuntimeDyld invariant checker for verifying that RuntimeDyld has correctly applied relocations&period;
| xref:llvm/RuntimeDyldCheckerImpl.adoc[`RuntimeDyldCheckerImpl`] 
| 
| 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`] 
| 
| xref:llvm/RuntimeLibraryAnalysis.adoc[`RuntimeLibraryAnalysis`] 
| 
| xref:llvm/RuntimeLibraryInfoWrapper.adoc[`RuntimeLibraryInfoWrapper`] 
| 
| 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`] 
| 
| 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`] 
| This node represents a polynomial recurrence on the trip count of the specified loop&period; This is the primary focus of the ScalarEvolution framework&semi; all the other SCEV subclasses are mostly just supporting infrastructure to allow SCEVAddRecExpr expressions to be created and analyzed&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`] 
| This class represents a constant integer value&period;
| xref:llvm/SCEVCouldNotCompute.adoc[`SCEVCouldNotCompute`] 
| An object of this class is returned by queries that could not be answered&period; For example, if you ask for the number of iterations of a linked&hyphen;list traversal loop, you will get one of these&period; None of the standard SCEV operations are valid on this class, it is just a marker&period;
| xref:llvm/SCEVDivision.adoc[`SCEVDivision`] 
| 
| xref:llvm/SCEVDivisionPrinterPass.adoc[`SCEVDivisionPrinterPass`] 
| 
| 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`] 
| This node is the base class for sequential&sol;in&hyphen;order min&sol;max selections&period; Note that their fundamental difference from SCEVMinMaxExpr&apos;s is that they are early&hyphen;returning upon reaching saturation point&period; I&period;e&period; given `0 umin&lowbar;seq poison`, the result will be `0`, while the result of `0 umin poison` is `poison`&period; When returning early, later expressions are not executed, so `0 umin&lowbar;seq (%x u&sol; 0)` does not result in undefined behavior&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`] 
| This class represents a composition of other SCEV predicates, and is the class that most clients will interact with&period; This is equivalent to a logical &quot;AND&quot; of all the predicates in the union&period;
| xref:llvm/SCEVUnknown.adoc[`SCEVUnknown`] 
| This means that we are dealing with an entirely unknown SCEV value, and only represent it as its LLVM Value&period; This is the &quot;bottom&quot; value for the analysis&period;
| xref:llvm/SCEVUseT-0f.adoc[`SCEVUseT`] 
| 
| 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`] 
| This class represents an assumption made on an AddRec expression&period; Given an affine AddRec expression &lcub;a,&plus;,b&rcub;, we assume that it has the nssw or nusw flags (defined below) in the first X iterations of the loop, where X is a SCEV expression returned by getPredicatedBackedgeTakenCount)&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`] 
| Keeps track of dbg&lowbar;value information through SDISel&period; We do not build SDNodes for these so as not to perturb the generated code&semi; instead the info is kept off to the side in this structure&period; Each SDNode may have one or more associated dbg&lowbar;value entries&period; This information is kept in DbgValMap&period; Byval parameters are handled separately because they don&apos;t use alloca&apos;s, which busts the normal mechanism&period; There is good reason for handling all parameters separately&colon; they may not have code generated for them, they should always go at the beginning of the function regardless of other code motion, and debug info for them is potentially useful even if the parameter is unused&period; Right now only byval parameters are handled separately&period;
| xref:llvm/SDDbgLabel.adoc[`SDDbgLabel`] 
| 
| xref:llvm/SDDbgOperand.adoc[`SDDbgOperand`] 
| 
| xref:llvm/SDDbgValue.adoc[`SDDbgValue`] 
| 
| xref:llvm/SDLoc.adoc[`SDLoc`] 
| Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation functions&period; When an SDNode is created from the DAGBuilder, the DebugLoc is extracted from the original Instruction, and IROrder is the ordinal position of the instruction&period; When an SDNode is created after the DAG is being built, both DebugLoc and the IROrder are propagated from the original SDNode&period; So SDLoc class provides two constructors besides the default one, one to be used by the DAGBuilder, the other to be used by others&period;
| xref:llvm/SDNode.adoc[`SDNode`] 
| Represents one node in the SelectionDAG&period;
| xref:llvm/SDNodeDesc.adoc[`SDNodeDesc`] 
| 
| xref:llvm/SDNodeFlags.adoc[`SDNodeFlags`] 
| These are IR&hyphen;level optimization flags that may be propagated to SDNodes&period; TODO&colon; This data structure should be shared by the IR optimizer and the the backend&period;
| xref:llvm/SDNodeInfo.adoc[`SDNodeInfo`] 
| 
| xref:llvm/SDNodeIterator.adoc[`SDNodeIterator`] 
| 
| xref:llvm/SDTypeConstraint.adoc[`SDTypeConstraint`] 
| 
| xref:llvm/SDUse.adoc[`SDUse`] 
| Represents a use of a SDNode&period; This class holds an SDValue, which records the SDNode being used and the result number, a pointer to the SDNode using the value, and Next and Prev pointers, which link together all the uses of an SDNode&period;
| xref:llvm/SDVTList.adoc[`SDVTList`] 
| This represents a list of ValueType&apos;s that has been intern&apos;d by a SelectionDAG&period; Instances of this simple value class are returned by SelectionDAG&colon;&colon;getVTList(&period;&period;&period;)&period;
| xref:llvm/SDVTListNode.adoc[`SDVTListNode`] 
| 
| xref:llvm/SDValue.adoc[`SDValue`] 
| Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation&period; Many nodes return multiple values, from loads (which define a token and a return value) to ADDC (which returns a result and a carry value), to calls (which may return an arbitrary number of 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`] 
| 
| xref:llvm/SEHUnwindMapEntry.adoc[`SEHUnwindMapEntry`] 
| Similar to CxxUnwindMapEntry, but supports SEH filters&period;
| xref:llvm/SExtInst.adoc[`SExtInst`] 
| This class represents a sign extension of integer types&period;
| xref:llvm/SHA1.adoc[`SHA1`] 
| A class that wrap the SHA1 algorithm&period;
| xref:llvm/SHA256.adoc[`SHA256`] 
| 
| xref:llvm/SIToFPInst.adoc[`SIToFPInst`] 
| This class represents a cast from signed integer to floating point&period;
| xref:llvm/SLPVectorizerPass.adoc[`SLPVectorizerPass`] 
| 
| 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`] 
| This class represents the scheduled code&period; The main data structure is a map from scheduled cycle to instructions&period; During scheduling, the data structure explicitly represents all stages&sol;iterations&period; When the algorithm finshes, the schedule is collapsed into a single stage, which represents instructions from different loop iterations&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`] 
| 
| xref:llvm/SMTSort.adoc[`SMTSort`] 
| Generic base class for SMT sorts
| xref:llvm/SPIRVObjectWriter.adoc[`SPIRVObjectWriter`] 
| 
| xref:llvm/SROAOptions.adoc[`SROAOptions`] 
| 
| xref:llvm/SROAPass.adoc[`SROAPass`] 
| 
| 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`] 
| 
| xref:llvm/SSAUpdaterTraits.adoc[`SSAUpdaterTraits`] 
| 
| 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`] 
| 
| xref:llvm/SSPLayoutInfo.adoc[`SSPLayoutInfo`] 
| 
| xref:llvm/SUnit.adoc[`SUnit`] 
| Scheduling unit&period; This is a node in the scheduling DAG&period;
| xref:llvm/SUnitIterator.adoc[`SUnitIterator`] 
| 
| xref:llvm/SafeStackPass.adoc[`SafeStackPass`] 
| 
| 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`] 
| 
| xref:llvm/SampleProfileInference.adoc[`SampleProfileInference`] 
| Sample profile inference pass&period;
| xref:llvm/SampleProfileLoaderBaseImpl.adoc[`SampleProfileLoaderBaseImpl`] 
| 
| xref:llvm/SampleProfileLoaderPass.adoc[`SampleProfileLoaderPass`] 
| The sample profiler data loader pass&period;
| xref:llvm/SampleProfileMatcher.adoc[`SampleProfileMatcher`] 
| 
| xref:llvm/SampleProfileProbePass.adoc[`SampleProfileProbePass`] 
| 
| xref:llvm/SampleProfileProber.adoc[`SampleProfileProber`] 
| Sample profile pseudo prober&period;
| xref:llvm/SampleProfileSummaryBuilder.adoc[`SampleProfileSummaryBuilder`] 
| 
| xref:llvm/SandboxVectorizerPass.adoc[`SandboxVectorizerPass`] 
| 
| xref:llvm/SanitizerBinaryMetadataOptions.adoc[`SanitizerBinaryMetadataOptions`] 
| 
| xref:llvm/SanitizerBinaryMetadataPass.adoc[`SanitizerBinaryMetadataPass`] 
| The pass should be inserted after optimizations&period;
| xref:llvm/SanitizerCoverageOptions.adoc[`SanitizerCoverageOptions`] 
| 
| xref:llvm/SanitizerCoveragePass.adoc[`SanitizerCoveragePass`] 
| This is the ModuleSanitizerCoverage pass used in the new pass manager&period; The pass instruments functions for coverage, adds initialization calls to the module for trace PC guards and 8bit counters if they are requested, and appends globals to llvm&period;compiler&period;used&period;
| xref:llvm/SanitizerStatReport.adoc[`SanitizerStatReport`] 
| 
| 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`] 
| 
| xref:llvm/ScalarEvolutionsTest.adoc[`ScalarEvolutionsTest`] 
| 
| xref:llvm/ScalarizeMaskedMemIntrinPass.adoc[`ScalarizeMaskedMemIntrinPass`] 
| 
| xref:llvm/ScalarizerPass.adoc[`ScalarizerPass`] 
| 
| xref:llvm/ScalarizerPassOptions.adoc[`ScalarizerPassOptions`] 
| 
| xref:llvm/ScaledNumber.adoc[`ScaledNumber`] 
| Simple representation of a scaled number&period;
| xref:llvm/ScaledNumberBase.adoc[`ScaledNumberBase`] 
| 
| xref:llvm/ScanInfo.adoc[`ScanInfo`] 
| ScanInfo holds the information to assist in lowering of Scan reduction&period; Before lowering, the body of the for loop specifying scan reduction is expected to have the following structure
| xref:llvm/SchedBoundary.adoc[`SchedBoundary`] 
| Each Scheduling boundary is associated with ready queues&period; It tracks the current cycle in the direction of movement, and maintains the state of &quot;hazards&quot; and other interlocks at the current cycle&period;
| xref:llvm/SchedDFSImpl.adoc[`SchedDFSImpl`] 
| 
| 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`] 
| 
| xref:llvm/ScheduleDAGInstrs.adoc[`ScheduleDAGInstrs`] 
| A ScheduleDAG for scheduling lists of MachineInstr&period;
| xref:llvm/ScheduleDAGMI.adoc[`ScheduleDAGMI`] 
| ScheduleDAGMI is an implementation of ScheduleDAGInstrs that simply schedules machine instructions according to the given MachineSchedStrategy without much extra book&hyphen;keeping&period; This is the common functionality between PreRA and PostRA MachineScheduler&period;
| xref:llvm/ScheduleDAGMILive.adoc[`ScheduleDAGMILive`] 
| ScheduleDAGMILive is an implementation of ScheduleDAGInstrs that schedules machine instructions while updating LiveIntervals and tracking regpressure&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`] 
| This interface is used to plug different priorities computation algorithms into the list scheduler&period; It implements the interface of a standard priority queue, where nodes are inserted in arbitrary order and returned in priority order&period; The computation of the priority and the representation of the queue are totally up to the implementation to decide&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`] 
| 
| xref:llvm/ScoreboardHazardRecognizer.adoc[`ScoreboardHazardRecognizer`] 
| 
| xref:llvm/SectionKind.adoc[`SectionKind`] 
| SectionKind &hyphen; This is a simple POD value that classifies the properties of a section&period; A section is classified into the deepest possible classification, and then the target maps them onto their sections based on what capabilities they have&period;
| xref:llvm/SectionMemoryManager.adoc[`SectionMemoryManager`] 
| This is a simple memory manager which implements the methods called by the RuntimeDyld class to allocate memory for section&hyphen;based loading of objects, usually those generated by the MCJIT execution engine&period;
| xref:llvm/SectionName.adoc[`SectionName`] 
| 
| xref:llvm/SelectAddr.adoc[`SelectAddr`] 
| Storage of either a normal Value address, or a select condition together with a pair of addresses for the &quot;true&quot; and &quot;false&quot; variant of a select&hyphen;dependent address&period; If the addresses are not present (both null), V is a normal address&semi; otherwise V is a select condition and the pair holds the &quot;true&quot; and &quot;false&quot; addresses&period;
| xref:llvm/SelectInst.adoc[`SelectInst`] 
| This class represents the LLVM &apos;select&apos; instruction&period;
| xref:llvm/SelectOptimizePass.adoc[`SelectOptimizePass`] 
| 
| xref:llvm/SelectPatternResult.adoc[`SelectPatternResult`] 
| 
| xref:llvm/SelectionDAG.adoc[`SelectionDAG`] 
| This is used to represent a portion of an LLVM function in a low&hyphen;level Data Dependence DAG representation suitable for instruction selection&period; This DAG is constructed as the first step of instruction selection in order to allow implementation of machine specific optimizations and code simplifications&period;
| xref:llvm/SelectionDAGBuilder.adoc[`SelectionDAGBuilder`] 
| 
| 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`] 
| 
| xref:llvm/SelectionDAGISelPass.adoc[`SelectionDAGISelPass`] 
| 
| xref:llvm/SelectionDAGTargetInfo.adoc[`SelectionDAGTargetInfo`] 
| Targets can subclass this to parameterize the SelectionDAG lowering and instruction selection process&period;
| xref:llvm/SeparateConstOffsetFromGEPPass.adoc[`SeparateConstOffsetFromGEPPass`] 
| 
| xref:llvm/SetState-0b.adoc[`SetState`] 
| Simple state for a set&period;
| xref:llvm/SetTheory.adoc[`SetTheory`] 
| 
| 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`] 
| 
| xref:llvm/ShapeT.adoc[`ShapeT`] 
| 
| xref:llvm/ShiftOfShiftedLogic.adoc[`ShiftOfShiftedLogic`] 
| 
| xref:llvm/ShlOperator.adoc[`ShlOperator`] 
| 
| xref:llvm/ShouldNotRunFunctionPassesAnalysis.adoc[`ShouldNotRunFunctionPassesAnalysis`] 
| 
| 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`] 
| 
| 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`] 
| This SDNode is used to implement the code generator support for the llvm IR shufflevector instruction&period; It combines elements from two input vectors into a new input vector, with the selection and ordering of elements determined by an array of integers, referred to as the shuffle mask&period; For input vectors of width N, mask indices of 0&period;&period;N&hyphen;1 refer to elements from the LHS input, and indices from N to 2N&hyphen;1 the RHS&period; An index of &hyphen;1 is treated as undef, such that the code generator may put any value in the corresponding element of the result&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`] 
| 
| 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, which computes and caches whether an object is captured in the function at all, but does not distinguish whether it was captured before or after the context instruction&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`] 
| This pass transforms loops that contain branches or switches on loop&hyphen; invariant conditions to have multiple loops&period; For example, it turns the left into the right code&colon;
| 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`] 
| 
| xref:llvm/SimplifyCFGPass.adoc[`SimplifyCFGPass`] 
| A pass to simplify and canonicalize the CFG of a function&period;
| xref:llvm/SimplifyQuery.adoc[`SimplifyQuery`] 
| 
| xref:llvm/SimplifyTypeTestsPass.adoc[`SimplifyTypeTestsPass`] 
| 
| 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; The number of memory access in the loop (and whether there are too many) is determined in the constructors when using MemorySSA&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`] 
| 
| xref:llvm/SizeOffsetWeakTrackingVH.adoc[`SizeOffsetWeakTrackingVH`] 
| SizeOffsetValue &hyphen; Used by `ObjectSizeOffsetEvaluator,` which works with `Values&period;`
| xref:llvm/SjLjEHPreparePass.adoc[`SjLjEHPreparePass`] 
| 
| 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`] 
| 
| xref:llvm/SlotIndexesPrinterPass.adoc[`SlotIndexesPrinterPass`] 
| 
| xref:llvm/SlotIndexesWrapperPass.adoc[`SlotIndexesWrapperPass`] 
| 
| xref:llvm/SlotMapping.adoc[`SlotMapping`] 
| This struct contains the mappings from the slot numbers to unnamed metadata nodes, global values and types&period; It also contains the mapping for the named types&period; It can be used to save the parsing state of an LLVM IR module so that the textual references to the values in the module can be parsed outside of the module&apos;s source&period;
| xref:llvm/SlotTracker.adoc[`SlotTracker`] 
| 
| xref:llvm/SmallBitVector.adoc[`SmallBitVector`] 
| Variable&hyphen;sized bit array optimized for small bit counts&period;
| xref:llvm/SmallDenseMap.adoc[`SmallDenseMap`] 
| 
| 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`] 
| SmallPtrSet &hyphen; This class implements a set which is optimized for holding SmallSize or less elements&period; This internally rounds up SmallSize to the next power of two if it is not already a power of two&period; See the comments above SmallPtrSetImplBase for details of the algorithm&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`] 
| SmallPtrSetImplBase &hyphen; This is the common code shared among all the SmallPtrSet&lt;&gt;&apos;s, which is almost everything&period; SmallPtrSet has two modes, one for small and one for large sets&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`] 
| SmallSet &hyphen; This maintains a set of unique values, optimizing for the case when the set is small (less than N)&period; In this case, the set can be maintained with no mallocs&period; If the set gets large, we expand to using an std&colon;&colon;set to maintain reasonable lookup times&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`] 
| This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector &apos;N&apos; template parameter&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`] 
| This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD&period; The extra dummy template argument is used by ArrayRef to avoid unnecessarily requiring T to be complete&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; Objects in a SparseSet are identified by keys that can be uniquely converted to a small integer less than the set&apos;s universe&period; This class allows the set to hold values that differ from the set&apos;s key type as long as an index can still be derived from the value&period; SparseSet never directly compares ValueT, only their indices, so it can map keys to arbitrary values&period; SparseSetValTraits computes the index from the value object&period; To compute the index from a key, SparseSet uses a separate KeyFunctorT template argument&period;
| xref:llvm/SparseSolver.adoc[`SparseSolver`] 
| SparseSolver &hyphen; This class is a general purpose solver for Sparse Conditional Propagation with a programmable lattice function&period;
| xref:llvm/Spec.adoc[`Spec`] 
| 
| xref:llvm/SpecSig.adoc[`SpecSig`] 
| 
| 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`] 
| 
| xref:llvm/Spelling.adoc[`Spelling`] 
| 
| xref:llvm/SpillPlacement.adoc[`SpillPlacement`] 
| 
| xref:llvm/SpillPlacementAnalysis.adoc[`SpillPlacementAnalysis`] 
| 
| xref:llvm/SpillPlacementWrapperLegacy.adoc[`SpillPlacementWrapperLegacy`] 
| 
| 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`] 
| 
| xref:llvm/SrcValueSDNode.adoc[`SrcValueSDNode`] 
| An SDNode that holds an arbitrary LLVM IR Value&period; This is used when the SelectionDAG needs to make a simple reference to something in the LLVM IR representation&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`] 
| 
| xref:llvm/StableFunctionMapRecord.adoc[`StableFunctionMapRecord`] 
| The structure of the serialized stable function map is as follows&colon; &hyphen; Number of unique function&sol;module names &hyphen; Total size of unique function&sol;module names for opt&hyphen;in skipping &hyphen; Unique function&sol;module names &hyphen; Padding to align to 4 bytes &hyphen; Number of StableFunctionEntries &hyphen; Hashes of each StableFunctionEntry &hyphen; Fixed&hyphen;size fields for each StableFunctionEntry (the order is consistent with the hashes above)&colon; &hyphen; FunctionNameId &hyphen; ModuleNameId &hyphen; InstCount &hyphen; Relative offset to the beginning of IndexOperandHashes for this entry &hyphen; Total size of variable&hyphen;sized IndexOperandHashes for lazy&hyphen;loading support &hyphen; Variable&hyphen;sized IndexOperandHashes for each StableFunctionEntry&colon; &hyphen; Number of IndexOperandHashes &hyphen; Contents of each IndexOperandHashes &hyphen; InstIndex &hyphen; OpndIndex &hyphen; OpndHash
| xref:llvm/StackColoringPass.adoc[`StackColoringPass`] 
| 
| xref:llvm/StackFrameLayoutAnalysisPass.adoc[`StackFrameLayoutAnalysisPass`] 
| 
| xref:llvm/StackLifetime.adoc[`StackLifetime`] 
| Compute live ranges of allocas&period; Live ranges are represented as sets of &quot;interesting&quot; instructions, which are defined as instructions that may start or end an alloca&apos;s lifetime&period; These are&colon; &ast; lifetime&period;start and lifetime&period;end intrinsics &ast; first instruction of any basic block Interesting instructions are numbered in the depth&hyphen;first walk of the CFG, and in the program order inside each basic block&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`] 
| 
| xref:llvm/StackOffset.adoc[`StackOffset`] 
| StackOffset holds a fixed and a scalable offset in bytes&period;
| xref:llvm/StackProtector.adoc[`StackProtector`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| Call sites that get wrapped by a gc&period;statepoint (currently only in RewriteStatepointsForGC and potentially in other passes in the future) can have attributes that describe properties of gc&period;statepoint call they will be eventually be wrapped in&period; This struct is used represent such directives&period;
| xref:llvm/StatepointOpers.adoc[`StatepointOpers`] 
| MI&hyphen;level Statepoint operands
| xref:llvm/StaticDataAnnoatorPass.adoc[`StaticDataAnnoatorPass`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| &quot;foo&quot; &hyphen; Represent an initialization by a string value&period;
| xref:llvm/StringLiteral.adoc[`StringLiteral`] 
| A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs with the length computed at compile time&period; In order to avoid the invocation of a global constructor, StringLiteral should _only_ be used in a constexpr context, as such&colon;
| xref:llvm/StringMap-044.adoc[`StringMap`] 
| StringMap &hyphen; This is an unconventional map that is specialized for handling keys that are &quot;strings&quot;, which are basically ranges of bytes&period; This does some funky memory allocation and hashing things to make it extremely efficient, storing the string data _after_ the value in the map&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`] 
| StringToOffsetTable &hyphen; This class uniques a bunch of nul&hyphen;terminated strings and keeps track of their offset in a massive contiguous string allocation&period; It can then output this string blob and use indexes into the string to reference each piece&period;
| xref:llvm/StripConvergenceIntrinsicsPass.adoc[`StripConvergenceIntrinsicsPass`] 
| 
| xref:llvm/StripDeadCGProfilePass.adoc[`StripDeadCGProfilePass`] 
| 
| xref:llvm/StripDeadDebugInfoPass.adoc[`StripDeadDebugInfoPass`] 
| 
| xref:llvm/StripDeadPrototypesPass.adoc[`StripDeadPrototypesPass`] 
| Pass to remove unused function declarations&period;
| xref:llvm/StripDebugDeclarePass.adoc[`StripDebugDeclarePass`] 
| 
| xref:llvm/StripDebugMachineModulePass.adoc[`StripDebugMachineModulePass`] 
| 
| xref:llvm/StripGCRelocates.adoc[`StripGCRelocates`] 
| 
| xref:llvm/StripNonDebugSymbolsPass.adoc[`StripNonDebugSymbolsPass`] 
| 
| xref:llvm/StripNonLineTableDebugInfoPass.adoc[`StripNonLineTableDebugInfoPass`] 
| 
| xref:llvm/StripSymbolsPass.adoc[`StripSymbolsPass`] 
| 
| 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`] 
| 
| xref:llvm/StructuredGEPInst.adoc[`StructuredGEPInst`] 
| 
| xref:llvm/StructurizeCFGPass.adoc[`StructurizeCFGPass`] 
| 
| xref:llvm/SubOperator.adoc[`SubOperator`] 
| 
| xref:llvm/SubsectionAndTagToTagName.adoc[`SubsectionAndTagToTagName`] 
| 
| 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`] 
| 
| xref:llvm/SubtargetFeatures.adoc[`SubtargetFeatures`] 
| Manages the enabling and disabling of subtarget specific features&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`] 
| 
| xref:llvm/SuffixTree.adoc[`SuffixTree`] 
| 
| xref:llvm/SuffixTreeInternalNode.adoc[`SuffixTreeInternalNode`] 
| 
| xref:llvm/SuffixTreeLeafNode.adoc[`SuffixTreeLeafNode`] 
| 
| xref:llvm/SuffixTreeNode.adoc[`SuffixTreeNode`] 
| A node in a suffix tree which represents a substring or suffix&period;
| xref:llvm/SuperRegClassIterator.adoc[`SuperRegClassIterator`] 
| 
| xref:llvm/SuspendCrossingInfo.adoc[`SuspendCrossingInfo`] 
| 
| xref:llvm/SwiftErrorValueTracking.adoc[`SwiftErrorValueTracking`] 
| 
| 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`] 
| This class provides APIs to retrieve edges from&sol;to an SUnit node, with a particular focus on loop&hyphen;carried dependencies&period; Since SUnit is not designed to represent such edges, handling them directly using its APIs has required non&hyphen;trivial logic in the past&period; This class serves as a wrapper around SUnit, offering a simpler interface for managing these dependencies&period;
| xref:llvm/SwingSchedulerDDGEdge.adoc[`SwingSchedulerDDGEdge`] 
| Represents a dependence between two instruction&period;
| xref:llvm/SwitchInst.adoc[`SwitchInst`] 
| Multiway switch
| xref:llvm/SwitchInstProfUpdateWrapper.adoc[`SwitchInstProfUpdateWrapper`] 
| A wrapper class to simplify modification of SwitchInst cases along with their prof branch&lowbar;weights metadata&period;
| xref:llvm/SymbolInfoTy.adoc[`SymbolInfoTy`] 
| 
| xref:llvm/SymbolRemappingParseError.adoc[`SymbolRemappingParseError`] 
| 
| 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`] 
| 
| xref:llvm/SymbolsMapKey.adoc[`SymbolsMapKey`] 
| 
| 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`] 
| 
| xref:llvm/TableGenOutputFiles.adoc[`TableGenOutputFiles`] 
| 
| xref:llvm/TagNameItem.adoc[`TagNameItem`] 
| 
| xref:llvm/TailCallElimPass.adoc[`TailCallElimPass`] 
| 
| xref:llvm/TailDuplicatePass.adoc[`TailDuplicatePass`] 
| 
| xref:llvm/TailDuplicatePassBase-03.adoc[`TailDuplicatePassBase`] 
| 
| xref:llvm/TailDuplicator.adoc[`TailDuplicator`] 
| Utility class to perform tail duplication&period;
| xref:llvm/TailFoldingInfo.adoc[`TailFoldingInfo`] 
| 
| xref:llvm/TarWriter.adoc[`TarWriter`] 
| 
| 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; It holds the direction of stack growth, the known stack alignment on entry to each function, and the offset to the locals area&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`] 
| 
| 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`] 
| 
| xref:llvm/TargetLoweringObjectFileCOFF.adoc[`TargetLoweringObjectFileCOFF`] 
| 
| xref:llvm/TargetLoweringObjectFileELF.adoc[`TargetLoweringObjectFileELF`] 
| 
| xref:llvm/TargetLoweringObjectFileGOFF.adoc[`TargetLoweringObjectFileGOFF`] 
| 
| xref:llvm/TargetLoweringObjectFileMachO.adoc[`TargetLoweringObjectFileMachO`] 
| 
| xref:llvm/TargetLoweringObjectFileWasm.adoc[`TargetLoweringObjectFileWasm`] 
| 
| xref:llvm/TargetLoweringObjectFileXCOFF.adoc[`TargetLoweringObjectFileXCOFF`] 
| 
| 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`] 
| 
| xref:llvm/TargetPassConfig.adoc[`TargetPassConfig`] 
| Target&hyphen;Independent Code Generator Pass Configuration Options&period;
| xref:llvm/TargetRegionEntryInfo.adoc[`TargetRegionEntryInfo`] 
| Data structure to contain the information needed to uniquely identify a target entry&period;
| xref:llvm/TargetRegisterInfo.adoc[`TargetRegisterInfo`] 
| TargetRegisterInfo base class &hyphen; We assume that the target defines a static array of TargetRegisterDesc objects that represent all of the machine registers that the target has&period; As such, we simply have to track a pointer to this array so that we can turn register number into a register descriptor&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`] 
| TargetSubtargetInfo &hyphen; Generic base class for all target subtargets&period; All Target&hyphen;specific options that control code generation and printing should be exposed through a TargetSubtargetInfo&hyphen;derived class&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`] 
| 
| xref:llvm/TemporalProfTraceTy.adoc[`TemporalProfTraceTy`] 
| An ordered list of functions identified by their NameRef found in INSTR&lowbar;PROF&lowbar;DATA
| xref:llvm/TensorSpec.adoc[`TensorSpec`] 
| 
| xref:llvm/TernOpInit.adoc[`TernOpInit`] 
| !op (X, Y, Z) &hyphen; Combine two inits&period;
| xref:llvm/TextChangeReporter-07.adoc[`TextChangeReporter`] 
| 
| xref:llvm/TextCodeGenDataReader.adoc[`TextCodeGenDataReader`] 
| This format is a simple text format that&apos;s suitable for test data&period; The header is a custom format starting with `&colon;` per line to indicate which codegen data is recorded&period; `&num;` is used to indicate a comment&period; The subsequent data is a YAML format per each codegen data in order&period; Currently, it only has a function outlined hash tree&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`] 
| 
| xref:llvm/ThinLTOCodeGenerator.adoc[`ThinLTOCodeGenerator`] 
| This class define an interface similar to the LTOCodeGenerator, but adapted for ThinLTO processing&period; The ThinLTOCodeGenerator is not intended to be reuse for multiple compilation&colon; the model is that the client adds modules to the generator and ask to perform the ThinLTO optimizations &sol; codegen, and finally destroys the codegenerator&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 to be run on a thread pool&period; Thread pool tasks in different groups can run on the same threadpool but can be waited for separately&period; It is even possible for tasks of one group to submit and wait for tasks of another group, as long as this does not form a loop&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`] 
| A helper struct to create IR loop nests for tiling in IR of the following form&colon; for ColumnLoop&period;Index &equals; 0&period;&period;NumColumns for RowLoop&period;Index &equals; 0&period;&period;NumRows for KLoop&period;Index &equals; 0&period;&period;NumInner
| xref:llvm/TimePassesHandler.adoc[`TimePassesHandler`] 
| This class implements &hyphen;time&hyphen;passes functionality for new pass manager&period; It provides the pass&hyphen;instrumentation callbacks that measure the pass execution time&period; They collect timing info into individual timers as passes are being run&period;
| xref:llvm/TimeProfilingPassesHandler.adoc[`TimeProfilingPassesHandler`] 
| This class implements &hyphen;&hyphen;time&hyphen;trace functionality for new pass manager&period; It provides the pass&hyphen;instrumentation callbacks that measure the pass execution time&period; They collect time tracing info by TimeProfiler&period;
| xref:llvm/TimeRecord.adoc[`TimeRecord`] 
| 
| xref:llvm/TimeRegion.adoc[`TimeRegion`] 
| The TimeRegion class is used as a helper class to call the startTimer() and stopTimer() methods of the Timer class&period; When the object is constructed, it starts the timer specified as its argument&period; When it is destroyed, it stops the relevant timer&period; This makes it easy to time a region of code&period;
| xref:llvm/TimeTraceMetadata.adoc[`TimeTraceMetadata`] 
| 
| xref:llvm/TimeTraceProfiler.adoc[`TimeTraceProfiler`] 
| 
| xref:llvm/TimeTraceProfilerEntry.adoc[`TimeTraceProfilerEntry`] 
| 
| xref:llvm/TimeTraceScope.adoc[`TimeTraceScope`] 
| The TimeTraceScope is a helper class to call the begin and end functions of the time trace profiler&period; When the object is constructed, it begins the section&semi; and when it is destroyed, it stops it&period; If the time profiler is not initialized, the overhead is a single branch&period;
| xref:llvm/Timer.adoc[`Timer`] 
| This class is used to track the amount of time spent between invocations of its startTimer()&sol;stopTimer() methods&period; Given appropriate OS support it can also keep track of the RSS of the program at various points&period; By default, the Timer will print the amount of time it has captured to standard error when the last timer is destroyed, otherwise it is printed when its TimerGroup is destroyed&period; Timers do not print their information if they are never started&period;
| xref:llvm/TimerGlobals.adoc[`TimerGlobals`] 
| 
| xref:llvm/TimerGroup.adoc[`TimerGroup`] 
| The TimerGroup class is used to group together related timers into a single report that is printed when the TimerGroup is destroyed&period; It is illegal to destroy a TimerGroup object before all of the Timers in it are gone&period; A TimerGroup can be specified for a newly created timer in its constructor&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`] 
| 
| xref:llvm/ToolOutputFile.adoc[`ToolOutputFile`] 
| This class contains a raw&lowbar;fd&lowbar;ostream and adds a few extra features commonly needed for compiler&hyphen;like tool output files&colon; &hyphen; The file is automatically deleted if the process is killed&period; &hyphen; The file is automatically deleted when the ToolOutputFile object is destroyed unless the client calls keep()&period;
| xref:llvm/Trace.adoc[`Trace`] 
| 
| 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`] 
| The utility class that helps computing the index of the object inside trie from its hash&period; The generator can be configured with the number of bits used for each level of trie structure with `NumRootsBits` and `NumSubtrieBits&period;` For example, try computing indexes for a 16&hyphen;bit hash 0x1234 with 8&hyphen;bit root and 4&hyphen;bit sub&hyphen;trie&colon;
| xref:llvm/TrieRawHashMapTestHelper.adoc[`TrieRawHashMapTestHelper`] 
| Helper used by unit tests to inspect ThreadSafeTrieRawHashMapBase internals&period;
| xref:llvm/TriggerCrashFunctionPass.adoc[`TriggerCrashFunctionPass`] 
| 
| xref:llvm/TriggerCrashModulePass.adoc[`TriggerCrashModulePass`] 
| 
| xref:llvm/Triple.adoc[`Triple`] 
| Triple &hyphen; Helper class for working with autoconf configuration names&period; For historical reasons, we also call these &apos;triples&apos; (they used to contain exactly three fields)&period;
| xref:llvm/TruncInst.adoc[`TruncInst`] 
| This class represents a truncation of integer types&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`] 
| 
| xref:llvm/Type.adoc[`Type`] 
| The instances of the Type class are immutable&colon; once they are created, they are never changed&period; Also note that only one instance of a particular type is ever created&period; Thus seeing if two types are equal is a matter of doing a trivial pointer comparison&period; To enforce that no two equal instances are created, Type instances can only be created via static factory methods in class Type and in derived classes&period; Once allocated, Types are never free&apos;d&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`] 
| The following data structures summarize type metadata information&period; For type metadata overview see https&colon;&sol;&sol;llvm&period;org&sol;docs&sol;TypeMetadata&period;html&period; Each type metadata includes both the type identifier and the offset of the address point of the type (the address held by objects of that type which may not be the beginning of the virtual table)&period; Vtable definitions are decorated with type metadata for the types they are compatible with&period;
| xref:llvm/TypeIdSummary.adoc[`TypeIdSummary`] 
| 
| xref:llvm/TypePromotionPass.adoc[`TypePromotionPass`] 
| 
| xref:llvm/TypeSanitizerPass.adoc[`TypeSanitizerPass`] 
| 
| xref:llvm/TypeSize.adoc[`TypeSize`] 
| 
| xref:llvm/TypeSwitch-0e.adoc[`TypeSwitch`] 
| This class implements a switch&hyphen;like dispatch statement for a value of &apos;T&apos; using dyn&lowbar;cast functionality&period; Each `Case&lt;T&gt;` takes a callable to be invoked if the root value isa&lt;T&gt;, the callable is invoked with the result of dyn&lowbar;cast&lt;T&gt;() as a parameter&period;
| xref:llvm/TypeTestResolution.adoc[`TypeTestResolution`] 
| 
| xref:llvm/TypeUnitMetaInfo.adoc[`TypeUnitMetaInfo`] 
| 
| 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 few GPU targets, such as DXIL and SPIR&hyphen;V, have typed pointers&period; This pointer type abstraction is used for tracking the types of these pointers&period; It is not legal to use this type, or derived types containing this type, in LLVM IR&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`] 
| This class represents a cast 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`] 
| !op (X) &hyphen; Transform an init&period;
| xref:llvm/UnaryInstruction.adoc[`UnaryInstruction`] 
| 
| xref:llvm/UnaryOperator.adoc[`UnaryOperator`] 
| 
| xref:llvm/UncondBrInst.adoc[`UncondBrInst`] 
| Unconditional Branch instruction&period;
| xref:llvm/UndefValue.adoc[`UndefValue`] 
| &apos;undef&apos; values are things that do not have specified contents&period; These are used for a variety of purposes, including global variable initializers and operands to instructions&period; &apos;undef&apos; values can occur with any first&hyphen;class type&period;
| xref:llvm/UnderlyingObject.adoc[`UnderlyingObject`] 
| 
| 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`] 
| 
| xref:llvm/UniqueBBID.adoc[`UniqueBBID`] 
| 
| xref:llvm/UniqueMachineInstr.adoc[`UniqueMachineInstr`] 
| A class that wraps MachineInstrs and derives from FoldingSetNode in order to be uniqued in a CSEMap&period; The tradeoff here is extra memory allocations for UniqueMachineInstr vs making MachineInstr bigger&period;
| xref:llvm/UniquePtrCast.adoc[`UniquePtrCast`] 
| This cast trait provides std&colon;&colon;unique&lowbar;ptr casting&period; It has the semantics of moving the contents of the input unique&lowbar;ptr into the output unique&lowbar;ptr during the cast&period; It&apos;s also a good example of how to implement a move&hyphen;only 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`] 
| UniqueVector &hyphen; This class produces a sequential ID number (base 1) for each unique entry that is added&period; T is the type of entries in the vector&period; This class should have an implementation of operator&equals;&equals; and of operator&lt;&period; Entries can be fetched using operator&lsqb;&rsqb;with the entry ID&period;
| xref:llvm/UnitIndexEntry.adoc[`UnitIndexEntry`] 
| 
| xref:llvm/UnpackMachineBundlesPass.adoc[`UnpackMachineBundlesPass`] 
| 
| xref:llvm/UnreachableBlockElimPass.adoc[`UnreachableBlockElimPass`] 
| 
| xref:llvm/UnreachableInst.adoc[`UnreachableInst`] 
| This function has undefined behavior&period; In particular, the presence of this instruction indicates some higher level knowledge that the end of the block cannot be reached&period;
| xref:llvm/UnreachableMachineBlockElimPass.adoc[`UnreachableMachineBlockElimPass`] 
| 
| xref:llvm/UnrollCostEstimator.adoc[`UnrollCostEstimator`] 
| Produce an estimate of the unrolled cost of the specified loop&period;
| xref:llvm/UnrollLoopOptions.adoc[`UnrollLoopOptions`] 
| 
| xref:llvm/UnrollPragmaInfo.adoc[`UnrollPragmaInfo`] 
| 
| xref:llvm/UnrolledInstAnalyzer.adoc[`UnrolledInstAnalyzer`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/VAArgInst.adoc[`VAArgInst`] 
| This class represents the va&lowbar;arg llvm instruction, which returns an argument of the specified type given a va&lowbar;list and increments that list
| 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`] 
| 
| xref:llvm/VLIWResourceModel.adoc[`VLIWResourceModel`] 
| 
| xref:llvm/VNInfo.adoc[`VNInfo`] 
| VNInfo &hyphen; Value Number Information&period; This class holds information about a machine level values, including definition and use points&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`] 
| 
| xref:llvm/VPLoadSDNode.adoc[`VPLoadSDNode`] 
| This class is used to represent a VP&lowbar;LOAD node
| xref:llvm/VPReductionIntrinsic.adoc[`VPReductionIntrinsic`] 
| This represents vector predication reduction intrinsics&period;
| xref:llvm/VPSCEVExpander.adoc[`VPSCEVExpander`] 
| 
| 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`] 
| 
| xref:llvm/VRegMaskOrUnit.adoc[`VRegMaskOrUnit`] 
| 
| xref:llvm/VTByHwModePair.adoc[`VTByHwModePair`] 
| 
| 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`] 
| 
| xref:llvm/ValID.adoc[`ValID`] 
| ValID &hyphen; Represents a reference of a definition of some sort with no type&period; There are several cases where we have to parse the value but where the type can depend on later context&period; This may either be a numeric reference or a symbolic (%var) reference&period; This is just a discriminated union&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`] 
| 
| xref:llvm/ValueFromPointerCast.adoc[`ValueFromPointerCast`] 
| This cast trait provides casting for the specific case of casting to a value&hyphen;typed object from a pointer&hyphen;typed object&period; Note that `To` must be nullable&sol;constructible from a pointer to `From` to use this cast&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`] 
| ValueIsPresent provides a way to check if a value is, well, present&period; For pointers, this is the equivalent of checking against nullptr, for Optionals this is the equivalent of checking hasValue()&period; It also provides a method for unwrapping a value (think calling &period;value() on an optional)&period;
| xref:llvm/ValueIterator.adoc[`ValueIterator`] 
| 
| 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`] 
| 
| xref:llvm/ValueMapConfig.adoc[`ValueMapConfig`] 
| This class defines the default behavior for configurable aspects of ValueMap&lt;&gt;&period; User Configs should inherit from this class to be as compatible as possible with future versions of ValueMap&period;
| xref:llvm/ValueMapIteratorImpl.adoc[`ValueMapIteratorImpl`] 
| 
| 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`] 
| 
| xref:llvm/ValueSymbolTable.adoc[`ValueSymbolTable`] 
| This class provides a symbol table of name&sol;value pairs&period; It is essentially a std&colon;&colon;map&lt;std&colon;&colon;string,Value&ast;&gt; but has a controlled interface provided by LLVM as well as ensuring uniqueness of names&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`] 
| 
| xref:llvm/VarStreamArrayExtractor-071.adoc[`VarStreamArrayExtractor`] 
| VarStreamArrayExtractor is intended to be specialized to provide customized extraction logic&period; On input it receives a BinaryStreamRef pointing to the beginning of the next record, but where the length of the record is not yet known&period; Upon completion, it should return an appropriate Error instance if a record could not be extracted, or if one could be extracted it should return success and set Len to the number of bytes this record occupied in the underlying stream, and it should fill out the fields of the value type Item appropriately to represent the current record&period;
| xref:llvm/VarStreamArrayIterator.adoc[`VarStreamArrayIterator`] 
| VarStreamArray represents an array of variable length records backed by a stream&period; This could be a contiguous sequence of bytes in memory, it could be a file on disk, or it could be a PDB stream where bytes are stored as discontiguous blocks in a file&period; Usually it is desirable to treat arrays as contiguous blocks of memory, but doing so with large PDB files, for example, could mean allocating huge amounts of memory just to allow re&hyphen;ordering of stream data to be contiguous before iterating over it&period; By abstracting this out, we need not duplicate this memory, and we can iterate over arrays in arbitrarily formatted streams&period; Elements are parsed lazily on iteration, so there is no upfront cost associated with building or copying a VarStreamArray, no matter how large it may be&period;
| xref:llvm/VariadicOperandTraits-04.adoc[`VariadicOperandTraits`] 
| VariadicOperandTraits &hyphen; determine the allocation regime of the Use array when it is a prefix to the User object, and the number of Use objects is only known at allocation time&period;
| xref:llvm/VecDesc.adoc[`VecDesc`] 
| Provides info so a possible vectorization of a function can be computed&period; Function &apos;VectorFnName&apos; is equivalent to &apos;ScalarFnName&apos; vectorized by a factor &apos;VectorizationFactor&apos;&period; The VABIPrefix string holds information about isa, mask, vlen, and vparams so a scalar&hyphen;to&hyphen;vector mapping of the form&colon; _ZGV&lt;isa&gt;&lt;mask&gt;&lt;vlen&gt;&lt;vparams&gt;_&lt;scalarname&gt;(&lt;vectorname&gt;) can be constructed where&colon;
| 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`] 
| Create a verifier pass&period;
| xref:llvm/VerifierSupport.adoc[`VerifierSupport`] 
| 
| xref:llvm/VerifyInstrumentation.adoc[`VerifyInstrumentation`] 
| 
| 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`] 
| 
| xref:llvm/VersionedClause.adoc[`VersionedClause`] 
| 
| xref:llvm/VirtFuncOffset.adoc[`VirtFuncOffset`] 
| The ValueInfo and offset for a function within a vtable definition initializer array&period;
| xref:llvm/VirtReg2IndexFunctor.adoc[`VirtReg2IndexFunctor`] 
| 
| 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`] 
| 
| xref:llvm/VirtRegMapAnalysis.adoc[`VirtRegMapAnalysis`] 
| 
| xref:llvm/VirtRegMapPrinterPass.adoc[`VirtRegMapPrinterPass`] 
| 
| xref:llvm/VirtRegMapWrapperLegacy.adoc[`VirtRegMapWrapperLegacy`] 
| 
| xref:llvm/VirtRegOrUnit.adoc[`VirtRegOrUnit`] 
| Wrapper class representing a virtual register or register unit&period;
| xref:llvm/VirtRegRewriterPass.adoc[`VirtRegRewriterPass`] 
| 
| xref:llvm/WarnMissedTransformationsPass.adoc[`WarnMissedTransformationsPass`] 
| 
| xref:llvm/WasmEHPreparePass.adoc[`WasmEHPreparePass`] 
| 
| 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`] 
| 
| xref:llvm/WholeProgramDevirtResolution.adoc[`WholeProgramDevirtResolution`] 
| 
| xref:llvm/WideIVInfo.adoc[`WideIVInfo`] 
| Collect information about induction variables that are used by sign&sol;zero extend operations&period; This information is recorded by CollectExtend and provides the input to WidenIV&period;
| xref:llvm/WinCOFFObjectWriter.adoc[`WinCOFFObjectWriter`] 
| 
| xref:llvm/WinCOFFWriter.adoc[`WinCOFFWriter`] 
| 
| xref:llvm/WinEHFuncInfo.adoc[`WinEHFuncInfo`] 
| 
| xref:llvm/WinEHHandlerType.adoc[`WinEHHandlerType`] 
| 
| xref:llvm/WinEHPreparePass.adoc[`WinEHPreparePass`] 
| 
| xref:llvm/WinEHTryBlockMapEntry.adoc[`WinEHTryBlockMapEntry`] 
| 
| xref:llvm/WindowScheduler.adoc[`WindowScheduler`] 
| The main class in the implementation of the target independent window scheduler&period;
| xref:llvm/WindowsResourceProcessor.adoc[`WindowsResourceProcessor`] 
| 
| xref:llvm/WithCache.adoc[`WithCache`] 
| 
| 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 which can be read from as well as written to&period; Note that writing to a BinaryStream always necessitates copying from the input buffer to the stream&apos;s backing store&period; Streams are assumed to be buffered so that to be portable it is necessary to call commit() on the stream when all data has been written&period;
| xref:llvm/WritableBinaryStreamRef.adoc[`WritableBinaryStreamRef`] 
| 
| 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`] 
| 
| xref:llvm/XCOFFSymbolInfoTy.adoc[`XCOFFSymbolInfoTy`] 
| 
| xref:llvm/XRayInstrumentationPass.adoc[`XRayInstrumentationPass`] 
| 
| 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`] 
| This class represents zero extension of integer types&period;
| xref:llvm/add_const_past_pointer-00.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`] 
| 
| xref:llvm/buffer_unique_ostream.adoc[`buffer&lowbar;unique&lowbar;ostream`] 
| 
| 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`] 
| circular&lowbar;raw&lowbar;ostream &hyphen; A raw&lowbar;ostream which _can_ save its data to a circular buffer, or can pass it through directly to an underlying stream if specified with a buffer of zero&period;
| xref:llvm/concat_iterator.adoc[`concat&lowbar;iterator`] 
| Iterator wrapper that concatenates sequences together&period;
| xref:llvm/const_pointer_or_const_ref-01.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`] 
| Walks the defining accesses of MemoryDefs&period; Stops after we hit something that has no defining use (e&period;g&period; a MemoryPhi or liveOnEntry)&period; Note that, when comparing against a null def&lowbar;chain&lowbar;iterator, this will compare equal only after walking said Phi&sol;liveOnEntry&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`] 
| 
| 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`] 
| 
| 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`] 
| formatted&lowbar;raw&lowbar;ostream &hyphen; A raw&lowbar;ostream that wraps another one and keeps track of line and column position, allowing padding out to specific column boundaries and querying the number of lines written to the stream&period; This assumes that the contents of the stream is valid UTF&hyphen;8 encoded text&period; This doesn&apos;t attempt to handle everything Unicode can do (combining characters, right&hyphen;to&hyphen;left markers, etc), but should cover the cases likely to appear in source code or diagnostic messages&period;
| xref:llvm/formatv_object.adoc[`formatv&lowbar;object`] 
| 
| 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; This is intended for use as the type of a function parameter that is not used after the function in question returns&period;
| xref:llvm/function_traits-0b.adoc[`function&lowbar;traits`] 
| This class provides various trait information about a callable object&period; &ast; To access the number of arguments&colon; Traits&colon;&colon;num&lowbar;args &ast; To access the type of an argument&colon; Traits&colon;&colon;arg&lowbar;t&lt;Index&gt; &ast; To access the type of the result&colon; Traits&colon;&colon;result&lowbar;t
| xref:llvm/generic_gep_type_iterator.adoc[`generic&lowbar;gep&lowbar;type&lowbar;iterator`] 
| 
| 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 intrusive lists based on ilist&lowbar;node&period; Much like ilist&lowbar;iterator, but with the addition of two bits recording whether this position (when in a range) is half or fully open&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-0b.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`] 
| 
| 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`] 
| 
| 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`] 
| Function object to check whether the first component of a container supported by std&colon;&colon;get (like std&colon;&colon;pair and std&colon;&colon;tuple) compares less than the first component of another container&period;
| xref:llvm/less_second.adoc[`less&lowbar;second`] 
| Function object to check whether the second component of a container supported by std&colon;&colon;get (like std&colon;&colon;pair and std&colon;&colon;tuple) compares less than the second component of another container&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`] 
| 
| 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 base class used to implement const and non&hyphen;const iterators 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`] 
| 
| xref:llvm/rank-06.adoc[`rank`] 
| Utility type to build an inheritance chain that makes it easy 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`] 
| raw&lowbar;os&lowbar;ostream &hyphen; A raw&lowbar;ostream that writes to an std&colon;&colon;ostream&period; This is a simple adaptor class&period; It does not check for output errors&semi; clients should use the underlying stream to detect errors&period;
| xref:llvm/raw_ostream.adoc[`raw&lowbar;ostream`] 
| This class implements an extremely fast bulk output stream that can _only_ output to a stream&period; It does not support seeking, reopening, rewinding, line buffered disciplines etc&period; It is a simple buffer that outputs a chunk at a time&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`] 
| An abstract base class for streams implementations that also support a pwrite operation&period; This is useful for code that can mostly stream out data, but needs to patch in a header that needs to know the output size&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`] 
| 
| 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 an SmallVector or SmallString&period; This is a simple adaptor class&period; This class does not encounter output errors&period; raw&lowbar;svector&lowbar;ostream operates without a buffer, delegating all memory management to the SmallString&period; Thus the SmallString is always up&hyphen;to&hyphen;date, may be used directly and there is no need to call flush()&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`] 
| Sort the nodes of a directed SCC in the decreasing order of the edge weights&period; The instantiating GraphT type should have weighted edge type declared in its graph traits in order to use this iterator&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`] 
| Define a template that can be specialized by smart pointers to reflect the fact that they are automatically dereferenced, and are not involved with the template selection process&period;&period;&period; the default implementation is a noop&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`] 
| Provide an iterator that walks defs, giving both the memory access, and the current pointer location, updating the pointer location as it changes due to phi node translation&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:llvm/AAAlignmentStateType.adoc[`AAAlignmentStateType`] 
| 
| 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`] 
| 
| xref:llvm/AnchorList.adoc[`AnchorList`] 
| 
| xref:llvm/AnchorMap.adoc[`AnchorMap`] 
| 
| xref:llvm/ArgAuxType.adoc[`ArgAuxType`] 
| 
| xref:llvm/Assume2KnowledgeMap.adoc[`Assume2KnowledgeMap`] 
| A mapping from intrinsics (&equals;`llvm&period;assume` calls) to a value range (&equals;knowledge) that is encoded in them&period; How the value range is interpreted depends on the RetainedKnowledgeKey that was used to get this out of the RetainedKnowledgeMap&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`] 
| 
| xref:llvm/BlockSequence.adoc[`BlockSequence`] 
| A sequence of basic blocks&period;
| xref:llvm/Boolean.adoc[`Boolean`] 
| 
| xref:llvm/BuildFnTy.adoc[`BuildFnTy`] 
| 
| 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`] 
| CCCustomFn &hyphen; This function assigns a location for Val, possibly updating all args to reflect changes and indicates if it handled it&period; It must set isCustom if it handles the arg and returns true&period;
| xref:llvm/CFGUpdate.adoc[`CFGUpdate`] 
| 
| 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`] 
| 
| xref:llvm/ClusterInfo.adoc[`ClusterInfo`] 
| Keep record of which SUnit are in the same cluster group&period;
| xref:llvm/ColorVector.adoc[`ColorVector`] 
| 
| xref:llvm/ConstMap.adoc[`ConstMap`] 
| 
| xref:llvm/ConstOperandBundleDef.adoc[`ConstOperandBundleDef`] 
| 
| xref:llvm/ContextualFoldingSet.adoc[`ContextualFoldingSet`] 
| This template class is a further refinement of FoldingSet which provides a context argument when calling Profile on its nodes&period; Currently, that argument is fixed at initialization time&period;
| xref:llvm/ConvergenceVerifier.adoc[`ConvergenceVerifier`] 
| 
| xref:llvm/Cost.adoc[`Cost`] 
| 
| xref:llvm/CostTblEntry.adoc[`CostTblEntry`] 
| 
| xref:llvm/CtxProfContextualProfiles.adoc[`CtxProfContextualProfiles`] 
| 
| xref:llvm/CtxProfFlatIndirectCallProfile.adoc[`CtxProfFlatIndirectCallProfile`] 
| 
| xref:llvm/CtxProfFlatProfile.adoc[`CtxProfFlatProfile`] 
| 
| xref:llvm/DDGBase.adoc[`DDGBase`] 
| 
| xref:llvm/DDGDotGraphTraits.adoc[`DDGDotGraphTraits`] 
| 
| xref:llvm/DDGEdgeBase.adoc[`DDGEdgeBase`] 
| 
| xref:llvm/DDGInfo.adoc[`DDGInfo`] 
| 
| xref:llvm/DDGNodeBase.adoc[`DDGNodeBase`] 
| 
| xref:llvm/DILineInfoTable.adoc[`DILineInfoTable`] 
| 
| 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`] 
| 
| xref:llvm/DataLayoutCallbackFuncTy.adoc[`DataLayoutCallbackFuncTy`] 
| 
| xref:llvm/DataLayoutCallbackTy-0c.adoc[`DataLayoutCallbackTy`] 
| 
| xref:llvm/DataLayoutCallbackTy-04.adoc[`DataLayoutCallbackTy`] 
| 
| xref:llvm/DbgRecordIterator.adoc[`DbgRecordIterator`] 
| 
| xref:llvm/DebugLocRef.adoc[`DebugLocRef`] 
| 
| xref:llvm/DefaultThreadPool.adoc[`DefaultThreadPool`] 
| 
| xref:llvm/DiagnosticHandlerFunction.adoc[`DiagnosticHandlerFunction`] 
| 
| xref:llvm/DomTreeBase.adoc[`DomTreeBase`] 
| 
| xref:llvm/DomTreeNode.adoc[`DomTreeNode`] 
| 
| xref:llvm/EnableIfConvertibleToInputIterator.adoc[`EnableIfConvertibleToInputIterator`] 
| SFINAE helper that is valid when `Iterator` models an input iterator&period;
| xref:llvm/ExceptionSymbolProvider.adoc[`ExceptionSymbolProvider`] 
| 
| xref:llvm/FileCacheFunction.adoc[`FileCacheFunction`] 
| This is a callable that manages file caching operations&period; It accepts a task ID `Task,` a unique key `Key,` and a module name `ModuleName,` and returns AddStreamFn()&period; This function determines whether a cache hit or miss occurs and handles the appropriate actions&period;
| xref:llvm/FlatIndirectTargets.adoc[`FlatIndirectTargets`] 
| 
| xref:llvm/FloatingPointPredicateUtils.adoc[`FloatingPointPredicateUtils`] 
| 
| xref:llvm/FoldingSet.adoc[`FoldingSet`] 
| This template class is used to instantiate a specialized implementation of the folding set to the node class T&period; T must be a subclass of FoldingSetNode and implement a Profile function&period;
| xref:llvm/FoldingSetNode.adoc[`FoldingSetNode`] 
| Convenience alias for the base node type stored in a folding set&period;
| xref:llvm/ForwardIDFCalculator.adoc[`ForwardIDFCalculator`] 
| 
| xref:llvm/FuncProbeFactorMap.adoc[`FuncProbeFactorMap`] 
| 
| 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`] 
| 
| xref:llvm/FunctionModRefBehavior.adoc[`FunctionModRefBehavior`] 
| 
| xref:llvm/FunctionPassManager.adoc[`FunctionPassManager`] 
| Convenience typedef for a pass manager over functions&period;
| xref:llvm/FuzzerInitFun.adoc[`FuzzerInitFun`] 
| 
| xref:llvm/FuzzerTestFun.adoc[`FuzzerTestFun`] 
| 
| xref:llvm/GCMetadataPrinterRegistry.adoc[`GCMetadataPrinterRegistry`] 
| GCMetadataPrinterRegistry &hyphen; The GC assembly printer registry uses all the defaults from Registry&period;
| xref:llvm/GCRegistry.adoc[`GCRegistry`] 
| Subclasses of GCStrategy are made available for use during compilation by adding them to the global GCRegistry&period; This can done either within the LLVM source tree or via a loadable plugin&period; An example registeration would be&colon; static GCRegistry&colon;&colon;Add&lt;CustomGC&gt; X(&quot;custom&hyphen;name&quot;, &quot;my custom supper fancy gc strategy&quot;)&semi;
| 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`] 
| 
| xref:llvm/GetTypeByIDTy.adoc[`GetTypeByIDTy`] 
| 
| xref:llvm/GetterTy.adoc[`GetterTy`] 
| 
| xref:llvm/GlobalCtorTransformFn.adoc[`GlobalCtorTransformFn`] 
| Apply &apos;Fn&apos; to the list of global ctors of module M and replace contructor record with the one returned by `Fn`&period; If `nullptr` was returned, the corresponding constructor will be removed from the array&period; For details see https&colon;&sol;&sol;llvm&period;org&sol;docs&sol;LangRef&period;html&num;the&hyphen;llvm&hyphen;global&hyphen;ctors&hyphen;global&hyphen;variable
| xref:llvm/GlobalValueSummaryList.adoc[`GlobalValueSummaryList`] 
| 
| xref:llvm/GlobalValueSummaryMapTy.adoc[`GlobalValueSummaryMapTy`] 
| 
| xref:llvm/HTTPContentProvider.adoc[`HTTPContentProvider`] 
| An HTTPContentProvider is called by the HTTPServer to obtain chunks of the streaming response body&period; The returned chunk should be located at Offset bytes and have Length bytes&period;
| xref:llvm/HTTPRequestHandler.adoc[`HTTPRequestHandler`] 
| 
| xref:llvm/HasIteratorTag.adoc[`HasIteratorTag`] 
| True if `Iterator&apos;s` category is convertible to `Tag&period;`
| xref:llvm/HasRunOnLoopT.adoc[`HasRunOnLoopT`] 
| 
| xref:llvm/HashNodeIdMapTy.adoc[`HashNodeIdMapTy`] 
| 
| xref:llvm/IdHashNodeMapTy.adoc[`IdHashNodeMapTy`] 
| 
| xref:llvm/IdHashNodeStableMapTy.adoc[`IdHashNodeStableMapTy`] 
| 
| xref:llvm/IdxMBBPair.adoc[`IdxMBBPair`] 
| 
| 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`] 
| 
| xref:llvm/IndexPair.adoc[`IndexPair`] 
| The pair of an instruction index and a operand index&period;
| xref:llvm/IndexPairHash.adoc[`IndexPairHash`] 
| 
| xref:llvm/InlineCostFeatures.adoc[`InlineCostFeatures`] 
| 
| xref:llvm/InlineFeatures.adoc[`InlineFeatures`] 
| 
| xref:llvm/InlineSite.adoc[`InlineSite`] 
| 
| xref:llvm/InsnRange.adoc[`InsnRange`] 
| This is used to track range of instructions with identical lexical scope&period;
| xref:llvm/InstructionIdMap.adoc[`InstructionIdMap`] 
| 
| 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`] 
| 
| xref:llvm/LegalizeMutation.adoc[`LegalizeMutation`] 
| 
| xref:llvm/LiveRegUnitSet.adoc[`LiveRegUnitSet`] 
| 
| xref:llvm/LiveVirtRegBitSet.adoc[`LiveVirtRegBitSet`] 
| 
| 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`] 
| 
| xref:llvm/LoopVectorTy.adoc[`LoopVectorTy`] 
| 
| xref:llvm/MBBOrBasicBlock.adoc[`MBBOrBasicBlock`] 
| 
| xref:llvm/MCAsmMacroParameters.adoc[`MCAsmMacroParameters`] 
| 
| xref:llvm/MCFixupKind.adoc[`MCFixupKind`] 
| Extensible enumeration to represent the type of a fixup&period;
| xref:llvm/MCLOHArgs.adoc[`MCLOHArgs`] 
| 
| xref:llvm/MCLOHDirectives.adoc[`MCLOHDirectives`] 
| 
| 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`] 
| 
| xref:llvm/MCPseudoProbeInlineStack.adoc[`MCPseudoProbeInlineStack`] 
| 
| xref:llvm/MCSectionSubPair.adoc[`MCSectionSubPair`] 
| 
| xref:llvm/MCSymbolTableEntry.adoc[`MCSymbolTableEntry`] 
| MCContext stores MCSymbolTableValue in a string map (see MCSymbol&colon;&colon;operator new)&period; To avoid redundant storage of the name, MCSymbol stores a pointer (8 bytes &hyphen;&hyphen; half the size of a StringRef) to the entry to access it&period;
| xref:llvm/MDTypeCallbackTy.adoc[`MDTypeCallbackTy`] 
| 
| xref:llvm/MFGetterFnT.adoc[`MFGetterFnT`] 
| 
| xref:llvm/MachineBasicBlockComparator.adoc[`MachineBasicBlockComparator`] 
| 
| xref:llvm/MachineConvergenceVerifier.adoc[`MachineConvergenceVerifier`] 
| 
| xref:llvm/MachineDomTreeNode.adoc[`MachineDomTreeNode`] 
| 
| xref:llvm/MachineFloatingPointPredicateUtils.adoc[`MachineFloatingPointPredicateUtils`] 
| 
| xref:llvm/MachineFunctionAnalysisManager.adoc[`MachineFunctionAnalysisManager`] 
| 
| xref:llvm/MachineFunctionAnalysisManagerFunctionProxy.adoc[`MachineFunctionAnalysisManagerFunctionProxy`] 
| 
| xref:llvm/MachineFunctionAnalysisManagerModuleProxy.adoc[`MachineFunctionAnalysisManagerModuleProxy`] 
| 
| xref:llvm/MachineFunctionPassManager.adoc[`MachineFunctionPassManager`] 
| Convenience typedef for a pass manager over functions&period;
| xref:llvm/MachineSSAContext.adoc[`MachineSSAContext`] 
| 
| xref:llvm/MachineUniformityInfo.adoc[`MachineUniformityInfo`] 
| 
| xref:llvm/MacroFusionPredTy.adoc[`MacroFusionPredTy`] 
| Check if the instr pair, FirstMI and SecondMI, should be fused together, based on the dependency between them, Dep&period; Given SecondMI, when FirstMI is unspecified, then check if SecondMI may be part of a fused pair at all&period;
| xref:llvm/MemCpyFamilyLoweringInfo.adoc[`MemCpyFamilyLoweringInfo`] 
| 
| xref:llvm/MemProfCallStackHashTable.adoc[`MemProfCallStackHashTable`] 
| 
| xref:llvm/MemProfFrameHashTable.adoc[`MemProfFrameHashTable`] 
| 
| xref:llvm/MemProfRecordHashTable.adoc[`MemProfRecordHashTable`] 
| 
| xref:llvm/MemoryEffects.adoc[`MemoryEffects`] 
| Summary of how a function affects memory in the program&period;
| xref:llvm/MetadataPredicate.adoc[`MetadataPredicate`] 
| 
| xref:llvm/MetadataSetTy.adoc[`MetadataSetTy`] 
| 
| 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 `Function` 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`] 
| 
| xref:llvm/Name2RegClassMap.adoc[`Name2RegClassMap`] 
| 
| xref:llvm/NewLoopsMap.adoc[`NewLoopsMap`] 
| 
| xref:llvm/NfaPath.adoc[`NfaPath`] 
| 
| xref:llvm/NormalizePredTy.adoc[`NormalizePredTy`] 
| 
| xref:llvm/OffsetsStringPool.adoc[`OffsetsStringPool`] 
| 
| xref:llvm/OnDiskHashTableImplV3.adoc[`OnDiskHashTableImplV3`] 
| 
| xref:llvm/OperandBuildSteps.adoc[`OperandBuildSteps`] 
| 
| xref:llvm/OperandBundleDef.adoc[`OperandBundleDef`] 
| 
| xref:llvm/OperandVector.adoc[`OperandVector`] 
| 
| xref:llvm/PBQPRAGraph.adoc[`PBQPRAGraph`] 
| 
| xref:llvm/ParamLoadedValue.adoc[`ParamLoadedValue`] 
| 
| xref:llvm/ParamLocs.adoc[`ParamLocs`] 
| 
| xref:llvm/ParamLocsVecTy.adoc[`ParamLocsVecTy`] 
| 
| xref:llvm/PassConfigCallback.adoc[`PassConfigCallback`] 
| 
| xref:llvm/PhiToDefMap.adoc[`PhiToDefMap`] 
| 
| 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`] 
| 
| xref:llvm/PostDomTreeBase.adoc[`PostDomTreeBase`] 
| 
| xref:llvm/PostIncLoopSet.adoc[`PostIncLoopSet`] 
| 
| xref:llvm/PotentialConstantIntValuesState.adoc[`PotentialConstantIntValuesState`] 
| 
| xref:llvm/PotentialLLVMValuesState.adoc[`PotentialLLVMValuesState`] 
| 
| xref:llvm/ProbeFactorMap.adoc[`ProbeFactorMap`] 
| 
| xref:llvm/RV32YCapabilityFormat.adoc[`RV32YCapabilityFormat`] 
| 
| xref:llvm/RV64YCapabilityFormat.adoc[`RV64YCapabilityFormat`] 
| 
| xref:llvm/RandomEngine.adoc[`RandomEngine`] 
| 
| xref:llvm/RawInstrProfReader32.adoc[`RawInstrProfReader32`] 
| 
| xref:llvm/RawInstrProfReader64.adoc[`RawInstrProfReader64`] 
| 
| xref:llvm/ReferenceGroupTy.adoc[`ReferenceGroupTy`] 
| A reference group represents a set of memory references that exhibit temporal or spacial reuse&period; Two references belong to the same reference group with respect to a inner loop L iff&colon; 1&period; they have a loop independent dependency, or 2&period; they have a loop carried dependence with a small dependence distance (e&period;g&period; less than 2) carried by the inner loop, or 3&period; they refer to the same array, and the subscript in their innermost dimension is less than or equal to &apos;d&apos; (where &apos;d&apos; is less than the cache line size)
| xref:llvm/ReferenceGroupsTy.adoc[`ReferenceGroupsTy`] 
| 
| 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`] 
| In place of applying the relocations to the data we&apos;ve read from disk we use a separate mapping table to the side and checking that at locations in the dwarf where we expect relocated values&period; This adds a bit of complexity to the dwarf parsing&sol;extraction at the benefit of not allocating memory for the entire size of the debug info sections&period;
| xref:llvm/RequireAnalysisLoopPass.adoc[`RequireAnalysisLoopPass`] 
| An alias template to easily name a require analysis loop pass&period;
| xref:llvm/RetainedKnowledgeKey.adoc[`RetainedKnowledgeKey`] 
| The map Key contains the Value on for which the attribute is valid and the Attribute that is valid for that value&period; If the Attribute is not on any value, the Value is nullptr&period;
| xref:llvm/RetainedKnowledgeMap.adoc[`RetainedKnowledgeMap`] 
| 
| xref:llvm/ReverseIDFCalculator.adoc[`ReverseIDFCalculator`] 
| 
| xref:llvm/RuntimePointerCheck-03e.adoc[`RuntimePointerCheck`] 
| A memcheck which made up of a pair of grouped pointers&period;
| xref:llvm/RuntimePointerCheck-0b.adoc[`RuntimePointerCheck`] 
| 
| xref:llvm/RuntimePointerCheck-038.adoc[`RuntimePointerCheck`] 
| 
| xref:llvm/SCEVUse.adoc[`SCEVUse`] 
| 
| xref:llvm/SDNodeTSFlags.adoc[`SDNodeTSFlags`] 
| 
| 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`] 
| 
| xref:llvm/SaveRestorePoints.adoc[`SaveRestorePoints`] 
| 
| xref:llvm/SectionLengths.adoc[`SectionLengths`] 
| 
| xref:llvm/SectionSymbolsTy.adoc[`SectionSymbolsTy`] 
| 
| xref:llvm/SmallInstListTy.adoc[`SmallInstListTy`] 
| 
| xref:llvm/SmallVectorSizeType.adoc[`SmallVectorSizeType`] 
| Unsigned size&sol;capacity type used by SmallVector for element type `T&period;`
| xref:llvm/SmallVirtRegSet.adoc[`SmallVirtRegSet`] 
| 
| xref:llvm/SpecMap.adoc[`SpecMap`] 
| 
| xref:llvm/Statistic.adoc[`Statistic`] 
| Statistic type that actually tracks values when stats are enabled&period;
| xref:llvm/SummaryEntryVector.adoc[`SummaryEntryVector`] 
| 
| xref:llvm/TTI.adoc[`TTI`] 
| 
| xref:llvm/TUVectorTy.adoc[`TUVectorTy`] 
| 
| xref:llvm/TableGenMainFn.adoc[`TableGenMainFn`] 
| Returns true on error, false otherwise&period;
| xref:llvm/TagNameMap.adoc[`TagNameMap`] 
| 
| xref:llvm/TargetFlagsType.adoc[`TargetFlagsType`] 
| Holds target&hyphen;specific properties for a symbol&period;
| xref:llvm/TargetRegisterClass.adoc[`TargetRegisterClass`] 
| 
| xref:llvm/TrackingMDNodeRef.adoc[`TrackingMDNodeRef`] 
| 
| xref:llvm/TrackingValueAsMetadataRef.adoc[`TrackingValueAsMetadataRef`] 
| 
| xref:llvm/TypeAtIndex.adoc[`TypeAtIndex`] 
| Find the type at a given index in a list of types&period;
| xref:llvm/TypeConversionCostTblEntry.adoc[`TypeConversionCostTblEntry`] 
| 
| xref:llvm/TypeGetter.adoc[`TypeGetter`] 
| 
| xref:llvm/TypeIdCompatibleVtableInfo.adoc[`TypeIdCompatibleVtableInfo`] 
| List of vtable definitions decorated by a particular type identifier, and their corresponding offsets in that type identifier&apos;s metadata&period; Note that each type identifier may be compatible with multiple vtables, due to inheritance, which is why this is a vector&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`] 
| 
| xref:llvm/UTF32.adoc[`UTF32`] 
| 
| xref:llvm/UTF8.adoc[`UTF8`] 
| 
| xref:llvm/UnderlyingObjectsVector.adoc[`UnderlyingObjectsVector`] 
| 
| xref:llvm/UniformityInfo.adoc[`UniformityInfo`] 
| 
| xref:llvm/UniquingStringPool.adoc[`UniquingStringPool`] 
| 
| xref:llvm/UseListOrderStack.adoc[`UseListOrderStack`] 
| 
| xref:llvm/VReg2SUnitMultiMap.adoc[`VReg2SUnitMultiMap`] 
| Track local uses of virtual registers&period; These uses are gathered by the DAG builder and may be consulted by the scheduler to avoid iterating an entire vreg use list&period;
| xref:llvm/VReg2SUnitOperIdxMultiMap.adoc[`VReg2SUnitOperIdxMultiMap`] 
| 
| xref:llvm/VTableFuncList.adoc[`VTableFuncList`] 
| List of functions referenced by a particular vtable definition&period;
| xref:llvm/ValueMapConstIterator.adoc[`ValueMapConstIterator`] 
| 
| xref:llvm/ValueMapIterator.adoc[`ValueMapIterator`] 
| 
| xref:llvm/ValueName.adoc[`ValueName`] 
| 
| xref:llvm/ValueToSCEVMapTy.adoc[`ValueToSCEVMapTy`] 
| 
| xref:llvm/ValueToValueMap.adoc[`ValueToValueMap`] 
| 
| xref:llvm/ValueToValueMapTy.adoc[`ValueToValueMapTy`] 
| 
| xref:llvm/ValueType.adoc[`ValueType`] 
| 
| xref:llvm/ValueTypeCallbackTy.adoc[`ValueTypeCallbackTy`] 
| 
| 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; First const DIScope &ast;&colon; Represents the scope of the debug variable&period; Second const DIScope &ast;&colon; Represents the InlinedAt scope of the debug variable&period; const DILocalVariable &ast;&colon; It is a pointer to the debug variable itself&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`] 
| 
| xref:llvm/const_inst_range.adoc[`const&lowbar;inst&lowbar;range`] 
| 
| xref:llvm/const_memoryaccess_def_iterator.adoc[`const&lowbar;memoryaccess&lowbar;def&lowbar;iterator`] 
| 
| xref:llvm/const_pred_iterator.adoc[`const&lowbar;pred&lowbar;iterator`] 
| 
| xref:llvm/const_pred_range.adoc[`const&lowbar;pred&lowbar;range`] 
| 
| xref:llvm/const_succ_iterator.adoc[`const&lowbar;succ&lowbar;iterator`] 
| 
| xref:llvm/const_succ_range.adoc[`const&lowbar;succ&lowbar;range`] 
| 
| 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`] 
| 
| xref:llvm/gvsummary_iterator.adoc[`gvsummary&lowbar;iterator`] 
| 
| 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`] 
| 
| xref:llvm/inst_range.adoc[`inst&lowbar;range`] 
| 
| xref:llvm/is_detected.adoc[`is&lowbar;detected`] 
| Detects if a given trait holds for some set of arguments &apos;Args&apos;&period; For example, the given trait could be used to detect if a given type has a copy assignment operator&colon; template&lt;class T&gt; using has&lowbar;copy&lowbar;assign&lowbar;t &equals; decltype(std&colon;&colon;declval&lt;T&amp;&gt;() &equals; std&colon;&colon;declval&lt;const T&amp;&gt;())&semi; bool fooHasCopyAssign &equals; is&lowbar;detected&lt;has&lowbar;copy&lowbar;assign&lowbar;t, FooClass&gt;&colon;&colon;value&semi;
| 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`] 
| 
| 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`] 
| 
| xref:llvm/pred_range.adoc[`pred&lowbar;range`] 
| 
| 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`] 
| 
| xref:llvm/succ_range.adoc[`succ&lowbar;range`] 
| 
| 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`] 
| 
| xref:llvm/unique_value.adoc[`unique&lowbar;value`] 
| Use this instead of std&colon;&colon;unique&lowbar;ptr&lt;Value&gt; or std&colon;&colon;unique&lowbar;ptr&lt;Instruction&gt;&period; Those don&apos;t work because Value and Instruction&apos;s destructors are protected, aren&apos;t virtual, and won&apos;t destroy the complete object&period;
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:llvm/_04enum-01b.adoc[`Unnamed enum`] 
| 
| xref:llvm/_04enum-0b7.adoc[`Unnamed enum`] 
| 
| 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`] 
| 
| xref:llvm/_04enum-0b0.adoc[`Unnamed enum`] 
| 
| xref:llvm/_04enum-0e.adoc[`Unnamed enum`] 
| 
| xref:llvm/AlignStyle.adoc[`AlignStyle`] 
| 
| xref:llvm/AllocFnKind.adoc[`AllocFnKind`] 
| 
| xref:llvm/AllocTokenMode.adoc[`AllocTokenMode`] 
| Modes for generating allocation token IDs&period;
| xref:llvm/AllocationType.adoc[`AllocationType`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/BinaryStreamFlags.adoc[`BinaryStreamFlags`] 
| 
| xref:llvm/BitcodeError.adoc[`BitcodeError`] 
| 
| xref:llvm/BitstreamWrapperHeader.adoc[`BitstreamWrapperHeader`] 
| Offsets of the 32&hyphen;bit fields of bitstream wrapper header&period;
| xref:llvm/CGDataKind.adoc[`CGDataKind`] 
| 
| xref:llvm/CGDataMode.adoc[`CGDataMode`] 
| 
| xref:llvm/CGDataSectKind.adoc[`CGDataSectKind`] 
| 
| 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`] 
| 
| xref:llvm/ChangeStatus.adoc[`ChangeStatus`] 
| Tracks whether abstract attribute state changed&period;
| xref:llvm/CloneFunctionChangeType.adoc[`CloneFunctionChangeType`] 
| 
| xref:llvm/ClrHandlerType.adoc[`ClrHandlerType`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/ComplexDeinterleavingRotation.adoc[`ComplexDeinterleavingRotation`] 
| 
| 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`] 
| 
| xref:llvm/ConversionFlags.adoc[`ConversionFlags`] 
| 
| xref:llvm/ConversionResult.adoc[`ConversionResult`] 
| 
| 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`] 
| 
| xref:llvm/DebuggerKind.adoc[`DebuggerKind`] 
| Identify a debugger for &quot;tuning&quot; the debug info&period;
| xref:llvm/DepClassTy.adoc[`DepClassTy`] 
| 
| 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`] 
| 
| xref:llvm/EABI.adoc[`EABI`] 
| Embedded ABI version selection&period;
| xref:llvm/EHPersonality.adoc[`EHPersonality`] 
| 
| xref:llvm/EmitDwarfUnwindType.adoc[`EmitDwarfUnwindType`] 
| 
| xref:llvm/ExceptionHandling.adoc[`ExceptionHandling`] 
| 
| xref:llvm/ExpandVariadicsMode.adoc[`ExpandVariadicsMode`] 
| 
| xref:llvm/ExplorationDirection.adoc[`ExplorationDirection`] 
| Enum that allows us to spell out the direction&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`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| IR2Vec computes two kinds of embeddings&colon; Symbolic and Flow&hyphen;aware&period; Symbolic embeddings capture the &quot;syntactic&quot; and &quot;statistical correlation&quot; of the IR entities&period; Flow&hyphen;aware embeddings build on top of symbolic embeddings and additionally capture the flow information in the IR&period; IR2VecKind is used to specify the type of embeddings to generate&period; Note&colon; Implementation of FlowAware embeddings is not same as the one described in the paper&period; The current implementation is a simplified version that captures the flow information (SSA&hyphen;based use&hyphen;defs) without tracing through memory level use&hyphen;defs in the embedding computation described in the paper&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`] 
| 
| xref:llvm/InlinePass.adoc[`InlinePass`] 
| 
| xref:llvm/InlinerFunctionImportStatsOpts.adoc[`InlinerFunctionImportStatsOpts`] 
| 
| 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`] 
| An enum describing the attributes of an instrumented profile&period;
| xref:llvm/InstrProfSectKind.adoc[`InstrProfSectKind`] 
| 
| xref:llvm/InstrProfValueKind.adoc[`InstrProfValueKind`] 
| 
| xref:llvm/IntegerStyle.adoc[`IntegerStyle`] 
| Integer formatting style for native writers&period;
| xref:llvm/KCFIHashAlgorithm.adoc[`KCFIHashAlgorithm`] 
| 
| xref:llvm/LEB128Sign.adoc[`LEB128Sign`] 
| 
| xref:llvm/LLVMConstants.adoc[`LLVMConstants`] 
| 
| xref:llvm/LibFunc.adoc[`LibFunc`] 
| 
| xref:llvm/LiveRangeStage.adoc[`LiveRangeStage`] 
| 
| 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`] 
| 
| xref:llvm/LoopPeelDirection.adoc[`LoopPeelDirection`] 
| 
| xref:llvm/LoopUnrollResult.adoc[`LoopUnrollResult`] 
| Represents the result of a `UnrollLoop` invocation&period;
| xref:llvm/MCDataRegionType.adoc[`MCDataRegionType`] 
| 
| xref:llvm/MCLOHType.adoc[`MCLOHType`] 
| Linker Optimization Hint Type&period;
| xref:llvm/MCPseudoProbeFlag.adoc[`MCPseudoProbeFlag`] 
| 
| xref:llvm/MCRegUnit.adoc[`MCRegUnit`] 
| Register units are used to compute register aliasing&period; Every register has at least one register unit, but it can have more&period; Two registers overlap if and only if they have a common register unit&period;
| xref:llvm/MCSymbolAttr.adoc[`MCSymbolAttr`] 
| 
| xref:llvm/MCVersionMinType.adoc[`MCVersionMinType`] 
| 
| xref:llvm/MIR2VecKind.adoc[`MIR2VecKind`] 
| 
| xref:llvm/MSDemangleFlags.adoc[`MSDemangleFlags`] 
| 
| xref:llvm/MachineCombinerPattern.adoc[`MachineCombinerPattern`] 
| These are instruction patterns matched by the machine combiner pass&period;
| xref:llvm/MachineFunctionDataHotness.adoc[`MachineFunctionDataHotness`] 
| 
| 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`] 
| 
| xref:llvm/OnCuIndexOverflow.adoc[`OnCuIndexOverflow`] 
| 
| xref:llvm/OptimizationLevel.adoc[`OptimizationLevel`] 
| 
| xref:llvm/OverflowResult.adoc[`OverflowResult`] 
| 
| xref:llvm/PGOCtxProfileBlockIDs.adoc[`PGOCtxProfileBlockIDs`] 
| 
| xref:llvm/PGOCtxProfileRecords.adoc[`PGOCtxProfileRecords`] 
| 
| xref:llvm/PGOInstrumentationType.adoc[`PGOInstrumentationType`] 
| 
| xref:llvm/PGOViewCountsType.adoc[`PGOViewCountsType`] 
| 
| xref:llvm/PGSOQueryType.adoc[`PGSOQueryType`] 
| 
| xref:llvm/PassDebuggingString.adoc[`PassDebuggingString`] 
| 
| xref:llvm/PassKind.adoc[`PassKind`] 
| 
| xref:llvm/PassManagerType.adoc[`PassManagerType`] 
| Different types of internal pass managers&period; External pass managers (PassManager and FunctionPassManager) are not represented here&period; Ordering of pass manager types is important here&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`] 
| 
| xref:llvm/PrevailingType.adoc[`PrevailingType`] 
| PrevailingType enum used as a return type of callback passed to computeDeadSymbolsAndUpdateIndirectCalls&period; Yes and No values used when status explicitly set by symbols resolution, otherwise status is Unknown&period;
| xref:llvm/PrintPipelinePassesFormat.adoc[`PrintPipelinePassesFormat`] 
| 
| xref:llvm/PseudoProbeAttributes.adoc[`PseudoProbeAttributes`] 
| 
| xref:llvm/PseudoProbeReservedId.adoc[`PseudoProbeReservedId`] 
| 
| xref:llvm/PseudoProbeType.adoc[`PseudoProbeType`] 
| 
| xref:llvm/RecurKind.adoc[`RecurKind`] 
| These are the kinds of recurrences that we support&period;
| xref:llvm/RegAllocType.adoc[`RegAllocType`] 
| 
| 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`] 
| 
| xref:llvm/RemapFlags.adoc[`RemapFlags`] 
| These are flags that the value mapping APIs allow&period;
| xref:llvm/ReplaceExitVal.adoc[`ReplaceExitVal`] 
| 
| xref:llvm/ReplacementType.adoc[`ReplacementType`] 
| 
| xref:llvm/RoundingMode.adoc[`RoundingMode`] 
| Rounding mode&period;
| xref:llvm/RunOutliner.adoc[`RunOutliner`] 
| 
| xref:llvm/SCEVNoWrapFlags.adoc[`SCEVNoWrapFlags`] 
| NoWrapFlags are bitfield indices into SCEV&apos;s SubclassData&period;
| xref:llvm/SCEVTypes.adoc[`SCEVTypes`] 
| 
| xref:llvm/SDNF.adoc[`SDNF`] 
| 
| xref:llvm/SDNP.adoc[`SDNP`] 
| 
| xref:llvm/SDTC.adoc[`SDTC`] 
| 
| xref:llvm/SanitizerStatKind.adoc[`SanitizerStatKind`] 
| 
| 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`] 
| 
| xref:llvm/SwiftAsyncFramePointerMode.adoc[`SwiftAsyncFramePointerMode`] 
| Indicates when and how the Swift async frame pointer bit should be set&period;
| xref:llvm/SymtabWritingMode.adoc[`SymtabWritingMode`] 
| 
| xref:llvm/TailFoldingStyle.adoc[`TailFoldingStyle`] 
| 
| xref:llvm/TensorType.adoc[`TensorType`] 
| 
| xref:llvm/TextEncoding.adoc[`TextEncoding`] 
| 
| 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`] 
| 
| xref:llvm/TransformationMode.adoc[`TransformationMode`] 
| The mode sets how eager a transformation should be applied&period;
| xref:llvm/UWTableKind.adoc[`UWTableKind`] 
| 
| xref:llvm/UncountableExitTrait.adoc[`UncountableExitTrait`] 
| Indicates the characteristics of a loop with an uncountable exit&period; &ast; None &hyphen;&hyphen; No uncountable exit present&period; &ast; ReadOnly &hyphen;&hyphen; At least one uncountable exit in a readonly loop&period; &ast; ReadWrite &hyphen;&hyphen; At least one uncountable exit in a loop with side effects that may require masking&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`] 
| Enum describing how values behave with respect to uniformity and divergence, to answer the question&colon; if the same instruction is executed by two threads in a convergent set of threads, will its result value be uniform, i&period;e&period; the same on both threads?
| 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`] 
| 
| xref:llvm/cgdata_error.adoc[`cgdata&lowbar;error`] 
| 
| xref:llvm/endianness.adoc[`endianness`] 
| Byte order of multi&hyphen;byte values&period;
| xref:llvm/errc.adoc[`errc`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/stream_error_code.adoc[`stream&lowbar;error&lowbar;code`] 
| 
|===


== 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, converted to the corresponding unsigned integer type&period; Avoids undefined behavior in std&colon;&colon;abs when you pass it INT&lowbar;MIN or similar&period;
| xref:llvm/AddOverflow-00.adoc[`AddOverflow`] 
| `AddOverflow` overloads
| xref:llvm/AnalyzePhysRegInBundle.adoc[`AnalyzePhysRegInBundle`] 
| AnalyzePhysRegInBundle &hyphen; Analyze how the current instruction or bundle uses a physical register&period; This function should not be called after operator&plus;&plus;(), it expects a fresh iterator&period;
| xref:llvm/AnalyzeVirtRegInBundle.adoc[`AnalyzeVirtRegInBundle`] 
| AnalyzeVirtRegInBundle &hyphen; Analyze how the current instruction or bundle uses a virtual register&period; This function should not be called after operator&plus;&plus;(), it expects a fresh iterator&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`] 
| 
| xref:llvm/AreStatisticsEnabled.adoc[`AreStatisticsEnabled`] 
| Check if statistics are enabled&period;
| xref:llvm/BitcodeErrorCategory.adoc[`BitcodeErrorCategory`] 
| 
| xref:llvm/BuildMI-06f.adoc[`BuildMI`] 
| `BuildMI` overloads
| xref:llvm/BuryPointer-0e.adoc[`BuryPointer`] 
| 
| 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`] 
| 
| xref:llvm/CheckBitcodeOutputToConsole.adoc[`CheckBitcodeOutputToConsole`] 
| Determine if the raw&lowbar;ostream provided is connected to a terminal&period; If so, generate a warning message to errs() advising against display of bitcode and return true&period; Otherwise just return false&period; Check for output written to a console
| xref:llvm/CloneAndPruneFunctionInto.adoc[`CloneAndPruneFunctionInto`] 
| This works exactly like CloneFunctionInto, except that it does some simple constant prop and DCE on the fly&period; The effect of this is to copy significantly less code in cases where (for example) a function call with constant arguments is inlined, and those constant arguments cause a significant amount of code in the callee to be dead&period; Since this doesn&apos;t produce an exactly copy of the input, it can&apos;t be used for things like CloneFunction or CloneModule&period;
| xref:llvm/CloneAndPruneIntoFromInst.adoc[`CloneAndPruneIntoFromInst`] 
| 
| xref:llvm/CloneBasicBlock.adoc[`CloneBasicBlock`] 
| Return a copy of the specified basic block, but without embedding the block into a particular function&period; The block returned is an exact copy of the specified basic block, without any remapping having been performed&period; Because of this, this is only suitable for applications where the basic block will be inserted into the same function that it was cloned from (loop unrolling would use this, for example)&period;
| xref:llvm/CloneFunction.adoc[`CloneFunction`] 
| Return a copy of the specified function and add it to that function&apos;s module&period; Also, any references specified in the VMap are changed to refer to their mapped value instead of the original one&period; If any of the arguments to the function are in the VMap, the arguments are deleted from the resultant function&period; The VMap is updated to include mappings from all of the instructions and basicblocks in the function from their old to new values&period; The final argument captures information about the cloned code if non&hyphen;null&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, transforming the old arguments into references to VMap values&period; Note that if NewFunc already has basic blocks, the ones cloned into it will be added to the end of the function&period; This function fills in a list of return instructions, and can optionally remap types and&sol;or append the specified suffix to all values cloned&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`] 
| 
| xref:llvm/ComputeASanStackFrameDescription.adoc[`ComputeASanStackFrameDescription`] 
| 
| xref:llvm/ComputeASanStackFrameLayout.adoc[`ComputeASanStackFrameLayout`] 
| 
| 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`] 
| Compute the linearized index of a member in a nested aggregate&sol;struct&sol;array&period;
| 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; i&period;e&period; x &equals;&equals; sext(trunc(x to MaxSignificantBits) to bitwidth(x))&period; Similar to the APInt&colon;&colon;getSignificantBits function&period;
| xref:llvm/ComputeNumSignBits.adoc[`ComputeNumSignBits`] 
| Return the number of times the sign bit of the register is replicated into the other bits&period; We know that at least 1 bit is always equal to the sign bit (itself), but other cases can give us information&period; For example, immediately after an &quot;ashr X, 2&quot;, we know that the top 3 bits are all equal to each other, so we return 3&period; For vectors, return the number of sign bits for the vector element with the mininum number of known sign 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`] 
| ComputeValueVTs &hyphen; Given an LLVM IR type, compute a sequence of EVTs that represent all the individual underlying non&hyphen;aggregate types that comprise it&period;
| xref:llvm/ConstantFoldBinOp.adoc[`ConstantFoldBinOp`] 
| 
| xref:llvm/ConstantFoldBinaryInstruction.adoc[`ConstantFoldBinaryInstruction`] 
| 
| 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`] 
| ConstantFoldCall &hyphen; Attempt to constant fold a call to the specified function with the specified arguments, returning null if unsuccessful&period;
| xref:llvm/ConstantFoldCastInstruction.adoc[`ConstantFoldCastInstruction`] 
| 
| xref:llvm/ConstantFoldCastOp.adoc[`ConstantFoldCastOp`] 
| 
| 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 (icmp&sol;fcmp) with the specified operands&period; Returns null or a constant expression of the specified operands on failure&period; Denormal inputs may be flushed based on the denormal handling mode&period;
| xref:llvm/ConstantFoldCompareInstruction.adoc[`ConstantFoldCompareInstruction`] 
| 
| xref:llvm/ConstantFoldConstant.adoc[`ConstantFoldConstant`] 
| ConstantFoldConstant &hyphen; Fold the constant using the specified DataLayout&period; This function always returns a non&hyphen;null constant&colon; Either the folding result, or the original constant if further folding is not possible&period;
| xref:llvm/ConstantFoldExtOp.adoc[`ConstantFoldExtOp`] 
| 
| xref:llvm/ConstantFoldExtractElementInstruction.adoc[`ConstantFoldExtractElementInstruction`] 
| Attempt to constant fold an extractelement instruction with the specified operands and indices&period; The constant result is returned if successful&semi; if not, null is returned&period;
| xref:llvm/ConstantFoldExtractValueInstruction.adoc[`ConstantFoldExtractValueInstruction`] 
| Attempt to constant fold an extractvalue instruction with the specified operands and indices&period; The constant result is returned if successful&semi; if not, null is returned&period;
| xref:llvm/ConstantFoldFPBinOp.adoc[`ConstantFoldFPBinOp`] 
| 
| xref:llvm/ConstantFoldFPInstOperands.adoc[`ConstantFoldFPInstOperands`] 
| Attempt to constant fold a floating point binary operation with the specified operands, applying the denormal handling mod to the operands&period; Returns null or a constant expression of the specified operands on failure&period;
| xref:llvm/ConstantFoldGetElementPtr.adoc[`ConstantFoldGetElementPtr`] 
| 
| xref:llvm/ConstantFoldICmp.adoc[`ConstantFoldICmp`] 
| 
| xref:llvm/ConstantFoldInsertElementInstruction.adoc[`ConstantFoldInsertElementInstruction`] 
| Attempt to constant fold an insertelement instruction with the specified operands and indices&period; The constant result is returned if successful&semi; if not, null is returned&period;
| xref:llvm/ConstantFoldInsertValueInstruction.adoc[`ConstantFoldInsertValueInstruction`] 
| Attempt to constant fold an insertvalue instruction with the specified operands and indices&period; The constant result is returned if successful&semi; if not, null is returned&period;
| xref:llvm/ConstantFoldInstOperands.adoc[`ConstantFoldInstOperands`] 
| ConstantFoldInstOperands &hyphen; Attempt to constant fold an instruction with the specified operands&period; If successful, the constant result is returned, if not, null is returned&period; Note that this function can fail when attempting to fold instructions like loads and stores, which have no constant expression form&period;
| xref:llvm/ConstantFoldInstruction.adoc[`ConstantFoldInstruction`] 
| ConstantFoldInstruction &hyphen; Try to constant fold the specified instruction&period; If successful, the constant result is returned, if not, null is returned&period; Note that this fails if not all of the operands are constant&period; Otherwise, this function can only fail when attempting to fold instructions like loads and stores, which have no constant expression form&period;
| xref:llvm/ConstantFoldIntToFloat.adoc[`ConstantFoldIntToFloat`] 
| 
| 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`] 
| 
| xref:llvm/ConstantFoldLoadFromConst-0a.adoc[`ConstantFoldLoadFromConst`] 
| `ConstantFoldLoadFromConst` overloads
| xref:llvm/ConstantFoldLoadFromConstPtr-0d.adoc[`ConstantFoldLoadFromConstPtr`] 
| `ConstantFoldLoadFromConstPtr` overloads
| xref:llvm/ConstantFoldLoadFromUniformValue.adoc[`ConstantFoldLoadFromUniformValue`] 
| If C is a uniform value where all bits are the same (either all zero, all ones, all undef or all poison), return the corresponding uniform value in the new type&period; If the value is not uniform or the result cannot be represented, return null&period;
| xref:llvm/ConstantFoldLoadThroughBitcast.adoc[`ConstantFoldLoadThroughBitcast`] 
| ConstantFoldLoadThroughBitcast &hyphen; try to cast constant to destination type returning null if unsuccessful&period; Can cast pointer to pointer or pointer to integer and vice versa if their sizes are equal&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; See class ShuffleVectorInst for a description of the mask representation&period; The constant result is returned if successful&semi; if not, null is returned&period;
| xref:llvm/ConstantFoldTerminator.adoc[`ConstantFoldTerminator`] 
| If a terminator instruction is predicated on a constant value, convert it into an unconditional branch to the constant destination&period; This is a nontrivial operation because the successors of this basic block must have their PHI nodes updated&period; Also calls RecursivelyDeleteTriviallyDeadInstructions() on any branch&sol;switch conditions and indirectbr addresses this might make dead if DeleteDeadConditions is true&period;
| xref:llvm/ConstantFoldUnaryInstruction.adoc[`ConstantFoldUnaryInstruction`] 
| 
| xref:llvm/ConstantFoldUnaryIntOp.adoc[`ConstantFoldUnaryIntOp`] 
| Tries to constant fold a unary integer operation (G&lowbar;CTLZ, G&lowbar;CTTZ, G&lowbar;CTPOP and their &lowbar;ZERO&lowbar;POISON variants, G&lowbar;ABS, G&lowbar;BSWAP, G&lowbar;BITREVERSE) on `Src&period;` If `Src` is a vector then it tries to do an element&hyphen;wise constant fold&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`] 
| Find in type conversion cost table&period;
| xref:llvm/ConvertDebugDeclareToDebugValue-0a.adoc[`ConvertDebugDeclareToDebugValue`] 
| `ConvertDebugDeclareToDebugValue` overloads
| xref:llvm/ConvertUTF16toUTF32.adoc[`ConvertUTF16toUTF32`] 
| 
| xref:llvm/ConvertUTF16toUTF8.adoc[`ConvertUTF16toUTF8`] 
| 
| xref:llvm/ConvertUTF32toUTF16.adoc[`ConvertUTF32toUTF16`] 
| 
| xref:llvm/ConvertUTF32toUTF8.adoc[`ConvertUTF32toUTF8`] 
| 
| xref:llvm/ConvertUTF8toUTF16.adoc[`ConvertUTF8toUTF16`] 
| 
| 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`] 
| Find in cost table&period;
| 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 from `BB&period;` The set of deleted blocks must have no predecessors that are not being deleted themselves&period; `BBs` must have no duplicating blocks&period; If there are loops among this set of blocks, all relevant loop info updates should be done before this function is called&period; If `KeepOneInputPHIs` is true, one&hyphen;input Phis in successors of blocks being deleted will be preserved&period;
| xref:llvm/DeleteDeadPHIs.adoc[`DeleteDeadPHIs`] 
| Examine each PHI in the given block and delete it if it is dead&period; Also recursively delete any operands that become dead as a result&period; This includes tracing the def&hyphen;use list from the PHI to see if it is ultimately unused or if it reaches an unused cycle&period; Return true if any PHIs were deleted&period;
| xref:llvm/DemotePHIToStack.adoc[`DemotePHIToStack`] 
| This function takes a virtual register computed by a phi node and replaces it with a slot in the stack frame, allocated via alloca&period; The phi node is deleted and it returns the pointer to the alloca inserted&period;
| xref:llvm/DemoteRegToStack.adoc[`DemoteRegToStack`] 
| This function takes a virtual register computed by an Instruction and replaces it with a slot in the stack frame, allocated via alloca&period; This allows the CFG to be changed around without fear of invalidating the SSA information for the value&period; It returns the pointer to the alloca inserted to create a stack slot for X&period;
| xref:llvm/DetermineUseCaptureKind.adoc[`DetermineUseCaptureKind`] 
| Determine what kind of capture behaviour `U` may exhibit&period;
| xref:llvm/DiffFilesWithTolerance.adoc[`DiffFilesWithTolerance`] 
| DiffFilesWithTolerance &hyphen; Compare the two files specified, returning 0 if the files match, 1 if they are different, and 2 if there is a file error&period; This function allows you to specify an absolute and relative FP error that is allowed to exist&period; If you specify a string to fill in for the error option, it will set the string to an error message if an error occurs, or if the files are different&period;
| xref:llvm/DisplayGraph.adoc[`DisplayGraph`] 
| 
| xref:llvm/DuplicateInstructionsInSplitBetween.adoc[`DuplicateInstructionsInSplitBetween`] 
| Split edge between BB and PredBB and duplicate all non&hyphen;Phi instructions from BB between its beginning and the StopAt instruction into the split block&period; Phi nodes are not duplicated, but their uses are handled correctly&colon; we replace them with the uses of corresponding Phi inputs&period; ValueMapping is used to map the original instructions from BB to their newly&hyphen;created copies&period; Returns the split block&period;
| xref:llvm/EliminateDuplicatePHINodes-0d.adoc[`EliminateDuplicatePHINodes`] 
| Check for and eliminate duplicate PHI nodes in this block&period; This doesn&apos;t try to be clever about PHI nodes which differ only in the order of the incoming values, but instcombine orders them so it usually won&apos;t matter&period;
| xref:llvm/EliminateNewDuplicatePHINodes.adoc[`EliminateNewDuplicatePHINodes`] 
| 
| xref:llvm/EliminateUnreachableBlocks.adoc[`EliminateUnreachableBlocks`] 
| Delete all basic blocks from `F` that are not reachable from its entry node&period; If `KeepOneInputPHIs` is true, one&hyphen;input Phis in successors of blocks being deleted will be preserved&period;
| xref:llvm/EmitDetailedRecords.adoc[`EmitDetailedRecords`] 
| 
| xref:llvm/EmitImportsFiles.adoc[`EmitImportsFiles`] 
| Emit into `OutputFilename` the files module `ModulePath` will import from&period;
| xref:llvm/EmitJSON.adoc[`EmitJSON`] 
| 
| 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`] 
| 
| xref:llvm/FindFunctionBackedges.adoc[`FindFunctionBackedges`] 
| Analyze the specified function to find all of the loop backedges in the function and return them&period; This is a relatively cheap (compared to computing dominators and loop info) analysis&period;
| xref:llvm/FindInsertedValue.adoc[`FindInsertedValue`] 
| Given an aggregate and an sequence of indices, see if the scalar value indexed is already around as a register, for example if it were inserted directly into the aggregate&period;
| xref:llvm/FlattenCFG.adoc[`FlattenCFG`] 
| This function is used to flatten a CFG&period; For example, it uses parallel&hyphen;and and parallel&hyphen;or mode to collapse if&hyphen;conditions and merge if&hyphen;regions with identical statements&period;
| xref:llvm/FlushFPConstant.adoc[`FlushFPConstant`] 
| Attempt to flush float point constant according to denormal mode set in the instruction&apos;s parent function attributes&period; If so, return a zero with the correct sign, otherwise return the original constant&period; Inputs and outputs to floating point instructions can have their mode set separately, so the direction is also needed&period;
| xref:llvm/FoldReturnIntoUncondBranch.adoc[`FoldReturnIntoUncondBranch`] 
| This method duplicates the specified return instruction into a predecessor which ends in an unconditional branch&period; If the return instruction returns a value defined by a PHI, propagate the right value into the return&period; It returns the new return instruction in the predecessor&period;
| xref:llvm/FoldSingleEntryPHINodes.adoc[`FoldSingleEntryPHINodes`] 
| We know that BB has one predecessor&period; If there are any single&hyphen;entry PHI nodes in it, fold them away&period; This handles the case when all entries to the PHI nodes in a block are guaranteed equal, such as when the block has exactly one predecessor&period;
| xref:llvm/GVTOP.adoc[`GVTOP`] 
| 
| xref:llvm/GetIfCondition.adoc[`GetIfCondition`] 
| Check whether BB is the merge point of a if&hyphen;region&period; If so, return the branch instruction that determines which entry into BB will be taken&period; Also, return by references the block that will be entered from if the condition is true, and the block that will be entered if the condition is false&period;
| xref:llvm/GetPointerBaseWithConstantOffset-08.adoc[`GetPointerBaseWithConstantOffset`] 
| Analyze the specified pointer to see if it can be expressed as a base pointer plus a constant offset&period; Return the base and offset to the caller&period;
| xref:llvm/GetReturnInfo.adoc[`GetReturnInfo`] 
| Given an LLVM IR type and return type attributes, compute the return value EVTs and flags, and optionally also the offsets, if the return value is being lowered to memory&period;
| xref:llvm/GetShadowBytes.adoc[`GetShadowBytes`] 
| 
| xref:llvm/GetShadowBytesAfterScope.adoc[`GetShadowBytesAfterScope`] 
| 
| 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`] 
| Search for the specified successor of basic block BB and return its position in the terminator instruction&apos;s list of successors&period; It is an error to call this with a block that is not a successor&period;
| xref:llvm/GetUnrollMetadata.adoc[`GetUnrollMetadata`] 
| 
| 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`] 
| Creates and inserts a dbg&lowbar;value record intrinsic before a store that has an associated llvm&period;dbg&period;value intrinsic&period;
| xref:llvm/InsertPreheaderForLoop.adoc[`InsertPreheaderForLoop`] 
| 
| xref:llvm/InvertBranch.adoc[`InvertBranch`] 
| 
| xref:llvm/IsBlockFollowedByDeoptOrUnreachable.adoc[`IsBlockFollowedByDeoptOrUnreachable`] 
| Check if we can prove that all paths starting from this block converge to a block that either has a llvm&period;experimental&period;deoptimize call prior to its terminating return instruction or is terminated by unreachable&period; All blocks in the traversed sequence must have an unique successor, maybe except for the last one&period;
| xref:llvm/IsConstantOffsetFromGlobal.adoc[`IsConstantOffsetFromGlobal`] 
| If this constant is a constant offset from a global, return the global and the constant&period; Because of constantexprs, this function is recursive&period; If the global is part of a dso&lowbar;local&lowbar;equivalent constant, return it through `Equiv` if it is provided&period;
| xref:llvm/IsSingleCodeUnitUTF16Codepoint.adoc[`IsSingleCodeUnitUTF16Codepoint`] 
| 
| xref:llvm/IsSingleCodeUnitUTF32Codepoint.adoc[`IsSingleCodeUnitUTF32Codepoint`] 
| 
| xref:llvm/IsSingleCodeUnitUTF8Codepoint.adoc[`IsSingleCodeUnitUTF8Codepoint`] 
| 
| xref:llvm/Lo_32.adoc[`Lo&lowbar;32`] 
| Return the low 32 bits of a 64 bit value&period;
| xref:llvm/LoadIntFromMemory.adoc[`LoadIntFromMemory`] 
| Loads the integer stored in the LoadBytes bytes starting from Src into IntVal, which is assumed to be wide enough and to hold zero&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, &hyphen;1 if the value is zero&period; (32 bit edition&period;) Ex&period; Log2&lowbar;32(32) &equals;&equals; 5, Log2&lowbar;32(1) &equals;&equals; 0, Log2&lowbar;32(0) &equals;&equals; &hyphen;1, Log2&lowbar;32(6) &equals;&equals; 2
| xref:llvm/Log2_32_Ceil.adoc[`Log2&lowbar;32&lowbar;Ceil`] 
| Return the ceil log base 2 of the specified value, 32 if the value is zero&period; (32 bit edition)&period; Ex&period; Log2&lowbar;32&lowbar;Ceil(32) &equals;&equals; 5, Log2&lowbar;32&lowbar;Ceil(1) &equals;&equals; 0, Log2&lowbar;32&lowbar;Ceil(6) &equals;&equals; 3
| 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; It may perform loop latch simplication as well if the flag RotationOnly is false&period; The flag Threshold represents the size threshold of the loop header&period; If the loop header&apos;s size exceeds the threshold, the loop rotation will give up&period; The flag IsUtilMode controls the heuristic used in the LoopRotation&period; If it is true, the profitability heuristic will be ignored&period;
| xref:llvm/LowerDbgDeclare.adoc[`LowerDbgDeclare`] 
| Lowers dbg&period;declare records into appropriate set of 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`] 
| BB is a block with one predecessor and its predecessor is known to have one successor (BB!)&period; Eliminate the edge between them, moving the instructions in the predecessor into BB&period; This deletes the predecessor block&period;
| xref:llvm/MergeBlockIntoPredecessor.adoc[`MergeBlockIntoPredecessor`] 
| Attempts to merge a block into its predecessor, if possible&period; The return value indicates success or failure&period; By default do not merge blocks if BB&apos;s predecessor has multiple successors&period; If PredecessorWithTwoSuccessors &equals; true, the blocks can only be merged if BB&apos;s Pred has a branch to BB and to AnotherBB, and BB has a single successor Sing&period; In this case the branch will be updated with Sing instead of BB, and BB will still be merged into its predecessor and removed&period; If `DT` is not nullptr, update it directly&semi; in that case, DTU must be nullptr&period;
| xref:llvm/MergeBlockSuccessorsIntoGivenBlocks.adoc[`MergeBlockSuccessorsIntoGivenBlocks`] 
| Merge block(s) sucessors, if possible&period; Return true if at least two of the blocks were merged together&period; In order to merge, each block must be terminated by an unconditional branch&period; If L is provided, then the blocks merged into their predecessors must be in L&period; In addition, This utility calls on another utility&colon; MergeBlockIntoPredecessor&period; Blocks are successfully merged when the call to MergeBlockIntoPredecessor returns true&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`] 
| Check whether null pointer dereferencing is considered undefined behavior for a given function or an address space&period; Null pointer access in non&hyphen;zero address space is not considered undefined&period; Return value&colon; false &equals;&gt; null pointer dereference is undefined&period; Return value&colon; true &equals;&gt; null pointer dereference is not undefined&period;
| xref:llvm/NumDigitsBase10.adoc[`NumDigitsBase10`] 
| Returns the number of digits in the given integer&period;
| xref:llvm/PTOGV.adoc[`PTOGV`] 
| 
| xref:llvm/PeelSingleBlockLoop.adoc[`PeelSingleBlockLoop`] 
| Peels a single block loop&period; Loop must have two successors, one of which must be itself&period; Similarly it must have two predecessors, one of which must be itself&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`] 
| Instrumentation passes often insert conditional checks into entry blocks&period; Call this function before splitting the entry block to move instructions that must remain in the entry block up before the split point&period; Static allocas and llvm&period;localescape calls, for example, must remain in the entry block&period;
| xref:llvm/PrintDomTree.adoc[`PrintDomTree`] 
| 
| xref:llvm/PrintError-04a.adoc[`PrintError`] 
| 
| xref:llvm/PrintFatalError-0d.adoc[`PrintFatalError`]  [.small]#[noreturn]#
| 
| xref:llvm/PrintFatalNote-05.adoc[`PrintFatalNote`]  [.small]#[noreturn]#
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/RecursivelyDeleteDeadPHINode.adoc[`RecursivelyDeleteDeadPHINode`] 
| If the specified value is an effectively dead PHI node, due to being a def&hyphen;use chain of single&hyphen;use nodes that either forms a cycle or is terminated by a trivially dead instruction, delete it&period; If that makes any of its operands trivially dead, delete them too, recursively&period; Return true if a change was made&period;
| xref:llvm/RecursivelyDeleteTriviallyDeadInstructions-00.adoc[`RecursivelyDeleteTriviallyDeadInstructions`] 
| `RecursivelyDeleteTriviallyDeadInstructions` overloads
| xref:llvm/RecursivelyDeleteTriviallyDeadInstructionsPermissive.adoc[`RecursivelyDeleteTriviallyDeadInstructionsPermissive`] 
| Same functionality as RecursivelyDeleteTriviallyDeadInstructions, but allow instructions that are not trivially dead&period; These will be ignored&period; Returns true if any changes were made, i&period;e&period; any instructions trivially dead were found and deleted&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 source location atom&period; Called by RemapInstruction&period; This updates the instruction&apos;s atom group number if it has been mapped (e&period;g&period; with llvm&colon;&colon;mapAtomInstance), which is necessary to distinguish source code atoms on duplicated code paths&period;
| xref:llvm/RemoveRedundantDbgInstrs.adoc[`RemoveRedundantDbgInstrs`] 
| Try to remove redundant dbg&period;value instructions from given basic block&period; Returns true if at least one instruction was removed&period; Remove redundant pseudo ops when RemovePseudoOp is true&period;
| xref:llvm/ReplaceInstWithInst-05.adoc[`ReplaceInstWithInst`] 
| `ReplaceInstWithInst` overloads
| xref:llvm/ReplaceInstWithValue.adoc[`ReplaceInstWithValue`] 
| Replace all uses of an instruction (specified by BI) with a value, then remove and delete the original instruction&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`] 
| Restores the topmost element of the &quot;pretty&quot; stack state to State, which should come from a previous call to SavePrettyStackState()&period; This is useful when using a CrashRecoveryContext in code that also uses PrettyStackTraceEntries, to make sure the stack that&apos;s printed if a crash happens after a crash that&apos;s been recovered by CrashRecoveryContext doesn&apos;t have frames on it that were added in code unwound by the CrashRecoveryContext&period;
| xref:llvm/ReverseStackTrace.adoc[`ReverseStackTrace`] 
| 
| 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, X and Y, of type T&period; Clamp the result to the maximum representable value of T on overflow&period; ResultOverflowed indicates if the result is larger than the maximum representable value of type T&period;
| xref:llvm/SaturatingMultiplyAdd.adoc[`SaturatingMultiplyAdd`] 
| Multiply two unsigned integers, X and Y, and add the unsigned integer, A to the product&period; Clamp the result to the maximum representable value of T on overflow&period; ResultOverflowed indicates if the result is larger than the maximum representable value of type T&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`] 
| 
| xref:llvm/SimplifyInstructionsInBlock.adoc[`SimplifyInstructionsInBlock`] 
| Scan the specified basic block and try to simplify any instructions in it and recursively delete dead instructions&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`] 
| Loop over all of the edges in the CFG, breaking critical edges as they are found&period; Returns the number of broken edges&period;
| xref:llvm/SplitBlock-06.adoc[`SplitBlock`] 
| Split the specified block at the specified instruction&period;
| xref:llvm/SplitBlockAndInsertForEachLane-0b.adoc[`SplitBlockAndInsertForEachLane`] 
| `SplitBlockAndInsertForEachLane` overloads
| xref:llvm/SplitBlockAndInsertIfElse-07.adoc[`SplitBlockAndInsertIfElse`] 
| Similar to SplitBlockAndInsertIfThen, but the inserted block is on the false path of the branch&period;
| xref:llvm/SplitBlockAndInsertIfThen-00.adoc[`SplitBlockAndInsertIfThen`] 
| Split the containing block at the specified instruction &hyphen; everything before SplitBefore stays in the old basic block, and the rest of the instructions in the BB are moved to a new block&period; The two blocks are connected by a conditional branch (with value of Cmp being the condition)&period; Before&colon; Head SplitBefore Tail After&colon; Head if (Cond) ThenBlock SplitBefore Tail
| xref:llvm/SplitBlockAndInsertIfThenElse-06.adoc[`SplitBlockAndInsertIfThenElse`] 
| `SplitBlockAndInsertIfThenElse` overloads
| xref:llvm/SplitBlockAndInsertSimpleForLoop.adoc[`SplitBlockAndInsertSimpleForLoop`] 
| Insert a for (int i &equals; 0&semi; i &lt; End&semi; i&plus;&plus;) loop structure (with the exception that `End` is assumed &gt; 0, and thus not checked on entry) at `SplitBefore&period;` Returns the first insert point in the loop body, and the PHINode for the induction variable (i&period;e&period; &quot;i&quot; above)&period;
| xref:llvm/SplitBlockPredecessors-01.adoc[`SplitBlockPredecessors`] 
| This method introduces at least one new basic block into the function and moves some of the predecessors of BB to be predecessors of the new block&period; The new predecessors are indicated by the Preds array&period; The new block is given a suffix of &apos;Suffix&apos;&period; Returns new basic block to which predecessors from Preds are now pointing&period;
| xref:llvm/SplitCriticalEdge-0f.adoc[`SplitCriticalEdge`] 
| `SplitCriticalEdge` overloads
| xref:llvm/SplitEdge.adoc[`SplitEdge`] 
| Split the edge connecting the specified blocks, and return the newly created basic block between `From` and `To&period;`
| xref:llvm/SplitIndirectBrCriticalEdges.adoc[`SplitIndirectBrCriticalEdges`] 
| 
| xref:llvm/SplitKnownCriticalEdge.adoc[`SplitKnownCriticalEdge`] 
| If it is known that an edge is critical, SplitKnownCriticalEdge can be called directly, rather than calling SplitCriticalEdge first&period;
| xref:llvm/SplitLandingPadPredecessors.adoc[`SplitLandingPadPredecessors`] 
| This method transforms the landing pad, OrigBB, by introducing two new basic blocks into the function&period; One of those new basic blocks gets the predecessors listed in Preds&period; The other basic block gets the remaining predecessors of OrigBB&period; The landingpad instruction OrigBB is clone into both of the new basic blocks&period; The new blocks are given the suffixes &apos;Suffix1&apos; and &apos;Suffix2&apos;, and are returned in the NewBBs vector&period;
| xref:llvm/SplitModule.adoc[`SplitModule`] 
| Splits the module M into N linkable partitions&period; The function ModuleCallback is called N times passing each individual partition as the MPart argument&period; PreserveLocals&colon; Split without externalizing locals&period; RoundRobin&colon; Use round&hyphen;robin distribution of functions to modules instead of the default name&hyphen;hash&hyphen;based one&period;
| xref:llvm/SplitMultiBrEdge.adoc[`SplitMultiBrEdge`] 
| Create a new intermediate target block for a callbr or switch edge&period;
| xref:llvm/SplitString.adoc[`SplitString`] 
| SplitString &hyphen; Split up the specified string according to the specified delimiters, appending the result fragments to the output list&period;
| xref:llvm/StoreIntToMemory.adoc[`StoreIntToMemory`] 
| Fills the StoreBytes bytes of memory starting from Dst with the integer held in IntVal&period;
| xref:llvm/StrCmpOptionName.adoc[`StrCmpOptionName`] 
| 
| xref:llvm/StrCmpOptionPrefixes.adoc[`StrCmpOptionPrefixes`] 
| 
| xref:llvm/StripDebugInfo-03.adoc[`StripDebugInfo`] 
| Strip debug info in the module if it exists&period;
| xref:llvm/StripTemplateParameters.adoc[`StripTemplateParameters`] 
| If `Name` is the name of a templated function that includes template parameters, returns a substring of `Name` containing no template parameters&period; E&period;g&period;&colon; StripTemplateParameters(&quot;foo&lt;int&gt;&quot;) &equals; &quot;foo&quot;&period;
| xref:llvm/StructuralHash-0f.adoc[`StructuralHash`] 
| `StructuralHash` overloads
| xref:llvm/StructuralHashWithDifferences.adoc[`StructuralHashWithDifferences`] 
| Computes a structural hash of a given function, considering the structure and content of the function&apos;s instructions while allowing for selective ignoring of certain operands based on custom criteria&period; This hash can be used to identify functions that are structurally similar or identical, which is useful in optimizations, deduplication, or analysis tasks&period;
| xref:llvm/SubOverflow-02.adoc[`SubOverflow`] 
| `SubOverflow` overloads
| xref:llvm/TableGenMain-0b.adoc[`TableGenMain`] 
| 
| xref:llvm/TableGenParseFile.adoc[`TableGenParseFile`] 
| Parse the TableGen file defined within the main buffer of the given SourceMgr&period; On success, populates the provided RecordKeeper with the parsed records and returns false&period; On failure, returns true&period;
| xref:llvm/TryToSimplifyUncondBranchFromEmptyBlock.adoc[`TryToSimplifyUncondBranchFromEmptyBlock`] 
| BB is known to contain an unconditional branch, and contains no instructions other than PHI nodes, potential debug intrinsics and the branch&period; If possible, eliminate BB by rewriting all the predecessors to branch to the successor block and return true&period; If we can&apos;t transform, return false&period;
| xref:llvm/UnrollAndJamLoop.adoc[`UnrollAndJamLoop`] 
| 
| xref:llvm/UnrollLoop.adoc[`UnrollLoop`] 
| 
| xref:llvm/UnrollRuntimeLoopRemainder.adoc[`UnrollRuntimeLoopRemainder`] 
| 
| 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`] 
| This is an auto&hyphen;upgrade hook for any old intrinsic function syntaxes which need to have both the function updated as well as all calls updated to the new function&period; This should only be run in a post&hyphen;processing fashion so that it can update all calls to the old function&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`] 
| 
| 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`] 
| This is a more granular function that simply checks an intrinsic function for upgrading, and returns true if it requires upgrading&period; It may return null in NewFn if the all calls to the original intrinsic function should be transformed to non&hyphen;function&hyphen;call instructions&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`] 
| 
| xref:llvm/UpgradeTBAANode.adoc[`UpgradeTBAANode`] 
| If the given TBAA tag uses the scalar TBAA format, create a new node corresponding to the upgrade to the struct&hyphen;path aware TBAA format&period; Otherwise return the `TBAANode` itself&period;
| xref:llvm/ViewGraph.adoc[`ViewGraph`] 
| ViewGraph &hyphen; Emit a dot graph, run &apos;dot&apos;, run gv on the postscript file, then cleanup&period; For use from the debugger&period;
| xref:llvm/WriteBitcodeToFile.adoc[`WriteBitcodeToFile`] 
| Write the specified module to the specified raw output stream&period;
| xref:llvm/WriteDOTGraphToFile.adoc[`WriteDOTGraphToFile`] 
| 
| xref:llvm/WriteGraph-063.adoc[`WriteGraph`] 
| Writes graph into a provided `Filename&period;` If `Filename` is empty, generates a random one&period;
| xref:llvm/abs-0e.adoc[`abs`] 
| `abs` overloads
| xref:llvm/accumulate-06.adoc[`accumulate`] 
| `accumulate` overloads
| xref:llvm/adaptNoAliasScopes.adoc[`adaptNoAliasScopes`] 
| Adapt the metadata for the specified instruction according to the provided mapping&period; This is normally used after cloning an instruction, when some noalias scopes needed to be cloned&period;
| xref:llvm/addAssumptions-05.adoc[`addAssumptions`] 
| `addAssumptions` overloads
| xref:llvm/addClonedBlockToLoopInfo.adoc[`addClonedBlockToLoopInfo`] 
| @&rcub;
| xref:llvm/addDiffRuntimeChecks.adoc[`addDiffRuntimeChecks`] 
| 
| xref:llvm/addEnumValues.adoc[`addEnumValues`] 
| Helper which adds two underlying types of enumeration type&period; Implicit conversion to a common type is accepted&period;
| xref:llvm/addHash.adoc[`addHash`] 
| Feed version components of `VT` into hash builder `HBuilder&period;`
| xref:llvm/addInnerLoopsToHeadersMap.adoc[`addInnerLoopsToHeadersMap`] 
| 
| 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 to ORE message&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`] 
| Provide wrappers to std&colon;&colon;all&lowbar;of which take ranges instead of having to pass begin&sol;end explicitly&period;
| xref:llvm/all_of_zip.adoc[`all&lowbar;of&lowbar;zip`] 
| Compare two zipped ranges using the provided predicate (as last argument)&period; Return true if all elements satisfy the predicate and false otherwise&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`] 
| Provide wrappers to std&colon;&colon;any&lowbar;of which take ranges instead of having to pass begin&sol;end explicitly&period;
| xref:llvm/appendLEB128.adoc[`appendLEB128`] 
| 
| xref:llvm/appendLoopsToWorklist-02.adoc[`appendLoopsToWorklist`] 
| `appendLoopsToWorklist` overloads
| xref:llvm/appendReversedLoopsToWorklist.adoc[`appendReversedLoopsToWorklist`] 
| Utility that implements appending of loops onto a worklist given a range&period; It has the same behavior as appendLoopsToWorklist, but assumes the range of loops has already been reversed, so it processes loops in the given order&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 list of global ctors of module M with the given Priority&period; This wraps the function in the appropriate structure and stores it along side other global constructors&period; For details see https&colon;&sol;&sol;llvm&period;org&sol;docs&sol;LangRef&period;html&num;the&hyphen;llvm&hyphen;global&hyphen;ctors&hyphen;global&hyphen;variable
| xref:llvm/appendToGlobalDtors.adoc[`appendToGlobalDtors`] 
| Same as appendToGlobalCtors(), but for global dtors&period;
| xref:llvm/appendToUsed.adoc[`appendToUsed`] 
| Adds global values to the llvm&period;used list&period;
| xref:llvm/append_range.adoc[`append&lowbar;range`] 
| Wrapper function to append range `R` to container `C`&period;
| xref:llvm/append_values.adoc[`append&lowbar;values`] 
| Appends all `Values` to container `C`&period;
| xref:llvm/applyDebugifyMetadata.adoc[`applyDebugifyMetadata`] 
| Add synthesized debug information to a module&period;
| xref:llvm/applyDebugifyMetadataToMachineFunction.adoc[`applyDebugifyMetadataToMachineFunction`] 
| 
| xref:llvm/applyFlowInference-0c.adoc[`applyFlowInference`] 
| 
| xref:llvm/applyProfMetadataIfEnabled.adoc[`applyProfMetadataIfEnabled`] 
| 
| 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`] 
| 
| xref:llvm/attributesPermitTailCall.adoc[`attributesPermitTailCall`] 
| Test if given that the input instruction is in the tail call position, if there is an attribute mismatch between the caller and the callee that will inhibit tail call optimizations&period; `AllowDifferingSizes` is an output parameter which, if forming a tail call is permitted, determines whether it&apos;s permitted only if the size of the caller&apos;s and callee&apos;s return types match exactly&period;
| xref:llvm/avoidZeroOffsetLandingPad.adoc[`avoidZeroOffsetLandingPad`] 
| 
| 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`] 
| 
| 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 the specified loop&period; Handles loop nests and general loop structures subject to the precondition that the loop has no parent loop and has a single latch block&period; Preserves all listed analyses&period;
| xref:llvm/buildAssumeFromInst.adoc[`buildAssumeFromInst`] 
| Build a call to llvm&period;assume to preserve informations that can be derived from the given instruction&period; If no information derived from `I,` this call returns null&period; The returned instruction is not inserted anywhere&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`] 
| Clone a DBG&lowbar;VALUE whose value has been spilled to FrameIndex&period;
| 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`] 
| 
| xref:llvm/calculateClrEHStateNumbers.adoc[`calculateClrEHStateNumbers`] 
| 
| xref:llvm/calculateCountScale.adoc[`calculateCountScale`] 
| Calculate what to divide by to scale counts&period;
| xref:llvm/calculateDbgEntityHistory.adoc[`calculateDbgEntityHistory`] 
| 
| xref:llvm/calculateSEHStateForAsynchEH.adoc[`calculateSEHStateForAsynchEH`] 
| 
| xref:llvm/calculateSEHStateNumbers.adoc[`calculateSEHStateNumbers`] 
| 
| xref:llvm/calculateWinCXXEHStateNumbers.adoc[`calculateWinCXXEHStateNumbers`] 
| Analyze the IR in ParentFn and it&apos;s handlers to build WinEHFuncInfo, which describes the state numbers and tables used by &lowbar;&lowbar;CxxFrameHandler3&period; This analysis assumes that WinEHPrepare has already been run&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`] 
| canConstantFoldCallTo &hyphen; Return true if its even possible to fold a call to the specified function&period;
| xref:llvm/canConvertToMinOrMaxIntrinsic.adoc[`canConvertToMinOrMaxIntrinsic`] 
| Check if the values in `VL` are select instructions that can be converted to a min or max (vector) intrinsic&period; Returns the intrinsic ID, if such a conversion is possible, together with a bool indicating whether all select conditions are only used by the selects&period; Otherwise return Intrinsic&colon;&colon;not&lowbar;intrinsic&period;
| xref:llvm/canCreatePoison-0a.adoc[`canCreatePoison`] 
| Returns true if `Reg` can create poison from non&hyphen;poison operands&period;
| xref:llvm/canCreateUndefOrPoison-05.adoc[`canCreateUndefOrPoison`] 
| `canCreateUndefOrPoison` overloads
| xref:llvm/canHoistLoad.adoc[`canHoistLoad`] 
| Returns true if it is legal to hoist `LI` out of `CurLoop&period;` This is the load&hyphen;specific subset of `canSinkOrHoistInst` it rejects volatile or ordered loads, allows constant&hyphen;memory &sol; invariant&period;load &sol; invariant&period;start&hyphen; dominated loads unconditionally, and otherwise queries `MSSA` for an in&hyphen;loop clobber&period; `TargetExecutesOncePerLoop` has the same meaning as in `canSinkOrHoistInst` (set to true when hoisting to the preheader)&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`] 
| 
| 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`] 
| 
| xref:llvm/canPeel.adoc[`canPeel`] 
| 
| xref:llvm/canPeelLastIteration.adoc[`canPeelLastIteration`] 
| Returns true if the last iteration of `L` can be peeled off&period; It makes sure the loop exit condition can be adjusted when peeling and that the loop executes at least 2 iterations&period;
| xref:llvm/canRenameComdatFunc.adoc[`canRenameComdatFunc`] 
| Check if we can safely rename this Comdat function&period; Instances of the same comdat function may have different control flows thus can not share the same counter variable&period;
| xref:llvm/canReplaceOperandWithVariable.adoc[`canReplaceOperandWithVariable`] 
| Given an instruction, is it legal to set operand OpIdx to a non&hyphen;constant value?
| xref:llvm/canReplacePointersIfEqual.adoc[`canReplacePointersIfEqual`] 
| Returns true if a pointer value `From` can be replaced with another pointer value To if they are deemed equal through some means (e&period;g&period; information from conditions)&period; NOTE&colon; The current implementation allows replacement in Icmp and PtrToInt instructions, as well as when we are replacing with a null pointer&period; Additionally it also allows replacement of pointers when both pointers have the same underlying object&period;
| xref:llvm/canReplacePointersInUseIfEqual.adoc[`canReplacePointersInUseIfEqual`] 
| 
| 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`] 
| 
| xref:llvm/canSinkOrHoistInst.adoc[`canSinkOrHoistInst`] 
| Returns true if is legal to hoist or sink this instruction disregarding the possible introduction of faults&period; Reasoning about potential faulting instructions is the responsibility of the caller since it is challenging to do efficiently from within this routine&period; `TargetExecutesOncePerLoop` is true only when it is guaranteed that the target executes at most once per execution of the loop body&period; This is used to assess the legality of duplicating atomic loads&period; Generally, this is true when moving out of loop and not true when moving into loops&period; If `ORE` is set use it to emit optimization remarks&period;
| xref:llvm/canTrackArgumentsInterprocedurally.adoc[`canTrackArgumentsInterprocedurally`] 
| Determine if the values of the given function&apos;s arguments can be tracked interprocedurally&period; The value of an argument can be tracked if the function has local linkage and its address is not taken&period;
| xref:llvm/canTrackGlobalVariableInterprocedurally.adoc[`canTrackGlobalVariableInterprocedurally`] 
| Determine if the value maintained in the given global variable can be tracked interprocedurally&period; A value can be tracked if the global variable has local linkage and is only used by non&hyphen;volatile loads and stores&period;
| xref:llvm/canTrackReturnsInterprocedurally.adoc[`canTrackReturnsInterprocedurally`] 
| Determine if the values of the given function&apos;s returns can be tracked interprocedurally&period; Return values can be tracked if the function has an exact definition and it doesn&apos;t have the &quot;naked&quot; attribute&period; Naked functions may contain assembly code that returns untrackable values&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` is a valid vector element type, void, or an unpacked literal struct where all elements are valid vector element types&period; Note&colon; Even if a type can be vectorized that does not mean it is valid to do so in all cases&period; For example, a vectorized struct (as returned by toVectorizedTy) does not perform (de)interleaving, so it can&apos;t be used for vectorizing loads&sol;stores&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`] 
| 
| xref:llvm/capturesAddressIsNullOnly.adoc[`capturesAddressIsNullOnly`] 
| 
| xref:llvm/capturesAll.adoc[`capturesAll`] 
| 
| xref:llvm/capturesAnyProvenance.adoc[`capturesAnyProvenance`] 
| 
| xref:llvm/capturesAnything.adoc[`capturesAnything`] 
| 
| xref:llvm/capturesFullProvenance.adoc[`capturesFullProvenance`] 
| 
| xref:llvm/capturesNothing.adoc[`capturesNothing`] 
| 
| xref:llvm/capturesReadProvenanceOnly.adoc[`capturesReadProvenanceOnly`] 
| 
| 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`] 
| 
| xref:llvm/changeToCall.adoc[`changeToCall`] 
| This function converts the specified invoke into a normal call&period;
| xref:llvm/changeToInvokeAndSplitBasicBlock.adoc[`changeToInvokeAndSplitBasicBlock`] 
| Convert the CallInst to InvokeInst with the specified unwind edge basic block&period; This also splits the basic block where CI is located, because InvokeInst is a terminator instruction&period; Returns the newly split basic block&period;
| xref:llvm/changeToUnreachable.adoc[`changeToUnreachable`] 
| Insert an unreachable instruction before the specified instruction, making it and the rest of the code in the block dead&period;
| xref:llvm/checkDebugInfoMetadata.adoc[`checkDebugInfoMetadata`] 
| Check original debug information after a pass&period;
| xref:llvm/checkForCycles-0d.adoc[`checkForCycles`] 
| 
| xref:llvm/checkGEPType.adoc[`checkGEPType`] 
| 
| 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`] 
| Helper function to clamp a state `S` of type `StateType` with the information in `R` and indicate&sol;return if `S` did change (as&hyphen;in update is required to be run again)&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`] 
| 
| 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;` Returns the loop and the blocks in `Blocks&period;`
| xref:llvm/cloneNoAliasScopes.adoc[`cloneNoAliasScopes`] 
| Duplicate the specified list of noalias decl scopes&period; The &apos;Ext&apos; string is added as an extension to the name&period; Afterwards, the ClonedScopes contains the mapping of the original scope MDNode onto the cloned scope&period; Be aware that the cloned scopes are still part of the original scope domain&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`] 
| Given a vector of strings (names of global objects like functions or, virtual tables) `NameStrs,` the method generates a combined string `Result` that is ready to be serialized&period; The `Result` string is comprised of three fields&colon; The first field is the length of the uncompressed strings, and the the second field is the length of the zlib&hyphen;compressed string&period; Both fields are encoded in ULEB128&period; If `doCompress` is false, the third field is the uncompressed strings&semi; otherwise it is the compressed string&period; When the string compression is off, the second field will have value zero&period;
| xref:llvm/collectPGOFuncNameStrings.adoc[`collectPGOFuncNameStrings`] 
| Produce `Result` string with the same format described above&period; The input is vector of PGO function name variables that are referenced&period; The global variable element in &apos;NameVars&apos; is a string containing the pgo name of a function&period; See `createPGOFuncNameVar` that creates these global variables&period;
| xref:llvm/collectParametricTerms.adoc[`collectParametricTerms`] 
| Collect parametric terms occurring in step expressions (first step of delinearization)&period;
| xref:llvm/collectPossibleValues.adoc[`collectPossibleValues`] 
| Enumerates all possible immediate values of V and inserts them into the set `Constants&period;` If `AllowUndefOrPoison` is false, it fails when V may contain undef&sol;poison elements&period; Returns true if the result is complete&period; Otherwise, the result is incomplete (more than MaxCount values)&period; NOTE&colon; The constant values are not distinct&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`] 
| 
| xref:llvm/colorEHFunclets.adoc[`colorEHFunclets`] 
| If an EH funclet personality is in use (see isFuncletEHPersonality), this will recompute which blocks are in which funclet&period; It is possible that some blocks are in multiple funclets&period; Consider this analysis to be expensive&period;
| xref:llvm/combineAAMetadata.adoc[`combineAAMetadata`] 
| Combine metadata of two instructions, where instruction J is a memory access that has been merged into K&period; This will intersect alias&hyphen;analysis metadata, while preserving other known metadata&period;
| xref:llvm/combineMetadataForCSE.adoc[`combineMetadataForCSE`] 
| Combine the metadata of two instructions so that K can replace J&period; This specifically handles the case of CSE&hyphen;like transformations&period; Some metadata can only be kept if K dominates J&period; For this to be correct, K cannot be hoisted&period;
| xref:llvm/commonAlignment.adoc[`commonAlignment`] 
| Returns the alignment that satisfies both alignments&period; Same semantic as MinAlign&period;
| xref:llvm/compareLoops.adoc[`compareLoops`] 
| 
| xref:llvm/compareVectors.adoc[`compareVectors`] 
| 
| 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`] 
| 
| 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 all the symbols that are &quot;dead&quot;&colon; i&period;e these that can&apos;t be reached in the graph from any of the given symbols listed in `GUIDPreservedSymbols&period;` Non&hyphen;prevailing symbols are symbols without a prevailing copy anywhere in IR and are normally dead, `isPrevailing` predicate returns status of symbol&period; Also update call edges for indirect calls to local functions added from SamplePGO when needed&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`] 
| 
| 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 false if we can prove that the specified FP value&apos;s sign bit is 0&period; Return true if we can prove that the specified FP value&apos;s sign bit is 1&period; Otherwise return std&colon;&colon;nullopt&period;
| xref:llvm/computeLTOCacheKey.adoc[`computeLTOCacheKey`] 
| Computes a unique hash for the Module considering the current list of export&sol;import and other global analysis results&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`] 
| This version also leverages the sign bit of Add if known&period;
| xref:llvm/computeOverflowForSignedMul.adoc[`computeOverflowForSignedMul`] 
| 
| xref:llvm/computeOverflowForSignedSub.adoc[`computeOverflowForSignedSub`] 
| 
| xref:llvm/computeOverflowForUnsignedAdd.adoc[`computeOverflowForUnsignedAdd`] 
| 
| xref:llvm/computeOverflowForUnsignedMul.adoc[`computeOverflowForUnsignedMul`] 
| 
| xref:llvm/computeOverflowForUnsignedSub.adoc[`computeOverflowForUnsignedSub`] 
| 
| xref:llvm/computePeelCount.adoc[`computePeelCount`] 
| 
| xref:llvm/computeRemLatency.adoc[`computeRemLatency`] 
| 
| xref:llvm/computeUnrollCount.adoc[`computeUnrollCount`] 
| 
| xref:llvm/computeValueLLTs-0f.adoc[`computeValueLLTs`] 
| computeValueLLTs &hyphen; Given an LLVM IR type, compute a sequence of LLTs that represent all the individual underlying non&hyphen;aggregate types that comprise it&period;
| xref:llvm/concat.adoc[`concat`] 
| Returns a concatenated range across two or more ranges&period; Does not modify the 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`] 
| 
| xref:llvm/constrainOperandRegClass-06.adoc[`constrainOperandRegClass`] 
| `constrainOperandRegClass` overloads
| xref:llvm/constrainRegToClass.adoc[`constrainRegToClass`] 
| Try to constrain Reg to the specified register class&period; If this fails, create a new virtual register in the correct class&period;
| xref:llvm/constrainSelectedInstRegOperands.adoc[`constrainSelectedInstRegOperands`] 
| Mutate the newly&hyphen;selected instruction `I` to constrain its (possibly generic) virtual register operands to the instruction&apos;s register class&period; This could involve inserting COPYs before (for uses) or after (for defs)&period; This requires the number of operands to match the instruction description&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`] 
| target CFG with begin()&sol;end() iterator interfaces&period; 3) `LI` must be a valid LoopInfoBase that contains up&hyphen;to&hyphen;date loop analysis information of the CFG&period;
| xref:llvm/convertCtxProfToYaml.adoc[`convertCtxProfToYaml`] 
| 
| 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`] 
| Converts a string from snake&hyphen;case to camel&hyphen;case by replacing all occurrences of &apos;&lowbar;&apos; followed by a lowercase letter with the letter in uppercase&period; Optionally allow capitalization of the first letter (if it is a lowercase letter)
| xref:llvm/convertToDeclaration.adoc[`convertToDeclaration`] 
| Converts value `GV` to declaration, or replaces with a declaration if it is an alias&period; Returns true if converted, false if replaced&period;
| xref:llvm/convertToSnakeFromCamelCase.adoc[`convertToSnakeFromCamelCase`] 
| Converts a string from camel&hyphen;case to snake&hyphen;case by replacing all uppercase letters with &apos;&lowbar;&apos; followed by the letter in lowercase, except if the uppercase letter is the first character of the string&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; Return whether anything was changed&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 the metadata from the source instruction to the destination (the replacement for the source instruction)&period;
| xref:llvm/copyModuleAttrToFunctions.adoc[`copyModuleAttrToFunctions`] 
| Copies module attributes to the functions in the module&period; Currently only effects ARM, Thumb and AArch64 targets&period; Supported attributes&colon; &hyphen; branch&hyphen;target&hyphen;enforcement &hyphen; branch&hyphen;protection&hyphen;pauth&hyphen;lr &hyphen; guarded&hyphen;control&hyphen;stack &hyphen; sign&hyphen;return&hyphen;address &hyphen; sign&hyphen;return&hyphen;address&hyphen;with&hyphen;bkey
| xref:llvm/copyNonnullMetadata.adoc[`copyNonnullMetadata`] 
| Copy a nonnull metadata node to a new load instruction&period;
| xref:llvm/copyRangeMetadata.adoc[`copyRangeMetadata`] 
| Copy a range metadata node to a new load instruction&period;
| xref:llvm/copy_if.adoc[`copy&lowbar;if`] 
| Provide wrappers to std&colon;&colon;copy&lowbar;if which take ranges instead of having to pass begin&sol;end explicitly&period;
| xref:llvm/count.adoc[`count`] 
| Wrapper function around std&colon;&colon;count to count the number of times an element `Element` occurs in the given range `Range&period;`
| xref:llvm/count_if.adoc[`count&lowbar;if`] 
| Wrapper function around std&colon;&colon;count&lowbar;if to count the number of times an element satisfying a given predicate occurs in a range&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`] 
| 
| xref:llvm/createARMELFStreamer.adoc[`createARMELFStreamer`] 
| 
| xref:llvm/createAggressiveAntiDepBreaker.adoc[`createAggressiveAntiDepBreaker`] 
| 
| 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`] 
| AtomicExpandPass &hyphen; At IR level this pass replace atomic instructions with &lowbar;&lowbar;atomic&lowbar;&ast; library calls, or target specific instruction which implement the same semantics in a way which better fits the target backend&period;
| xref:llvm/createBURRListDAGScheduler.adoc[`createBURRListDAGScheduler`] 
| createBURRListDAGScheduler &hyphen; This creates a bottom 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`] 
| 
| xref:llvm/createBasicBlockMatchingAndInferencePass.adoc[`createBasicBlockMatchingAndInferencePass`] 
| createBasicBlockMatchingAndInferencePass &hyphen; This pass enables matching and inference when using propeller&period;
| xref:llvm/createBasicBlockPathCloningPass.adoc[`createBasicBlockPathCloningPass`] 
| 
| 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`] 
| 
| xref:llvm/createBasicRegisterAllocator-0a.adoc[`createBasicRegisterAllocator`] 
| BasicRegisterAllocation Pass &hyphen; This pass implements a degenerate global register allocator using the basic regalloc framework&period;
| 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`] 
| createBranchFolder &hyphen; Create the BranchFolder pass, optionally disabling the common&hyphen;code hoisting and&sol;or basic&hyphen;block reordering sub&hyphen;phases&period; Default enables both (full BranchFolding behavior)&period;
| xref:llvm/createBreakCriticalEdgesPass.adoc[`createBreakCriticalEdgesPass`] 
| 
| xref:llvm/createBreakFalseDepsLegacyPass.adoc[`createBreakFalseDepsLegacyPass`] 
| Creates Break False Dependencies pass&period;
| xref:llvm/createCFGSimplificationPass.adoc[`createCFGSimplificationPass`] 
| 
| 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`] 
| 
| xref:llvm/createCOFFMasmParser.adoc[`createCOFFMasmParser`] 
| 
| xref:llvm/createCallGraphDOTPrinterPass.adoc[`createCallGraphDOTPrinterPass`] 
| 
| xref:llvm/createCallGraphViewerPass.adoc[`createCallGraphViewerPass`] 
| 
| xref:llvm/createCallMatchingInvoke.adoc[`createCallMatchingInvoke`] 
| Create a call that matches the invoke `II` in terms of arguments, attributes, debug information, etc&period; The call is not placed in a block and it will not have a name&period; The invoke instruction is not removed, nor are the uses replaced by the new call&period;
| xref:llvm/createCanonicalizeFreezeInLoopsPass.adoc[`createCanonicalizeFreezeInLoopsPass`] 
| 
| 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`] 
| 
| xref:llvm/createCopyConstrainDAGMutation.adoc[`createCopyConstrainDAGMutation`] 
| 
| xref:llvm/createCriticalAntiDepBreaker.adoc[`createCriticalAntiDepBreaker`] 
| 
| xref:llvm/createCtxProfFromYAML.adoc[`createCtxProfFromYAML`] 
| 
| xref:llvm/createCustomBehaviour.adoc[`createCustomBehaviour`] 
| 
| xref:llvm/createDAGLinearizer.adoc[`createDAGLinearizer`] 
| createDAGLinearizer &hyphen; This creates a &quot;no&hyphen;scheduling&quot; scheduler which linearize the DAG using topological order&period;
| xref:llvm/createDXContainerStreamer.adoc[`createDXContainerStreamer`] 
| 
| xref:llvm/createDXILResourceBindingWrapperPassPass.adoc[`createDXILResourceBindingWrapperPassPass`] 
| 
| xref:llvm/createDXILResourceTypeWrapperPassPass.adoc[`createDXILResourceTypeWrapperPassPass`] 
| 
| xref:llvm/createDXILResourceWrapperPassPass.adoc[`createDXILResourceWrapperPassPass`] 
| 
| xref:llvm/createDarwinAsmParser.adoc[`createDarwinAsmParser`] 
| 
| 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`] 
| 
| xref:llvm/createDeadStoreEliminationPass.adoc[`createDeadStoreEliminationPass`] 
| 
| 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`] 
| createDefaultScheduler &hyphen; This creates 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`] 
| 
| xref:llvm/createDevelopmentModeAdvisorProvider.adoc[`createDevelopmentModeAdvisorProvider`] 
| 
| xref:llvm/createDevelopmentModePriorityAdvisorAnalysis.adoc[`createDevelopmentModePriorityAdvisorAnalysis`] 
| 
| xref:llvm/createDevelopmentModePriorityAdvisorProvider.adoc[`createDevelopmentModePriorityAdvisorProvider`] 
| 
| 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`] 
| 
| xref:llvm/createDomOnlyViewerWrapperPassPass.adoc[`createDomOnlyViewerWrapperPassPass`] 
| 
| xref:llvm/createDomPrinterWrapperPassPass.adoc[`createDomPrinterWrapperPassPass`] 
| 
| xref:llvm/createDomViewerWrapperPassPass.adoc[`createDomViewerWrapperPassPass`] 
| 
| 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`] 
| 
| xref:llvm/createELFStreamer.adoc[`createELFStreamer`] 
| 
| xref:llvm/createEarlyCSEPass.adoc[`createEarlyCSEPass`] 
| 
| xref:llvm/createExpandIRInstsPass.adoc[`createExpandIRInstsPass`] 
| 
| xref:llvm/createExpandReductionsPass.adoc[`createExpandReductionsPass`] 
| This pass expands the reduction intrinsics into sequences of shuffles&period;
| xref:llvm/createExpandVariadicsPass.adoc[`createExpandVariadicsPass`] 
| 
| 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`] 
| createFastDAGScheduler &hyphen; This creates a &quot;fast&quot; scheduler&period;
| xref:llvm/createFastRegisterAllocator-0f.adoc[`createFastRegisterAllocator`] 
| FastRegisterAllocation Pass &hyphen; This pass register allocates as fast as possible&period; It is best suited for debug code where live ranges are short&period;
| xref:llvm/createFileError-09.adoc[`createFileError`] 
| `createFileError` overloads
| xref:llvm/createFixIrreduciblePass.adoc[`createFixIrreduciblePass`] 
| 
| xref:llvm/createFlattenCFGPass.adoc[`createFlattenCFGPass`] 
| 
| 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`] 
| 
| xref:llvm/createGCEmptyBasicBlocksLegacyPass.adoc[`createGCEmptyBasicBlocksLegacyPass`] 
| createGCEmptyBasicblocksPass &hyphen; Empty basic blocks (basic blocks without real code) appear as the result of optimization passes removing instructions&period; These blocks confuscate profile analysis (e&period;g&period;, basic block sections) since they will share the address of their fallthrough blocks&period; This pass garbage&hyphen;collects such 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`] 
| 
| xref:llvm/createGOFFObjectWriter-0b.adoc[`createGOFFObjectWriter`] 
| Construct a new GOFF writer instance&period;
| xref:llvm/createGOFFStreamer.adoc[`createGOFFStreamer`] 
| 
| xref:llvm/createGVNPass-02.adoc[`createGVNPass`] 
| Create a legacy GVN pass&period;
| xref:llvm/createGlobalDCEPass.adoc[`createGlobalDCEPass`] 
| 
| xref:llvm/createGlobalMergeFuncPass.adoc[`createGlobalMergeFuncPass`] 
| This pass performs merging similar functions globally&period;
| xref:llvm/createGlobalMergePass.adoc[`createGlobalMergePass`] 
| GlobalMerge &hyphen; This pass merges internal (by default) globals into structs to enable reuse of a base pointer by indexed addressing modes&period; It can also be configured to focus on size optimizations only&period;
| xref:llvm/createGlobalsAAWrapperPass.adoc[`createGlobalsAAWrapperPass`] 
| 
| xref:llvm/createGraphFilename.adoc[`createGraphFilename`] 
| 
| xref:llvm/createGreedyRegisterAllocator-02.adoc[`createGreedyRegisterAllocator`] 
| Greedy register allocation pass &hyphen; This pass implements a global register allocator for optimized builds&period;
| xref:llvm/createHardwareLoopsLegacyPass.adoc[`createHardwareLoopsLegacyPass`] 
| Create Hardware Loop pass&period;
| xref:llvm/createHybridListDAGScheduler.adoc[`createHybridListDAGScheduler`] 
| createHybridListDAGScheduler &hyphen; This creates a bottom up register pressure aware list scheduler that make use of latency information to avoid stalls for long latency instructions in low register pressure mode&period; In high register pressure mode it schedules to reduce register pressure&period;
| xref:llvm/createILPListDAGScheduler.adoc[`createILPListDAGScheduler`] 
| createILPListDAGScheduler &hyphen; This creates a bottom up register pressure aware list scheduler that tries to increase instruction level parallelism in low register pressure mode&period; In high register pressure mode it schedules to reduce register pressure&period;
| xref:llvm/createIVUsersPass.adoc[`createIVUsersPass`] 
| 
| xref:llvm/createIfConverter.adoc[`createIfConverter`] 
| 
| xref:llvm/createImmutableModuleSummaryIndexWrapperPass.adoc[`createImmutableModuleSummaryIndexWrapperPass`] 
| 
| xref:llvm/createIndirectBrExpandPass.adoc[`createIndirectBrExpandPass`] 
| 
| xref:llvm/createInferAddressSpacesPass.adoc[`createInferAddressSpacesPass`] 
| 
| xref:llvm/createInlineAsmPreparePass.adoc[`createInlineAsmPreparePass`] 
| 
| 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`] 
| 
| xref:llvm/createInstrPostProcess.adoc[`createInstrPostProcess`] 
| 
| xref:llvm/createInstructionCombiningPass.adoc[`createInstructionCombiningPass`] 
| 
| xref:llvm/createInstrumentManager.adoc[`createInstrumentManager`] 
| 
| 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`] 
| 
| xref:llvm/createLFIAsmParser.adoc[`createLFIAsmParser`] 
| 
| xref:llvm/createLICMPass.adoc[`createLICMPass`] 
| 
| xref:llvm/createLazyValueInfoPass.adoc[`createLazyValueInfoPass`] 
| createLazyValueInfoPass &hyphen; This creates an instance of the LazyValueInfo pass&period;
| xref:llvm/createLibcallLoweringInfoWrapper.adoc[`createLibcallLoweringInfoWrapper`] 
| 
| xref:llvm/createLoadClusterDAGMutation.adoc[`createLoadClusterDAGMutation`] 
| If ReorderWhileClustering is set to true, no attempt will be made to reduce reordering due to store clustering&period;
| xref:llvm/createLoadStoreVectorizerPass.adoc[`createLoadStoreVectorizerPass`] 
| Create a legacy pass manager instance of the LoadStoreVectorizer pass
| xref:llvm/createLoopDataPrefetchPass.adoc[`createLoopDataPrefetchPass`] 
| 
| xref:llvm/createLoopSimplifyPass.adoc[`createLoopSimplifyPass`] 
| 
| xref:llvm/createLoopStrengthReducePass.adoc[`createLoopStrengthReducePass`] 
| 
| xref:llvm/createLoopTermFoldPass.adoc[`createLoopTermFoldPass`] 
| 
| xref:llvm/createLoopUnrollPass.adoc[`createLoopUnrollPass`] 
| 
| xref:llvm/createLowerAtomicPass.adoc[`createLowerAtomicPass`] 
| 
| 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`] 
| 
| xref:llvm/createLowerInvokePass.adoc[`createLowerInvokePass`] 
| 
| xref:llvm/createLowerSwitchPass.adoc[`createLowerSwitchPass`] 
| 
| xref:llvm/createMCAsmParser.adoc[`createMCAsmParser`] 
| Create an MCAsmParser instance for parsing assembly similar to gas syntax
| xref:llvm/createMCMasmParser.adoc[`createMCMasmParser`] 
| Create an MCAsmParser instance for parsing Microsoft MASM&hyphen;style assembly
| xref:llvm/createMCRelocationInfo.adoc[`createMCRelocationInfo`] 
| 
| xref:llvm/createMCSymbolizer.adoc[`createMCSymbolizer`] 
| 
| 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`] 
| 
| xref:llvm/createMachineBlockHashInfoPass.adoc[`createMachineBlockHashInfoPass`] 
| createMachineBlockHashInfoPass &hyphen; This pass computes basic block hashes&period;
| xref:llvm/createMachineCopyPropagationPass.adoc[`createMachineCopyPropagationPass`] 
| 
| 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 scheduling mutation to pair instructions back to back for instructions that benefit according to the target&hyphen;specific predicate functions&period; shouldScheduleAdjacent will be true if any of the provided predicates are true&period; If BranchOnly is true, only branch instructions with one of their predecessors will be fused&period;
| xref:llvm/createMemCpyLoopKnownSize.adoc[`createMemCpyLoopKnownSize`] 
| Emit a loop implementing the semantics of an llvm&period;memcpy whose size is a compile time constant&period; Loop is inserted at `InsertBefore&period;`
| xref:llvm/createMemCpyLoopUnknownSize.adoc[`createMemCpyLoopUnknownSize`] 
| Emit a loop implementing the semantics of llvm&period;memcpy where the size is not a compile&hyphen;time constant&period; Loop will be inserted at `InsertBefore&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`] 
| 
| 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`] 
| 
| xref:llvm/createNullStreamer.adoc[`createNullStreamer`] 
| Create a dummy machine code streamer, which does nothing&period; This is useful for timing the assembler front end&period;
| xref:llvm/createObjCARCContractPass.adoc[`createObjCARCContractPass`] 
| 
| 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 the PGOFuncName meta data if PGOFuncName is different from function&apos;s raw name&period; This should only apply to internal linkage functions declared by users only&period; TODO&colon; Update all callers to &apos;createPGONameMetadata&apos; and deprecate this function&period;
| xref:llvm/createPGOFuncNameVar-04.adoc[`createPGOFuncNameVar`] 
| Create and return the global variable for function name used in PGO instrumentation&period; `FuncName` is the IRPGO function name (returned by `getIRPGOFuncName)` for LLVM IR instrumentation and PGO function name (returned by `getPGOFuncName)` for front&hyphen;end instrumentation&period;
| xref:llvm/createPGONameMetadata.adoc[`createPGONameMetadata`] 
| Create the PGOName metadata if a global object&apos;s PGO name is different from its mangled name&period; This should apply to local&hyphen;linkage global objects only&period;
| xref:llvm/createPHIsForSplitLoopExit.adoc[`createPHIsForSplitLoopExit`] 
| When a loop exit edge is split, LCSSA form may require new PHIs in the new exit block&period; This function inserts the new PHIs, as needed&period; Preds is a list of preds inside the loop, SplitBB is the new loop exit block, and DestBB is the old loop exit, now the successor of SplitBB&period;
| xref:llvm/createPartiallyInlineLibCallsPass.adoc[`createPartiallyInlineLibCallsPass`] 
| 
| xref:llvm/createPostDomOnlyPrinterWrapperPassPass.adoc[`createPostDomOnlyPrinterWrapperPassPass`] 
| 
| xref:llvm/createPostDomOnlyViewerWrapperPassPass.adoc[`createPostDomOnlyViewerWrapperPassPass`] 
| 
| xref:llvm/createPostDomPrinterWrapperPassPass.adoc[`createPostDomPrinterWrapperPassPass`] 
| 
| xref:llvm/createPostDomTree.adoc[`createPostDomTree`] 
| 
| xref:llvm/createPostDomViewerWrapperPassPass.adoc[`createPostDomViewerWrapperPassPass`] 
| 
| xref:llvm/createPostInlineEntryExitInstrumenterPass.adoc[`createPostInlineEntryExitInstrumenterPass`] 
| 
| xref:llvm/createPreISelIntrinsicLoweringPass.adoc[`createPreISelIntrinsicLoweringPass`] 
| This pass lowers the @llvm&period;load&period;relative and @llvm&period;objc&period;&ast; intrinsics to instructions&period; This is unsafe to do earlier because a pass may combine the constant initializer into the load, which may result in an overflowing evaluation&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`] 
| 
| xref:llvm/createProfileFileNameVar.adoc[`createProfileFileNameVar`] 
| 
| xref:llvm/createProfileSamplingVar.adoc[`createProfileSamplingVar`] 
| 
| xref:llvm/createPrologEpilogInserterPass.adoc[`createPrologEpilogInserterPass`] 
| 
| xref:llvm/createPromoteMemoryToRegisterPass.adoc[`createPromoteMemoryToRegisterPass`] 
| 
| xref:llvm/createPseudoProbeInserter.adoc[`createPseudoProbeInserter`] 
| This pass inserts pseudo probe annotation for callsite profiling&period;
| xref:llvm/createReassociatePass.adoc[`createReassociatePass`] 
| 
| xref:llvm/createRegAllocScoringPass.adoc[`createRegAllocScoringPass`] 
| When learning an eviction policy, extract score(reward) information, otherwise this does nothing
| xref:llvm/createRegToMemWrapperPass.adoc[`createRegToMemWrapperPass`] 
| 
| 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`] 
| Return a MachineFunction pass that identifies call sites and propagates register usage information of callee to caller if available with PysicalRegisterUsageInfo pass&period;
| xref:llvm/createRegionInfoPass.adoc[`createRegionInfoPass`] 
| 
| xref:llvm/createRegionOnlyPrinterPass.adoc[`createRegionOnlyPrinterPass`] 
| 
| xref:llvm/createRegionOnlyViewerPass.adoc[`createRegionOnlyViewerPass`] 
| 
| xref:llvm/createRegionPrinterPass.adoc[`createRegionPrinterPass`] 
| 
| xref:llvm/createRegionViewerPass.adoc[`createRegionViewerPass`] 
| 
| xref:llvm/createReleaseModeAdvisorAnalysisLegacy.adoc[`createReleaseModeAdvisorAnalysisLegacy`] 
| 
| xref:llvm/createReleaseModeAdvisorProvider.adoc[`createReleaseModeAdvisorProvider`] 
| 
| xref:llvm/createReleaseModeModelRunner.adoc[`createReleaseModeModelRunner`] 
| Helper to construct the appropriate MLModelRunner in release mode&colon; 1&period; InteractiveModelRunner if an interactive channel is specified&period; 2&period; EmitCModelRunner if MLIR lowering is enabled&period; 3&period; ReleaseModeModelRunner&lt;CompiledModelType&gt; otherwise&period;
| xref:llvm/createReleaseModePriorityAdvisorAnalysis.adoc[`createReleaseModePriorityAdvisorAnalysis`] 
| 
| xref:llvm/createReleaseModePriorityAdvisorProvider.adoc[`createReleaseModePriorityAdvisorProvider`] 
| 
| xref:llvm/createReplaceWithVeclibLegacyPass.adoc[`createReplaceWithVeclibLegacyPass`] 
| 
| xref:llvm/createReplicatedMask.adoc[`createReplicatedMask`] 
| Create a mask with replicated elements&period;
| xref:llvm/createResetMachineFunctionPass.adoc[`createResetMachineFunctionPass`] 
| This pass resets a MachineFunction when it has the FailedISel property as if it was just created&period; If EmitFallbackDiag is true, the pass will emit a DiagnosticInfoISelFallback for every MachineFunction it resets&period; If AbortOnFailedISel is true, abort compilation instead of resetting&period;
| xref:llvm/createRuntimeLibraryInfoWrapperPass.adoc[`createRuntimeLibraryInfoWrapperPass`] 
| 
| 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`] 
| 
| xref:llvm/createSROAPass.adoc[`createSROAPass`] 
| 
| 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`] 
| 
| xref:llvm/createScalarizerPass.adoc[`createScalarizerPass`] 
| Create a legacy pass manager instance of the Scalarizer pass
| 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`] 
| 
| xref:llvm/createSelectOptimizePass.adoc[`createSelectOptimizePass`] 
| This pass converts conditional moves to conditional jumps when profitable&period;
| xref:llvm/createSeparateConstOffsetFromGEPPass.adoc[`createSeparateConstOffsetFromGEPPass`] 
| 
| 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`] 
| 
| 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`] 
| createSourceListDAGScheduler &hyphen; This creates a bottom up list scheduler that schedules nodes in source code order when possible&period;
| xref:llvm/createSpeculativeExecutionIfHasBranchDivergencePass.adoc[`createSpeculativeExecutionIfHasBranchDivergencePass`] 
| 
| xref:llvm/createSpeculativeExecutionPass.adoc[`createSpeculativeExecutionPass`] 
| 
| 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`] 
| If ReorderWhileClustering is set to true, no attempt will be made to reduce reordering due to store clustering&period;
| xref:llvm/createStraightLineStrengthReducePass.adoc[`createStraightLineStrengthReducePass`] 
| 
| 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`] 
| 
| xref:llvm/createStripConvergenceIntrinsicsPass.adoc[`createStripConvergenceIntrinsicsPass`] 
| 
| xref:llvm/createStripDebugMachineModuleLegacyPass.adoc[`createStripDebugMachineModuleLegacyPass`] 
| Creates MIR Strip Debug pass&period;
| xref:llvm/createStructurizeCFGPass.adoc[`createStructurizeCFGPass`] 
| When `SkipUniformRegions` is true the structizer will not structurize regions that only contain uniform branches&period;
| xref:llvm/createTailCallEliminationPass.adoc[`createTailCallEliminationPass`] 
| 
| xref:llvm/createTargetTransformInfoWrapperPass.adoc[`createTargetTransformInfoWrapperPass`] 
| Create an analysis pass wrapper around a TTI object&period;
| xref:llvm/createTriggerCrashFunctionPass.adoc[`createTriggerCrashFunctionPass`] 
| 
| xref:llvm/createTypeBasedAAWrapperPass.adoc[`createTypeBasedAAWrapperPass`] 
| 
| xref:llvm/createTypePromotionLegacyPass.adoc[`createTypePromotionLegacyPass`] 
| Create IR Type Promotion pass&period;
| xref:llvm/createUnaryMask.adoc[`createUnaryMask`] 
| Given a shuffle mask for a binary shuffle, create the equivalent shuffle mask assuming both operands are identical&period; This assumes that the unary shuffle will use elements from operand 0 (operand 1 will be unused)&period;
| xref:llvm/createUnifyLoopExitsPass.adoc[`createUnifyLoopExitsPass`] 
| 
| xref:llvm/createUnpackMachineBundlesLegacy.adoc[`createUnpackMachineBundlesLegacy`] 
| 
| xref:llvm/createUnreachableBlockEliminationPass.adoc[`createUnreachableBlockEliminationPass`] 
| createUnreachableBlockEliminationPass &hyphen; The LLVM code generator does not work well with unreachable basic blocks (what live ranges make sense for a block that cannot be reached?)&period; As such, a code generator should either not instruction select unreachable blocks, or run this pass as its last LLVM modifying pass to clean up blocks that are not reachable from the entry block&period;
| xref:llvm/createVLIWDAGScheduler.adoc[`createVLIWDAGScheduler`] 
| createVLIWDAGScheduler &hyphen; Scheduler for VLIW targets&period; This creates top down DFA driven list scheduler with clustering heuristic to control register pressure&period;
| xref:llvm/createVerifierPass.adoc[`createVerifierPass`] 
| 
| xref:llvm/createVirtRegRewriter.adoc[`createVirtRegRewriter`] 
| 
| xref:llvm/createWasmAsmParser.adoc[`createWasmAsmParser`] 
| 
| xref:llvm/createWasmDwoObjectWriter.adoc[`createWasmDwoObjectWriter`] 
| 
| 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`] 
| 
| xref:llvm/createWideIV.adoc[`createWideIV`] 
| Widen Induction Variables &hyphen; Extend the width of an IV to cover its widest uses&period;
| xref:llvm/createWinCOFFDwoObjectWriter.adoc[`createWinCOFFDwoObjectWriter`] 
| 
| 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`] 
| 
| xref:llvm/createXCOFFObjectWriter.adoc[`createXCOFFObjectWriter`] 
| 
| 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`] 
| 
| xref:llvm/declareSanitizerInitFunction.adoc[`declareSanitizerInitFunction`] 
| 
| xref:llvm/decodeBase64.adoc[`decodeBase64`] 
| 
| xref:llvm/decodeMaybeAlign.adoc[`decodeMaybeAlign`] 
| Dual operation of the encode function above&period;
| xref:llvm/decodePackedBCD-05.adoc[`decodePackedBCD`] 
| 
| xref:llvm/decodeSLEB128.adoc[`decodeSLEB128`] 
| Utility function to decode a SLEB128 value&period;
| xref:llvm/decodeSLEB128AndInc.adoc[`decodeSLEB128AndInc`] 
| 
| xref:llvm/decodeULEB128.adoc[`decodeULEB128`] 
| Utility function to decode a ULEB128 value&period;
| xref:llvm/decodeULEB128AndInc.adoc[`decodeULEB128AndInc`] 
| 
| xref:llvm/decodeULEB128AndIncUnsafe.adoc[`decodeULEB128AndIncUnsafe`] 
| 
| xref:llvm/decomposeBitTest.adoc[`decomposeBitTest`] 
| Decompose an icmp into the form ((X &amp; Mask) pred C) if possible&period; Unless `AllowNonZeroC` is true, C will always be 0&period; If `DecomposeAnd` is specified, then, for equality predicates, this will decompose bitmasking via `and`&period;
| xref:llvm/decomposeBitTestICmp.adoc[`decomposeBitTestICmp`] 
| Decompose an icmp into the form ((X &amp; Mask) pred C) if possible&period; Unless `AllowNonZeroC` is true, C will always be 0&period; If `DecomposeAnd` is specified, then, for equality predicates, this will decompose bitmasking via `and`&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`] 
| 
| xref:llvm/deleteDeadLoop.adoc[`deleteDeadLoop`] 
| This function deletes dead loops&period; The caller of this function needs to guarantee that the loop is infact dead&period; The function requires a bunch or prerequisites to be present&colon; &hyphen; The loop needs to be in LCSSA form &hyphen; The loop needs to have a Preheader &hyphen; A unique dedicated exit block must exist
| 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 this SCEVAddRecExpr into two vectors of SCEVs representing the subscripts and sizes of an access to a fixed size array&period; This is a special case of delinearization for fixed size arrays&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`] 
| 
| xref:llvm/describeFuzzerControlFlowOps.adoc[`describeFuzzerControlFlowOps`] 
| 
| xref:llvm/describeFuzzerFloatOps.adoc[`describeFuzzerFloatOps`] 
| 
| xref:llvm/describeFuzzerIntOps.adoc[`describeFuzzerIntOps`] 
| Getters for the default sets of operations, per general category&period; @&lcub;
| xref:llvm/describeFuzzerOtherOps.adoc[`describeFuzzerOtherOps`] 
| 
| xref:llvm/describeFuzzerPointerOps.adoc[`describeFuzzerPointerOps`] 
| 
| xref:llvm/describeFuzzerUnaryOperations.adoc[`describeFuzzerUnaryOperations`] 
| 
| xref:llvm/describeFuzzerVectorOps.adoc[`describeFuzzerVectorOps`] 
| 
| xref:llvm/deserializeSectionKind.adoc[`deserializeSectionKind`] 
| Convert a value read from an index section to the internal representation&period;
| xref:llvm/detachDeadBlocks.adoc[`detachDeadBlocks`] 
| Replace contents of every block in `BBs` with single unreachable instruction&period; If `Updates` is specified, collect all necessary DT updates into this vector&period; If `KeepOneInputPHIs` is true, one&hyphen;input Phis in successors of blocks being deleted will be preserved&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`] 
| 
| xref:llvm/disableAutoConversion.adoc[`disableAutoConversion`] 
| 
| 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`] 
| 
| xref:llvm/dlltoolDriverMain.adoc[`dlltoolDriverMain`] 
| 
| xref:llvm/doSystemDiff.adoc[`doSystemDiff`] 
| 
| 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 the debug intrinsic instructions for the 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`] 
| 
| xref:llvm/dumpMessage.adoc[`dumpMessage`] 
| 
| xref:llvm/dumpRegSetPressure.adoc[`dumpRegSetPressure`] 
| 
| xref:llvm/dumpTypeQualifiedName.adoc[`dumpTypeQualifiedName`] 
| Dump the qualified type name of `DIE` to `OS&period;`
| xref:llvm/dumpTypeUnqualifiedName.adoc[`dumpTypeUnqualifiedName`] 
| 
| 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 the edge connect the specficed blocks in the case that `Succ` is an Exception Handling Block
| xref:llvm/embedBitcodeInModule.adoc[`embedBitcodeInModule`] 
| If EmbedBitcode is set, save a copy of the llvm IR as data in the &lowbar;&lowbar;LLVM,&lowbar;&lowbar;bitcode section (&period;llvmbc on non&hyphen;MacOS)&period; If available, pass the serialized module via the Buf parameter&period; If not, pass an empty (default&hyphen;initialized) MemoryBufferRef, and the serialization will be handled by this API&period; The same behavior happens if the provided Buf is not bitcode (i&period;e&period; if it&apos;s invalid data or even textual LLVM assembly)&period; If EmbedCmdline is set, the command line is also exported in the corresponding section (&lowbar;&lowbar;LLVM,&lowbar;cmdline &sol; &period;llvmcmd) &hyphen; even if CmdArgs were empty&period;
| xref:llvm/embedBufferInModule.adoc[`embedBufferInModule`] 
| Embed the memory buffer `Buf` into the module `M` as a global using the specified section name&period; Also provide a metadata entry to identify it in the module using the same section name&period; If `SectionExclude` is true !exclude is applied to the global in order to apply necessary linkage flags to exclude the section from a link&period; If false, apply !metadata&lowbar;section&lowbar;kind which results in no additional section linkage flags&period;
| xref:llvm/emitAMDGPUPrintfCall.adoc[`emitAMDGPUPrintfCall`] 
| 
| 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`] 
| 
| 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`] 
| Emit a DWARFv5 Accelerator Table consisting of entries in the specified AccelTable&period; The `CUs` contains either symbols keeping offsets to the start of compilation unit, either offsets to the start of compilation unit themselves&period;
| xref:llvm/emitFPutC.adoc[`emitFPutC`] 
| Emit a call to the fputc function&period; This assumes that Char is an &apos;int&apos;, and File is a pointer to FILE&period;
| xref:llvm/emitFPutS.adoc[`emitFPutS`] 
| Emit a call to the fputs function&period; Str is required to be a pointer and File is a pointer to FILE&period;
| xref:llvm/emitFWrite.adoc[`emitFWrite`] 
| Emit a call to the fwrite function&period; This assumes that Ptr is a pointer, Size is an &apos;size&lowbar;t&apos;, and File is a pointer to FILE&period;
| xref:llvm/emitGEPOffset.adoc[`emitGEPOffset`] 
| Given a getelementptr instruction&sol;constantexpr, emit the code necessary to compute the offset from the base pointer (without adding in the base pointer)&period; Return the result as a signed integer of intptr size&period; When NoAssumptions is true, no assumptions about index computation not overflowing is made&period;
| xref:llvm/emitHotColdNew.adoc[`emitHotColdNew`] 
| Emit a call to the hot&sol;cold operator new function&period;
| xref:llvm/emitHotColdNewAligned.adoc[`emitHotColdNewAligned`] 
| 
| xref:llvm/emitHotColdNewAlignedNoThrow.adoc[`emitHotColdNewAlignedNoThrow`] 
| 
| xref:llvm/emitHotColdNewNoThrow.adoc[`emitHotColdNewNoThrow`] 
| 
| xref:llvm/emitHotColdSizeReturningNew.adoc[`emitHotColdSizeReturningNew`] 
| 
| xref:llvm/emitHotColdSizeReturningNewAligned.adoc[`emitHotColdSizeReturningNewAligned`] 
| 
| xref:llvm/emitInlinedInto.adoc[`emitInlinedInto`] 
| Emit ORE message&period;
| xref:llvm/emitInlinedIntoBasedOnCost.adoc[`emitInlinedIntoBasedOnCost`] 
| Emit ORE message based in cost (default heuristic)&period;
| xref:llvm/emitLFIBundleAlign.adoc[`emitLFIBundleAlign`] 
| 
| xref:llvm/emitLFINoteSection.adoc[`emitLFINoteSection`] 
| 
| xref:llvm/emitLinkerFlagsForGlobalCOFF.adoc[`emitLinkerFlagsForGlobalCOFF`] 
| 
| xref:llvm/emitLinkerFlagsForUsedCOFF.adoc[`emitLinkerFlagsForUsedCOFF`] 
| 
| 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 the memchr function&period; This assumes that Ptr is a pointer, Val is an &apos;int&apos; value, and Len is an &apos;size&lowbar;t&apos; value&period;
| xref:llvm/emitMemCmp.adoc[`emitMemCmp`] 
| Emit a call to the memcmp function&period;
| xref:llvm/emitMemCpyChk.adoc[`emitMemCpyChk`] 
| Emit a call to the &lowbar;&lowbar;memcpy&lowbar;chk function to the builder&period; This expects that the Len and ObjSize have type &apos;size&lowbar;t&apos; and Dst&sol;Src are pointers&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 the putchar function&period; This assumes that Char is an &apos;int&apos;&period;
| xref:llvm/emitPutS.adoc[`emitPutS`] 
| Emit a call to the puts function&period; This assumes that 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`] 
| emitSourceFileHeader &hyphen; Output an LLVM style file header to the specified raw&lowbar;ostream&period;
| xref:llvm/emitStpCpy.adoc[`emitStpCpy`] 
| Emit a call to the stpcpy function to the builder, for the specified pointer arguments&period;
| xref:llvm/emitStpNCpy.adoc[`emitStpNCpy`] 
| Emit a call to the stpncpy function to the builder, 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 the strchr function to the builder, for the specified pointer and character&period; Ptr is required to be some pointer type, and the return value has &apos;i8&ast;&apos; type&period;
| xref:llvm/emitStrCpy.adoc[`emitStrCpy`] 
| Emit a call to the strcpy function to the builder, for the specified pointer arguments&period;
| xref:llvm/emitStrDup.adoc[`emitStrDup`] 
| Emit a call to the strdup function to the builder, for the specified pointer&period; Ptr is required to be some pointer type, and the return value has &apos;i8&ast;&apos; type&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 the strlen function to the builder, for the specified pointer&period; Ptr is required to be some pointer type, and the return value has &apos;size&lowbar;t&apos; type&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 the strncpy function to the builder, 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 the wcslen function to the builder, for the specified pointer&period; Ptr is required to be some pointer type, and the return value has &apos;size&lowbar;t&apos; type&period;
| xref:llvm/enableAutoConversion-02.adoc[`enableAutoConversion`] 
| 
| xref:llvm/encode-04.adoc[`encode`] 
| `encode` overloads
| xref:llvm/encodeBase64.adoc[`encodeBase64`] 
| 
| 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`] 
| Given two or more input ranges, returns a new range whose values are tuples (A, B, C, &period;&period;&period;), such that A is the 0&hyphen;based index of the item in the sequence, and B, C, &period;&period;&period;, are the values from the original input ranges&period; All input ranges are required to have equal lengths&period; Note that the returned iterator allows for the values (B, C, &period;&period;&period;) to be modified&period; Example&colon;
| xref:llvm/equal-0bd.adoc[`equal`] 
| `equal` overloads
| xref:llvm/equal_to.adoc[`equal&lowbar;to`] 
| Functor variant of std&colon;&colon;equal&lowbar;to that can be used as a UnaryPredicate in functional algorithms like all&lowbar;of&period; `Args` is forwarded and stored by value&period; If you would like to pass by reference, use `std&colon;&colon;ref` or `std&colon;&colon;cref`&period;
| xref:llvm/erase.adoc[`erase`] 
| Wrapper function to remove a value from a container&colon;
| xref:llvm/eraseInstr.adoc[`eraseInstr`] 
| 
| xref:llvm/eraseInstrs.adoc[`eraseInstrs`] 
| 
| xref:llvm/erase_if.adoc[`erase&lowbar;if`] 
| Provide a container algorithm similar to C&plus;&plus; Library Fundamentals v2&apos;s `erase&lowbar;if` which is equivalent to&colon;
| 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`] 
| 
| xref:llvm/errs.adoc[`errs`] 
| This returns a reference to a raw&lowbar;ostream for standard error&period; Use it like&colon; errs() &lt;&lt; &quot;foo&quot; &lt;&lt; &quot;bar&quot;&semi; By default, the stream is tied to stdout to ensure stdout is flushed before stderr is written, to ensure the error messages are written in their expected place&period;
| xref:llvm/exp.adoc[`exp`] 
| Implement IEEE 754&hyphen;2019 exp functions
| xref:llvm/expandAtomicMemCpyAsLoop.adoc[`expandAtomicMemCpyAsLoop`] 
| Expand `AtomicMemCpy` as a loop&period; `AtomicMemCpy` is not deleted&period;
| xref:llvm/expandDivision.adoc[`expandDivision`] 
| Generate code to divide two integers, replacing Div with the generated code&period; This currently generates code similarly to compiler&hyphen;rt&apos;s implementations, but future work includes generating more specialized code when more information about the operands are known&period; Implements both 32bit and 64bit scalar division&period;
| xref:llvm/expandDivisionUpTo32Bits.adoc[`expandDivisionUpTo32Bits`] 
| Generate code to divide two integers, replacing Div with the generated code&period; Uses ExpandDivision with a 32bit Div which makes it useful for targets with little or no support for less than 32 bit arithmetic&period;
| xref:llvm/expandDivisionUpTo64Bits.adoc[`expandDivisionUpTo64Bits`] 
| Generate code to divide two integers, replacing Div with the generated code&period; Uses ExpandDivision with a 64bit Div&period;
| xref:llvm/expandMemCpyAsLoop.adoc[`expandMemCpyAsLoop`] 
| Expand `MemCpy` as a loop&period; `MemCpy` is not deleted&period;
| xref:llvm/expandMemMoveAsLoop.adoc[`expandMemMoveAsLoop`] 
| Expand `MemMove` as a loop&period; `MemMove` is not deleted&period; Returns true if the memmove was lowered&period;
| xref:llvm/expandMemSetAsLoop-0b.adoc[`expandMemSetAsLoop`] 
| `expandMemSetAsLoop` overloads
| xref:llvm/expandMemSetPatternAsLoop-0d.adoc[`expandMemSetPatternAsLoop`] 
| `expandMemSetPatternAsLoop` overloads
| xref:llvm/expandReductionViaLoop.adoc[`expandReductionViaLoop`] 
| Expand a scalable vector reduction into a runtime loop that applies `RdxOpcode` element by element, starting from `Acc` as the initial accumulator value (typically the reduction identity)&period; If `DT` and&sol;or `LI` are provided, they are updated to reflect the new basic blocks&period;
| xref:llvm/expandRemainder.adoc[`expandRemainder`] 
| Generate code to calculate the remainder of two integers, replacing Rem with the generated code&period; This currently generates code using the udiv expansion, but future work includes generating more specialized code, e&period;g&period; when more information about the operands are known&period; Implements both 32bit and 64bit scalar division&period;
| xref:llvm/expandRemainderUpTo32Bits.adoc[`expandRemainderUpTo32Bits`] 
| Generate code to calculate the remainder of two integers, replacing Rem with the generated code&period; Uses ExpandReminder with a 32bit Rem which makes it useful for targets with little or no support for less than 32 bit arithmetic&period;
| xref:llvm/expandRemainderUpTo64Bits.adoc[`expandRemainderUpTo64Bits`] 
| Generate code to calculate the remainder of two integers, replacing Rem with the generated code&period; Uses ExpandReminder with a 64bit Rem&period;
| xref:llvm/expandVectorPredicationIntrinsic.adoc[`expandVectorPredicationIntrinsic`] 
| Expand a vector predication intrinsic&period; Returns the kind of expansion that was applied to the 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`] 
| 
| xref:llvm/expectedToOptional.adoc[`expectedToOptional`] 
| Convert an Expected to an std&colon;&colon;optional 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/exportDebugifyStats.adoc[`exportDebugifyStats`] 
| 
| xref:llvm/extractBranchWeights-05.adoc[`extractBranchWeights`] 
| `extractBranchWeights` overloads
| xref:llvm/extractBuildAttributesSubsections.adoc[`extractBuildAttributesSubsections`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| Compute the possible floating&hyphen;point classes that `LHS` could be based on fcmp Pred `LHS,` `RHS&period;`
| 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`] 
| Provide wrappers to std&colon;&colon;fill which take ranges instead of having to pass begin&sol;end explicitly&period;
| xref:llvm/fillMapFromAssume.adoc[`fillMapFromAssume`] 
| Insert into the map all the informations contained in the operand bundles of the llvm&period;assume&period; This should be used when many queries are going to be made on the same llvm&period;assume&period; String attributes are not inserted in the map&period; If the IR changes the map will be outdated&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`] 
| finalizeBundles &hyphen; Finalize instruction bundles in the specified MachineFunction&period; Return true if any bundles are finalized&period;
| xref:llvm/finalizeLLVMOptimizationRemarks.adoc[`finalizeLLVMOptimizationRemarks`] 
| Finalize optimization remarks and deregister the RemarkStreamer from the `Context&period;` This must be called before closing the (file) stream that was used to set up the remarks&period;
| xref:llvm/find.adoc[`find`] 
| Provide wrappers to std&colon;&colon;find which take ranges instead of having to pass begin&sol;end explicitly&period;
| xref:llvm/findAllocaForValue-007.adoc[`findAllocaForValue`] 
| Returns unique alloca where the value comes from, or nullptr&period; If OffsetZero is true check that V points to the begining of the alloca&period;
| 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`] 
| 
| xref:llvm/findMaximalSubpartOfIllFormedUTF8Sequence.adoc[`findMaximalSubpartOfIllFormedUTF8Sequence`] 
| 
| 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`] 
| 
| 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`] 
| Provide wrappers to std&colon;&colon;find&lowbar;if which take ranges instead of having to pass begin&sol;end explicitly&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` that satisfies `P(&lt;member` of `Range&gt;` &ast;, AllowRepeats)&hyphen;&gt;T &ast; returning nullptr when no values or multiple values were found&period; When `AllowRepeats` is true, multiple values that compare equal are allowed&period;
| xref:llvm/find_singleton_nested.adoc[`find&lowbar;singleton&lowbar;nested`] 
| Return a pair consisting of the single value in `Range` that satisfies `P(&lt;member` of `Range&gt;` _, AllowRepeats)&hyphen;&gt;std&colon;&colon;pair&lt;T_, bool&gt; returning nullptr when no values or multiple values were found, and a bool indicating whether multiple values were found to cause the nullptr&period; When `AllowRepeats` is true, multiple values that compare equal are allowed&period; The predicate `P` returns a pair&lt;T &ast;, bool&gt; where T is the singleton while the bool indicates whether multiples have already been found&period; It is expected that first will be nullptr when second is true&period; This allows using find&lowbar;singleton&lowbar;nested within the predicate P&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`] 
| 
| xref:llvm/fmt_consume.adoc[`fmt&lowbar;consume`] 
| 
| xref:llvm/fmt_pad.adoc[`fmt&lowbar;pad`] 
| 
| xref:llvm/fmt_repeat.adoc[`fmt&lowbar;repeat`] 
| 
| 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`] 
| If this basic block is ONLY a setcc and a branch, and if a predecessor branches to us and one of our successors, fold the setcc into the predecessor and use logical operations to pick the right destination&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`] 
| Provide wrappers to std&colon;&colon;for&lowbar;each which take ranges instead of having to pass begin&sol;end explicitly&period;
| xref:llvm/forcePrintFuncIR.adoc[`forcePrintFuncIR`] 
| 
| xref:llvm/forcePrintModuleIR.adoc[`forcePrintModuleIR`] 
| 
| 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`] 
| These are helper functions used to produce formatted output&period; They use template type deduction to construct the appropriate instance of the format&lowbar;object class to simplify their construction&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`] 
| format&lowbar;decimal &hyphen; Output `N` as a right justified, fixed&hyphen;width decimal&period; If number will not fit in width, full number is still printed&period; Examples&colon; OS &lt;&lt; format&lowbar;decimal(0, 5) &equals;&gt; &quot; 0&quot; OS &lt;&lt; format&lowbar;decimal(255, 5) &equals;&gt; &quot; 255&quot; OS &lt;&lt; format&lowbar;decimal(&hyphen;1, 3) &equals;&gt; &quot; &hyphen;1&quot; OS &lt;&lt; format&lowbar;decimal(12345, 3) &equals;&gt; &quot;12345&quot;
| xref:llvm/format_hex.adoc[`format&lowbar;hex`] 
| format&lowbar;hex &hyphen; Output `N` as a fixed width hexadecimal&period; If number will not fit in width, full number is still printed&period; Examples&colon; OS &lt;&lt; format&lowbar;hex(255, 4) &equals;&gt; 0xff OS &lt;&lt; format&lowbar;hex(255, 4, true) &equals;&gt; 0xFF OS &lt;&lt; format&lowbar;hex(255, 6) &equals;&gt; 0x00ff OS &lt;&lt; format&lowbar;hex(255, 2) &equals;&gt; 0xff
| xref:llvm/format_hex_no_prefix.adoc[`format&lowbar;hex&lowbar;no&lowbar;prefix`] 
| format&lowbar;hex&lowbar;no&lowbar;prefix &hyphen; Output `N` as a fixed width hexadecimal&period; Does not prepend &apos;0x&apos; to the outputted string&period; If number will not fit in width, full number is still printed&period; Examples&colon; OS &lt;&lt; format&lowbar;hex&lowbar;no&lowbar;prefix(255, 2) &equals;&gt; ff OS &lt;&lt; format&lowbar;hex&lowbar;no&lowbar;prefix(255, 2, true) &equals;&gt; FF OS &lt;&lt; format&lowbar;hex&lowbar;no&lowbar;prefix(255, 4) &equals;&gt; 00ff OS &lt;&lt; format&lowbar;hex&lowbar;no&lowbar;prefix(255, 1) &equals;&gt; ff
| xref:llvm/formatv-0e6.adoc[`formatv`] 
| 
| 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`] 
| Create an artificial edge between FirstSU and SecondSU&period; Make data dependencies from the FirstSU also dependent on the SecondSU to prevent them from being scheduled between the FirstSU and the SecondSU and vice&hyphen;versa&period; Fusing more than 2 instructions is not currently supported&period;
| xref:llvm/gatherImportedSummariesForModule.adoc[`gatherImportedSummariesForModule`] 
| `ModuleToSummariesForIndex` will be populated with the needed summaries from each required module path&period; Use a std&colon;&colon;map instead of StringMap to get stable order for bitcode emission&period;
| xref:llvm/gatherPeelingPreferences.adoc[`gatherPeelingPreferences`] 
| 
| xref:llvm/gatherUnrollingPreferences.adoc[`gatherUnrollingPreferences`] 
| 
| xref:llvm/gcd.adoc[`gcd`] 
| Returns the greatest common divisor of `A` and `B&period;`
| xref:llvm/gcovOneInput.adoc[`gcovOneInput`] 
| 
| xref:llvm/generateParamAccessSummary.adoc[`generateParamAccessSummary`] 
| 
| xref:llvm/gep_type_begin-0a.adoc[`gep&lowbar;type&lowbar;begin`] 
| 
| xref:llvm/gep_type_end-03.adoc[`gep&lowbar;type&lowbar;end`] 
| 
| xref:llvm/get-07.adoc[`get`] 
| `get` overloads
| xref:llvm/getAddressSanitizerParams.adoc[`getAddressSanitizerParams`] 
| 
| xref:llvm/getAllocAlignment.adoc[`getAllocAlignment`] 
| Gets the alignment argument for an aligned&lowbar;alloc&hyphen;like function, using either built&hyphen;in knowledge based on fuction names&sol;signatures or allocalign attributes&period; Note&colon; the Value returned may not indicate a valid alignment, per the definition of the allocalign attribute&period;
| xref:llvm/getAllocSize.adoc[`getAllocSize`] 
| Return the size of the requested allocation&period; With a trivial mapper, this is similar to calling getObjectSize(&period;&period;&period;, Exact), but without looking through calls that return their argument&period; A mapper function can be used to replace one Value&ast; (operand to the allocation) with another&period; This is useful when doing abstract interpretation&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`] 
| 
| xref:llvm/getArgumentAliasingToReturnedPointer-03.adoc[`getArgumentAliasingToReturnedPointer`] 
| This function returns call pointer argument that is considered the same by aliasing rules&period; You CAN&apos;T use it to replace one value with another&period; If `MustPreserveOffset` is true, the call must preserve the byte offset of the pointer within its underlying object&period; Offset preservation implies nullness preservation&semi; pass true when callers reason about either offset or null equality (e&period;g&period; GEP decomposition, dereferenceability, isKnownNonZero)&period;
| 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`] 
| 
| 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`] 
| Helper functions for StringRef&colon;&colon;getAsInteger&period;
| xref:llvm/getAssumeAlignInfo.adoc[`getAssumeAlignInfo`] 
| 
| xref:llvm/getAssumeDereferenceableInfo.adoc[`getAssumeDereferenceableInfo`] 
| 
| xref:llvm/getAssumeNoUndefInfo.adoc[`getAssumeNoUndefInfo`] 
| 
| xref:llvm/getAssumeNonNullInfo.adoc[`getAssumeNonNullInfo`] 
| 
| xref:llvm/getAssumeSeparateStorageInfo.adoc[`getAssumeSeparateStorageInfo`] 
| 
| 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`] 
| A helper function that returns an atomic operation&apos;s sync scope&semi; returns std&colon;&colon;nullopt if it is not an atomic operation&period;
| xref:llvm/getAttributeBasedInliningDecision.adoc[`getAttributeBasedInliningDecision`] 
| Returns InlineResult&colon;&colon;success() if the call site should be always inlined because of user directives, and the inlining is viable&period; Returns InlineResult&colon;&colon;failure() if the inlining may never happen because of user directives or incompatibilities detectable without needing callee traversal&period; Otherwise returns std&colon;&colon;nullopt, meaning that inlining should be decided based on other criteria (e&period;g&period; 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 returns the size of base objects (like allocas, global variables and allocator calls) and std&colon;&colon;nullopt otherwise&period; Requires ExactSizeFromOffset mode&period;
| xref:llvm/getBestSimplifyQuery-06.adoc[`getBestSimplifyQuery`] 
| 
| xref:llvm/getBitcodeFileContents.adoc[`getBitcodeFileContents`] 
| Returns the contents of a bitcode file&period; This includes the raw contents of the symbol table embedded in the bitcode file&period; Clients which require a symbol table should prefer to use irsymtab&colon;&colon;read instead of this function because it creates a reader for the irsymtab and handles upgrading bitcode files without a symbol table or with an old symbol table&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 header of the specified bitcode buffer and extract just the producer string information&period; If successful, this returns a string&period; On error, this returns &quot;&quot;&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, returns the inverted operand&period; Otherwise returns an empty SDValue&period; Only bits set in `Mask` are required to be inverted, other bits may be arbitrary&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`] 
| 
| xref:llvm/getBundleAttrFromOBU.adoc[`getBundleAttrFromOBU`] 
| 
| 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`] 
| 
| xref:llvm/getCPUDefaultTargetFeatures.adoc[`getCPUDefaultTargetFeatures`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/getConstantRangeFromMetadata.adoc[`getConstantRangeFromMetadata`] 
| Parse out a conservative ConstantRange from !range metadata&period;
| xref:llvm/getConstantStringInfo.adoc[`getConstantStringInfo`] 
| This function computes the length of a null&hyphen;terminated C string pointed to by V&period; If successful, it returns true and returns the string in Str&period; If unsuccessful, it returns false&period; This does not include the trailing null character by default&period; If TrimAtNul is set to false, then this returns any trailing null characters as well as any other characters that come after it&period;
| xref:llvm/getConstrainedIntrinsicID.adoc[`getConstrainedIntrinsicID`] 
| Returns constrained intrinsic id to represent the given instruction in strictfp function&period; If the instruction is already a constrained intrinsic or does not have a constrained intrinsic counterpart, the function returns zero&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 smallest type that covers both `OrigTy` and `TargetTy` and is multiple of TargetTy&period;
| xref:llvm/getCoverageMappingVarName.adoc[`getCoverageMappingVarName`] 
| Return the name of a covarage mapping variable (internal linkage) for each instrumented source module&period; Such variables are allocated in the &lowbar;&lowbar;llvm&lowbar;covmap section&period;
| xref:llvm/getCoverageUnusedNamesVarName.adoc[`getCoverageUnusedNamesVarName`] 
| Return the name of the internal variable recording the array of PGO name vars referenced by the coverage mapping&period; The owning functions of those names are not emitted by FE (e&period;g, unused inline functions&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`] 
| Inline helper to return a range of DbgRecords attached to a marker&period; It needs to be inlined as it&apos;s frequently called, but also come after the declaration of DbgMarker&period; Thus&colon; it&apos;s pre&hyphen;declared by users like Instruction, then an inlineable body defined here&period;
| xref:llvm/getDeadRegState.adoc[`getDeadRegState`] 
| 
| xref:llvm/getDebugMetadataVersionFromModule.adoc[`getDebugMetadataVersionFromModule`] 
| Return Debug Info Metadata Version by checking module flags&period;
| xref:llvm/getDebugRegState.adoc[`getDebugRegState`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/getDefaultInlineOrder.adoc[`getDefaultInlineOrder`] 
| 
| xref:llvm/getDefaultMaxUsesToExploreForCaptureTracking.adoc[`getDefaultMaxUsesToExploreForCaptureTracking`] 
| getDefaultMaxUsesToExploreForCaptureTracking &hyphen; Return default value of the maximal number of uses to explore before giving up&period; It is used by PointerMayBeCaptured family analysis&period;
| xref:llvm/getDefaultPrecision.adoc[`getDefaultPrecision`] 
| Return the default digit precision for float formatting style `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`] 
| 
| xref:llvm/getDisjunctionWeights.adoc[`getDisjunctionWeights`] 
| Get the branch weights of a branch conditioned on b1 &verbar;&verbar; b2, where b1 and b2 are 2 booleans that are the conditions of 2 branches for which we have the branch weights B1 and B2, respectively&period; In both B1 and B2, the first position (index 0) is for the &apos;true&apos; branch, and the second position (index 1) is for the &apos;false&apos; branch&period;
| xref:llvm/getEHPersonalityName.adoc[`getEHPersonalityName`] 
| 
| xref:llvm/getEHScopeMembership.adoc[`getEHScopeMembership`] 
| 
| xref:llvm/getEarlyClobberRegState.adoc[`getEarlyClobberRegState`] 
| 
| xref:llvm/getEffectiveCodeModel.adoc[`getEffectiveCodeModel`] 
| Helper method for getting the code model, returning Default if CM does not have a value&period; The tiny and kernel models will produce an error, so targets that support them or require more complex codemodel selection logic should implement and call their own getEffectiveCodeModel&period;
| xref:llvm/getExitBlockHelper.adoc[`getExitBlockHelper`] 
| getExitBlock &hyphen; If getExitBlocks would return exactly one block, return that block&period; Otherwise return null&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`] 
| Given a constant, create a debug information expression&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`] 
| getFCmpCondCode &hyphen; Return the ISD condition code corresponding to the given LLVM IR floating&hyphen;point condition code&period; This includes consideration of global floating&hyphen;point math flags&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`] 
| Convert an integer comparison with a constant RHS into an equivalent form with the strictness flipped predicate&period; Return the new predicate and corresponding constant RHS if possible&period; Otherwise return std&colon;&colon;nullopt&period; E&period;g&period;, (icmp sgt X, 0) &hyphen;&gt; (icmp sle X, 1)&period; For a samesign predicate, fail if adjusting the constant would change its sign bit, because that would change the comparison&apos;s poison domain&period;
| xref:llvm/getFloatFn.adoc[`getFloatFn`] 
| Get the name of the overloaded floating point function corresponding to _Ty&period;_ Return the LibFunc in _TheLibFunc&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`] 
| Given a PGO function name, remove the filename prefix and return the original (static) function name&period;
| xref:llvm/getFunctionAtVTableOffset.adoc[`getFunctionAtVTableOffset`] 
| Given a vtable and a specified offset, returns the function and the trivial pointer at the specified offset in pair iff the pointer at the specified offset is a function or an alias to a function&period; Returns a pair of nullptr otherwise&period;
| xref:llvm/getFunctionLiveInPhysReg.adoc[`getFunctionLiveInPhysReg`] 
| Return a virtual register corresponding to the incoming argument register `PhysReg&period;` This register is expected to have class `RC,` and optional type `RegTy&period;` This assumes all references to the register will use the same type&period;
| xref:llvm/getGCDType.adoc[`getGCDType`] 
| Return a type where the total size is the greatest common divisor of `OrigTy` and `TargetTy&period;` This will try to either change the number of vector elements, or bitwidth of scalars&period; The intent is the result type can be used as the result of a G&lowbar;UNMERGE&lowbar;VALUES from `OrigTy,` and then some combination of G&lowbar;MERGE&lowbar;VALUES, G&lowbar;BUILD&lowbar;VECTOR and G&lowbar;CONCAT&lowbar;VECTORS (possibly with intermediate casts) can re&hyphen;form `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`] 
| 
| xref:llvm/getHorizDemandedEltsForFirstOperand.adoc[`getHorizDemandedEltsForFirstOperand`] 
| Compute the demanded elements mask of horizontal binary operations&period; A horizontal operation combines two adjacent elements in a vector operand&period; This function returns a mask for the elements that correspond to the first operand of this horizontal combination&period; For example, for two vectors &lsqb;X1, X2, X3, X4&rsqb;and &lsqb;Y1, Y2, Y3, Y4&rsqb;, the resulting mask can include the elements X1, X3, Y1, and Y3&period; To get the other operands, simply shift the result of this function to the left by 1&period;
| xref:llvm/getHotnessName.adoc[`getHotnessName`] 
| 
| 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`] 
| 
| xref:llvm/getIConstantSplatVal-0f.adoc[`getIConstantSplatVal`] 
| 
| 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`] 
| 
| xref:llvm/getImplRegState.adoc[`getImplRegState`] 
| 
| 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`] 
| 
| 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; If &hyphen;inline&hyphen;threshold option is not explicitly passed, the default threshold is computed from `OptLevel&period;` An `OptLevel` value above 3 is considered an aggressive optimization mode&period; Optimization for size is handled via separate thresholds for optsize&sol;minsize, rather than changes to the default threshold&period;
| xref:llvm/getInliningCostEstimate.adoc[`getInliningCostEstimate`] 
| Get the cost estimate ignoring thresholds&period; This is similar to getInlineCost when passed InlineParams&colon;&colon;ComputeFullInlineCost, or a non&hyphen;null ORE&period; It uses default InlineParams otherwise&period; Contrary to getInlineCost, which makes a threshold&hyphen;based final evaluation of should&sol;shouldn&apos;t inline, captured in InlineResult, getInliningCostEstimate returns&colon; &hyphen; std&colon;&colon;nullopt, if the inlining cannot happen (is illegal) &hyphen; an integer, representing the cost&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`] 
| 
| xref:llvm/getInstrProfBitmapVarPrefix.adoc[`getInstrProfBitmapVarPrefix`] 
| Return the name prefix of profile bitmap variables&period;
| xref:llvm/getInstrProfCounterBiasVarName.adoc[`getInstrProfCounterBiasVarName`] 
| 
| 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 runtime initialization method that is generated by the compiler&period; The function calls &lowbar;&lowbar;llvm&lowbar;profile&lowbar;register&lowbar;functions and &lowbar;&lowbar;llvm&lowbar;profile&lowbar;override&lowbar;default&lowbar;filename functions if needed&period; This function has internal linkage and invoked at startup time via init&lowbar;array&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`] 
| 
| 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 function that registers all the per&hyphen;function control data at program startup time by calling &lowbar;&lowbar;llvm&lowbar;register&lowbar;function&period; This function has internal linkage and is called by &lowbar;&lowbar;llvm&lowbar;profile&lowbar;init runtime method&period; This function is not generated for these platforms&colon; Darwin, Linux, and FreeBSD&period;
| xref:llvm/getInstrProfRuntimeHookVarName.adoc[`getInstrProfRuntimeHookVarName`] 
| Return the name of the hook variable defined in profile runtime library&period; A reference to the variable causes the linker to link in the runtime initialization module (which defines the 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| Try to infer an 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,` by changing the number of vector elements or scalar bitwidth&period; The intent is a G&lowbar;MERGE&lowbar;VALUES, G&lowbar;BUILD&lowbar;VECTOR, or G&lowbar;CONCAT&lowbar;VECTORS can be constructed from `OrigTy` elements, and unmerged into `TargetTy&period;` It is an error to call this function where one argument is a fixed vector and the other is a scalable vector, since it is illegal to build a G&lowbar;&lcub;MERGE&verbar;UNMERGE&rcub;&lowbar;VALUES between fixed and scalable vectors&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 the header of the specified bitcode buffer and prepare for lazy deserialization of function bodies&period; If ShouldLazyLoadMetadata is true, lazily load metadata as well&period; If IsImporting is true, this module is being parsed for ThinLTO importing into another module&period;
| xref:llvm/getLazyIRFileModule.adoc[`getLazyIRFileModule`] 
| If the given file holds a bitcode image, return a Module for it which does lazy deserialization of function bodies&period; Otherwise, attempt to parse it as LLVM Assembly and return a fully populated Module&period; The ShouldLazyLoadMetadata flag is passed down to the bitcode reader to optionally enable lazy metadata loading&period;
| xref:llvm/getLazyIRModule.adoc[`getLazyIRModule`] 
| If the given MemoryBuffer holds a bitcode image, return a Module for it which does lazy deserialization of function bodies&period; Otherwise, attempt to parse it as LLVM Assembly and return a fully populated Module&period; The ShouldLazyLoadMetadata flag is passed down to the bitcode reader to optionally enable lazy metadata loading&period; This takes ownership of `Buffer&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`] 
| A helper function that returns the address space of the pointer operand of load or store instruction&period;
| xref:llvm/getLoadStoreAlignment.adoc[`getLoadStoreAlignment`] 
| A helper function that returns the alignment of load or store instruction&period;
| xref:llvm/getLoadStorePointerOperand-0a.adoc[`getLoadStorePointerOperand`] 
| A helper function that returns the pointer operand of a load or store instruction&period; Returns nullptr if not load or store&period;
| xref:llvm/getLoadStoreType.adoc[`getLoadStoreType`] 
| A helper function that returns the type of a load or store instruction&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 either&colon; &hyphen; `std&colon;&colon;nullopt,` if the implementation is unable to handle the loop form of `L` (e&period;g&period;, `L` must have a latch block that controls the loop exit)&period; &hyphen; The value of `llvm&period;loop&period;estimated&lowbar;trip&lowbar;count` from the loop metadata of `L,` if that metadata is present&period; &hyphen; Else, a new estimate of the trip count from the latch branch weights of `L&period;`
| xref:llvm/getLoopPassPreservedAnalyses.adoc[`getLoopPassPreservedAnalyses`] 
| Returns the minimum set of Analyses that all loop passes must preserve&period;
| xref:llvm/getLoopProbability.adoc[`getLoopProbability`] 
| Based on branch weight metadata, return either&colon; &hyphen; An unknown probability if the implementation is unable to handle the loop form of `L` (e&period;g&period;, `L` must have a latch block that controls the loop exit)&period; &hyphen; The probability `P` that, at the end of any iteration, the latch of `L` will start another iteration such that `1 &hyphen; P` is the probability of exiting the loop&period;
| xref:llvm/getLoopVectorizeKindPrefix.adoc[`getLoopVectorizeKindPrefix`] 
| Return a short prefix describing the loop&apos;s vectorizer origin based on the `llvm&period;loop&period;vectorize&period;body` and `llvm&period;loop&period;vectorize&period;epilogue` metadata&period; The result is one of `&quot;vectorized` epilogue &quot;, `&quot;vectorized` &quot;, `&quot;epilogue` &quot;, or `&quot;&quot;` (empty) and is intended to be prepended to loop&hyphen;kind tokens in optimization remarks&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`] 
| 
| xref:llvm/getLosslessUnsignedTrunc.adoc[`getLosslessUnsignedTrunc`] 
| 
| 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`] 
| 
| xref:llvm/getMachineFunctionPassPreservedAnalyses.adoc[`getMachineFunctionPassPreservedAnalyses`] 
| Returns the minimum set of Analyses that all machine function passes must preserve&period;
| xref:llvm/getMachineType.adoc[`getMachineType`] 
| 
| xref:llvm/getMaxFreq.adoc[`getMaxFreq`] 
| 
| xref:llvm/getMemCacheHintMetadata.adoc[`getMemCacheHintMetadata`] 
| Return the cache hint metadata node for memory operand `OperandNo` on `I,` or nullptr when the instruction has no hint for that operand&period; For a `CallBase,` `OperandNo` is an argument index&semi; otherwise it is an instruction operand index&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`] 
| Add metadata from `Inst` to `Metadata,` if it can be preserved after vectorization&period; It can be preserved after vectorization if the kind is one of &lsqb;MD&lowbar;tbaa, MD&lowbar;alias&lowbar;scope, MD&lowbar;noalias, MD&lowbar;fpmath, MD&lowbar;nontemporal,&rsqb; MD&lowbar;access&lowbar;group, MD&lowbar;mmra&rsqb;&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 and return the module summary index object if found, or an empty summary if not&period; If Path refers to an empty file and IgnoreEmptyThinLTOIndexFile is true, then this function will return nullptr&period;
| xref:llvm/getNameFromBundleAttr.adoc[`getNameFromBundleAttr`] 
| 
| xref:llvm/getNextAvailablePluginDiagnosticKind.adoc[`getNextAvailablePluginDiagnosticKind`] 
| Get the next available kind ID for a plugin diagnostic&period; Each time this function is called, it returns a different number&period; Therefore, a plugin that wants to &quot;identify&quot; its own classes with a dynamic identifier, just have to use this method to get a new ID and assign it to each of its classes&period; The returned ID will be greater than or equal to DK&lowbar;FirstPluginKind&period; Thus, the plugin identifiers will not conflict with the DiagnosticKind values&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`] 
| 
| xref:llvm/getNumBranchWeights.adoc[`getNumBranchWeights`] 
| 
| xref:llvm/getNumBytesForUTF8.adoc[`getNumBytesForUTF8`] 
| 
| xref:llvm/getNumOfCalls.adoc[`getNumOfCalls`] 
| 
| xref:llvm/getObjCNamesIfSelector.adoc[`getObjCNamesIfSelector`] 
| If `Name` is the AT&lowbar;name of a DIE which refers to an Objective&hyphen;C selector, returns an instance of ObjCSelectorNames&period; The Selector and ClassName fields are guaranteed to be non&hyphen;empty in the result&period;
| xref:llvm/getObjectSize.adoc[`getObjectSize`] 
| Compute the size of the object pointed by Ptr&period; Returns true and the object size in Size if successful, and false otherwise&period; In this context, by object we mean the region of memory starting at Ptr to the end of the underlying object pointed to by Ptr&period;
| xref:llvm/getOpcodeDef-06.adoc[`getOpcodeDef`] 
| `getOpcodeDef` overloads
| xref:llvm/getOptionalBoolLoopAttribute.adoc[`getOptionalBoolLoopAttribute`] 
| 
| xref:llvm/getOptionalElementCountLoopAttribute.adoc[`getOptionalElementCountLoopAttribute`] 
| Find a combination of metadata (&quot;llvm&period;loop&period;vectorize&period;width&quot; and &quot;llvm&period;loop&period;vectorize&period;scalable&period;enable&quot;) for a loop and use it to construct a ElementCount&period; If scalable&period;enable is present the count is scalable&semi; if scalable&period;disable is present or the tag is absent, it is fixed&hyphen;width&period; If the metadata &quot;llvm&period;loop&period;vectorize&period;width&quot; cannot be found then std&colon;&colon;nullopt is returned&period;
| xref:llvm/getOptionalIntLoopAttribute.adoc[`getOptionalIntLoopAttribute`] 
| Find named metadata for a loop with an integer value&period;
| xref:llvm/getOrCreateFunctionComdat.adoc[`getOrCreateFunctionComdat`] 
| 
| xref:llvm/getOrCreateSanitizerCtorAndInitFunctions.adoc[`getOrCreateSanitizerCtorAndInitFunctions`] 
| Creates sanitizer constructor function lazily&period; If a constructor and init function already exist, this function returns it&period; Otherwise it calls `createSanitizerCtorAndInitFunctions&period;` The FunctionsCreatedCallback is invoked in that case, passing the new Ctor and Init function&period;
| xref:llvm/getOrEnforceKnownAlignment.adoc[`getOrEnforceKnownAlignment`] 
| Try to ensure that the alignment of `V` is at least `PrefAlign` bytes&period; If the owning object can be modified and has an alignment less than `PrefAlign,` it will be increased and `PrefAlign` returned&period; If the alignment cannot be increased, the known alignment of the value is returned&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, except that the module takes ownership of the memory buffer if successful&period; If successful, this moves Buffer&period; On error, this _does not_ move Buffer&period; If IsImporting is true, this module is being parsed for ThinLTO importing into another module&period;
| xref:llvm/getPGOFuncName-06.adoc[`getPGOFuncName`] 
| `getPGOFuncName` overloads
| xref:llvm/getPGOFuncNameMetadata.adoc[`getPGOFuncNameMetadata`] 
| Return the PGOFuncName meta data associated with a function&period;
| xref:llvm/getPGOFuncNameMetadataName.adoc[`getPGOFuncNameMetadataName`] 
| 
| xref:llvm/getPGOFuncNameVarInitializer.adoc[`getPGOFuncNameVarInitializer`] 
| Return the initializer in string of the PGO name var `NameVar&period;`
| xref:llvm/getPGOFuncNameVarName.adoc[`getPGOFuncNameVarName`] 
| Return the name of the global variable used to store a function name in PGO instrumentation&period; `FuncName` is the IRPGO function name (returned by `getIRPGOFuncName)` for LLVM IR instrumentation and PGO function name (returned by `getPGOFuncName)` for front&hyphen;end instrumentation&period;
| xref:llvm/getPGOName.adoc[`getPGOName`] 
| 
| xref:llvm/getPGONameMetadataName.adoc[`getPGONameMetadataName`] 
| 
| xref:llvm/getParsedIRPGOName.adoc[`getParsedIRPGOName`] 
| 
| 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`] 
| Processes a Constant recursively looking into elements of arrays, structs and expressions to find a trivial pointer element that is located at the given offset (relative to the beginning of the whole outer 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`] 
| A helper function that returns the pointer operand of a load, store or GEP instruction&period; Returns nullptr if not load, store, or GEP&period;
| xref:llvm/getPointersDiff.adoc[`getPointersDiff`] 
| Returns the distance between the pointers `PtrA` and `PtrB` iff they are compatible and it is possible to calculate the distance between them&period; This is a simple API that does not depend on the analysis pass&period;
| xref:llvm/getPredForFCmpCode.adoc[`getPredForFCmpCode`] 
| This is the complement of getFCmpCode&period; It turns a predicate code into either a constant true or false or the predicate for a new FCmp&period; Non&hyphen;NULL return value will be a true or false constant&period; NULL return means a new ICmp is needed&period; The predicate is output in Pred&period;
| xref:llvm/getPredForICmpCode.adoc[`getPredForICmpCode`] 
| This is the complement of getICmpCode&period; It turns a predicate code into either a constant true or false or the predicate for a new ICmp&period; The sign is passed in to determine which kind of predicate to use in the new ICmp instruction&period; Non&hyphen;NULL return value will be a true or false constant&period; NULL return means a new ICmp is needed&period; The predicate is output in Pred&period;
| xref:llvm/getPrefetchTargetSymbolName.adoc[`getPrefetchTargetSymbolName`] 
| 
| xref:llvm/getPtrStride-0d.adoc[`getPtrStride`] 
| `getPtrStride` overloads
| xref:llvm/getRandomBytes.adoc[`getRandomBytes`] 
| 
| 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`] 
| 
| xref:llvm/getRenamableRegState.adoc[`getRenamableRegState`] 
| 
| xref:llvm/getReplayInlineAdvisor.adoc[`getReplayInlineAdvisor`] 
| 
| xref:llvm/getSLEB128Size.adoc[`getSLEB128Size`] 
| Utility function to get the size of the SLEB128&hyphen;encoded value&period;
| xref:llvm/getScope-0a.adoc[`getScope`] 
| 
| 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`] 
| Transform a shuffle mask&apos;s output demanded element mask into demanded element masks for the 2 operands, returns false if the mask isn&apos;t valid&period; Both `DemandedLHS` and `DemandedRHS` are initialised to &lsqb;SrcWidth&rsqb;&period; `AllowUndefElts` permits &quot;&hyphen;1&quot; indices to be treated as undef&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`] 
| Asserts that the given container has a single element and returns 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`] 
| If all non&hyphen;negative `Mask` elements are the same value, return that value&period; If all elements are negative (undefined) or `Mask` contains different non&hyphen;negative values, return &hyphen;1&period;
| xref:llvm/getSplatValue.adoc[`getSplatValue`] 
| Get splat value if the input is a splat vector or return nullptr&period; The value may be extracted from a splat constants vector or from a sequence of instructions that broadcast a single value into a vector&period;
| xref:llvm/getSrcRegIgnoringCopies.adoc[`getSrcRegIgnoringCopies`] 
| Find the source register for `Reg,` folding away any trivial copies&period; It will be an output register of the instruction that getDefIgnoringCopies returns&period; May return an invalid register if `Reg` is not a generic virtual register&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`] 
| 
| xref:llvm/getStartAndEndForAccess-01.adoc[`getStartAndEndForAccess`] 
| Calculate Start and End points of memory access using exact backedge taken count `BTC` if computable or maximum backedge taken count `MaxBTC` otherwise&period;
| xref:llvm/getStrideFromAddRec.adoc[`getStrideFromAddRec`] 
| If `AR` is an affine AddRec for `Lp` with a constant step, return the step in units of `AccessTy&apos;s` allocation size&period; Returns std&colon;&colon;nullopt if the step is not constant, does not divide the access size, or `AccessTy` is a scalable vector&period; `Ptr` is only used for debug output and may be null&period;
| xref:llvm/getStringFnAttrAsInt.adoc[`getStringFnAttrAsInt`] 
| 
| 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 of the form&colon; &lcub; &quot;name&quot;&colon; &lt;string&gt;, &quot;port&quot;&colon; &lt;int&gt;, &quot;type&quot;&colon; &lt;string&period; Use LLVM&apos;s types, e&period;g&period; float, double, int64&lowbar;t&gt;, &quot;shape&quot;&colon; &lt;array of ints&gt; &rcub; For the &quot;type&quot; field, see the C&plus;&plus; primitive types used in TFUTILS&lowbar;SUPPORTED&lowbar;TYPES&period;
| xref:llvm/getTimeTraceProfilerInstance.adoc[`getTimeTraceProfilerInstance`] 
| 
| xref:llvm/getToken.adoc[`getToken`] 
| getToken &hyphen; This function extracts one token from source, ignoring any leading characters that appear in the Delimiters string, and ending the token at any of the characters that appear in the Delimiters string&period; If there are no tokens in the source string, an empty string is returned&period; The function returns a pair containing the extracted token and the remaining tail string&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`] 
| 
| xref:llvm/getUndefRegState.adoc[`getUndefRegState`] 
| 
| xref:llvm/getUnderlyingObject-05.adoc[`getUnderlyingObject`] 
| This method strips off any GEP address adjustments, pointer casts or `llvm&period;threadlocal&period;address` from the specified value `V,` returning the original object being addressed&period; Note that the returned value has pointer type if the specified value does&period; If the `MaxLookup` value is non&hyphen;zero, it limits the number of instructions to be stripped off&period;
| 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`] 
| 
| xref:llvm/getUniqueInternalLinkagePostfix.adoc[`getUniqueInternalLinkagePostfix`] 
| 
| 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`] 
| 
| 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 the value profile data from `Inst` and returns them if `Inst` is annotated with value profile data&period; Returns an empty vector otherwise&period;
| xref:llvm/getVectorIntrinsicIDForCall.adoc[`getVectorIntrinsicIDForCall`] 
| Returns intrinsic ID for call&period; For the input call instruction it finds mapping intrinsic and returns its intrinsic ID, in case it does not found it return 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`] 
| 
| xref:llvm/getWeakLeft.adoc[`getWeakLeft`] 
| 
| xref:llvm/getWeightFromBranchProb.adoc[`getWeightFromBranchProb`] 
| 
| xref:llvm/get_array_pod_sort_comparator.adoc[`get&lowbar;array&lowbar;pod&lowbar;sort&lowbar;comparator`] 
| get&lowbar;array&lowbar;pod&lowbar;sort&lowbar;comparator &hyphen; This is an internal helper function used to get type deduction of T right&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`] 
| Returns how many physical cores (as opposed to logical cores returned from thread&colon;&colon;hardware&lowbar;concurrency(), which includes hyperthreads)&period; Returns &hyphen;1 if unknown for the current host system&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`] 
| Returns a mask that represents on which hardware thread, core, CPU, NUMA group, the calling thread can be executed&period; On Windows, threads cannot cross CPU sockets boundaries&period;
| xref:llvm/get_thread_name.adoc[`get&lowbar;thread&lowbar;name`] 
| Get the name of the current thread&period; The level of support for getting a thread&apos;s name varies wildly across operating systems, and it is not even guaranteed that if you can successfully set a thread&apos;s name that you can later get it back&period; This function is intended for diagnostic purposes, and as with setting a thread&apos;s name no indication of whether the operation succeeded or failed is returned&period;
| xref:llvm/get_threadid.adoc[`get&lowbar;threadid`] 
| Return the current thread id, as used in various OS system calls&period; Note that not all platforms guarantee that the value returned will be unique across the entire system, so portable code should not assume this&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;` When Num is above the max number of threads specified by the `Default` strategy, we attempt to equally allocate the threads on all CPU sockets&period; &quot;0&quot; or an empty string will return the `Default` strategy&period; &quot;all&quot; for using all hardware threads&period;
| xref:llvm/guessSuccessors.adoc[`guessSuccessors`] 
| Determine a possible list of successors of a basic block based on the basic block machine operand being used inside the block&period; This should give you the correct list of successor blocks in most cases except for things like jump tables where the basic block references can&apos;t easily be found&period; The MIRPRinter will skip printing successors if they match the result of this function and the parser will use this function to construct a list if it is missing&period;
| xref:llvm/handleAllErrors-0d.adoc[`handleAllErrors`] 
| `handleAllErrors` overloads
| xref:llvm/handleErrorImpl-07.adoc[`handleErrorImpl`] 
| `handleErrorImpl` overloads
| xref:llvm/handleErrors.adoc[`handleErrors`] 
| Pass the ErrorInfo(s) contained in E to their respective handlers&period; Any unhandled errors (or Errors returned by handlers) are re&hyphen;concatenated and returned&period; Because this function returns an error, its result must also be checked or returned&period; If you intend to handle all errors use handleAllErrors (which returns void, and will abort() on unhandled errors) instead&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`] 
| If a terminator in an unreachable basic block has an operand of type Instruction, transform it into poison&period; Return true if any operands are changed to poison&period; Original Values prior to being changed to poison are returned in `PoisonedValues&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`] 
| 
| xref:llvm/hasExplicitlyUnknownBranchWeights.adoc[`hasExplicitlyUnknownBranchWeights`] 
| 
| xref:llvm/hasFloatFn.adoc[`hasFloatFn`] 
| Check whether the overloaded floating point function corresponding to _Ty_ is available&period;
| xref:llvm/hasInstrProfHashMismatch.adoc[`hasInstrProfHashMismatch`] 
| This checks if the source of this function has drifted since this binary was profiled previously&period; For now, we are piggy backing on what PGO does to detect this with instrumented profiles&period; PGO emits an hash of the IR and checks if the hash has changed&period; Advanced basic block layout is usually done on top of PGO optimized binaries and hence this check works well in practice&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`] 
| 
| xref:llvm/hasLessThanNumFused.adoc[`hasLessThanNumFused`] 
| Checks if the number of cluster edges between SU and its predecessors is less than FuseLimit
| xref:llvm/hasMustProgress.adoc[`hasMustProgress`] 
| Look for the loop attribute that requires progress within the loop&period; Note&colon; Most consumers probably want &quot;isMustProgress&quot; which checks the containing function attribute too&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`] 
| Check if the loop header has a conditional branch that is not loop&hyphen;invariant, because it involves load instructions&period; If all paths from either the true or false successor to the header or loop exists do not modify the memory feeding the condition, perform &apos;partial unswitching&apos;&period; That is, duplicate the instructions feeding the condition in the pre&hyphen;header&period; Then unswitch on the duplicated condition&period; The condition is now known in the unswitched version for the &apos;invariant&apos; path through the original loop&period;
| xref:llvm/hasProfMD.adoc[`hasProfMD`] 
| Checks if an Instruction has MD&lowbar;prof Metadata
| xref:llvm/hasRegState.adoc[`hasRegState`] 
| 
| xref:llvm/hasSingleElement.adoc[`hasSingleElement`] 
| Returns true if the given container only contains a single 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`] 
| 
| xref:llvm/hasUnrollTransformation.adoc[`hasUnrollTransformation`] 
| @&lcub; Get the mode for LLVM&apos;s supported loop transformations&period;
| xref:llvm/hasValidBranchWeightMD.adoc[`hasValidBranchWeightMD`] 
| Checks if an instructions has valid Branch Weight Metadata
| xref:llvm/hasVectorizeTransformation.adoc[`hasVectorizeTransformation`] 
| 
| xref:llvm/hasWholeProgramVisibility.adoc[`hasWholeProgramVisibility`] 
| 
| 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`] 
| hexdigit &hyphen; Return the hexadecimal character for the given number `X` (which should be less than 16)&period;
| xref:llvm/hoistAllInstructionsInto.adoc[`hoistAllInstructionsInto`] 
| Hoist all of the instructions in the `IfBlock` to the dominant block `DomBlock,` by moving its instructions to the insertion point `InsertPt&period;`
| xref:llvm/hoistRegion.adoc[`hoistRegion`] 
| Walk the specified region of the CFG (defined by all blocks dominated by the specified block, and that are in the current loop) in depth first order w&period;r&period;t the DominatorTree&period; This allows us to visit definitions before uses, allowing us to hoist a loop body in one pass without iteration&period; Takes DomTreeNode, AAResults, LoopInfo, DominatorTree, TargetLibraryInfo, Loop, AliasSet information for all instructions of the loop and loop safety information as arguments&period; Diagnostics is emitted via `ORE&period;` It returns changed status&period; `AllowSpeculation` is whether values should be hoisted even if they are not guaranteed to execute in the loop, but are safe to speculatively execute&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; For example, if ValAssumedPoison is `icmp X, 10` and V is `icmp X, 5`, impliesPoison returns true&period;
| xref:llvm/includes-0f.adoc[`includes`] 
| `includes` overloads
| 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`] 
| The value returned by this function can be returned from convertToErrorCode for Error values where no sensible translation to std&colon;&colon;error&lowbar;code exists&period; It should only be used in this situation, and should never be used where a sensible conversion to std&colon;&colon;error&lowbar;code is available, as attempts to convert to&sol;from this error will result in a fatal error&period; (i&period;e&period; it is a programmatic error to try to convert such a value)&period;
| xref:llvm/inferAlignFromPtrInfo.adoc[`inferAlignFromPtrInfo`] 
| 
| xref:llvm/inferAttributesFromOthers.adoc[`inferAttributesFromOthers`] 
| If we can infer one attribute from another on the declaration of a function, explicitly materialize the maximal set in the IR&period;
| xref:llvm/inferNonMandatoryLibFuncAttrs-0b.adoc[`inferNonMandatoryLibFuncAttrs`] 
| Analyze the name and prototype of the given function and set any applicable attributes&period; Note that this merely helps optimizations on an already existing function but does not consider mandatory attributes&period;
| xref:llvm/initializeAAResultsWrapperPassPass.adoc[`initializeAAResultsWrapperPassPass`] 
| 
| xref:llvm/initializeAlwaysInlinerLegacyPassPass.adoc[`initializeAlwaysInlinerLegacyPassPass`] 
| 
| xref:llvm/initializeAnalysis.adoc[`initializeAnalysis`] 
| Initialize all passes linked into the Analysis library&period;
| xref:llvm/initializeAssignmentTrackingAnalysisPass.adoc[`initializeAssignmentTrackingAnalysisPass`] 
| 
| xref:llvm/initializeAssumptionCacheTrackerPass.adoc[`initializeAssumptionCacheTrackerPass`] 
| 
| xref:llvm/initializeAtomicExpandLegacyPass.adoc[`initializeAtomicExpandLegacyPass`] 
| 
| xref:llvm/initializeBarrierNoopPass.adoc[`initializeBarrierNoopPass`] 
| 
| xref:llvm/initializeBasicAAWrapperPassPass.adoc[`initializeBasicAAWrapperPassPass`] 
| 
| xref:llvm/initializeBasicBlockMatchingAndInferencePass.adoc[`initializeBasicBlockMatchingAndInferencePass`] 
| 
| xref:llvm/initializeBasicBlockPathCloningPass.adoc[`initializeBasicBlockPathCloningPass`] 
| 
| xref:llvm/initializeBasicBlockSectionsPass.adoc[`initializeBasicBlockSectionsPass`] 
| 
| xref:llvm/initializeBasicBlockSectionsProfileReaderWrapperPassPass.adoc[`initializeBasicBlockSectionsProfileReaderWrapperPassPass`] 
| 
| xref:llvm/initializeBlockFrequencyInfoWrapperPassPass.adoc[`initializeBlockFrequencyInfoWrapperPassPass`] 
| 
| xref:llvm/initializeBranchFolderLegacyPass.adoc[`initializeBranchFolderLegacyPass`] 
| 
| xref:llvm/initializeBranchProbabilityInfoWrapperPassPass.adoc[`initializeBranchProbabilityInfoWrapperPassPass`] 
| 
| xref:llvm/initializeBranchRelaxationLegacyPass.adoc[`initializeBranchRelaxationLegacyPass`] 
| 
| xref:llvm/initializeBreakCriticalEdgesPass.adoc[`initializeBreakCriticalEdgesPass`] 
| 
| xref:llvm/initializeBreakFalseDepsLegacyPass.adoc[`initializeBreakFalseDepsLegacyPass`] 
| 
| xref:llvm/initializeCFGSimplifyPassPass.adoc[`initializeCFGSimplifyPassPass`] 
| 
| xref:llvm/initializeCFGuardLongjmpPass.adoc[`initializeCFGuardLongjmpPass`] 
| 
| xref:llvm/initializeCFGuardPass.adoc[`initializeCFGuardPass`] 
| 
| xref:llvm/initializeCFIFixupLegacyPass.adoc[`initializeCFIFixupLegacyPass`] 
| 
| xref:llvm/initializeCFIInstrInserterLegacyPass.adoc[`initializeCFIInstrInserterLegacyPass`] 
| 
| xref:llvm/initializeCallGraphDOTPrinterPass.adoc[`initializeCallGraphDOTPrinterPass`] 
| 
| xref:llvm/initializeCallGraphViewerPass.adoc[`initializeCallGraphViewerPass`] 
| 
| xref:llvm/initializeCallGraphWrapperPassPass.adoc[`initializeCallGraphWrapperPassPass`] 
| 
| xref:llvm/initializeCanonicalizeFreezeInLoopsPass.adoc[`initializeCanonicalizeFreezeInLoopsPass`] 
| 
| xref:llvm/initializeCheckDebugMachineModuleLegacyPass.adoc[`initializeCheckDebugMachineModuleLegacyPass`] 
| 
| xref:llvm/initializeCodeGen.adoc[`initializeCodeGen`] 
| Initialize all passes linked into the CodeGen library&period;
| xref:llvm/initializeCodeGenPrepareLegacyPassPass.adoc[`initializeCodeGenPrepareLegacyPassPass`] 
| 
| xref:llvm/initializeComplexDeinterleavingLegacyPassPass.adoc[`initializeComplexDeinterleavingLegacyPassPass`] 
| 
| xref:llvm/initializeConstantHoistingLegacyPassPass.adoc[`initializeConstantHoistingLegacyPassPass`] 
| 
| xref:llvm/initializeCore.adoc[`initializeCore`] 
| Initialize all passes linked into the Core library&period;
| xref:llvm/initializeCycleInfoWrapperPassPass.adoc[`initializeCycleInfoWrapperPassPass`] 
| 
| xref:llvm/initializeDAEPass.adoc[`initializeDAEPass`] 
| 
| xref:llvm/initializeDCELegacyPassPass.adoc[`initializeDCELegacyPassPass`] 
| 
| xref:llvm/initializeDSELegacyPassPass.adoc[`initializeDSELegacyPassPass`] 
| 
| xref:llvm/initializeDXILMetadataAnalysisWrapperPassPass.adoc[`initializeDXILMetadataAnalysisWrapperPassPass`] 
| 
| xref:llvm/initializeDXILMetadataAnalysisWrapperPrinterPass.adoc[`initializeDXILMetadataAnalysisWrapperPrinterPass`] 
| 
| xref:llvm/initializeDXILResourceBindingWrapperPassPass.adoc[`initializeDXILResourceBindingWrapperPassPass`] 
| 
| xref:llvm/initializeDXILResourceTypeWrapperPassPass.adoc[`initializeDXILResourceTypeWrapperPassPass`] 
| 
| xref:llvm/initializeDXILResourceWrapperPassPass.adoc[`initializeDXILResourceWrapperPassPass`] 
| 
| xref:llvm/initializeDeadMachineInstructionElimPass.adoc[`initializeDeadMachineInstructionElimPass`] 
| 
| xref:llvm/initializeDebugifyMachineModulePass.adoc[`initializeDebugifyMachineModulePass`] 
| 
| xref:llvm/initializeDependenceAnalysisWrapperPassPass.adoc[`initializeDependenceAnalysisWrapperPassPass`] 
| 
| xref:llvm/initializeDetectDeadLanesLegacyPass.adoc[`initializeDetectDeadLanesLegacyPass`] 
| 
| xref:llvm/initializeDomOnlyPrinterWrapperPassPass.adoc[`initializeDomOnlyPrinterWrapperPassPass`] 
| 
| xref:llvm/initializeDomOnlyViewerWrapperPassPass.adoc[`initializeDomOnlyViewerWrapperPassPass`] 
| 
| xref:llvm/initializeDomPrinterWrapperPassPass.adoc[`initializeDomPrinterWrapperPassPass`] 
| 
| xref:llvm/initializeDomViewerWrapperPassPass.adoc[`initializeDomViewerWrapperPassPass`] 
| 
| xref:llvm/initializeDominanceFrontierWrapperPassPass.adoc[`initializeDominanceFrontierWrapperPassPass`] 
| 
| xref:llvm/initializeDominatorTreeWrapperPassPass.adoc[`initializeDominatorTreeWrapperPassPass`] 
| 
| xref:llvm/initializeDummyCGSCCPassPass.adoc[`initializeDummyCGSCCPassPass`] 
| 
| xref:llvm/initializeDwarfEHPrepareLegacyPassPass.adoc[`initializeDwarfEHPrepareLegacyPassPass`] 
| 
| xref:llvm/initializeEHContGuardTargetsLegacyPass.adoc[`initializeEHContGuardTargetsLegacyPass`] 
| 
| xref:llvm/initializeEarlyCSELegacyPassPass.adoc[`initializeEarlyCSELegacyPassPass`] 
| 
| xref:llvm/initializeEarlyCSEMemSSALegacyPassPass.adoc[`initializeEarlyCSEMemSSALegacyPassPass`] 
| 
| xref:llvm/initializeEarlyIfConverterLegacyPass.adoc[`initializeEarlyIfConverterLegacyPass`] 
| 
| xref:llvm/initializeEarlyIfPredicatorPass.adoc[`initializeEarlyIfPredicatorPass`] 
| 
| xref:llvm/initializeEarlyMachineLICMPass.adoc[`initializeEarlyMachineLICMPass`] 
| 
| xref:llvm/initializeEarlyTailDuplicateLegacyPass.adoc[`initializeEarlyTailDuplicateLegacyPass`] 
| 
| xref:llvm/initializeEdgeBundlesWrapperLegacyPass.adoc[`initializeEdgeBundlesWrapperLegacyPass`] 
| 
| xref:llvm/initializeExpandIRInstsLegacyPassPass.adoc[`initializeExpandIRInstsLegacyPassPass`] 
| 
| xref:llvm/initializeExpandPostRALegacyPass.adoc[`initializeExpandPostRALegacyPass`] 
| 
| xref:llvm/initializeExpandReductionsPass.adoc[`initializeExpandReductionsPass`] 
| 
| xref:llvm/initializeExpandVariadicsPass.adoc[`initializeExpandVariadicsPass`] 
| 
| xref:llvm/initializeExternalAAWrapperPassPass.adoc[`initializeExternalAAWrapperPassPass`] 
| 
| xref:llvm/initializeFEntryInserterLegacyPass.adoc[`initializeFEntryInserterLegacyPass`] 
| 
| xref:llvm/initializeFinalizeISelPass.adoc[`initializeFinalizeISelPass`] 
| 
| xref:llvm/initializeFixIrreduciblePass.adoc[`initializeFixIrreduciblePass`] 
| 
| xref:llvm/initializeFixupStatepointCallerSavedLegacyPass.adoc[`initializeFixupStatepointCallerSavedLegacyPass`] 
| 
| xref:llvm/initializeFlattenCFGLegacyPassPass.adoc[`initializeFlattenCFGLegacyPassPass`] 
| 
| xref:llvm/initializeFuncletLayoutLegacyPass.adoc[`initializeFuncletLayoutLegacyPass`] 
| 
| xref:llvm/initializeGCEmptyBasicBlocksLegacyPass.adoc[`initializeGCEmptyBasicBlocksLegacyPass`] 
| 
| xref:llvm/initializeGCMachineCodeAnalysisPass.adoc[`initializeGCMachineCodeAnalysisPass`] 
| 
| xref:llvm/initializeGCModuleInfoPass.adoc[`initializeGCModuleInfoPass`] 
| 
| xref:llvm/initializeGISelCSEAnalysisWrapperPassPass.adoc[`initializeGISelCSEAnalysisWrapperPassPass`] 
| 
| xref:llvm/initializeGISelValueTrackingAnalysisLegacyPass.adoc[`initializeGISelValueTrackingAnalysisLegacyPass`] 
| 
| xref:llvm/initializeGVNLegacyPassPass.adoc[`initializeGVNLegacyPassPass`] 
| 
| xref:llvm/initializeGlobalDCELegacyPassPass.adoc[`initializeGlobalDCELegacyPassPass`] 
| 
| xref:llvm/initializeGlobalISel.adoc[`initializeGlobalISel`] 
| Initialize all passes linked into the GlobalISel library&period;
| xref:llvm/initializeGlobalMergeFuncPassWrapperPass.adoc[`initializeGlobalMergeFuncPassWrapperPass`] 
| 
| xref:llvm/initializeGlobalMergePass.adoc[`initializeGlobalMergePass`] 
| 
| xref:llvm/initializeGlobalsAAWrapperPassPass.adoc[`initializeGlobalsAAWrapperPassPass`] 
| 
| xref:llvm/initializeHardwareLoopsLegacyPass.adoc[`initializeHardwareLoopsLegacyPass`] 
| 
| xref:llvm/initializeIPO.adoc[`initializeIPO`] 
| Initialize all passes linked into the IPO library&period;
| xref:llvm/initializeIRTranslatorLegacyPass.adoc[`initializeIRTranslatorLegacyPass`] 
| 
| xref:llvm/initializeIVUsersWrapperPassPass.adoc[`initializeIVUsersWrapperPassPass`] 
| 
| xref:llvm/initializeIfConverterPass.adoc[`initializeIfConverterPass`] 
| 
| xref:llvm/initializeImmutableModuleSummaryIndexWrapperPassPass.adoc[`initializeImmutableModuleSummaryIndexWrapperPassPass`] 
| 
| xref:llvm/initializeImplicitNullChecksLegacyPass.adoc[`initializeImplicitNullChecksLegacyPass`] 
| 
| xref:llvm/initializeIndirectBrExpandLegacyPassPass.adoc[`initializeIndirectBrExpandLegacyPassPass`] 
| 
| xref:llvm/initializeInferAddressSpacesPass.adoc[`initializeInferAddressSpacesPass`] 
| 
| xref:llvm/initializeInitUndefLegacyPass.adoc[`initializeInitUndefLegacyPass`] 
| 
| xref:llvm/initializeInlineAsmPreparePass.adoc[`initializeInlineAsmPreparePass`] 
| 
| xref:llvm/initializeInsertCodePrefetchPass.adoc[`initializeInsertCodePrefetchPass`] 
| 
| xref:llvm/initializeInstCombine.adoc[`initializeInstCombine`] 
| Initialize all passes linked into the InstCombine library&period;
| xref:llvm/initializeInstSimplifyLegacyPassPass.adoc[`initializeInstSimplifyLegacyPassPass`] 
| 
| xref:llvm/initializeInstructionCombiningPassPass.adoc[`initializeInstructionCombiningPassPass`] 
| 
| xref:llvm/initializeInstructionSelectLegacyPass.adoc[`initializeInstructionSelectLegacyPass`] 
| 
| xref:llvm/initializeInterleavedAccessPass.adoc[`initializeInterleavedAccessPass`] 
| 
| xref:llvm/initializeInterleavedLoadCombinePass.adoc[`initializeInterleavedLoadCombinePass`] 
| 
| xref:llvm/initializeJMCInstrumenterPass.adoc[`initializeJMCInstrumenterPass`] 
| 
| xref:llvm/initializeLCSSAVerificationPassPass.adoc[`initializeLCSSAVerificationPassPass`] 
| 
| xref:llvm/initializeLCSSAWrapperPassPass.adoc[`initializeLCSSAWrapperPassPass`] 
| 
| xref:llvm/initializeLFIMCStreamer.adoc[`initializeLFIMCStreamer`] 
| 
| xref:llvm/initializeLazyBFIPassPass.adoc[`initializeLazyBFIPassPass`] 
| 
| xref:llvm/initializeLazyBPIPassPass.adoc[`initializeLazyBPIPassPass`] 
| Helper for client passes to initialize dependent passes for LBPI&period;
| xref:llvm/initializeLazyBlockFrequencyInfoPassPass.adoc[`initializeLazyBlockFrequencyInfoPassPass`] 
| 
| xref:llvm/initializeLazyBranchProbabilityInfoPassPass.adoc[`initializeLazyBranchProbabilityInfoPassPass`] 
| 
| xref:llvm/initializeLazyMachineBlockFrequencyInfoPassPass.adoc[`initializeLazyMachineBlockFrequencyInfoPassPass`] 
| 
| xref:llvm/initializeLazyValueInfoWrapperPassPass.adoc[`initializeLazyValueInfoWrapperPassPass`] 
| 
| xref:llvm/initializeLegacyLICMPassPass.adoc[`initializeLegacyLICMPassPass`] 
| 
| xref:llvm/initializeLegalizerLegacyPass.adoc[`initializeLegalizerLegacyPass`] 
| 
| xref:llvm/initializeLibcallLoweringInfoWrapperPass.adoc[`initializeLibcallLoweringInfoWrapperPass`] 
| 
| xref:llvm/initializeLiveDebugValuesLegacyPass.adoc[`initializeLiveDebugValuesLegacyPass`] 
| 
| xref:llvm/initializeLiveDebugVariablesWrapperLegacyPass.adoc[`initializeLiveDebugVariablesWrapperLegacyPass`] 
| 
| xref:llvm/initializeLiveIntervalsWrapperPassPass.adoc[`initializeLiveIntervalsWrapperPassPass`] 
| 
| xref:llvm/initializeLiveRangeShrinkPass.adoc[`initializeLiveRangeShrinkPass`] 
| 
| xref:llvm/initializeLiveRegMatrixWrapperLegacyPass.adoc[`initializeLiveRegMatrixWrapperLegacyPass`] 
| 
| xref:llvm/initializeLiveStacksWrapperLegacyPass.adoc[`initializeLiveStacksWrapperLegacyPass`] 
| 
| xref:llvm/initializeLiveVariablesWrapperPassPass.adoc[`initializeLiveVariablesWrapperPassPass`] 
| 
| xref:llvm/initializeLoadStoreOptLegacyPass.adoc[`initializeLoadStoreOptLegacyPass`] 
| 
| xref:llvm/initializeLoadStoreVectorizerLegacyPassPass.adoc[`initializeLoadStoreVectorizerLegacyPassPass`] 
| 
| xref:llvm/initializeLocalStackSlotPassPass.adoc[`initializeLocalStackSlotPassPass`] 
| 
| xref:llvm/initializeLocalizerLegacyPass.adoc[`initializeLocalizerLegacyPass`] 
| 
| xref:llvm/initializeLogicalSROALegacyPassPass.adoc[`initializeLogicalSROALegacyPassPass`] 
| 
| xref:llvm/initializeLoopDataPrefetchLegacyPassPass.adoc[`initializeLoopDataPrefetchLegacyPassPass`] 
| 
| xref:llvm/initializeLoopInfoWrapperPassPass.adoc[`initializeLoopInfoWrapperPassPass`] 
| 
| xref:llvm/initializeLoopPassPass.adoc[`initializeLoopPassPass`] 
| 
| xref:llvm/initializeLoopSimplifyPass.adoc[`initializeLoopSimplifyPass`] 
| 
| xref:llvm/initializeLoopStrengthReducePass.adoc[`initializeLoopStrengthReducePass`] 
| 
| xref:llvm/initializeLoopTermFoldPass.adoc[`initializeLoopTermFoldPass`] 
| 
| xref:llvm/initializeLoopUnrollPass.adoc[`initializeLoopUnrollPass`] 
| 
| xref:llvm/initializeLowerAtomicLegacyPassPass.adoc[`initializeLowerAtomicLegacyPassPass`] 
| 
| xref:llvm/initializeLowerEmuTLSPass.adoc[`initializeLowerEmuTLSPass`] 
| 
| xref:llvm/initializeLowerGlobalDtorsLegacyPassPass.adoc[`initializeLowerGlobalDtorsLegacyPassPass`] 
| 
| xref:llvm/initializeLowerIntrinsicsPass.adoc[`initializeLowerIntrinsicsPass`] 
| 
| xref:llvm/initializeLowerInvokeLegacyPassPass.adoc[`initializeLowerInvokeLegacyPassPass`] 
| 
| xref:llvm/initializeLowerSwitchLegacyPassPass.adoc[`initializeLowerSwitchLegacyPassPass`] 
| 
| xref:llvm/initializeMIR2VecPrinterLegacyPassPass.adoc[`initializeMIR2VecPrinterLegacyPassPass`] 
| 
| xref:llvm/initializeMIR2VecVocabLegacyAnalysisPass.adoc[`initializeMIR2VecVocabLegacyAnalysisPass`] 
| 
| xref:llvm/initializeMIR2VecVocabPrinterLegacyPassPass.adoc[`initializeMIR2VecVocabPrinterLegacyPassPass`] 
| 
| xref:llvm/initializeMIRAddFSDiscriminatorsPass.adoc[`initializeMIRAddFSDiscriminatorsPass`] 
| 
| xref:llvm/initializeMIRCanonicalizerPass.adoc[`initializeMIRCanonicalizerPass`] 
| 
| xref:llvm/initializeMIRNamerPass.adoc[`initializeMIRNamerPass`] 
| 
| xref:llvm/initializeMIRPrintingPassPass.adoc[`initializeMIRPrintingPassPass`] 
| 
| xref:llvm/initializeMIRProfileLoaderPassPass.adoc[`initializeMIRProfileLoaderPassPass`] 
| 
| xref:llvm/initializeMachineBlockFrequencyInfoWrapperPassPass.adoc[`initializeMachineBlockFrequencyInfoWrapperPassPass`] 
| 
| xref:llvm/initializeMachineBlockHashInfoPass.adoc[`initializeMachineBlockHashInfoPass`] 
| 
| xref:llvm/initializeMachineBlockPlacementLegacyPass.adoc[`initializeMachineBlockPlacementLegacyPass`] 
| 
| xref:llvm/initializeMachineBlockPlacementStatsLegacyPass.adoc[`initializeMachineBlockPlacementStatsLegacyPass`] 
| 
| xref:llvm/initializeMachineBranchProbabilityInfoWrapperPassPass.adoc[`initializeMachineBranchProbabilityInfoWrapperPassPass`] 
| 
| xref:llvm/initializeMachineCFGPrinterLegacyPass.adoc[`initializeMachineCFGPrinterLegacyPass`] 
| 
| xref:llvm/initializeMachineCSELegacyPass.adoc[`initializeMachineCSELegacyPass`] 
| 
| xref:llvm/initializeMachineCombinerLegacyPass.adoc[`initializeMachineCombinerLegacyPass`] 
| 
| xref:llvm/initializeMachineCopyPropagationLegacyPass.adoc[`initializeMachineCopyPropagationLegacyPass`] 
| 
| xref:llvm/initializeMachineCycleInfoPrinterLegacyPass.adoc[`initializeMachineCycleInfoPrinterLegacyPass`] 
| 
| xref:llvm/initializeMachineCycleInfoWrapperPassPass.adoc[`initializeMachineCycleInfoWrapperPassPass`] 
| 
| xref:llvm/initializeMachineDominanceFrontierWrapperPassPass.adoc[`initializeMachineDominanceFrontierWrapperPassPass`] 
| 
| xref:llvm/initializeMachineDominatorTreeWrapperPassPass.adoc[`initializeMachineDominatorTreeWrapperPassPass`] 
| 
| xref:llvm/initializeMachineFunctionPrinterPassPass.adoc[`initializeMachineFunctionPrinterPassPass`] 
| 
| xref:llvm/initializeMachineFunctionSplitterPass.adoc[`initializeMachineFunctionSplitterPass`] 
| 
| xref:llvm/initializeMachineKCFILegacyPass.adoc[`initializeMachineKCFILegacyPass`] 
| 
| xref:llvm/initializeMachineLICMPass.adoc[`initializeMachineLICMPass`] 
| 
| xref:llvm/initializeMachineLateInstrsCleanupLegacyPass.adoc[`initializeMachineLateInstrsCleanupLegacyPass`] 
| 
| xref:llvm/initializeMachineLoopInfoWrapperPassPass.adoc[`initializeMachineLoopInfoWrapperPassPass`] 
| 
| xref:llvm/initializeMachineModuleInfoWrapperPassPass.adoc[`initializeMachineModuleInfoWrapperPassPass`] 
| 
| xref:llvm/initializeMachineOptimizationRemarkEmitterPassPass.adoc[`initializeMachineOptimizationRemarkEmitterPassPass`] 
| 
| xref:llvm/initializeMachineOutlinerPass.adoc[`initializeMachineOutlinerPass`] 
| 
| xref:llvm/initializeMachinePipelinerPass.adoc[`initializeMachinePipelinerPass`] 
| 
| xref:llvm/initializeMachinePostDominatorTreeWrapperPassPass.adoc[`initializeMachinePostDominatorTreeWrapperPassPass`] 
| 
| xref:llvm/initializeMachineRegionInfoPassPass.adoc[`initializeMachineRegionInfoPassPass`] 
| 
| xref:llvm/initializeMachineRegisterClassInfoWrapperPassPass.adoc[`initializeMachineRegisterClassInfoWrapperPassPass`] 
| 
| xref:llvm/initializeMachineSanitizerBinaryMetadataLegacyPass.adoc[`initializeMachineSanitizerBinaryMetadataLegacyPass`] 
| 
| xref:llvm/initializeMachineSchedulerLegacyPass.adoc[`initializeMachineSchedulerLegacyPass`] 
| 
| xref:llvm/initializeMachineSinkingLegacyPass.adoc[`initializeMachineSinkingLegacyPass`] 
| 
| xref:llvm/initializeMachineTraceMetricsWrapperPassPass.adoc[`initializeMachineTraceMetricsWrapperPassPass`] 
| 
| xref:llvm/initializeMachineUniformityAnalysisPassPass.adoc[`initializeMachineUniformityAnalysisPassPass`] 
| 
| xref:llvm/initializeMachineUniformityInfoPrinterPassPass.adoc[`initializeMachineUniformityInfoPrinterPassPass`] 
| 
| xref:llvm/initializeMachineVerifierLegacyPassPass.adoc[`initializeMachineVerifierLegacyPassPass`] 
| 
| xref:llvm/initializeMemoryDependenceWrapperPassPass.adoc[`initializeMemoryDependenceWrapperPassPass`] 
| 
| xref:llvm/initializeMemorySSAWrapperPassPass.adoc[`initializeMemorySSAWrapperPassPass`] 
| 
| xref:llvm/initializeModuleSummaryIndexWrapperPassPass.adoc[`initializeModuleSummaryIndexWrapperPassPass`] 
| 
| xref:llvm/initializeModuloScheduleTestPass.adoc[`initializeModuloScheduleTestPass`] 
| 
| xref:llvm/initializeNaryReassociateLegacyPassPass.adoc[`initializeNaryReassociateLegacyPassPass`] 
| 
| xref:llvm/initializeObjCARCContractLegacyPassPass.adoc[`initializeObjCARCContractLegacyPassPass`] 
| 
| xref:llvm/initializeOptimizationRemarkEmitterWrapperPassPass.adoc[`initializeOptimizationRemarkEmitterWrapperPassPass`] 
| 
| xref:llvm/initializeOptimizePHIsLegacyPass.adoc[`initializeOptimizePHIsLegacyPass`] 
| 
| xref:llvm/initializePEILegacyPass.adoc[`initializePEILegacyPass`] 
| 
| xref:llvm/initializePHIEliminationPass.adoc[`initializePHIEliminationPass`] 
| 
| xref:llvm/initializePartiallyInlineLibCallsLegacyPassPass.adoc[`initializePartiallyInlineLibCallsLegacyPassPass`] 
| 
| xref:llvm/initializePatchableFunctionLegacyPass.adoc[`initializePatchableFunctionLegacyPass`] 
| 
| xref:llvm/initializePeepholeOptimizerLegacyPass.adoc[`initializePeepholeOptimizerLegacyPass`] 
| 
| xref:llvm/initializePhiValuesWrapperPassPass.adoc[`initializePhiValuesWrapperPassPass`] 
| 
| xref:llvm/initializePhysicalRegisterUsageInfoWrapperLegacyPass.adoc[`initializePhysicalRegisterUsageInfoWrapperLegacyPass`] 
| 
| xref:llvm/initializePlaceBackedgeSafepointsLegacyPassPass.adoc[`initializePlaceBackedgeSafepointsLegacyPassPass`] 
| 
| xref:llvm/initializePostDomOnlyPrinterWrapperPassPass.adoc[`initializePostDomOnlyPrinterWrapperPassPass`] 
| 
| xref:llvm/initializePostDomOnlyViewerWrapperPassPass.adoc[`initializePostDomOnlyViewerWrapperPassPass`] 
| 
| xref:llvm/initializePostDomPrinterWrapperPassPass.adoc[`initializePostDomPrinterWrapperPassPass`] 
| 
| xref:llvm/initializePostDomViewerWrapperPassPass.adoc[`initializePostDomViewerWrapperPassPass`] 
| 
| xref:llvm/initializePostDominatorTreeWrapperPassPass.adoc[`initializePostDominatorTreeWrapperPassPass`] 
| 
| xref:llvm/initializePostInlineEntryExitInstrumenterPass.adoc[`initializePostInlineEntryExitInstrumenterPass`] 
| 
| xref:llvm/initializePostMachineSchedulerLegacyPass.adoc[`initializePostMachineSchedulerLegacyPass`] 
| 
| xref:llvm/initializePostRAHazardRecognizerLegacyPass.adoc[`initializePostRAHazardRecognizerLegacyPass`] 
| 
| xref:llvm/initializePostRAMachineSinkingLegacyPass.adoc[`initializePostRAMachineSinkingLegacyPass`] 
| 
| xref:llvm/initializePostRASchedulerLegacyPass.adoc[`initializePostRASchedulerLegacyPass`] 
| 
| xref:llvm/initializePreISelIntrinsicLoweringLegacyPassPass.adoc[`initializePreISelIntrinsicLoweringLegacyPassPass`] 
| 
| xref:llvm/initializePrintFunctionPassWrapperPass.adoc[`initializePrintFunctionPassWrapperPass`] 
| 
| xref:llvm/initializePrintModulePassWrapperPass.adoc[`initializePrintModulePassWrapperPass`] 
| 
| xref:llvm/initializeProcessImplicitDefsLegacyPass.adoc[`initializeProcessImplicitDefsLegacyPass`] 
| 
| xref:llvm/initializeProfileSummaryInfoWrapperPassPass.adoc[`initializeProfileSummaryInfoWrapperPassPass`] 
| 
| xref:llvm/initializePromoteLegacyPassPass.adoc[`initializePromoteLegacyPassPass`] 
| 
| xref:llvm/initializePseudoProbeInserterPass.adoc[`initializePseudoProbeInserterPass`] 
| 
| xref:llvm/initializeRABasicPass.adoc[`initializeRABasicPass`] 
| 
| xref:llvm/initializeRAGreedyLegacyPass.adoc[`initializeRAGreedyLegacyPass`] 
| 
| xref:llvm/initializeReachingDefInfoWrapperPassPass.adoc[`initializeReachingDefInfoWrapperPassPass`] 
| 
| xref:llvm/initializeReassociateLegacyPassPass.adoc[`initializeReassociateLegacyPassPass`] 
| 
| xref:llvm/initializeRegAllocEvictionAdvisorAnalysisLegacyPass.adoc[`initializeRegAllocEvictionAdvisorAnalysisLegacyPass`] 
| 
| xref:llvm/initializeRegAllocFastPass.adoc[`initializeRegAllocFastPass`] 
| 
| xref:llvm/initializeRegAllocPriorityAdvisorAnalysisLegacyPass.adoc[`initializeRegAllocPriorityAdvisorAnalysisLegacyPass`] 
| 
| xref:llvm/initializeRegAllocScoringPass.adoc[`initializeRegAllocScoringPass`] 
| 
| xref:llvm/initializeRegBankSelectLegacyPass.adoc[`initializeRegBankSelectLegacyPass`] 
| 
| xref:llvm/initializeRegToMemWrapperPassPass.adoc[`initializeRegToMemWrapperPassPass`] 
| 
| xref:llvm/initializeRegUsageInfoCollectorLegacyPass.adoc[`initializeRegUsageInfoCollectorLegacyPass`] 
| 
| xref:llvm/initializeRegUsageInfoPropagationLegacyPass.adoc[`initializeRegUsageInfoPropagationLegacyPass`] 
| 
| xref:llvm/initializeRegionInfoPassPass.adoc[`initializeRegionInfoPassPass`] 
| 
| xref:llvm/initializeRegionOnlyPrinterPass.adoc[`initializeRegionOnlyPrinterPass`] 
| 
| xref:llvm/initializeRegionOnlyViewerPass.adoc[`initializeRegionOnlyViewerPass`] 
| 
| xref:llvm/initializeRegionPrinterPass.adoc[`initializeRegionPrinterPass`] 
| 
| xref:llvm/initializeRegionViewerPass.adoc[`initializeRegionViewerPass`] 
| 
| xref:llvm/initializeRegisterCoalescerLegacyPass.adoc[`initializeRegisterCoalescerLegacyPass`] 
| 
| xref:llvm/initializeRemoveLoadsIntoFakeUsesLegacyPass.adoc[`initializeRemoveLoadsIntoFakeUsesLegacyPass`] 
| 
| xref:llvm/initializeRemoveRedundantDebugValuesLegacyPass.adoc[`initializeRemoveRedundantDebugValuesLegacyPass`] 
| 
| xref:llvm/initializeRenameIndependentSubregsLegacyPass.adoc[`initializeRenameIndependentSubregsLegacyPass`] 
| 
| xref:llvm/initializeReplaceWithVeclibLegacyPass.adoc[`initializeReplaceWithVeclibLegacyPass`] 
| 
| xref:llvm/initializeResetMachineFunctionPass.adoc[`initializeResetMachineFunctionPass`] 
| 
| xref:llvm/initializeRuntimeLibraryInfoWrapperPass.adoc[`initializeRuntimeLibraryInfoWrapperPass`] 
| 
| xref:llvm/initializeSCEVAAWrapperPassPass.adoc[`initializeSCEVAAWrapperPassPass`] 
| 
| xref:llvm/initializeSROALegacyPassPass.adoc[`initializeSROALegacyPassPass`] 
| 
| xref:llvm/initializeSafeStackLegacyPassPass.adoc[`initializeSafeStackLegacyPassPass`] 
| 
| xref:llvm/initializeSafepointIRVerifierPass.adoc[`initializeSafepointIRVerifierPass`] 
| 
| xref:llvm/initializeScalarEvolutionWrapperPassPass.adoc[`initializeScalarEvolutionWrapperPassPass`] 
| 
| xref:llvm/initializeScalarOpts.adoc[`initializeScalarOpts`] 
| Initialize all passes linked into the ScalarOpts library&period;
| xref:llvm/initializeScalarizeMaskedMemIntrinLegacyPassPass.adoc[`initializeScalarizeMaskedMemIntrinLegacyPassPass`] 
| 
| xref:llvm/initializeScalarizerLegacyPassPass.adoc[`initializeScalarizerLegacyPassPass`] 
| 
| xref:llvm/initializeScavengerTestPass.adoc[`initializeScavengerTestPass`] 
| 
| xref:llvm/initializeScopedNoAliasAAWrapperPassPass.adoc[`initializeScopedNoAliasAAWrapperPassPass`] 
| 
| xref:llvm/initializeSelectOptimizePass.adoc[`initializeSelectOptimizePass`] 
| 
| xref:llvm/initializeSeparateConstOffsetFromGEPLegacyPassPass.adoc[`initializeSeparateConstOffsetFromGEPLegacyPassPass`] 
| 
| xref:llvm/initializeShadowStackGCLoweringPass.adoc[`initializeShadowStackGCLoweringPass`] 
| 
| xref:llvm/initializeShrinkWrapLegacyPass.adoc[`initializeShrinkWrapLegacyPass`] 
| 
| xref:llvm/initializeSinkingLegacyPassPass.adoc[`initializeSinkingLegacyPassPass`] 
| 
| xref:llvm/initializeSjLjEHPreparePass.adoc[`initializeSjLjEHPreparePass`] 
| 
| xref:llvm/initializeSlotIndexesWrapperPassPass.adoc[`initializeSlotIndexesWrapperPassPass`] 
| 
| xref:llvm/initializeSpeculativeExecutionLegacyPassPass.adoc[`initializeSpeculativeExecutionLegacyPassPass`] 
| 
| xref:llvm/initializeSpillPlacementWrapperLegacyPass.adoc[`initializeSpillPlacementWrapperLegacyPass`] 
| 
| xref:llvm/initializeStackColoringLegacyPass.adoc[`initializeStackColoringLegacyPass`] 
| 
| xref:llvm/initializeStackFrameLayoutAnalysisLegacyPass.adoc[`initializeStackFrameLayoutAnalysisLegacyPass`] 
| 
| xref:llvm/initializeStackMapLivenessPass.adoc[`initializeStackMapLivenessPass`] 
| 
| xref:llvm/initializeStackProtectorPass.adoc[`initializeStackProtectorPass`] 
| 
| xref:llvm/initializeStackSafetyGlobalInfoWrapperPassPass.adoc[`initializeStackSafetyGlobalInfoWrapperPassPass`] 
| 
| xref:llvm/initializeStackSafetyInfoWrapperPassPass.adoc[`initializeStackSafetyInfoWrapperPassPass`] 
| 
| xref:llvm/initializeStackSlotColoringLegacyPass.adoc[`initializeStackSlotColoringLegacyPass`] 
| 
| xref:llvm/initializeStaticDataAnnotatorLegacyPass.adoc[`initializeStaticDataAnnotatorLegacyPass`] 
| 
| xref:llvm/initializeStaticDataProfileInfoWrapperPassPass.adoc[`initializeStaticDataProfileInfoWrapperPassPass`] 
| 
| xref:llvm/initializeStaticDataSplitterLegacyPass.adoc[`initializeStaticDataSplitterLegacyPass`] 
| 
| xref:llvm/initializeStraightLineStrengthReduceLegacyPassPass.adoc[`initializeStraightLineStrengthReduceLegacyPassPass`] 
| 
| xref:llvm/initializeStripConvergenceIntrinsicsLegacyPassPass.adoc[`initializeStripConvergenceIntrinsicsLegacyPassPass`] 
| 
| xref:llvm/initializeStripDebugMachineModulePass.adoc[`initializeStripDebugMachineModulePass`] 
| 
| xref:llvm/initializeStructurizeCFGLegacyPassPass.adoc[`initializeStructurizeCFGLegacyPassPass`] 
| 
| xref:llvm/initializeTailCallElimPass.adoc[`initializeTailCallElimPass`] 
| 
| xref:llvm/initializeTailDuplicateLegacyPass.adoc[`initializeTailDuplicateLegacyPass`] 
| 
| xref:llvm/initializeTarget.adoc[`initializeTarget`] 
| Initialize all passes linked into the CodeGen library&period;
| xref:llvm/initializeTargetLibraryInfoWrapperPassPass.adoc[`initializeTargetLibraryInfoWrapperPassPass`] 
| 
| xref:llvm/initializeTargetPassConfigPass.adoc[`initializeTargetPassConfigPass`] 
| 
| xref:llvm/initializeTargetTransformInfoWrapperPassPass.adoc[`initializeTargetTransformInfoWrapperPassPass`] 
| 
| xref:llvm/initializeTransformUtils.adoc[`initializeTransformUtils`] 
| Initialize all passes linked into the TransformUtils library&period;
| xref:llvm/initializeTwoAddressInstructionLegacyPassPass.adoc[`initializeTwoAddressInstructionLegacyPassPass`] 
| 
| xref:llvm/initializeTypeBasedAAWrapperPassPass.adoc[`initializeTypeBasedAAWrapperPassPass`] 
| 
| xref:llvm/initializeTypePromotionLegacyPass.adoc[`initializeTypePromotionLegacyPass`] 
| 
| xref:llvm/initializeUniformityInfoWrapperPassPass.adoc[`initializeUniformityInfoWrapperPassPass`] 
| 
| xref:llvm/initializeUnifyLoopExitsLegacyPassPass.adoc[`initializeUnifyLoopExitsLegacyPassPass`] 
| 
| xref:llvm/initializeUnpackMachineBundlesLegacyPass.adoc[`initializeUnpackMachineBundlesLegacyPass`] 
| 
| xref:llvm/initializeUnreachableBlockElimLegacyPassPass.adoc[`initializeUnreachableBlockElimLegacyPassPass`] 
| 
| xref:llvm/initializeUnreachableMachineBlockElimLegacyPass.adoc[`initializeUnreachableMachineBlockElimLegacyPass`] 
| 
| xref:llvm/initializeVectorization.adoc[`initializeVectorization`] 
| Initialize all passes linked into the Vectorize library&period;
| xref:llvm/initializeVerifierLegacyPassPass.adoc[`initializeVerifierLegacyPassPass`] 
| 
| xref:llvm/initializeVirtRegMapWrapperLegacyPass.adoc[`initializeVirtRegMapWrapperLegacyPass`] 
| 
| xref:llvm/initializeVirtRegRewriterLegacyPass.adoc[`initializeVirtRegRewriterLegacyPass`] 
| 
| xref:llvm/initializeWasmEHPreparePass.adoc[`initializeWasmEHPreparePass`] 
| 
| xref:llvm/initializeWinEHPreparePass.adoc[`initializeWinEHPreparePass`] 
| 
| xref:llvm/initializeWindowsSecureHotPatchingPass.adoc[`initializeWindowsSecureHotPatchingPass`] 
| 
| xref:llvm/initializeWriteBitcodePassPass.adoc[`initializeWriteBitcodePassPass`] 
| 
| xref:llvm/initializeXRayInstrumentationLegacyPass.adoc[`initializeXRayInstrumentationLegacyPass`] 
| 
| xref:llvm/inlineCostFeatureToMlFeature.adoc[`inlineCostFeatureToMlFeature`] 
| 
| 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 the 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`] 
| 
| xref:llvm/inst_end-01.adoc[`inst&lowbar;end`] 
| 
| 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`] 
| 
| xref:llvm/instrs-03.adoc[`instrs`] 
| 
| xref:llvm/instructions-01d.adoc[`instructions`] 
| 
| xref:llvm/instructionsWithoutDebug.adoc[`instructionsWithoutDebug`] 
| Construct a range iterator which begins at `It` and moves forwards until `End` is reached, skipping any debug instructions&period;
| xref:llvm/interleave-0e.adoc[`interleave`] 
| `interleave` overloads
| xref:llvm/interleaveComma-0a.adoc[`interleaveComma`] 
| `interleaveComma` overloads
| xref:llvm/interleaved.adoc[`interleaved`] 
| Output range `R` as a sequence of interleaved elements&period; Requires the range element type to be printable using `raw&lowbar;ostream&amp; operator&lt;&lt;`&period; The `Separator` and `Prefix` &sol; `Suffix` can be customized&period; Examples&colon; &grave;c&plus;&plus; SmallVector&lt;int&gt; Vals &equals; &lcub;1, 2, 3&rcub;&semi; OS &lt;&lt; interleaved(Vals)&semi; &sol;&sol; &equals;&equals;&gt; &quot;1, 2, 3&quot; OS &lt;&lt; interleaved(Vals, &quot;&semi;&quot;)&semi; &sol;&sol; &equals;&equals;&gt; &quot;1&semi;2&semi;3&quot; OS &lt;&lt; interleaved(Vals, &quot; &quot;, &quot;&lcub;&quot;, &quot;&rcub;&quot;)&semi; &sol;&sol; &equals;&equals;&gt; &quot;&lcub;1 2 3&rcub;&quot; &grave;
| xref:llvm/interleaved_array.adoc[`interleaved&lowbar;array`] 
| Output range `R` as an array of interleaved elements&period; Requires the range element type to be printable using `raw&lowbar;ostream&amp; operator&lt;&lt;`&period; The `Separator` can be customized&period; Examples&colon; &grave;c&plus;&plus; SmallVector&lt;int&gt; Vals &equals; &lcub;1, 2, 3&rcub;&semi; OS &lt;&lt; interleaved&lowbar;array(Vals)&semi; &sol;&sol; &equals;&equals;&gt; &quot;&lsqb;1, 2, 3&rsqb;&quot; OS &lt;&lt; interleaved&lowbar;array(Vals, &quot;&semi;&quot;)&semi; &sol;&sol; &equals;&equals;&gt; &quot;&lsqb;1&semi;2&semi;3&rsqb;&quot; OS &lt;&lt; interleaved&lowbar;array(Vals, &quot; &quot;)&semi; &sol;&sol; &equals;&equals;&gt; &quot;&lsqb;1 2 3&rsqb;&quot; &grave;
| xref:llvm/internalizeModule.adoc[`internalizeModule`] 
| Helper function to internalize functions and variables in a Module&period;
| xref:llvm/intersectAccessGroups.adoc[`intersectAccessGroups`] 
| Compute the access&hyphen;group list of access groups that `Inst1` and `Inst2` are both in&period; If either instruction does not access memory at all, it is considered to be in every list&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 the given true&sol;false value, possibly reusing an existing copy&period;
| xref:llvm/invertFPClassTestIfSimpler.adoc[`invertFPClassTestIfSimpler`] 
| Evaluates if the specified FP class test is better performed as the inverse (i&period;e&period; fewer instructions should be required to lower it)&period; An example is the test &quot;inf&verbar;normal&verbar;subnormal&verbar;zero&quot;, which is an inversion of &quot;nan&quot;&period;
| xref:llvm/invoke.adoc[`invoke`] 
| C&plus;&plus;20 constexpr invoke&period; This uses `std&colon;&colon;apply` (constexpr in C&plus;&plus;17) to achieve constexpr invocation&period;
| xref:llvm/invokeGlobalTargetPassConfigCallbacks.adoc[`invokeGlobalTargetPassConfigCallbacks`] 
| 
| xref:llvm/isASCII-0b.adoc[`isASCII`] 
| `isASCII` overloads
| xref:llvm/isAcquireOrStronger.adoc[`isAcquireOrStronger`] 
| 
| 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 the induction variable `IV` in a Loop whose latch is `LatchBlock` would become dead if the exit test `Cond` were removed&period; Conservatively returns false if analysis is insufficient&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 iff the operand bundles of the provided llvm&period;assume doesn&apos;t contain any valuable information&period; This is true when&colon; &hyphen; The operand bundle is empty &hyphen; The operand bundle only contains information about dropped values or constant folded values&period;
| xref:llvm/isAsynchronousEHPersonality.adoc[`isAsynchronousEHPersonality`] 
| Returns true if this personality function catches asynchronous exceptions&period;
| xref:llvm/isAtLeastOrStrongerThan.adoc[`isAtLeastOrStrongerThan`] 
| 
| xref:llvm/isBaseOfObject.adoc[`isBaseOfObject`] 
| Return true if we know V to the base address of the corresponding memory object&period; This implies that any address less than V must be out of bounds for the underlying object&period; Note that just being isIdentifiedObject() is not enough &hyphen; For example, a negative offset from a noalias argument or call can be inbounds w&period;r&period;t the actual underlying 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; Assumes that an all ones constant is canonicalized to be operand 1&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; This is true for all i8 values obviously, but is also true for i32 0, i32 &hyphen;1, i16 0xF0F0, double 0&period;0 etc&period; If the value can&apos;t be handled with a repeated byte store (e&period;g&period; i16 0x1234), return null&period; If the value is entirely undef and padding, return undef&period;
| xref:llvm/isCFGuardCall.adoc[`isCFGuardCall`] 
| 
| xref:llvm/isCFGuardFunction.adoc[`isCFGuardFunction`] 
| 
| xref:llvm/isCallableCC.adoc[`isCallableCC`] 
| 
| xref:llvm/isCheckForZeroAndMulWithOverflow-08.adoc[`isCheckForZeroAndMulWithOverflow`] 
| Match one of the patterns up to the select&sol;logic op&colon; %Op0 &equals; icmp ne i4 %X, 0 %Agg &equals; call &lcub; i4, i1 &rcub; llvm&period;&lsqb;us&rsqb;mul&period;with&period;overflow&period;i4(i4 %X, i4 %Y) %Op1 &equals; extractvalue &lcub; i4, i1 &rcub; %Agg, 1 %ret &equals; select i1 %Op0, i1 %Op1, i1 false &sol; %ret &equals; and i1 %Op0, %Op1
| xref:llvm/isCompileUnit.adoc[`isCompileUnit`] 
| 
| 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`] 
| 
| 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`] 
| Return true if the specified edge is a critical edge&period; Critical edges are edges from a block with multiple successors to a block with multiple predecessors&period;
| xref:llvm/isCurrentDebugType.adoc[`isCurrentDebugType`] 
| isCurrentDebugType &hyphen; Return true if the specified string is the debug type specified on the command line, or if none was specified on the command line with the &hyphen;debug&hyphen;only&equals;X option&period; An optional level can be provided to control the verbosity of the output&period; If the provided level is not 0 and user specified a level below the provided level, return false&period;
| xref:llvm/isCycleInvariant.adoc[`isCycleInvariant`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/isFilterPassesEmpty.adoc[`isFilterPassesEmpty`] 
| 
| 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`] 
| 
| xref:llvm/isGPUProfTarget.adoc[`isGPUProfTarget`] 
| Determines whether module targets a GPU eligable for PGO instrumentation
| 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`] 
| 
| xref:llvm/isHexDigit.adoc[`isHexDigit`] 
| Checks if character `C` is a hexadecimal numeric character&period;
| xref:llvm/isIRPGOFlagSet.adoc[`isIRPGOFlagSet`] 
| Check if INSTR&lowbar;PROF&lowbar;RAW&lowbar;VERSION&lowbar;VAR is defined&period; This global is only being set in IR PGO compilation&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 umabigously identified at the function&hyphen;level&period; Different IdentifiedFunctionLocals can&apos;t alias&period; Further, an IdentifiedFunctionLocal can not alias with any function arguments other than itself, which is not necessarily true for IdentifiedObjects&period;
| xref:llvm/isIdentifiedObject.adoc[`isIdentifiedObject`] 
| Return true if this pointer refers to a distinct and identifiable object&period; This returns true for&colon; Global Variables and Functions (but not Global Aliases) Allocas ByVal and NoAlias Arguments NoAlias returns (e&period;g&period; calls to malloc)
| xref:llvm/isImpliedByDomCondition-0fb.adoc[`isImpliedByDomCondition`] 
| Return the boolean condition value in the context of the given instruction if it is known based on dominating conditions&period;
| xref:llvm/isImpliedCondition-0e.adoc[`isImpliedCondition`] 
| Return true if RHS is known to be implied true by LHS&period; Return false if RHS is known to be implied false by LHS&period; Otherwise, return std&colon;&colon;nullopt if no implication can be made&period; A &amp; B must be i1 (boolean) values or a vector of such values&period; Note that the truth table for implication is the same as &lt;&equals;u on i1 values (but not &lt;&equals;s!)&period; The truth table for both is&colon; &verbar; T &verbar; F (B) T &verbar; T &verbar; F F &verbar; T &verbar; T (A)
| xref:llvm/isInTailCallPosition.adoc[`isInTailCallPosition`] 
| Test if the given instruction is in a position to be optimized with a tail&hyphen;call&period; This roughly means that it&apos;s in a block with a return and there&apos;s nothing that needs to be scheduled between it and the return&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 the result produced by the instruction is not used, and the instruction will return&period; Certain side&hyphen;effecting instructions are also considered dead if there are no uses of the instruction&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`] 
| &lcub;launder,strip&rcub;&period;invariant&period;group returns pointer that aliases its argument, and it only captures pointer by returning it&period; These intrinsics are not marked as nocapture, because returning is considered as capture&period; The arguments are not marked as returned neither, because it would make it useless&period; If `MustPreserveOffset` is true, the intrinsic must preserve the byte offset of the pointer within its underlying object (which excludes `llvm&period;ptrmask`, since masking off low bits changes the byte offset while still aliasing the same object)&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; Currently can recoginze Value pair&colon; 1&colon; &lt;X, Y&gt; if X &equals; sub (0, Y) or Y &equals; sub (0, X) 2&colon; &lt;X, Y&gt; if X &equals; sub (A, B) and Y &equals; sub (B, A)
| 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; Return false if a value could ever be infinity&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; Return false if a value could ever be NaN&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; For vectors, return true if every element is known to be non&hyphen;zero when defined&period; For pointers, if the context instruction and dominator tree are specified, perform context&hyphen;sensitive analysis and return true if the pointer couldn&apos;t possibly be null at the specified instruction&period; Supports values with integer or pointer type and vectors of integers&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`] 
| 
| xref:llvm/isLegalUTF8String.adoc[`isLegalUTF8String`] 
| 
| xref:llvm/isLibFreeFunction.adoc[`isLibFreeFunction`] 
| isLibFreeFunction &hyphen; Returns true if the function is a builtin free()
| xref:llvm/isLibFuncEmittable-0c.adoc[`isLibFuncEmittable`] 
| Check whether the library function is available on target and also that it in the current Module is a Function with the right type&period;
| 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 there is a potentially a path from at least one block in &apos;Worklist&apos; to at least one block in &apos;StopSet&apos; within a single function without passing through any of the blocks in &apos;ExclusionSet&apos;&period; Returns false only if we can prove that once any block in &apos;Worklist&apos; has been reached then no blocks in &apos;StopSet&apos; can be executed without passing through any blocks in &apos;ExclusionSet&apos;&period; Conservatively returns true&period;
| xref:llvm/isMask_32.adoc[`isMask&lowbar;32`] 
| Return true if the argument is a non&hyphen;empty sequence of ones starting at the least significant bit with the remainder zero (32 bit version)&period; Ex&period; isMask&lowbar;32(0x0000FFFFU) &equals;&equals; true&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`] 
| Does this shuffle mask represent either one slide shuffle or a pair of two slide shuffles, combined with a select on some constant vector mask? A slide is a shuffle mask which shifts some set of elements up or down the vector, with all other elements being undefined&period; An identity shuffle will be matched a slide by 0&period; The output parameter provides the source (&hyphen;1 means no source), and slide direction for each slide&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`] 
| 
| xref:llvm/isModOrRefSet.adoc[`isModOrRefSet`] 
| 
| xref:llvm/isModSet.adoc[`isModSet`] 
| 
| 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`] 
| 
| 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; This condition is weaker than checking that the instruction is lanewise&colon; lanewise means that the same operation is splatted across all lanes, but we also include the case where there is a different operation on each lane, as long as the operation only uses data from that lane&period; An example of an operation that is not lanewise, but doesn&apos;t cross vector lanes is insertelement&period;
| xref:llvm/isNotVisibleOnUnwind.adoc[`isNotVisibleOnUnwind`] 
| Return true if Object memory is not visible after an unwind, in the sense that program semantics cannot depend on Object containing any particular value on unwind&period; If the RequiresNoCaptureBeforeUnwind out parameter is set to true, then the memory is only not visible if the object has not been captured prior to the unwind&period; Otherwise it is not visible even if captured&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`] 
| `isNullOrNullSplat` overloads
| 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 splatted vector of a constant 1 integer (with no undefs)&period; Build vector implicit truncation is allowed, but the truncated bits need to be zero&period;
| xref:llvm/isOneOrOneSplatFP.adoc[`isOneOrOneSplatFP`] 
| Return true if the value is a constant floating&hyphen;point value, or a splatted vector of a constant floating&hyphen;point value, of 1&period;0 (with no undefs)&period;
| xref:llvm/isOnesOrOnesSplat.adoc[`isOnesOrOnesSplat`] 
| Return true if the value is a constant 1 integer or a splatted vector of a constant 1 integer (with no undefs)&period; Does not permit build vector implicit truncation&period;
| xref:llvm/isOnlyUsedInZeroComparison.adoc[`isOnlyUsedInZeroComparison`] 
| 
| xref:llvm/isOnlyUsedInZeroEqualityComparison.adoc[`isOnlyUsedInZeroEqualityComparison`] 
| 
| xref:llvm/isOverflowIntrinsicNoWrap.adoc[`isOverflowIntrinsicNoWrap`] 
| Returns true if the arithmetic part of the `WO` &apos;s result is used only along the paths control dependent on the computation not overflowing, `WO` being an &lt;op&gt;&period;with&period;overflow intrinsic&period;
| xref:llvm/isPassInPrintList.adoc[`isPassInPrintList`] 
| 
| 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 there is at least one path from a block in &apos;Worklist&apos; to &apos;StopBB&apos; without passing through any blocks in &apos;ExclusionSet&apos;, returning true if uncertain&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`] 
| 
| xref:llvm/isPrefixedHexStyle.adoc[`isPrefixedHexStyle`] 
| Return true if hex style `S` includes a radix prefix&period;
| xref:llvm/isPresplitCoroSuspendExitEdge.adoc[`isPresplitCoroSuspendExitEdge`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/isReleaseModelValid-039.adoc[`isReleaseModelValid`] 
| `isReleaseModelValid` overloads
| xref:llvm/isReleaseOrStronger.adoc[`isReleaseOrStronger`] 
| 
| xref:llvm/isRemovableAlloc.adoc[`isRemovableAlloc`] 
| Return true if this is a call to an allocation function that does not have side effects that we are required to preserve beyond the effect of allocating a new object&period; Ex&colon; If our allocation routine has a counter for the number of objects allocated, and the program prints it on exit, can the value change due to optimization? Answer is highly language dependent&period; Note&colon; _Removable_ really does mean removable&semi; it does not mean observable&period; A language (e&period;g&period; C&plus;&plus;) can allow removing allocations without allowing insertion or speculative execution of allocation routines&period;
| xref:llvm/isSafeToDestroyConstant.adoc[`isSafeToDestroyConstant`] 
| It is safe to destroy a constant iff it is only used by constants itself&period; Note that constants cannot be cyclic, so this test is pretty easy to implement recursively&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`] 
| Return true if the instruction does not have any effects besides calculating the result and does not have undefined behavior&period;
| xref:llvm/isSafeToSpeculativelyExecuteWithOpcode.adoc[`isSafeToSpeculativelyExecuteWithOpcode`] 
| This returns the same result as isSafeToSpeculativelyExecute if Opcode is the actual opcode of Inst&period; If the provided and actual opcode differ, the function (virtually) overrides the opcode of Inst with the provided Opcode&period; There are come constraints in this case&colon; &ast; If Opcode has a fixed number of operands (eg, as binary operators do), then Inst has to have at least as many leading operands&period; The function will ignore all trailing operands beyond that number&period; &ast; If Opcode allows for an arbitrary number of operands (eg, as CallInsts do), then all operands are considered&period; &ast; The virtual instruction has to satisfy all typing rules of the provided Opcode&period; &ast; This function is pessimistic in the following sense&colon; If one actually materialized the virtual instruction, then isSafeToSpeculativelyExecute may say that the materialized instruction is speculatable whereas this function may have said that the instruction wouldn&apos;t be speculatable&period; This behavior is a shortcoming in the current implementation and not intentional&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`] 
| 
| 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; If it only checks the sign bit, set TrueIfSigned if the result of the comparison is true when the input value is signed&period;
| xref:llvm/isSpace.adoc[`isSpace`] 
| Checks whether character `C` is whitespace in the &quot;C&quot; locale&period;
| xref:llvm/isSpecialPass.adoc[`isSpecialPass`] 
| 
| xref:llvm/isSplatValue.adoc[`isSplatValue`] 
| Return true if each element of the vector value `V` is poisoned or equal to every other non&hyphen;poisoned element&period; If an index element is specified, either every element of the vector is poisoned or the element at that index is not poisoned and equal to every other non&hyphen;poisoned element&period; This may be more powerful than the related getSplatValue() because it is not limited by finding a scalar source value to a splatted vector&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`] 
| 
| xref:llvm/isStrongerThanUnordered.adoc[`isStrongerThanUnordered`] 
| 
| 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`] 
| 
| 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`] 
| Note&colon; There are intrinsics where implementing vectorization for the intrinsic is redundant, but we want to implement scalarization of the vector&period; To prevent the requirement that an intrinsic also implements vectorization we provide this separate function&period;
| xref:llvm/isTriviallyVectorizable.adoc[`isTriviallyVectorizable`] 
| Identify if the intrinsic is trivially vectorizable&period; This method returns true if the intrinsic&apos;s argument types are all scalars for the scalar form of the intrinsic and all vectors (or scalars handled by isVectorIntrinsicWithScalarOpAtArg) for the vector form of the intrinsic&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`] 
| 
| 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`] 
| Return true if it is valid to use the assumptions provided by an assume intrinsic, I, at the point in the control&hyphen;flow identified by the context instruction, CxtI&period; By default, ephemeral values of the assumption are treated as an invalid context, to prevent the assumption from being used to optimize away its argument&period; If the caller can ensure that this won&apos;t happen, it can call with AllowEphemerals set to true to get more valid assumptions&period;
| xref:llvm/isValidAtomicOrdering.adoc[`isValidAtomicOrdering`] 
| 
| xref:llvm/isValidAtomicOrderingCABI.adoc[`isValidAtomicOrderingCABI`] 
| 
| xref:llvm/isValueProfileMD.adoc[`isValueProfileMD`] 
| Checks if an MDNode contains value profiling Metadata
| xref:llvm/isVectorIntrinsicWithOverloadTypeAtArg.adoc[`isVectorIntrinsicWithOverloadTypeAtArg`] 
| Identifies if the vector form of the intrinsic is overloaded on the type of the operand at index `OpdIdx,` or on the return type if `OpdIdx` is &hyphen;1&period; `TTI` is used to consider target specific intrinsics, if no target specific intrinsics will be considered then it is appropriate to pass in nullptr&period;
| xref:llvm/isVectorIntrinsicWithScalarOpAtArg.adoc[`isVectorIntrinsicWithScalarOpAtArg`] 
| Identifies if the vector form of the intrinsic has a scalar operand&period; `TTI` is used to consider target specific intrinsics, if no target specific intrinsics will be considered then it is appropriate to pass in nullptr&period;
| xref:llvm/isVectorIntrinsicWithStructReturnOverloadAtField.adoc[`isVectorIntrinsicWithStructReturnOverloadAtField`] 
| Identifies if the vector form of the intrinsic that returns a struct is overloaded at the struct element index `RetIdx&period;` &sol;&sol;&sol; `TTI` is used to consider target specific intrinsics, if no target specific intrinsics will be considered then it is appropriate to pass in nullptr&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
| xref:llvm/isWritableObject.adoc[`isWritableObject`] 
| Return true if the Object is writable, in the sense that any location based on this pointer that can be loaded can also be stored to without trapping&period; Additionally, at the point Object is declared, stores can be introduced without data races&period; At later points, this is only the case if the pointer can not escape to a different thread&period;
| xref:llvm/isZeroOrZeroSplat.adoc[`isZeroOrZeroSplat`] 
| Return true if the value is a constant 0 integer or a splatted vector of a constant 0 integer (with no undefs)&period; Build vector implicit truncation is allowed&period;
| xref:llvm/isZeroOrZeroSplatFP.adoc[`isZeroOrZeroSplatFP`] 
| Return true if the value is a constant (&plus;&sol;&hyphen;)0&period;0 floating&hyphen;point value or a splatted vector thereof (with no undefs)&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`] 
| Returns a non&hyphen;NULL pointer to a NUL&hyphen;terminated C style string that should be explicitly freed, if successful&period; Otherwise, may return nullptr if mangled&lowbar;name is not a valid mangling or is nullptr&period;
| xref:llvm/itostr.adoc[`itostr`] 
| Convert a signed integer to a decimal string&period;
| xref:llvm/jitLinkForORC.adoc[`jitLinkForORC`] 
| 
| 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&period; The resulting Error is unchecked, and contains the ErrorInfo(s), if any, contained in E1, followed by the ErrorInfo(s), if any, contained in E2&period;
| xref:llvm/join_items.adoc[`join&lowbar;items`] 
| Joins the strings in the parameter pack `Items,` adding `Separator` between the elements&period; All arguments must be implicitly convertible to std&colon;&colon;string, or there should be an overload of std&colon;&colon;string&colon;&colon;operator&plus;&equals;() that accepts the argument explicitly&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`] 
| 
| xref:llvm/libDriverMain.adoc[`libDriverMain`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/llvm_thread_get_current_id_impl.adoc[`llvm&lowbar;thread&lowbar;get&lowbar;current&lowbar;id&lowbar;impl`] 
| 
| xref:llvm/llvm_thread_get_id_impl.adoc[`llvm&lowbar;thread&lowbar;get&lowbar;id&lowbar;impl`] 
| 
| xref:llvm/llvm_thread_join_impl.adoc[`llvm&lowbar;thread&lowbar;join&lowbar;impl`] 
| 
| xref:llvm/llvm_unreachable_internal.adoc[`llvm&lowbar;unreachable&lowbar;internal`]  [.small]#[noreturn]#
| This function calls abort(), and prints the optional message to stderr&period; Use the llvm&lowbar;unreachable macro (that adds location info), instead of calling this function directly&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; This function does not immediately create the cache directory if it does not yet exist&semi; this is done lazily the first time a file is added&period; The cache name appears in error messages for errors during caching&period; The temporary file prefix is used in the temporary file naming scheme used when writing files atomically&period;
| xref:llvm/logAllUnhandledErrors.adoc[`logAllUnhandledErrors`] 
| Log all errors (if any) in E to OS&period; If there are any errors, ErrorBanner will be printed before the first one is logged&period; A newline will be printed after each error&period;
| xref:llvm/longestCommonSequence.adoc[`longestCommonSequence`] 
| 
| 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`] 
| 
| xref:llvm/lowerGlobalIFuncUsersAsGlobalCtor.adoc[`lowerGlobalIFuncUsersAsGlobalCtor`] 
| Lower all calls to ifuncs by replacing uses with indirect calls loaded out of a global table initialized in a global constructor&period; This will introduce one constructor function and adds it to llvm&period;global&lowbar;ctors&period; The constructor will call the resolver function once for each ifunc&period;
| xref:llvm/lowerObjectSizeCall-02.adoc[`lowerObjectSizeCall`] 
| Try to turn a call to @llvm&period;objectsize into an integer value of the given Type&period; Returns null on failure&period; If MustSucceed is true, this function will not return null, and may return conservative values governed by the second argument of the call to objectsize&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`] 
| Checks that MIR is fully legal, returns an illegal instruction if it&apos;s not, nullptr otherwise
| xref:llvm/machineToStr.adoc[`machineToStr`] 
| 
| 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 point of `Guard,` replacing it with explicit branch by the condition of guard&apos;s first argument&period; The taken branch then goes to the block that contains `Guard&apos;s` successors, and the non&hyphen;taken branch goes to a newly&hyphen;created deopt block that contains a sole call of the deoptimize function `DeoptIntrinsic&period;` If &apos;UseWC&apos; is set, preserve the widenable nature of the guard by lowering to equivelent form&period; If not set, lower to a form without widenable semantics&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`] 
| 
| 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`] 
| Convert an `errc` value to a `std&colon;&colon;error&lowbar;code&period;`
| 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`] 
| Given a container of pairs, return a range over the first elements&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 pointees 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`] 
| Given a container of pairs, return a range over the second elements&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`] 
| 
| xref:llvm/mapWindowsError.adoc[`mapWindowsError`] 
| 
| 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;` `F` can be a function, lambda, or member pointer&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`] 
| 
| xref:llvm/maskContainsAllOneOrUndef.adoc[`maskContainsAllOneOrUndef`] 
| Given a mask vector of i1, Return true if any of the elements of this predicate mask are known to be true or undef&period; That is, return true if at least one lane can be assumed active&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`] 
| Pattern match integer &lsqb;SU&rsqb;MIN, &lsqb;SU&rsqb;MAX and ABS idioms, returning the kind and providing the out parameter results if we successfully match&period;
| xref:llvm/matchSimpleBinaryIntrinsicRecurrence.adoc[`matchSimpleBinaryIntrinsicRecurrence`] 
| Attempt to match a simple value&hyphen;accumulating recurrence of the form&colon; %llvm&period;intrinsic&period;acc &equals; phi Ty &lsqb;%Init, %Entry&rsqb;, &lsqb;%llvm&period;intrinsic, %backedge&rsqb; %llvm&period;intrinsic &equals; call Ty llvm&period;intrinsic(%OtherOp, %llvm&period;intrinsic&period;acc) OR %llvm&period;intrinsic&period;acc &equals; phi Ty &lsqb;%Init, %Entry&rsqb;, &lsqb;%llvm&period;intrinsic, %backedge&rsqb; %llvm&period;intrinsic &equals; call Ty llvm&period;intrinsic(%llvm&period;intrinsic&period;acc, %OtherOp)
| xref:llvm/matchSimpleRecurrence-06.adoc[`matchSimpleRecurrence`] 
| `matchSimpleRecurrence` overloads
| xref:llvm/matchSimpleTernaryIntrinsicRecurrence.adoc[`matchSimpleTernaryIntrinsicRecurrence`] 
| Attempt to match a simple value&hyphen;accumulating recurrence of the form&colon; %llvm&period;intrinsic&period;acc &equals; phi Ty &lsqb;%Init, %Entry&rsqb;, &lsqb;%llvm&period;intrinsic, %backedge&rsqb; %llvm&period;intrinsic &equals; call Ty llvm&period;intrinsic(%OtherOp0, %OtherOp1, %llvm&period;intrinsic&period;acc) OR %llvm&period;intrinsic&period;acc &equals; phi Ty &lsqb;%Init, %Entry&rsqb;, &lsqb;%llvm&period;intrinsic, %backedge&rsqb; %llvm&period;intrinsic &equals; call Ty llvm&period;intrinsic(%llvm&period;intrinsic&period;acc, %OtherOp0, %OtherOp1)
| xref:llvm/matchUnaryPredicate.adoc[`matchUnaryPredicate`] 
| Attempt to match a unary predicate against a scalar&sol;splat constant or every element of a constant G&lowbar;BUILD&lowbar;VECTOR&period; If `ConstVal` is null, the source value was undef&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`] 
| Implements IEEE&hyphen;754 2008 maxNum semantics&period; Returns the larger of the 2 arguments if both are not NaN&period; If either argument is a qNaN, returns the other argument&period; If either argument is sNaN, return a qNaN&period; &plus;0 is treated as ordered greater than &hyphen;0&period;
| xref:llvm/mayBeOldLoopAttachmentTag.adoc[`mayBeOldLoopAttachmentTag`] 
| Check whether a string looks like an old loop attachment tag&period;
| xref:llvm/mayContainIrreducibleControl.adoc[`mayContainIrreducibleControl`] 
| 
| 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; &ast; Memory dependence arises for example if the instruction reads from memory or may produce effects or undefined behaviour&period; Memory dependent instructions generally cannot be reorderd with respect to other memory dependent instructions&period; &ast; Control dependence arises for example if the instruction may fault if lifted above a throwing call or infinite loop&period;
| xref:llvm/maybeMarkSanitizerLibraryCallNoBuiltin.adoc[`maybeMarkSanitizerLibraryCallNoBuiltin`] 
| Given a CallInst, check if it calls a string function known to CodeGen, and mark it with NoBuiltin if so&period; To be used by sanitizers that intend to intercept string functions and want to avoid converting them to target specific instructions&period;
| xref:llvm/mergeSampleProfErrors.adoc[`mergeSampleProfErrors`] 
| 
| xref:llvm/mi_bundle_ops.adoc[`mi&lowbar;bundle&lowbar;ops`] 
| 
| xref:llvm/microsoftDemangle.adoc[`microsoftDemangle`] 
| Demangles the Microsoft symbol pointed at by mangled&lowbar;name and returns it&period; Returns a pointer to the start of a null&hyphen;terminated demangled string on success, or nullptr on error&period; If n&lowbar;read is non&hyphen;null and demangling was successful, it receives how many bytes of the input string were consumed&period; status receives one of the demangle&lowbar; enum entries above if it&apos;s not nullptr&period; Flags controls various details of the demangled representation&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`] 
| Implements IEEE&hyphen;754 2008 minNum semantics&period; Returns the smaller of the 2 arguments if both are not NaN&period; If either argument is a qNaN, returns the other argument&period; If either argument is sNaN, return a qNaN&period; &hyphen;0 is treated as ordered less than &plus;0&period;
| xref:llvm/mismatch.adoc[`mismatch`] 
| Provide wrappers to std&colon;&colon;mismatch which take ranges instead of having to pass begin&sol;end explicitly&period; This function returns a pair of iterators for the first mismatching elements from `R1` and `R2`&period; As an example, if&colon;
| xref:llvm/mod-06.adoc[`mod`] 
| `mod` overloads
| xref:llvm/move.adoc[`move`] 
| Provide wrappers to std&colon;&colon;move which take ranges instead of having to pass begin&sol;end explicitly&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 undefined behavior would provable be executed on the path to OnPathTo if Root produced a posion result&period; Note that this doesn&apos;t say anything about whether OnPathTo is actually executed or whether Root is actually poison&period; This can be used to assess whether a new use of Root can be added at a location which is control equivalent with OnPathTo (such as immediately before it) without introducing UB which didn&apos;t previously exist&period; Note that a false result conveys no information&period;
| xref:llvm/mustSuppressSpeculation.adoc[`mustSuppressSpeculation`] 
| Return true if speculation of the given load must be suppressed to avoid ordering or interfering with an active sanitizer&period; If not suppressed, dereferenceability and alignment must be proven separately&period; Note&colon; This is only needed for raw reasoning&semi; if you use the interface below (isSafeToSpeculativelyExecute), this is handled internally&period;
| xref:llvm/mustTriggerUB.adoc[`mustTriggerUB`] 
| Return true if the given instruction must trigger undefined behavior when I is executed with any operands which appear in KnownPoison holding a poison value at the point of execution&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 the scaled sequential indices for an equivalent mask of narrowed elements&period; Mask elements that are less than 0 (sentinel values) are repeated in the output mask&period;
| xref:llvm/needConversion.adoc[`needConversion`] 
| 
| xref:llvm/needsComdatForCounter.adoc[`needsComdatForCounter`] 
| Check if we can use Comdat for profile variables&period; This will eliminate the duplicated profile variables for Comdat functions&period;
| xref:llvm/needsParamAccessSummary.adoc[`needsParamAccessSummary`] 
| 
| xref:llvm/neg.adoc[`neg`] 
| Returns the negated value of the argument&period;
| xref:llvm/next_nodbg.adoc[`next&lowbar;nodbg`] 
| Increment `It,` then continue incrementing it while it points to a debug instruction&period; A replacement for std&colon;&colon;next&period;
| xref:llvm/nodes.adoc[`nodes`] 
| Return a range over all nodes of graph `G&period;`
| xref:llvm/nonMicrosoftDemangle.adoc[`nonMicrosoftDemangle`] 
| 
| xref:llvm/nonStrictlyPostDominate.adoc[`nonStrictlyPostDominate`] 
| In case that two BBs `ThisBlock` and `OtherBlock` are control flow equivalent but they do not strictly dominate and post&hyphen;dominate each other, we determine if `ThisBlock` is reached after `OtherBlock` in the control flow&period;
| xref:llvm/none_of.adoc[`none&lowbar;of`] 
| Provide wrappers to std&colon;&colon;none&lowbar;of which take ranges instead of having to pass begin&sol;end explicitly&period;
| xref:llvm/normalizeForPostIncUse.adoc[`normalizeForPostIncUse`] 
| Normalize `S` to be post&hyphen;increment for all loops present in `Loops&period;` Returns nullptr if the result is not invertible and `CheckInvertible` is true&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`] 
| Functor variant of std&colon;&colon;not&lowbar;equal&lowbar;to that can be used as a UnaryPredicate in functional algorithms like all&lowbar;of&period; `Args` is forwarded and stored by value&period; If you would like to pass by reference, use `std&colon;&colon;ref` or `std&colon;&colon;cref`&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;`] 
| Returns `A` divided by `B&period;`
| 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;`] 
| Right shift operator
| 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; Return true if anything changed&period;
| xref:llvm/optimized_def_chain.adoc[`optimized&lowbar;def&lowbar;chain`] 
| 
| xref:llvm/orderedStrictlyGreater.adoc[`orderedStrictlyGreater`] 
| Returns all FPClasses which are greater than all values in `Mask` That is, return all classes for which the comparison `fcmp ole LHS, RHS` will always return false&period; Ignores nan and treats the sign of the zeroes as ordered&period;
| xref:llvm/orderedStrictlyLess.adoc[`orderedStrictlyLess`] 
| Returns all FPClasses which are less than all values in `Mask` That is, return all classes for which the comparison `fcmp ole LHS, RHS` will always return false&period; Ignores nan and treats the sign of the zeroes as ordered&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`] 
| This utility template takes care of adding require&lt;&gt; and invalidate&lt;&gt; passes for an analysis to a given `PassManager&period;` It is intended to be used during parsing of a pass pipeline when parsing a single PipelineName&period; When registering a new function analysis FancyAnalysis with the pass pipeline name &quot;fancy&hyphen;analysis&quot;, a matching ParsePipelineCallback could look like this&colon;
| 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`] 
| parseAssemblyFile and parseAssemblyString are wrappers around this function&period; Parse LLVM Assembly from a MemoryBuffer&period;
| xref:llvm/parseAssemblyFile.adoc[`parseAssemblyFile`] 
| This function is a main interface to the LLVM Assembly Parser&period; It parses an ASCII file that (presumably) contains LLVM Assembly code&period; It returns a Module (intermediate representation) with the corresponding features&period; Note that this does not verify that the generated Module is valid, so you should run the verifier after parsing the file to check that it is okay&period; Parse LLVM Assembly from a file
| xref:llvm/parseAssemblyFileWithIndex.adoc[`parseAssemblyFileWithIndex`] 
| This function is a main interface to the LLVM Assembly Parser&period; It parses an ASCII file that (presumably) contains LLVM Assembly code, including a module summary&period; It returns a Module (intermediate representation) and a ModuleSummaryIndex with the corresponding features&period; Note that this does not verify that the generated Module or Index are valid, so you should run the verifier after parsing the file to check that they are okay&period; Parse LLVM Assembly from a file
| xref:llvm/parseAssemblyFileWithIndexNoUpgradeDebugInfo.adoc[`parseAssemblyFileWithIndexNoUpgradeDebugInfo`] 
| Only for use in llvm&hyphen;as for testing&semi; this does not produce a valid module&period;
| xref:llvm/parseAssemblyInto.adoc[`parseAssemblyInto`] 
| This function is the low&hyphen;level interface to the LLVM Assembly Parser&period; This is kept as an independent function instead of being inlined into parseAssembly for the convenience of interactive users that want to add recently parsed bits to an existing module&period;
| xref:llvm/parseAssemblyString.adoc[`parseAssemblyString`] 
| The function is a secondary interface to the LLVM Assembly Parser&period; It parses an ASCII string that (presumably) contains LLVM Assembly code&period; It returns a Module (intermediate representation) with the corresponding features&period; Note that this does not verify that the generated Module is valid, so you should run the verifier after parsing the file to check that it is okay&period; Parse LLVM Assembly from a string
| 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, the inverse of getAtomicScopeIRString&period; Returns the scope and whether it is the single address space variant&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; Defaults are taken from a default constructed CachePruningPolicy object&period; For example&colon; &quot;prune&lowbar;interval&equals;30s&colon;prune&lowbar;after&equals;24h&colon;cache&lowbar;size&equals;50%&quot; which means a pruning interval of 30 seconds, expiration time of 24 hours and maximum cache size of 50% of available disk space&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`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/parseMDNode.adoc[`parseMDNode`] 
| 
| 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`] 
| 
| xref:llvm/parseModule.adoc[`parseModule`] 
| Fuzzer friendly interface for the llvm bitcode parser&period;
| xref:llvm/parseNamedRegisterReference.adoc[`parseNamedRegisterReference`] 
| 
| xref:llvm/parsePrefetchTarget.adoc[`parsePrefetchTarget`] 
| 
| xref:llvm/parseRegisterReference.adoc[`parseRegisterReference`] 
| 
| xref:llvm/parseStackObjectReference.adoc[`parseStackObjectReference`] 
| 
| 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`] 
| This function is a main interface to the LLVM Assembly Parser&period; It parses an ASCII file that (presumably) contains LLVM Assembly code for a module summary&period; It returns a ModuleSummaryIndex with the corresponding features&period; Note that this does not verify that the generated Index is valid, so you should run the verifier after parsing the file to check that it is okay&period; Parse LLVM Assembly Index from a file
| xref:llvm/parseSummaryIndexAssemblyString.adoc[`parseSummaryIndexAssemblyString`] 
| The function is a secondary interface to the LLVM Assembly Parser&period; It parses an ASCII string that (presumably) contains LLVM Assembly code for a module summary&period; It returns a a ModuleSummaryIndex with the corresponding features&period; Note that this does not verify that the generated Index is valid, so you should run the verifier after parsing the file to check that it is okay&period; Parse LLVM Assembly from a string
| xref:llvm/parseType.adoc[`parseType`] 
| Parse a type in the given string&period;
| xref:llvm/parseTypeAtBeginning.adoc[`parseTypeAtBeginning`] 
| Parse a string `Asm` that starts with a type&period; `Read&lsqb;out&rsqb;` gives the number of characters that have been read to parse the type in `Asm&period;`
| xref:llvm/parseVirtualRegisterReference.adoc[`parseVirtualRegisterReference`] 
| 
| xref:llvm/parseWidenableBranch-01.adoc[`parseWidenableBranch`] 
| `parseWidenableBranch` overloads
| xref:llvm/parseWidenableGuard.adoc[`parseWidenableGuard`] 
| 
| xref:llvm/partition.adoc[`partition`] 
| Provide wrappers to std&colon;&colon;partition which take ranges instead of having to pass begin&sol;end explicitly&period;
| xref:llvm/partition_point.adoc[`partition&lowbar;point`] 
| Binary search for the first iterator in a range where a predicate is false&period; Requires that C is always true below some limit, and always false above it&period;
| xref:llvm/patchReplacementInstruction.adoc[`patchReplacementInstruction`] 
| Patch the replacement so that it is not more restrictive than the value being replaced&period; It assumes that the replacement does not get moved from its original position&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, returning the source vector operand of `V,` as long as `V` is an INSERT&lowbar;VECTOR&lowbar;ELT operation that do not insert into any of the demanded vector elts&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 source operand of `V` if it exists and `V` has a single use&period; If `V` is not a single&hyphen;use freeze, it is returned as&hyphen;is&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`] 
| VMap is the value&hyphen;map that maps instructions from the original loop to instructions in the last peeled&hyphen;off iteration&period; If `PeelLast` is true, peel off the last `PeelCount` iterations from `L` (canPeelLastIteration must be true for `L),` otherwise peel off the first `PeelCount` iterations&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`] 
| Given a mask vector of the form &lt;Y x i1&gt;, return an APInt (of bitwidth Y) for each lane which may be active&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`] 
| 
| xref:llvm/pred_empty.adoc[`pred&lowbar;empty`] 
| 
| xref:llvm/pred_end-0bf.adoc[`pred&lowbar;end`] 
| 
| xref:llvm/pred_size-01b.adoc[`pred&lowbar;size`] 
| Get the number of predecessors of `BB&period;` This is a linear time operation&period; Use xref:llvm/BasicBlock/hasNPredecessors.adoc[`BasicBlock&colon;&colon;hasNPredecessors()`] or hasNPredecessorsOrMore if able&period;
| xref:llvm/predecessors-01.adoc[`predecessors`] 
| 
| 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`] 
| Modify `M` to prepare it for dynamic debugging before running optimizations&period; Return a clone of the module which references global values in `M&period;` The names of the cloned function definitions in this module are prefixed with “&lowbar;&lowbar;dyndbg&period;”&period;
| xref:llvm/prepareTempFiles.adoc[`prepareTempFiles`] 
| 
| xref:llvm/prettyPrintRegisterOp.adoc[`prettyPrintRegisterOp`] 
| Pretty print a register opcode and operands&period;
| xref:llvm/prev_nodbg.adoc[`prev&lowbar;nodbg`] 
| Decrement `It,` then continue decrementing it while it points to a debug instruction&period; A replacement for std&colon;&colon;prev&period;
| xref:llvm/printAfterPasses.adoc[`printAfterPasses`] 
| 
| 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`] 
| 
| 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&sol;
| xref:llvm/printDwarfExpressionCompact.adoc[`printDwarfExpressionCompact`] 
| Print the expression in a format intended to be compact and useful to a user, but not perfectly unambiguous, or capable of representing every valid DWARF expression&period; Returns true if the expression was sucessfully printed&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`] 
| 
| xref:llvm/printGraphForFunction.adoc[`printGraphForFunction`] 
| 
| xref:llvm/printHTMLEscaped.adoc[`printHTMLEscaped`] 
| Print each character of the specified string, escaping HTML special characters&period;
| xref:llvm/printIRUnitNameForStackTrace-07.adoc[`printIRUnitNameForStackTrace`] 
| 
| 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`] 
| printLowerCase &hyphen; Print each character as lowercase if it is uppercase&period;
| xref:llvm/printMBBReference.adoc[`printMBBReference`] 
| Prints a machine basic block reference&period;
| xref:llvm/printMIR-06.adoc[`printMIR`] 
| `printMIR` overloads
| xref:llvm/printPercentEncoded.adoc[`printPercentEncoded`] 
| Print each character of `String` percent&hyphen;encoded for use as a URL query&hyphen;component value (RFC 3986)&colon; unreserved characters (ALPHA, DIGIT, &apos;&hyphen;&apos; &apos;&lowbar;&apos; &apos;&period;&apos; &apos;&#126;&apos;) are written directly&semi; every other byte becomes an uppercase %XX escape&period; Operates on raw bytes, so UTF&hyphen;8 round&hyphen;trips&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`] 
| 
| 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`] 
| Splits and processes shuffle mask depending on the number of input and output registers&period; The function does 2 main things&colon; 1) splits the source&sol;destination vectors into real registers&semi; 2) do the mask analysis to identify which real registers are permuted&period; Then the function processes resulting registers mask using provided action items&period; If no input register is defined, `NoInputAction` action is used&period; If only 1 input register is used, `SingleInputAction` is used, otherwise `ManyInputsAction` is used to process &gt; 2 input registers and masks&period;
| xref:llvm/product_of.adoc[`product&lowbar;of`] 
| Returns the product of all values in `Range` with `Init` initial value&period; The default initial value is 1&period;
| xref:llvm/programUndefinedIfPoison.adoc[`programUndefinedIfPoison`] 
| 
| 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`] 
| Promote the given indirect call site to conditionally call `Callee&period;` The promoted direct call instruction is predicated on &grave;CB&period;getCalledOperand() &equals;&equals; Callee&grave;&period;
| 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`] 
| Try to promote memory values to scalars by sinking stores out of the loop and moving loads to before the loop&period; We do this by looping over the stores in the loop, looking for stores to Must pointers which are loop invariant&period; It takes a set of must&hyphen;alias values, Loop exit blocks vector, loop exit blocks insertion point vector, PredIteratorCache, LoopInfo, DominatorTree, Loop, AliasSet information for all instructions of the loop and loop safety information as arguments&period; Diagnostics is emitted via `ORE&period;` It returns changed status&period; `AllowSpeculation` is whether values should be hoisted even if they are not guaranteed to execute in the loop, but are safe to speculatively execute&period;
| xref:llvm/propagateIRFlags.adoc[`propagateIRFlags`] 
| Get the intersection (logical and) of all of the potential IR flags of each scalar operation (VL) that will be converted into a vector (I)&period; If OpValue is non&hyphen;null, we only consider operations similar to OpValue when intersecting&period; Flag set&colon; NSW, NUW (if IncludeWrapFlags is true), exact, and all of fast&hyphen;math&period;
| xref:llvm/propagateMetadata.adoc[`propagateMetadata`] 
| Specifically, let Kinds &equals; &lsqb;MD&lowbar;tbaa, MD&lowbar;alias&lowbar;scope, MD&lowbar;noalias, MD&lowbar;fpmath,&rsqb; MD&lowbar;nontemporal, MD&lowbar;access&lowbar;group, MD&lowbar;mmra&rsqb;&period; For K in Kinds, we get the MDNode for K from each of the elements of VL, compute their &quot;intersection&quot; (i&period;e&period;, the most generic metadata value that covers all of the individual values), and set I&apos;s metadata for M equal to the intersection value&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`] 
| Returns the size of the `Range,` i&period;e&period;, the number of elements&period; This implementation takes inspiration from `std&colon;&colon;ranges&colon;&colon;size` from C&plus;&plus;20 and delegates the size check to `adl&lowbar;size` or `std&colon;&colon;distance`, in this order of preference&period; Unlike `llvm&colon;&colon;size`, this function does _not_ guarantee O(1) running time, and is intended to be used in generic code that does not know the exact range type&period;
| xref:llvm/readAbbrevAttribute.adoc[`readAbbrevAttribute`] 
| Read the next (attribute, form) specification from an abbreviation declaration at `Offset,` advancing `Offset` past it&period; `ImplicitConst` is set to the inline value of a DW&lowbar;FORM&lowbar;implicit&lowbar;const attribute and to std&colon;&colon;nullopt otherwise&period; Returns false on the terminating (0, 0) pair&period;
| xref:llvm/readAndDecodeStrings.adoc[`readAndDecodeStrings`] 
| `NameStrings` is a string composed of one or more possibly encoded sub&hyphen;strings&period; The substrings are separated by `01` (returned by InstrProf&period;h&colon;getInstrProfNameSeparator)&period; This method decodes the string and calls `NameCallback` for each substring&period;
| xref:llvm/readModuleSummaryIndex.adoc[`readModuleSummaryIndex`] 
| Parse the specified bitcode buffer and merge the index into CombinedIndex&period;
| xref:llvm/readWideAPInt.adoc[`readWideAPInt`] 
| 
| xref:llvm/recognizeBSwapOrBitReverseIdiom.adoc[`recognizeBSwapOrBitReverseIdiom`] 
| Try to match a bswap or bitreverse idiom&period;
| xref:llvm/recomputeLTOCacheKey.adoc[`recomputeLTOCacheKey`] 
| Recomputes the LTO cache key for a given key with an extra identifier&period;
| xref:llvm/recomputeLivenessFlags.adoc[`recomputeLivenessFlags`] 
| Recomputes dead and kill flags in `MBB&period;`
| xref:llvm/registerCodeGenCallback.adoc[`registerCodeGenCallback`] 
| 
| xref:llvm/remapDebugVariable.adoc[`remapDebugVariable`] 
| Remap the operands of the debug records attached to `Inst,` and the operands of `Inst` itself if it&apos;s a debug intrinsic&period;
| xref:llvm/remapInstructionsInBlocks.adoc[`remapInstructionsInBlocks`] 
| Remaps instructions in `Blocks` using the mapping in `VMap&period;`
| xref:llvm/removeASanIncompatibleFnAttributes.adoc[`removeASanIncompatibleFnAttributes`] 
| Remove memory attributes that are incompatible with the instrumentation added by AddressSanitizer and HWAddressSanitizer&period; `ReadsArgMem` &hyphen; indicates whether function arguments may be read by instrumentation and require removing `writeonly` attributes&period;
| xref:llvm/removeAllNonTerminatorAndEHPadInstructions.adoc[`removeAllNonTerminatorAndEHPadInstructions`] 
| Remove all instructions from a basic block other than its terminator and any present EH pad instructions&period; Returns the number of instructions that have been removed&period;
| xref:llvm/removeFromUsedLists.adoc[`removeFromUsedLists`] 
| Removes global values from the llvm&period;used and llvm&period;compiler&period;used arrays&period; `ShouldRemove` should return true for any initializer field that should not be included in the replacement global&period;
| xref:llvm/removeUnreachableBlocks.adoc[`removeUnreachableBlocks`] 
| Remove all blocks that can not be reached from the function&apos;s entry&period; When `FoldInstsToUnreachable` is true, it will also convert obviously unreachable instructions into unreachable (e&period;g, store to null)&period;
| xref:llvm/removeUnwindEdge.adoc[`removeUnwindEdge`] 
| Replace &apos;BB&apos;s terminator with one that does not have an unwind successor block&period; Rewrites `invoke` to `call`, etc&period; Updates any PHIs in unwind successor&period; Returns the instruction that replaced the original terminator, which might be a call in case the original terminator was an invoke&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`] 
| Provide wrappers to std&colon;&colon;remove&lowbar;if which take ranges instead of having to pass begin&sol;end explicitly&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`] 
| Point debug users of `From` to `To` or salvage them&period; Use this function only when replacing all uses of `From` with `To,` with a guarantee that `From` is going to 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`] 
| Replaces dbg&period;declare record when the address it describes is replaced with a new value&period; If Deref is true, an additional DW&lowbar;OP&lowbar;deref is prepended to the expression&period; If Offset is non&hyphen;zero, a constant displacement is added to the expression (between the optional Deref operations)&period; Offset can be negative&period;
| xref:llvm/replaceDbgValueForAlloca.adoc[`replaceDbgValueForAlloca`] 
| Replaces multiple dbg&period;value records when the alloca it describes is replaced with a new value&period; If Offset is non&hyphen;zero, a constant displacement is added to the expression (after the mandatory Deref)&period; Offset can be negative&period; New dbg&period;value records are inserted at the locations of the instructions they replace&period;
| xref:llvm/replaceDominatedUsesWith-05.adoc[`replaceDominatedUsesWith`] 
| `replaceDominatedUsesWith` overloads
| xref:llvm/replaceDominatedUsesWithIf-05.adoc[`replaceDominatedUsesWithIf`] 
| `replaceDominatedUsesWithIf` overloads
| xref:llvm/replaceNonLocalUsesWith.adoc[`replaceNonLocalUsesWith`] 
| 
| 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`] 
| Provide wrappers to std&colon;&colon;replace&lowbar;copy which take ranges instead of having to pass begin&sol;end explicitly&period;
| xref:llvm/replace_copy_if.adoc[`replace&lowbar;copy&lowbar;if`] 
| Provide wrappers to std&colon;&colon;replace&lowbar;copy&lowbar;if which take ranges instead of having to pass begin&sol;end explicitly&period;
| xref:llvm/reportAndResetTimings.adoc[`reportAndResetTimings`] 
| If &hyphen;time&hyphen;passes has been specified, report the timings immediately and then reset the timers to zero&period; By default it uses the stream created by CreateInfoOutputFile()&period;
| xref:llvm/reportChangedIR.adoc[`reportChangedIR`] 
| 
| 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`] 
| Report an ISel error as a missed optimization remark to the LLVMContext&apos;s diagnostic stream&period; Set the FailedISel MachineFunction property&period;
| 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]#
| Reports a bad alloc error, calling any user defined bad alloc error handler&period; In contrast to the generic &apos;report&lowbar;fatal&lowbar;error&apos; functions, this function might not terminate, e&period;g&period; the user defined error handler throws an exception, but it won&apos;t return&period;
| xref:llvm/report_fatal_error-09.adoc[`report&lowbar;fatal&lowbar;error`]  [.small]#[noreturn]#
| 
| 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`] 
| 
| 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;` The collection is iterated in reverse if `ShouldReverse` is true (otherwise, it is iterated forwards)&period;
| xref:llvm/rewriteLoopExitValues.adoc[`rewriteLoopExitValues`] 
| If the final value of any expressions that are recurrent in the loop can be computed, substitute the exit values from the loop into any instructions outside of the loop that use the final values of the current expressions&period; Return the number of loop exit values that have been replaced, and the corresponding phi node will be added to DeadInsts&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`] 
| Runs Fn on a new stack of at least the given size&period;
| xref:llvm/runWholeProgramDevirtOnIndex.adoc[`runWholeProgramDevirtOnIndex`] 
| Perform index&hyphen;based whole program devirtualization on the `Summary` index&period; Any devirtualized targets used by a type test in another module are added to the `ExportedGUIDs` set&period; For any local devirtualized targets only used within the defining module, the information necessary for locating the corresponding WPD resolution is recorded for the ValueInfo in case it is exported by cross module importing (in which case the devirtualized target name will need adjustment)&period;
| xref:llvm/rustDemangle.adoc[`rustDemangle`] 
| 
| 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 only the records in `DbgRecords` instead of finding every debug user of `I&period;` Every record must be a debug user of the instruction&period;
| xref:llvm/salvageDebugInfoImpl.adoc[`salvageDebugInfoImpl`] 
| Given an instruction `I` and DIExpression `DIExpr` operating on it, append the effects of `I` to the DIExpression operand list `Ops,` or return `nullptr` if it cannot be salvaged&period; `CurrentLocOps` is the number of SSA values referenced by the incoming `Ops&period;`
| xref:llvm/salvageKnowledge.adoc[`salvageKnowledge`] 
| Calls BuildAssumeFromInst and if the resulting llvm&period;assume is valid insert if before I&period; This is usually what need to be done to salvage the knowledge contained in the instruction I&period; The AssumptionCache must be provided if it is available or the cache may become silently be invalid&period; The DominatorTree can optionally be provided to enable cross&hyphen;block reasoning&period; This returns if a change was made&period;
| xref:llvm/sampleprof_category.adoc[`sampleprof&lowbar;category`] 
| 
| xref:llvm/saveUsesAndErase.adoc[`saveUsesAndErase`] 
| 
| 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`] 
| Attempt to narrow&sol;widen the `Mask` shuffle mask to the `NumDstElts` target width&period; Internally this will call narrowShuffleMaskElts&sol;widenShuffleMaskElts&period; This will assert unless NumDstElts is a multiple of Mask&period;size (or vice&hyphen;versa)&period; Returns false on failure, and ScaledMask will be in an undefined state&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`] 
| Iterate over an integral type from Begin to End inclusive&period; Note&colon; Begin and End values have to be within &lsqb;INTMAX&lowbar;MIN, INTMAX&lowbar;MAX &hyphen; 1&rsqb; for forward iteration (resp&period; &lsqb;INTMAX&lowbar;MIN &plus; 1, INTMAX&lowbar;MAX &hyphen; 1&rsqb;for reverse iteration)&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`] 
| A helper function that sets an atomic operation&apos;s sync scope&period;
| xref:llvm/setBranchProbability.adoc[`setBranchProbability`] 
| Set branch weight metadata for `B` to indicate that `P` and `1 &hyphen; P` are the probabilities of control flowing to its first and second target labels, respectively, or vice&hyphen;versa if `ForFirstTarget` is false&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`] 
| setCurrentDebugType &hyphen; Set the current debug type, as if the &hyphen;debug&hyphen;only&equals;X option were specified&period; Note that DebugFlag also needs to be set to true for debug output to be produced&period; The debug type format is &quot;type&lsqb;&colon;level&rsqb;&quot;, where the level is an optional integer&period; If a level is provided, the debug output is enabled only if the user specified a level at least as high as the provided level&period; 0 is a special level that acts as an opt&hyphen;out for this specific debug type without affecting the other debug output&period;
| xref:llvm/setCurrentDebugTypes.adoc[`setCurrentDebugTypes`] 
| setCurrentDebugTypes &hyphen; Set the current debug type, as if the &hyphen;debug&hyphen;only&equals;X,Y,Z option were specified&period; Note that DebugFlag also needs to be set to true for debug output to be produced&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 the branch weights for this terminator cannot be known at compile time&period; This should only be called by passes, and never as a default behavior in e&period;g&period; MDBuilder&period; The goal is to use this info to validate passes do not accidentally drop profile info, and this API is called in cases where the pass explicitly cannot provide that info&period; Defaulting it in would hide bugs where the pass forgets to transfer over or otherwise specify profile info&period; Use `PassName` to capture the pass name (i&period;e&period; DEBUG&lowbar;TYPE) for debuggability&period;
| xref:llvm/setExplicitlyUnknownBranchWeightsIfProfiled.adoc[`setExplicitlyUnknownBranchWeightsIfProfiled`] 
| Like setExplicitlyUnknownBranchWeights(&period;&period;&period;), but only sets unknown branch weights in the new instruction if the parent function of the original instruction has an entry count&period; This is to not confuse users by injecting profile data into non&hyphen;profiled functions&period; If `F` is nullptr, we will fetch the function from `I&period;`
| xref:llvm/setExplicitlyUnknownFunctionEntryCount.adoc[`setExplicitlyUnknownFunctionEntryCount`] 
| Analogous to setExplicitlyUnknownBranchWeights, but for functions and their entry counts&period;
| xref:llvm/setFileTag.adoc[`setFileTag`] 
| 
| 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`] 
| 
| xref:llvm/setInlineRemark.adoc[`setInlineRemark`] 
| Set the inline&hyphen;remark attribute&period;
| xref:llvm/setIrrLoopHeaderMetadata.adoc[`setIrrLoopHeaderMetadata`] 
| 
| xref:llvm/setKCFIType.adoc[`setKCFIType`] 
| Sets the KCFI type for the function&period; Used for compiler&hyphen;generated functions that are indirectly called in instrumented code&period;
| xref:llvm/setLoadStoreAlignment.adoc[`setLoadStoreAlignment`] 
| A helper function that set the alignment of load or store instruction&period;
| xref:llvm/setLoopEstimatedTripCount.adoc[`setLoopEstimatedTripCount`] 
| Set `llvm&period;loop&period;estimated&lowbar;trip&lowbar;count` with the value `EstimatedTripCount` in the loop metadata of `L&period;` Return false if the implementation is unable to handle the loop form of `L` (e&period;g&period;, `L` must have a latch block that controls the loop exit)&period; Otherwise, return true&period;
| xref:llvm/setLoopProbability.adoc[`setLoopProbability`] 
| Set branch weight metadata for the latch of `L` to indicate that, at the end of any iteration, `P` and `1 &hyphen; P` are the probabilities of starting another iteration and exiting the loop, respectively&period; Return false if the implementation is unable to handle the loop form of `L` (e&period;g&period;, `L` must have a latch block that controls the loop exit)&period; Otherwise, return true&period;
| xref:llvm/setProbeDistributionFactor.adoc[`setProbeDistributionFactor`] 
| 
| xref:llvm/setProfMetadata.adoc[`setProfMetadata`] 
| 
| xref:llvm/setUnwindEdgeTo.adoc[`setUnwindEdgeTo`] 
| Sets the unwind edge of an instruction to a particular successor&period;
| xref:llvm/setWidenableBranchCond.adoc[`setWidenableBranchCond`] 
| Given a branch we know is widenable (defined per Analysis&sol;GuardUtils&period;h), _set_ it&apos;s condition such that (only) &apos;Cond&apos; is known to hold on the taken path and that the branch remains widenable after transform&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`] 
| set&lowbar;intersect(A, B) &hyphen; Compute A &colon;&equals; A &circ; B Identical to set&lowbar;intersection, except that it works on set&lt;&gt;&apos;s and is nicer to use&period; Functionally, this iterates through S1, removing elements that are not contained in S2&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; Setting a thread&apos;s name can be helpful for enabling useful diagnostics under a debugger or when logging&period; The level of support for setting a thread&apos;s name varies wildly across operating systems, and we only make a best effort to perform the operation on supported platforms&period; No indication of success or failure is returned&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`] 
| 
| xref:llvm/setupModuleAsmPrinter.adoc[`setupModuleAsmPrinter`] 
| 
| xref:llvm/shouldFuncOptimizeForSizeImpl.adoc[`shouldFuncOptimizeForSizeImpl`] 
| 
| xref:llvm/shouldInline.adoc[`shouldInline`] 
| Return the cost only if the inliner should attempt to inline at the given CallSite&period; If we return the cost, we will emit an optimisation remark later using that cost, so we won&apos;t do so from this function&period; Return std&colon;&colon;nullopt if inlining should not be attempted&period;
| xref:llvm/shouldOptimizeForSize-00.adoc[`shouldOptimizeForSize`] 
| `shouldOptimizeForSize` overloads
| xref:llvm/shouldOptimizeForSizeImpl.adoc[`shouldOptimizeForSizeImpl`] 
| 
| xref:llvm/shouldPrintAfterAll.adoc[`shouldPrintAfterAll`] 
| 
| xref:llvm/shouldPrintAfterPass.adoc[`shouldPrintAfterPass`] 
| 
| xref:llvm/shouldPrintAfterSomePass.adoc[`shouldPrintAfterSomePass`] 
| 
| xref:llvm/shouldPrintBeforeAll.adoc[`shouldPrintBeforeAll`] 
| 
| xref:llvm/shouldPrintBeforePass.adoc[`shouldPrintBeforePass`] 
| 
| xref:llvm/shouldPrintBeforeSomePass.adoc[`shouldPrintBeforeSomePass`] 
| 
| 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`] 
| 
| 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; Returns a simplified result or null&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; In contrast to simplifyFMulInst, this function will not perform simplifications whose unrounded results differ when rounded to the argument type&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; If not, this returns null&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; If not, return null&period;
| xref:llvm/simplifyInstructionWithOperands.adoc[`simplifyInstructionWithOperands`] 
| Like `simplifyInstruction` but the operands of `I` are replaced with `NewOps&period;` Returns a simplified value, or null if none was found&period;
| xref:llvm/simplifyIntrinsic.adoc[`simplifyIntrinsic`] 
| Given operands for an intrinsic, fold the result or return null&period; Context Function is passed as `CxtF&period;` `ExBehavior` and `Rounding` only apply to constrained FP intrinsics&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`] 
| 
| xref:llvm/simplifyLoopIVs.adoc[`simplifyLoopIVs`] 
| SimplifyLoopIVs &hyphen; Simplify users of induction variables within this loop&period; This does not actually change or add IVs&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; See class ShuffleVectorInst for a description of the mask representation&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`] 
| simplifyUsersOfIV &hyphen; Simplify instructions that use this induction variable by using ScalarEvolution to analyze the IV&apos;s recurrence&period; Returns a pair where the first entry indicates that the function makes changes and the second entry indicates that it introduced new opportunities for loop unswitching&period;
| xref:llvm/simplifyWithOpReplaced.adoc[`simplifyWithOpReplaced`] 
| See if V simplifies when its operand Op is replaced with RepOp&period; If not, return null&period; AllowRefinement specifies whether the simplification can be a refinement (e&period;g&period; 0 instead of poison), or whether it needs to be strictly identical&period; Op and RepOp can be assumed to not be poison when determining refinement&period;
| xref:llvm/simplifyXorInst.adoc[`simplifyXorInst`] 
| Given operands for an Xor, fold the result or return null&period;
| xref:llvm/sinkRegion.adoc[`sinkRegion`] 
| Walk the specified region of the CFG (defined by all blocks dominated by the specified block, and that are in the current loop) in reverse depth first order w&period;r&period;t the DominatorTree&period; This allows us to visit uses before definitions, allowing us to sink a loop body in one pass without iteration&period; Takes DomTreeNode, AAResults, LoopInfo, DominatorTree, TargetLibraryInfo, Loop, AliasSet information for all instructions of the loop and loop safety information as arguments&period; Diagnostics is emitted via `ORE&period;` It returns changed status&period; `CurLoop` is a loop to do sinking on&period; `OutermostLoop` is used only when this function is called by `sinkRegionForLoopNest&period;`
| xref:llvm/sinkRegionForLoopNest.adoc[`sinkRegionForLoopNest`] 
| Call sinkRegion on loops contained within the specified loop in order from innermost to outermost&period;
| xref:llvm/size.adoc[`size`] 
| Get the size of a range&period; This is a wrapper function around std&colon;&colon;distance which is only enabled when the operation is O(1)&period;
| xref:llvm/skipDebugInstructionsBackward.adoc[`skipDebugInstructionsBackward`] 
| Decrement `It` until it points to a non&hyphen;debug instruction or to `Begin` and return the resulting iterator&period; This function should only be used MachineBasicBlock&colon;&colon;&lcub;iterator, const&lowbar;iterator, instr&lowbar;iterator, const&lowbar;instr&lowbar;iterator&rcub; and the respective reverse iterators&period;
| xref:llvm/skipDebugInstructionsForward.adoc[`skipDebugInstructionsForward`] 
| Increment `It` until it points to a non&hyphen;debug instruction or to `End` and return the resulting iterator&period; This function should only be used MachineBasicBlock&colon;&colon;&lcub;iterator, const&lowbar;iterator, instr&lowbar;iterator, const&lowbar;instr&lowbar;iterator&rcub; and the respective reverse iterators&period;
| xref:llvm/skipDebugIntrinsics.adoc[`skipDebugIntrinsics`] 
| Advance `It` while it points to a debug instruction and return the result&period; This assumes that `It` is not at the end of a block&period;
| xref:llvm/sort-049.adoc[`sort`] 
| `sort` overloads
| xref:llvm/sortBasicBlocksAndUpdateBranches.adoc[`sortBasicBlocksAndUpdateBranches`] 
| 
| 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`] 
| Like splitBB, but reuses the current block&apos;s name for the new name&period;
| xref:llvm/splitBlockBefore-00.adoc[`splitBlockBefore`] 
| Split the specified block at the specified instruction `SplitPt&period;` All instructions before `SplitPt` are moved to a new block and all instructions after `SplitPt` stay in the old block&period; The new block and the old block are joined by inserting an unconditional branch to the end of the new block&period; The new block with name `BBName` is returned&period;
| xref:llvm/splitModuleTransitiveFromEntryPoints.adoc[`splitModuleTransitiveFromEntryPoints`] 
| Splits the given module `M` into parts&period; Each output part is passed to `Callback` for further possible processing&period; Each part corresponds to a subset of the module that is transitively reachable from some entry point group&period; Each entry point group is defined by `EntryPointCategorizer` (EPC) as follows&colon; 1) If the function is not an entry point, then the Categorizer returns std&colon;&colon;nullopt&period; Therefore, the function doesn&apos;t belong to any group&period; However, the function and global objects can still be associated with some output parts if they are transitively used from some entry points&period; 2) If the function belongs to an entry point group, then EPC returns an integer which is an identifier of the group&period; If two entry points belong to one group, then EPC returns the same identifier for both of them&period;
| xref:llvm/stableHashValue-032.adoc[`stableHashValue`] 
| 
| 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`] 
| 
| xref:llvm/stripDebugifyMetadata.adoc[`stripDebugifyMetadata`] 
| Strip out all of the metadata and debug info inserted by debugify&period; If no llvm&period;debugify module&hyphen;level named metadata is present, this is a no&hyphen;op&period; Returns true if any change was made&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`] 
| Returns the inner value X if the expression has the form f(X) where f(X) &equals;&equals; 0 if and only if X &equals;&equals; 0, otherwise returns nullptr&period;
| xref:llvm/succ_begin-0f7.adoc[`succ&lowbar;begin`] 
| 
| xref:llvm/succ_empty-04.adoc[`succ&lowbar;empty`] 
| 
| xref:llvm/succ_end-05.adoc[`succ&lowbar;end`] 
| 
| xref:llvm/succ_size-05.adoc[`succ&lowbar;size`] 
| 
| 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`] 
| 
| xref:llvm/sum_of.adoc[`sum&lowbar;of`] 
| Returns the sum of all values in `Range` with `Init` initial value&period; The default initial value is 0&period;
| xref:llvm/swap-048.adoc[`swap`] 
| Exchange owned storage and hash state between `LHS` and `RHS&period;`
| xref:llvm/tensorValueToString.adoc[`tensorValueToString`] 
| For debugging&period;
| xref:llvm/thinLTOFinalizeInModule.adoc[`thinLTOFinalizeInModule`] 
| Based on the information recorded in the summaries during global summary&hyphen;based analysis&colon; 1&period; Resolve prevailing symbol linkages and constrain visibility (CanAutoHide and consider visibility from other definitions for ELF) in `TheModule` 2&period; (optional) Apply propagated function attributes to `TheModule` if PropagateAttrs is true
| xref:llvm/thinLTOInternalizeAndPromoteInIndex.adoc[`thinLTOInternalizeAndPromoteInIndex`] 
| Update the linkages in the given `Index` to mark exported values as external and non&hyphen;exported values as internal&period; The ThinLTO backends must apply the changes to the Module via thinLTOInternalizeModule&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;` Linkage changes recorded in the index and the ThinLTO backends must apply the changes to the module via thinLTOFinalizeInModule&period;
| xref:llvm/timeTraceAddInstantEvent.adoc[`timeTraceAddInstantEvent`] 
| 
| xref:llvm/timeTraceAsyncProfilerBegin.adoc[`timeTraceAsyncProfilerBegin`] 
| Manually begin a time section, with the given `Name` and `Detail&period;` This starts Async Events having `Name` as a category which is shown separately from other traces&period; See https&colon;&sol;&sol;docs&period;google&period;com&sol;document&sol;d&sol;1CvAClvFfyA5R&hyphen;PhYUmn5OOQtYMH4h6I0nSsKchNAySU&sol;preview&num;heading&equals;h&period;jh64i9l3vwa1 for more details&period;
| xref:llvm/timeTraceProfilerBegin-09.adoc[`timeTraceProfilerBegin`] 
| Manually begin a time section, with the given `Name` and `Detail&period;` Profiler copies the string data, so the pointers can be given into temporaries&period; Time sections can be hierarchical&semi; every Begin must have a matching End pair but they can nest&period;
| 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`] 
| Manually end the last time section&period;
| 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; This sets up the global `TimeTraceProfilerInstance` variable to be the profiler instance&period;
| xref:llvm/timeTraceProfilerWrite-04.adoc[`timeTraceProfilerWrite`] 
| `timeTraceProfilerWrite` overloads
| xref:llvm/toCABI.adoc[`toCABI`] 
| 
| 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`] 
| A helper for converting structs of vector types to structs of scalar types&period; Note&colon; Only unpacked literal struct types are supported&period;
| xref:llvm/toScalarizedTy.adoc[`toScalarizedTy`] 
| A helper for converting vectorized types to scalarized (non&hyphen;vector) types&period; For vector types, this is equivalent to calling &period;getScalarType()&period; For struct types, this returns a new struct where each element type has been converted to a scalar type&period; Note&colon; Only unpacked literal struct types are supported&period;
| xref:llvm/toString-09.adoc[`toString`] 
| `toString` overloads
| xref:llvm/toStringRef-009.adoc[`toStringRef`] 
| `toStringRef` overloads
| xref:llvm/toStringRefArray.adoc[`toStringRefArray`] 
| Given an array of c&hyphen;style strings terminated by a null pointer, construct a vector of StringRefs representing the same strings without the terminating null string&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`] 
| A helper function for converting Scalar types to vector types&period; If the incoming type is void, we return void&period; If the EC represents a scalar, we return the scalar type&period;
| xref:llvm/toVectorizedStructTy.adoc[`toVectorizedStructTy`] 
| A helper for converting structs of scalar types to structs of vector types&period; Note&colon; &hyphen; If `EC` is scalar, `StructTy` is returned unchanged &hyphen; Only unpacked literal struct types are supported
| xref:llvm/toVectorizedTy.adoc[`toVectorizedTy`] 
| A helper for converting to vectorized types&period; For scalar types, this is equivalent to calling `toVectorTy`&period; For struct types, this returns a new struct where each element type has been widened to a vector type&period; Note&colon; &hyphen; If the incoming type is void, we return void &hyphen; If `EC` is scalar, `Ty` is returned unchanged &hyphen; Only unpacked literal struct types are supported
| 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 the string `S` to an integer of the specified type using the radix `Base&period;` If `Base` is 0, auto&hyphen;detects the radix&period; Returns true if the number was successfully converted, false otherwise&period;
| xref:llvm/to_string-0dd.adoc[`to&lowbar;string`] 
| 
| xref:llvm/to_underlying.adoc[`to&lowbar;underlying`] 
| Returns underlying integer value of an enum&period; Backport of C&plus;&plus;23 std&colon;&colon;to&lowbar;underlying&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`] 
| Wrapper function around std&colon;&colon;transform to apply a function to a range and store the result elsewhere&period;
| xref:llvm/transformGlobalCtors.adoc[`transformGlobalCtors`] 
| 
| xref:llvm/transformGlobalDtors.adoc[`transformGlobalDtors`] 
| 
| xref:llvm/transformOptional.adoc[`transformOptional`] 
| Apply `F` to the contained value of `O` if present&period;
| xref:llvm/tryBiasPhysRegs.adoc[`tryBiasPhysRegs`] 
| 
| xref:llvm/tryEnforceAlignment.adoc[`tryEnforceAlignment`] 
| If the specified pointer points to an object that we control, try to modify the object&apos;s alignment to PrefAlign&period; Returns a minimum known alignment of the value after the operation, which may be lower than PrefAlign&period;
| xref:llvm/tryGetFromHex.adoc[`tryGetFromHex`] 
| Convert hexadecimal string `Input` to its binary representation and store the result in `Output&period;` Returns true if the binary representation could be converted from the hexadecimal string&period; Returns false if `Input` contains non&hyphen;hexadecimal digits&period; The output string is half the size of `Input&period;`
| xref:llvm/tryGetHexFromNibbles.adoc[`tryGetHexFromNibbles`] 
| Store the binary representation of the two provided values, `MSB` and `LSB,` that make up the nibbles of a hexadecimal digit&period; If `MSB` or `LSB` do not correspond to proper nibbles of a hexadecimal digit, this method returns false&period; Otherwise, returns true&period;
| xref:llvm/tryGreater.adoc[`tryGreater`] 
| 
| xref:llvm/tryLatency.adoc[`tryLatency`] 
| 
| xref:llvm/tryLess.adoc[`tryLess`] 
| 
| xref:llvm/tryPressure.adoc[`tryPressure`] 
| 
| 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`] 
| Conversion from LLVMErrorRef to Error for C error bindings&period;
| 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`] 
| Find all globals in `TheModule` that are referenced in `AsmUndefinedRefs,` as well as the user&hyphen;supplied functions definitions that are also libcalls, and create or update the magic &quot;llvm&period;compiler&lowbar;used&quot; global in `TheModule&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`] 
| Call after cross&hyphen;module importing to update the recorded single impl devirt target names for any locals that were exported&period;
| xref:llvm/updateIndirectCalls.adoc[`updateIndirectCalls`] 
| Update call edges for indirect calls to local functions added from SamplePGO when needed&period; Normally this is done during computeDeadSymbolsAndUpdateIndirectCalls, but can be called standalone when that is not called (e&period;g&period; during testing)&period;
| xref:llvm/updateLoopMetadataDebugLocations.adoc[`updateLoopMetadataDebugLocations`] 
| Update the debug locations contained within the MD&lowbar;loop metadata attached to the instruction `I,` if one exists&period; `Updater` is applied to Metadata operand in the MD&lowbar;loop metadata&colon; the returned value is included in the updated loop metadata node if it is non&hyphen;null&period;
| xref:llvm/updatePhiNodes.adoc[`updatePhiNodes`] 
| Replaces all uses of OldPred with the NewPred block in all PHINodes in a block&period;
| xref:llvm/updateProfileCallee.adoc[`updateProfileCallee`] 
| Updates profile information by adjusting the entry count by adding EntryDelta then scaling callsite information by the new count divided by the old count&period; VMap is used during inlinng to also update the new clone
| xref:llvm/updatePublicTypeTestCalls.adoc[`updatePublicTypeTestCalls`] 
| 
| xref:llvm/updateVCallVisibilityInIndex.adoc[`updateVCallVisibilityInIndex`] 
| 
| xref:llvm/updateVCallVisibilityInModule.adoc[`updateVCallVisibilityInModule`] 
| 
| 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`] 
| 
| xref:llvm/upward_defs_begin.adoc[`upward&lowbar;defs&lowbar;begin`] 
| 
| xref:llvm/upward_defs_end.adoc[`upward&lowbar;defs&lowbar;end`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/widenShuffleMaskElts-00.adoc[`widenShuffleMaskElts`] 
| `widenShuffleMaskElts` overloads
| xref:llvm/widenWidenableBranch.adoc[`widenWidenableBranch`] 
| Given a branch we know is widenable (defined per Analysis&sol;GuardUtils&period;h), widen it such that condition &apos;NewCond&apos; is also known to hold on the taken path&period; Branch remains widenable after transform&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 the result produced by the instruction would have no side effects if it was not used&period; This is equivalent to checking whether isInstructionTriviallyDead would be true if the use count was 0&period;
| xref:llvm/wrap-003e.adoc[`wrap`] 
| Conversion from Error to LLVMErrorRef for C error bindings&period;
| xref:llvm/write.adoc[`write`] 
| 
| xref:llvm/writeArchive.adoc[`writeArchive`] 
| 
| xref:llvm/writeArchiveToBuffer.adoc[`writeArchiveToBuffer`] 
| 
| xref:llvm/writeArchiveToStream.adoc[`writeArchiveToStream`] 
| 
| xref:llvm/writeIndexToFile.adoc[`writeIndexToFile`] 
| Write the specified module summary index to the given raw output stream, where it will be written in a new bitcode block&period; This is used when writing the combined index file for ThinLTO&period; When writing a subset of the index for a distributed backend, provide the `ModuleToSummariesForIndex` map&period; `DecSummaries` specifies the set of summaries for which the corresponding value should be imported as a declaration (prototype)&period;
| xref:llvm/writeMemProf.adoc[`writeMemProf`] 
| 
| xref:llvm/writeModule.adoc[`writeModule`] 
| Fuzzer friendly interface for the llvm bitcode printer&period;
| xref:llvm/writeThinLinkBitcodeToFile.adoc[`writeThinLinkBitcodeToFile`] 
| Write the specified thin link bitcode file (i&period;e&period;, the minimized bitcode file) to the given raw output stream, where it will be written in a new bitcode block&period; The thin link bitcode file is used for thin link, and it only contains the necessary information for thin link&period;
| xref:llvm/writeToOutput.adoc[`writeToOutput`] 
| This helper creates an output stream and then passes it to `Write&period;` The stream created is based on the specified `OutputFileName` llvm&colon;&colon;outs for &quot;&hyphen;&quot;, raw&lowbar;null&lowbar;ostream for &quot;&sol;dev&sol;null&quot;, and raw&lowbar;fd&lowbar;ostream for other names&period; For raw&lowbar;fd&lowbar;ostream instances, the stream writes to a temporary file&period; The final output file is atomically replaced with the temporary file after the `Write` function is finished&period;
| xref:llvm/write_double.adoc[`write&lowbar;double`] 
| Write floating&hyphen;point `D` to `S` using `Style` and optional `Precision&period;`
| xref:llvm/write_hex.adoc[`write&lowbar;hex`] 
| Write hex value `N` to `S` using `Style` and optional field `Width&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 iterator for two or more iteratable types&period; Iteration continues until the end of the _shortest_ iteratee is reached&period;
| xref:llvm/zip_equal.adoc[`zip&lowbar;equal`] 
| zip iterator that assumes that all iteratees have the same length&period; In builds with assertions on, this assumption is checked before the iteration starts&period;
| xref:llvm/zip_first.adoc[`zip&lowbar;first`] 
| zip iterator that, for the sake of efficiency, assumes the first iteratee to be the shortest&period; Iteration continues until the end of the first iteratee is reached&period; In builds with assertions on, we check that the assumption about the first iteratee being the shortest holds&period;
| xref:llvm/zip_longest.adoc[`zip&lowbar;longest`] 
| Iterate over two or more iterators at the same time&period; Iteration continues until all iterators reach the end&period; The std&colon;&colon;optional only contains a value if the iterator has not reached the end&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`] 
| 
| 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`] 
| 
| xref:llvm/BitWidth.adoc[`BitWidth`] 
| Number of bits needed to represent the largest enumerator of bitmask enum `E&period;`
| xref:llvm/BranchFolderPassID.adoc[`BranchFolderPassID`] 
| BranchFolding &hyphen; This pass performs machine code CFG based optimizations to delete branches to branches, eliminate branches to successor blocks (creating fall throughs), and eliminating branches over 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`] 
| 
| 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`] 
| 
| xref:llvm/DeadMachineInstructionElimID.adoc[`DeadMachineInstructionElimID`] 
| DeadMachineInstructionElim &hyphen; This pass removes dead machine instructions&period;
| xref:llvm/DebugFlag.adoc[`DebugFlag`] 
| This boolean is set to true if the &apos;&hyphen;debug&apos; command line option is specified&period; This should probably not be referenced directly, instead, use the DEBUG macro below&period;
| xref:llvm/DecisionName.adoc[`DecisionName`] 
| 
| 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`] 
| 
| xref:llvm/DefaultDecisionSpec.adoc[`DefaultDecisionSpec`] 
| 
| xref:llvm/DetectDeadLanesID.adoc[`DetectDeadLanesID`] 
| This pass adds dead&sol;undef flags after analyzing subregister lanes&period;
| xref:llvm/DisableGISelLegalityCheck.adoc[`DisableGISelLegalityCheck`] 
| 
| xref:llvm/DoInstrProfNameCompression.adoc[`DoInstrProfNameCompression`] 
| 
| 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`] 
| EnableDebugBuffering &hyphen; This defaults to false&period; If true, the debug stream will install signal handlers to dump any buffered debug output&period; It allows clients to selectively allow the debug stream to install signal handlers if they are certain there will be no conflict&period;
| xref:llvm/EnableFSDiscriminator.adoc[`EnableFSDiscriminator`] 
| 
| xref:llvm/EnableKnowledgeRetention.adoc[`EnableKnowledgeRetention`] 
| 
| xref:llvm/EnableLTOInternalization.adoc[`EnableLTOInternalization`] 
| Enable global value internalization in LTO&period;
| xref:llvm/EnableLoopInterleaving.adoc[`EnableLoopInterleaving`] 
| 
| xref:llvm/EnableLoopVectorization.adoc[`EnableLoopVectorization`] 
| 
| xref:llvm/EnablePGSO.adoc[`EnablePGSO`] 
| 
| xref:llvm/ErrorsPrinted.adoc[`ErrorsPrinted`] 
| 
| 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`] 
| 
| xref:llvm/ForgetSCEVInLoopUnroll.adoc[`ForgetSCEVInLoopUnroll`] 
| 
| 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`] 
| GCMachineCodeAnalysis &hyphen; Target&hyphen;independent pass to mark safe points in machine code&period; Must be added very late during code generation, just prior to output, and importantly after all CFG transformations (such as branch folding)&period;
| xref:llvm/GlobalIdentifierDelimiter.adoc[`GlobalIdentifierDelimiter`] 
| 
| xref:llvm/GraphHasNodeNumbers.adoc[`GraphHasNodeNumbers`] 
| Indicate whether a GraphTraits&lt;NodeT&gt;&colon;&colon;getNumber() is supported&period;
| xref:llvm/HybridPatchableTargetSuffix.adoc[`HybridPatchableTargetSuffix`] 
| 
| xref:llvm/HybridPatchableTargetSuffixArr.adoc[`HybridPatchableTargetSuffixArr`] 
| 
| 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`] 
| 
| xref:llvm/IndexedCodeGenDataLazyLoading.adoc[`IndexedCodeGenDataLazyLoading`] 
| 
| xref:llvm/InferAddressSpacesID.adoc[`InferAddressSpacesID`] 
| 
| xref:llvm/InitUndefID.adoc[`InitUndefID`] 
| 
| xref:llvm/InlineDecisionSpec.adoc[`InlineDecisionSpec`] 
| 
| xref:llvm/InvalidClusterId.adoc[`InvalidClusterId`] 
| 
| xref:llvm/IsNullable.adoc[`IsNullable`] 
| True if `T` is a pointer or constructible from `nullptr&period;`
| xref:llvm/IsaAndPresentPred.adoc[`IsaAndPresentPred`] 
| Function object wrapper for the `llvm&colon;&colon;isa&lowbar;and&lowbar;present` type check&period; The function call operator returns true when the value can be cast to any type in `Types`, or if the value is not present (e&period;g&period;, nullptr)&period; Example&colon; &grave; SmallVector&lt;Type&gt; myTypes &equals; &period;&period;&period;&semi; if (llvm&colon;&colon;all&lowbar;of(myTypes, llvm&colon;&colon;IsaAndPresentPred&lt;VectorType&gt;)) &period;&period;&period; &grave;
| xref:llvm/IsaPred.adoc[`IsaPred`] 
| Function object wrapper for the `llvm&colon;&colon;isa` type check&period; The function call operator returns true when the value can be cast to any type in `Types`&period; Example&colon; &grave; SmallVector&lt;Type&gt; myTypes &equals; &period;&period;&period;&semi; if (llvm&colon;&colon;all&lowbar;of(myTypes, llvm&colon;&colon;IsaPred&lt;VectorType&gt;)) &period;&period;&period; &grave;
| xref:llvm/IterativeBFIMaxIterationsPerBlock.adoc[`IterativeBFIMaxIterationsPerBlock`] 
| 
| xref:llvm/IterativeBFIPrecision.adoc[`IterativeBFIPrecision`] 
| 
| xref:llvm/LCSSAID.adoc[`LCSSAID`] 
| 
| 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`] 
| 
| xref:llvm/LLVMLoopUnrollFollowupUnrolled.adoc[`LLVMLoopUnrollFollowupUnrolled`] 
| 
| 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`] 
| LocalStackSlotAllocation &hyphen; This pass assigns local frame indices to stack slots relative to one another and allocates base registers to access them when it is estimated by the target to be out of range of normal frame pointer or stack pointer index addressing&period;
| xref:llvm/LoopSimplifyID.adoc[`LoopSimplifyID`] 
| 
| xref:llvm/LowerInvokePassID.adoc[`LowerInvokePassID`] 
| 
| xref:llvm/LowerSwitchID.adoc[`LowerSwitchID`] 
| 
| xref:llvm/MAX_SUBTARGET_FEATURES.adoc[`MAX&lowbar;SUBTARGET&lowbar;FEATURES`] 
| 
| xref:llvm/MAX_SUBTARGET_WORDS.adoc[`MAX&lowbar;SUBTARGET&lowbar;WORDS`] 
| 
| xref:llvm/MCScheduleOptions.adoc[`MCScheduleOptions`] 
| 
| 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`] 
| 
| 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`] 
| 
| 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`] 
| 
| xref:llvm/NoWarnSampleUnused.adoc[`NoWarnSampleUnused`] 
| 
| xref:llvm/OldBooleanLoopTags.adoc[`OldBooleanLoopTags`] 
| 
| 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`] 
| 
| xref:llvm/PGSOColdCodeOnlyForInstrPGO.adoc[`PGSOColdCodeOnlyForInstrPGO`] 
| 
| xref:llvm/PGSOColdCodeOnlyForPartialSamplePGO.adoc[`PGSOColdCodeOnlyForPartialSamplePGO`] 
| 
| xref:llvm/PGSOColdCodeOnlyForSamplePGO.adoc[`PGSOColdCodeOnlyForSamplePGO`] 
| 
| xref:llvm/PGSOLargeWorkingSetSizeOnly.adoc[`PGSOLargeWorkingSetSizeOnly`] 
| 
| xref:llvm/PHIEliminationID.adoc[`PHIEliminationID`] 
| PHIElimination &hyphen; This pass eliminates machine instruction PHI nodes by inserting copy instructions&period; This destroys SSA information, but is the desired input for some register allocators&period; This pass is &quot;required&quot; by these register allocator like this&colon; AU&period;addRequiredID(PHIEliminationID)&semi;
| xref:llvm/PartialUnrollingThreshold.adoc[`PartialUnrollingThreshold`] 
| 
| 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`] 
| 
| xref:llvm/PgsoCutoffSampleProf.adoc[`PgsoCutoffSampleProf`] 
| 
| xref:llvm/PoisonMaskElem.adoc[`PoisonMaskElem`] 
| 
| 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`] 
| 
| xref:llvm/PrintChanged.adoc[`PrintChanged`] 
| 
| xref:llvm/PrintDAGs.adoc[`PrintDAGs`] 
| 
| 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`] 
| 
| xref:llvm/ProfileInlineGrowthLimit.adoc[`ProfileInlineGrowthLimit`] 
| 
| xref:llvm/ProfileInlineLimitMax.adoc[`ProfileInlineLimitMax`] 
| 
| xref:llvm/ProfileInlineLimitMin.adoc[`ProfileInlineLimitMin`] 
| 
| xref:llvm/ProfileSummaryColdCount.adoc[`ProfileSummaryColdCount`] 
| 
| xref:llvm/ProfileSummaryCutoffCold.adoc[`ProfileSummaryCutoffCold`] 
| 
| xref:llvm/ProfileSummaryCutoffHot.adoc[`ProfileSummaryCutoffHot`] 
| 
| xref:llvm/ProfileSummaryHotCount.adoc[`ProfileSummaryHotCount`] 
| 
| xref:llvm/ProfileSummaryHugeWorkingSetSizeThreshold.adoc[`ProfileSummaryHugeWorkingSetSizeThreshold`] 
| 
| xref:llvm/ProfileSummaryLargeWorkingSetSizeThreshold.adoc[`ProfileSummaryLargeWorkingSetSizeThreshold`] 
| 
| 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`] 
| 
| 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`] 
| This function is used to do simplification of a CFG&period; For example, it adjusts branches to branches to eliminate the extra hop, it eliminates unreachable basic blocks, and does other peephole optimization of the CFG&period; It returns true if a modification was made, possibly deleting the basic block that was pointed to&period; LoopHeaders is an optional input parameter providing the set of loop headers that SimplifyCFG should not eliminate&period;
| xref:llvm/RewardName.adoc[`RewardName`] 
| 
| xref:llvm/SCEVCheapExpansionBudget.adoc[`SCEVCheapExpansionBudget`] 
| 
| xref:llvm/SSAUpdaterPhiSearchLimit.adoc[`SSAUpdaterPhiSearchLimit`] 
| 
| xref:llvm/SampleColdCallSiteThreshold.adoc[`SampleColdCallSiteThreshold`] 
| 
| xref:llvm/SampleHotCallSiteThreshold.adoc[`SampleHotCallSiteThreshold`] 
| 
| xref:llvm/SampleProfileMaxPropagateIterations.adoc[`SampleProfileMaxPropagateIterations`] 
| 
| xref:llvm/SampleProfileRecordCoverage.adoc[`SampleProfileRecordCoverage`] 
| 
| xref:llvm/SampleProfileSampleCoverage.adoc[`SampleProfileSampleCoverage`] 
| 
| xref:llvm/SampleProfileUseProfi.adoc[`SampleProfileUseProfi`] 
| 
| xref:llvm/SetLicmMssaNoAccForPromotionCap.adoc[`SetLicmMssaNoAccForPromotionCap`] 
| 
| xref:llvm/SetLicmMssaOptCap.adoc[`SetLicmMssaOptCap`] 
| 
| 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`] 
| 
| xref:llvm/SpillPlacementID.adoc[`SpillPlacementID`] 
| SpillPlacement analysis&period; Suggest optimal placement of spill code between basic blocks&period;
| xref:llvm/SrcMgr.adoc[`SrcMgr`] 
| 
| 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`] 
| StackMapLiveness &hyphen; This pass analyses the register live&hyphen;out set of stackmap&sol;patchpoint intrinsics and attaches the calculated information to the intrinsic for later emission to the StackMap&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`] 
| 
| xref:llvm/SwpForceIssueWidth.adoc[`SwpForceIssueWidth`] 
| 
| xref:llvm/TailDuplicateLegacyID.adoc[`TailDuplicateLegacyID`] 
| TailDuplicate &hyphen; Duplicate blocks with unconditional branches into tails of their predecessors&period;
| xref:llvm/TimePassesIsEnabled.adoc[`TimePassesIsEnabled`] 
| If the user specifies the &hyphen;time&hyphen;passes argument on an LLVM tool command line then the value of this boolean will be true, otherwise false&period; This is the storage for the &hyphen;time&hyphen;passes option&period;
| xref:llvm/TimePassesPerRun.adoc[`TimePassesPerRun`] 
| If TimePassesPerRun is true, there would be one line of report for each pass invocation&period; If TimePassesPerRun is false, there would be only one line of report for each pass (even there are more than one pass objects)&period; (For new pass manager only)
| 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`] 
| 
| xref:llvm/UseIterativeBFIInference.adoc[`UseIterativeBFIInference`] 
| 
| xref:llvm/UseSegmentSetForPhysRegs.adoc[`UseSegmentSetForPhysRegs`] 
| 
| 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`] 
| 
| xref:llvm/VerifyScheduling.adoc[`VerifyScheduling`] 
| 
| xref:llvm/ViewMISchedDAGs.adoc[`ViewMISchedDAGs`] 
| 
| 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`] 
| 
| xref:llvm/kSanitizerBinaryMetadataAtomicsBit.adoc[`kSanitizerBinaryMetadataAtomicsBit`] 
| 
| xref:llvm/kSanitizerBinaryMetadataAtomicsSection.adoc[`kSanitizerBinaryMetadataAtomicsSection`] 
| 
| xref:llvm/kSanitizerBinaryMetadataCoveredSection.adoc[`kSanitizerBinaryMetadataCoveredSection`] 
| 
| xref:llvm/kSanitizerBinaryMetadataUAR.adoc[`kSanitizerBinaryMetadataUAR`] 
| 
| xref:llvm/kSanitizerBinaryMetadataUARBit.adoc[`kSanitizerBinaryMetadataUARBit`] 
| 
| xref:llvm/kSanitizerBinaryMetadataUARHasSize.adoc[`kSanitizerBinaryMetadataUARHasSize`] 
| 
| xref:llvm/kSanitizerBinaryMetadataUARHasSizeBit.adoc[`kSanitizerBinaryMetadataUARHasSizeBit`] 
| 
|===


== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:llvm/LegalizeAction.adoc[`LegalizeAction`] 
| 
| xref:llvm/ObjectFile.adoc[`ObjectFile`] 
| 
| xref:llvm/PassManagerBase.adoc[`PassManagerBase`] 
| 
| xref:llvm/SectionRef.adoc[`SectionRef`] 
| 
| xref:llvm/SectionedAddress.adoc[`SectionedAddress`] 
| 
| 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"]
|===
| Name
| xref:llvm/sampleprof.adoc[`sampleprof`] 
| xref:llvm/sampleprofutil.adoc[`sampleprofutil`] 
|===



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