Hidden

Hidden docstrings that we don't want to show up, but we want to avoid failing checkdocs for:

LLVM.InitializeAArch64AsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeAArch64AsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeAArch64Disassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeAArch64Target — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeAArch64TargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeAArch64TargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeAMDGPUAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeAMDGPUAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeAMDGPUDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeAMDGPUTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeAMDGPUTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeAMDGPUTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeARCAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeARCAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeARCDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeARCTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeARCTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeARCTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeARMAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeARMAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeARMDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeARMTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeARMTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeARMTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeAVRAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeAVRAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeAVRDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeAVRTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeAVRTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeAVRTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeBPFAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeBPFAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeBPFDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeBPFTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeBPFTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeBPFTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeColossusAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeColossusAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeColossusDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeColossusTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeColossusTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeColossusTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeHexagonAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeHexagonAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeHexagonDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeHexagonTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeHexagonTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeHexagonTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeLanaiAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeLanaiAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeLanaiDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeLanaiTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeLanaiTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeLanaiTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeMipsAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeMipsAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeMipsDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeMipsTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeMipsTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeMipsTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeMSP430AsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeMSP430AsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeMSP430Disassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeMSP430Target — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeMSP430TargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeMSP430TargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeNativeAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeNativeAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeNativeDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeNativeTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeNVPTXAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeNVPTXAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeNVPTXDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeNVPTXTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeNVPTXTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeNVPTXTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializePowerPCAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializePowerPCAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializePowerPCDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializePowerPCTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializePowerPCTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializePowerPCTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeRISCVAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeRISCVAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeRISCVDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeRISCVTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeRISCVTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeRISCVTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeSparcAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeSparcAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeSparcDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeSparcTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeSparcTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeSparcTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeSystemZAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeSystemZAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeSystemZDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeSystemZTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeSystemZTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeSystemZTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeVEAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeVEAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeVEDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeVETarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeVETargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeVETargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeWebAssemblyAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeWebAssemblyAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeWebAssemblyDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeWebAssemblyTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeWebAssemblyTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeWebAssemblyTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeX86AsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeX86AsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeX86Disassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeX86Target — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeX86TargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeX86TargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.InitializeXCoreAsmParser — Function

LLVM.InitializeAllAsmParsers()
LLVM.InitializeXXXAsmParser()
LLVM.InitializeNativeAsmParser()

Enables use of assembly parsing functionality for specific targets.

source

LLVM.InitializeXCoreAsmPrinter — Function

LLVM.InitializeAllAsmPrinters()
LLVM.InitializeXXXAsmPrinter()
LLVM.InitializeNativeAsmPrinter()

Enables use of assembly output functionality for specific targets.

source

LLVM.InitializeXCoreDisassembler — Function

LLVM.InitializeAllDisassemblers()
LLVM.InitializeXXXDisassembler()
LLVM.InitializeNativeDisassembler()

Enables use of disassembly functionality for specific targets.

source

LLVM.InitializeXCoreTarget — Function

LLVM.InitializeAllTargets()
LLVM.InitializeXXXTarget()
LLVM.InitializeNativeTarget()

Enables use of specific targets.

source

LLVM.InitializeXCoreTargetInfo — Function

LLVM.InitializeAllTargetInfos()
LLVM.InitializeXXXTargetInfo()

Enables access to specific targets.

source

LLVM.InitializeXCoreTargetMC — Function

LLVM.InitializeAllTargetMCs()
LLVM.InitializeXXXTargetMC()

Enable use of machine code generation for specific targets.

source

LLVM.Int1Type — Function

LLVM.IntType(bits::Integer)

Create an integer type with the given bits width.

Short-hand constructors are available for common widths: LLVM.Int1Type, LLVM.Int8Type, LLVM.Int16Type, LLVM.Int32Type, LLVM.Int64Type, and LLVM.Int128Type.

source

LLVM.Int8Type — Function

LLVM.IntType(bits::Integer)

Create an integer type with the given bits width.

Short-hand constructors are available for common widths: LLVM.Int1Type, LLVM.Int8Type, LLVM.Int16Type, LLVM.Int32Type, LLVM.Int64Type, and LLVM.Int128Type.

source

LLVM.Int16Type — Function

LLVM.IntType(bits::Integer)

Create an integer type with the given bits width.

