llvm

Top-level LLVM library namespace.

Namespaces

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

Types

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

Type Aliases

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

Enums

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

Functions

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

Variables

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

Using Declarations

NameDescription
LegalizeAction Convenient alias for LegalizeActions::LegalizeAction.
ObjectFile Bring object::ObjectFile into this namespace.
PassManagerBase Alias for the legacy pass manager base class.
SectionRef Bring object::SectionRef into this namespace.
SectionedAddress Bring object::SectionedAddress into this namespace.
any Bring bitmask enum any-bits-set test into this namespace for ADL.
operator! Bring bitmask enum logical-not into this namespace for ADL.
operator& Bring bitmask enum bitwise AND into this namespace for ADL.
operator&= Bring bitmask enum in-place AND into this namespace for ADL.
operator<< Bring bitmask enum left-shift into this namespace for ADL.
operator<<= Bring bitmask enum in-place left-shift into this namespace for ADL.
operator>> Bring bitmask enum right-shift into this namespace for ADL.
operator>>= Bring bitmask enum in-place right-shift into this namespace for ADL.
operator^ Bring bitmask enum bitwise XOR into this namespace for ADL.
operator^= Bring bitmask enum in-place XOR into this namespace for ADL.
operator| Bring bitmask enum bitwise OR into this namespace for ADL.
operator|= Bring bitmask enum in-place OR into this namespace for ADL.
operator~ Bring bitmask enum bitwise NOT into this namespace for ADL.

Using Namespace Directives

NameDescription
sampleprof Sample profile data structures and helpers.
sampleprofutil Utilities shared by sample profile loader implementations.