Short-hand constructors are available for common widths: LLVM.Int1Type, LLVM.Int8Type, LLVM.Int16Type, LLVM.Int32Type, LLVM.Int64Type, and LLVM.Int128Type.

source

LLVM.Int32Type — Function

LLVM.IntType(bits::Integer)

Create an integer type with the given bits width.

Short-hand constructors are available for common widths: LLVM.Int1Type, LLVM.Int8Type, LLVM.Int16Type, LLVM.Int32Type, LLVM.Int64Type, and LLVM.Int128Type.

source

LLVM.Int64Type — Function

LLVM.IntType(bits::Integer)

Create an integer type with the given bits width.

Short-hand constructors are available for common widths: LLVM.Int1Type, LLVM.Int8Type, LLVM.Int16Type, LLVM.Int32Type, LLVM.Int64Type, and LLVM.Int128Type.

source

LLVM.Int128Type — Function

LLVM.IntType(bits::Integer)

Create an integer type with the given bits width.

Short-hand constructors are available for common widths: LLVM.Int1Type, LLVM.Int8Type, LLVM.Int16Type, LLVM.Int32Type, LLVM.Int64Type, and LLVM.Int128Type.

source

LLVM.ModulePassManager — Function

ModulePassManager()
CGSCCPassManager()
FunctionPassManager(; eager_invalidate=false)
LoopPassManager(; use_memory_ssa=false)
AAManager()

Create a new pass manager of the specified type. These objects can be used to construct pass pipelines, by add!ing passes to them, and finally add!ing them to a parent pass manager or pass builder.

Creating a pass manager and adding it to a parent manager or builder can be shortened using a single add!:

add!(parent, ModulePassManager()) do mpm
    add!(mpm, SomeModulePass())
end

This form does not add pass managers that are left empty.

With eager_invalidate=true, the analyses of each function are invalidated as soon as the passes of a function pass manager have run on it, rather than kept for the passes that come later (function<eager-inv>), which LLVM's pipelines do to save memory. With use_memory_ssa=true, a loop pass manager maintains MemorySSA for passes that require it (loop-mssa).

An AAManager selects the alias analyses that passes use (in order), instead of LLVM's default ones, and can only be added to a pass builder. Unlike other pass managers, it is meaningful when empty: the passes then use no alias analysis. LLVM's default alias analyses include those of the target machine, which an AAManager only includes where it lists TargetAA().

See also: add!, PassBuilder

source

LLVM.CGSCCPassManager — Function

ModulePassManager()
CGSCCPassManager()
FunctionPassManager(; eager_invalidate=false)
LoopPassManager(; use_memory_ssa=false)
AAManager()

Creating a pass manager and adding it to a parent manager or builder can be shortened using a single add!:

add!(parent, ModulePassManager()) do mpm
    add!(mpm, SomeModulePass())
end

This form does not add pass managers that are left empty.

See also: add!, PassBuilder

source

LLVM.FunctionPassManager — Function

ModulePassManager()
CGSCCPassManager()
FunctionPassManager(; eager_invalidate=false)
LoopPassManager(; use_memory_ssa=false)
AAManager()

Creating a pass manager and adding it to a parent manager or builder can be shortened using a single add!:

add!(parent, ModulePassManager()) do mpm
    add!(mpm, SomeModulePass())
end

This form does not add pass managers that are left empty.

See also: add!, PassBuilder

source

LLVM.LoopPassManager — Function

ModulePassManager()
CGSCCPassManager()
FunctionPassManager(; eager_invalidate=false)
LoopPassManager(; use_memory_ssa=false)
AAManager()

Creating a pass manager and adding it to a parent manager or builder can be shortened using a single add!:

add!(parent, ModulePassManager()) do mpm
    add!(mpm, SomeModulePass())
end

This form does not add pass managers that are left empty.

See also: add!, PassBuilder

source

LLVM.AAManager — Type

ModulePassManager()
CGSCCPassManager()
FunctionPassManager(; eager_invalidate=false)
LoopPassManager(; use_memory_ssa=false)
AAManager()

Creating a pass manager and adding it to a parent manager or builder can be shortened using a single add!:

add!(parent, ModulePassManager()) do mpm
    add!(mpm, SomeModulePass())
end

This form does not add pass managers that are left empty.

See also: add!, PassBuilder

source

LLVM.ModulePass — Function

ModulePass(name, callback; required=false, analyses=false, parse_options=nothing)
FunctionPass(name, callback; required=false, analyses=false, parse_options=nothing)

Create a new custom pass. The name is a string that will be used to identify the pass in the pass manager. The callback is a function that will be called when the pass is run. The function should take a single argument, the module or function to be processed, and return a boolean indicating whether the pass made any changes. Set required=true for a pass needed for correctness; LLVM then does not skip it on optnone functions or under -opt-bisect-limit. LLVM's instrumentation also knows the pass by its name, e.g., when listing the passes that run (with debug_logging=true), or when selecting passes to print the IR of (with LLVM's -print-before=name option). That does not work for a name that is also the class name of one of LLVM's passes, like InstCombinePass, which LLVM already knows by its own name.

With analyses=true, a pass can use LLVM's analyses: the callback is then called with two arguments, the function and its FunctionAnalysisManager (for a function pass), or the module and its ModuleAnalysisManager (for a module pass). Instead of a boolean, it may return a PreservedAnalyses value describing the analyses that remain valid after the pass:

function my_pass!(f::LLVM.Function, am::LLVM.FunctionAnalysisManager)
    domtree = am[DomTree]
    changed = ...
    # this pass does not modify the CFG
    return changed ? PreservedAnalyses(CFGAnalyses) : PreservedAnalyses(AllAnalyses)
end
FunctionPass("my-pass", my_pass!; analyses=true)

A module pass gets the analyses of each of its functions by indexing its manager with the function:

function my_module_pass!(mod::LLVM.Module, am::LLVM.ModuleAnalysisManager)
    for f in mod.functions
        isdeclaration(f) && continue
        domtree = am[f][DomTree]
        ...
    end
    return false
end
ModulePass("my-module-pass", my_module_pass!; analyses=true)

A pass can take options, which are written in a pipeline like those of LLVM's passes: name<options>. To support them, pass a function parse_options that takes the string between the angle brackets (an empty string if the pass is written as name or name<>), and returns the options. The callback is then called with those options as an extra, last argument. For example, a pass that is configured using my-pass<limit=N>:

function parse_my_options(str)
    limit = 10
    for opt in split(str, ';'; keepempty=false)
        key, value = split(opt, '=')
        key == "limit" || throw(ArgumentError("unknown option $key"))
        limit = parse(Int, value)
    end
    return (; limit)
end
my_pass!(f::LLVM.Function, am, options) = ...
FunctionPass("my-pass", my_pass!; analyses=true, parse_options=parse_my_options)

Each occurrence of the pass in a pipeline has its own options, which are used for every function or module that occurrence runs on, so they should not be mutated by the pass. The parser may be called more than once for an occurrence, so it should not have side effects. Options cannot contain the characters ,, ( and ), which separate passes in a pipeline. Exceptions thrown by the parser are rethrown as PassException by run!.

Before using a custom pass, it must be registered with a pass builder using register!. LLVM.jl catches exceptions from these callbacks and rethrows them as PassException after control has returned from LLVM. The optional passes that remain to run in the pipeline are skipped then, as are custom passes even if they are required, since the IR may be inconsistent. This is not a guarantee that nothing uses it: LLVM's required passes (like the pass managers and adaptors, which skip the passes they contain) still run, and with verify_each, LLVM verifies the IR after the failing pass and aborts if it is invalid. Callbacks registered directly through the LLVM.API.LLVMPassBuilderExtensionsRegister*Pass APIs must provide an equivalent exception barrier: Julia exceptions must not escape a callback, because they bypass C++ destructors in LLVM's pass runner.

See also: register!

source

LLVM.CFGAnalyses — Type

AllAnalyses
CFGAnalyses
FunctionAnalyses
LoopAnalyses

Markers for sets of analyses, used with PreservedAnalyses: AllAnalyses for every analysis, CFGAnalyses for the analyses that only depend on the control-flow graph of a function (like DomTree and PostDomTree), i.e., on its blocks and their terminators, FunctionAnalyses for the function analyses of the function (for a function pass), or of every function of the module (for a module pass), and LoopAnalyses (only for loop passes) for the analyses that a loop pass keeps valid when it changes a loop: the dominator tree, loop info and scalar evolution of the function.

source

LLVM.FunctionAnalyses — Type

AllAnalyses
CFGAnalyses
FunctionAnalyses
LoopAnalyses

source

LLVM.move_before! — Function

move_to_place!(updater::MemorySSAUpdater, access::MemoryUseOrDef, bb::BasicBlock, where::Symbol)

Update MemorySSA for an instruction that was moved to the block bb: move its access to the given place among the accesses of the block, which is :beginning, :end, or :before_terminator (which is :end, unless the terminator itself has an access, e.g., an invoke). The instruction must have been moved to that place first, e.g., to the beginning of the block (after its phis), or before its terminator. The accesses that used the moved access, and the access itself, are then updated, like when it is created there.

move_before! and move_after! move an access next to another one instead, after its instruction was moved next to the other's.

source

LLVM.move_after! — Function

move_to_place!(updater::MemorySSAUpdater, access::MemoryUseOrDef, bb::BasicBlock, where::Symbol)

move_before! and move_after! move an access next to another one instead, after its instruction was moved next to the other's.

source

LLVM.create_access_before! — Function

create_access_in_block!(updater::MemorySSAUpdater, inst::Instruction, bb::BasicBlock,
                        where::Symbol; definition=nothing)
create_access_before!(updater::MemorySSAUpdater, inst::Instruction,
                      access::MemoryUseOrDef; definition=nothing)
create_access_after!(updater::MemorySSAUpdater, inst::Instruction,
                     access::MemoryAccess; definition=nothing)

Create the access of a new instruction in the block bb that it was inserted in, at a place among the accesses of the block (:beginning, :end or :before_terminator, see move_to_place!), or before or after another access in its block, and return it: a MemoryUse or MemoryDef, depending on how the instruction accesses memory. The instruction must be at the corresponding place in the block.

Returns nothing if the instruction does not read or write memory, in which case MemorySSA does not need an access for it. MemorySSA also leaves out instructions that alias analysis finds not to access memory (e.g., a call to a function that only accesses memory that is not otherwise accessible), which this only detects for a place in a block on LLVM 19 and later: creating an access for such an instruction is invalid otherwise.

The access is created with definition as its defining access (a MemoryDef or MemoryPhi), which is not checked. Unless that is known to be correct, e.g., when the instruction replaces another one in the same place, leave it out and insert the access afterwards using insert_def! or insert_use!, which find its defining access and update the accesses that depend on it.

Creating an access for an instruction that already has one leaves the existing access inaccessible, and it must be removed using remove_access!.

source

LLVM.create_access_after! — Function

create_access_in_block!(updater::MemorySSAUpdater, inst::Instruction, bb::BasicBlock,
                        where::Symbol; definition=nothing)
create_access_before!(updater::MemorySSAUpdater, inst::Instruction,
                      access::MemoryUseOrDef; definition=nothing)
create_access_after!(updater::MemorySSAUpdater, inst::Instruction,
                     access::MemoryAccess; definition=nothing)

Creating an access for an instruction that already has one leaves the existing access inaccessible, and it must be removed using remove_access!.

source

LLVM.insert_use! — Function

insert_def!(updater::MemorySSAUpdater, def::MemoryDef; rename=false)
insert_use!(updater::MemorySSAUpdater, use::MemoryUse; rename=false)

Insert a new access (created using create_access_in_block!) into MemorySSA: find its defining access, and for a definition, make the accesses that now see the state it defines use it, adding phis where needed. With rename=true, the uses of the states that the access dominates are updated as well, which is needed unless they cannot be affected, e.g., when the access was created at the end of a block with no other accesses after it. Julia's and LLVM's passes pass rename=true when they move or clone memory operations.

source

LLVM.is_known_positive — Function

is_known_non_negative(v::Value; at=nothing, assumptions=nothing, domtree=nothing,
                      datalayout=nothing, use_instruction_info=true)
is_known_positive(v::Value; ...)
is_known_non_zero(v::Value; ...)

Check whether the integer (or vector of integers) v is known to be non-negative, or strictly positive, when interpreted as a signed integer, or whether the integer or pointer (or vector of them) v is known to be non-zero, using LLVM's value tracking. For vectors, the fact needs to hold for every element. The keyword arguments are the same as for ConstantRange(::Value).

Like other value tracking queries, these are facts about v if it is not poison: they do not prove that v is not poison (see is_guaranteed_not_to_be_poison). A result of false means that the fact could not be proven.

source

LLVM.is_known_non_zero — Function

is_known_non_negative(v::Value; at=nothing, assumptions=nothing, domtree=nothing,
                      datalayout=nothing, use_instruction_info=true)
is_known_positive(v::Value; ...)
is_known_non_zero(v::Value; ...)

source

LLVM.issignwrappedset — Function

iswrappedset(r::ConstantRange)
issignwrappedset(r::ConstantRange)

Check whether the range wraps around the end of the unsigned (or signed) integer domain, i.e., whether it contains both the maximum and the minimum unsigned (or signed) value, but is not the full range.

source

LLVM.union_with — Function

intersect_with(a::ConstantRange, b::ConstantRange; prefer=:smallest)
union_with(a::ConstantRange, b::ConstantRange; prefer=:smallest)

Compute a range that contains the intersection, or the union, of two ranges. As the exact result may not be a single range, there can be multiple candidates, of which the smallest one is returned by default. With prefer=:unsigned or prefer=:signed, a candidate that does not wrap in the unsigned or signed domain is preferred.

source

LLVM.satisfying_icmp_region — Function

allowed_icmp_region(predicate, r::ConstantRange)
satisfying_icmp_region(predicate, r::ConstantRange)

Compute the smallest range containing every value x for which icmp predicate x, y holds for some y in r (the allowed region), or for all y in r (the satisfying region). The predicate is an integer predicate, like LLVM.IntPredicate.ULT.

For example, if x < y is known to hold for some y in r, then x is in allowed_icmp_region(LLVM.IntPredicate.ULT, r).

source

LLVM.scev_minus — Function

scev_add(se::ScalarEvolution, operands::SCEV...)
scev_minus(se::ScalarEvolution, a::SCEV, b::SCEV)

Build the (simplified) expression for the sum of the operands, or for a - b. The operands must have the same type, where pointers count as integers of their index width, and only one of the operands of a sum can be a pointer. The difference of two pointers with different bases is a SCEVCouldNotCompute.

source

LLVM.SCEVConstant — Type

SCEV

A symbolic expression for a value, as computed by ScalarEvolution. Expressions are represented by a concrete subtype for each kind of expression: SCEVConstant, SCEVUnknown (a value that the analysis does not look into), SCEVAddExpr, SCEVMulExpr, SCEVUDivExpr, SCEVAddRecExpr (an add recurrence, like an induction variable of a loop), casts (SCEVTruncateExpr, SCEVZeroExtendExpr, SCEVSignExtendExpr, SCEVPtrToIntExpr), minima and maxima (SCEVUMaxExpr, SCEVSMaxExpr, SCEVUMinExpr, SCEVSMinExpr, SCEVSequentialUMinExpr), SCEVVScale (LLVM 17+), and SCEVCouldNotCompute (e.g., for the difference of pointers with different bases). Like the analysis itself, expressions must not be used after the pass that obtained them returns, or after the analysis was invalidated.

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVVScale — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVTruncateExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVZeroExtendExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVSignExtendExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVPtrToIntExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVAddExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVMulExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVUDivExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVAddRecExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVUMaxExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVSMaxExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVUMinExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVSMinExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVSequentialUMinExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVUnknown — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVCouldNotCompute — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source

LLVM.SCEVOtherExpr — Type

SCEV

Properties

s.type: the type of the expression (not available for SCEVCouldNotCompute).
s.operands: the operands of the expression (a vector of SCEVs).
s.value: the ConstantInt of a SCEVConstant, or the value of a SCEVUnknown.
s.loop: the Loop of a SCEVAddRecExpr.
s.start: the start value of a SCEVAddRecExpr (its first operand).
s.affine: whether a SCEVAddRecExpr is affine, i.e., has a step that is invariant in its loop (when it has two operands: {start,+,step}).
s.nuw, s.nsw, s.nw: the no-wrap flags of an n-ary expression (SCEVAddExpr, SCEVMulExpr, SCEVAddRecExpr, and the minima and maxima): whether it is known not to wrap in the unsigned or signed sense, and (for an add recurrence) whether it is known to never wrap back to its start value (no self-wrap). These are facts that scalar evolution proved or derived from the IR, which hold in the context of the expression.

source