Passes

AddressSanitizerPass(; options...) -> String

The asan module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AddressSanitizerPass(; foo=true, bar=2) is "asan<foo;bar=2>", while false values become no- options.

AlwaysInlinerPass(; options...) -> String

The always-inline module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AlwaysInlinerPass(; foo=true, bar=2) is "always-inline<foo;bar=2>", while false values become no- options.

Annotation2MetadataPass(; options...) -> String

The annotation2metadata module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., Annotation2MetadataPass(; foo=true, bar=2) is "annotation2metadata<foo;bar=2>", while false values become no- options.

AttributorPass(; options...) -> String

The attributor module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AttributorPass(; foo=true, bar=2) is "attributor<foo;bar=2>", while false values become no- options.

BlockExtractorPass(; options...) -> String

The extract-blocks module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., BlockExtractorPass(; foo=true, bar=2) is "extract-blocks<foo;bar=2>", while false values become no- options.

CGProfilePass(; options...) -> String

The cg-profile module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CGProfilePass(; foo=true, bar=2) is "cg-profile<foo;bar=2>", while false values become no- options.

CallGraphDOTPrinterPass(; options...) -> String

The dot-callgraph module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CallGraphDOTPrinterPass(; foo=true, bar=2) is "dot-callgraph<foo;bar=2>", while false values become no- options.

CallGraphPrinterPass(; options...) -> String

The print-callgraph module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CallGraphPrinterPass(; foo=true, bar=2) is "print-callgraph<foo;bar=2>", while false values become no- options.

CallGraphViewerPass(; options...) -> String

The view-callgraph module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CallGraphViewerPass(; foo=true, bar=2) is "view-callgraph<foo;bar=2>", while false values become no- options.

CalledValuePropagationPass(; options...) -> String

The called-value-propagation module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CalledValuePropagationPass(; foo=true, bar=2) is "called-value-propagation<foo;bar=2>", while false values become no- options.

CanonicalizeAliasesPass(; options...) -> String

The canonicalize-aliases module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CanonicalizeAliasesPass(; foo=true, bar=2) is "canonicalize-aliases<foo;bar=2>", while false values become no- options.

CheckDebugifyPass(; options...) -> String

The check-debugify module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CheckDebugifyPass(; foo=true, bar=2) is "check-debugify<foo;bar=2>", while false values become no- options.

ConstantMergePass(; options...) -> String

The constmerge module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ConstantMergePass(; foo=true, bar=2) is "constmerge<foo;bar=2>", while false values become no- options.

CoroCleanupPass(; options...) -> String

The coro-cleanup module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CoroCleanupPass(; foo=true, bar=2) is "coro-cleanup<foo;bar=2>", while false values become no- options.

CoroEarlyPass(; options...) -> String

The coro-early module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CoroEarlyPass(; foo=true, bar=2) is "coro-early<foo;bar=2>", while false values become no- options.

CrossDSOCFIPass(; options...) -> String

The cross-dso-cfi module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CrossDSOCFIPass(; foo=true, bar=2) is "cross-dso-cfi<foo;bar=2>", while false values become no- options.

DataFlowSanitizerPass(; options...) -> String

The dfsan module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DataFlowSanitizerPass(; foo=true, bar=2) is "dfsan<foo;bar=2>", while false values become no- options.

DeadArgumentEliminationPass(; options...) -> String

The deadargelim module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DeadArgumentEliminationPass(; foo=true, bar=2) is "deadargelim<foo;bar=2>", while false values become no- options.

DebugifyPass(; options...) -> String

The debugify module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DebugifyPass(; foo=true, bar=2) is "debugify<foo;bar=2>", while false values become no- options.

EliminateAvailableExternallyPass(; options...) -> String

The elim-avail-extern module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., EliminateAvailableExternallyPass(; foo=true, bar=2) is "elim-avail-extern<foo;bar=2>", while false values become no- options.

ForceFunctionAttrsPass(; options...) -> String

The forceattrs module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ForceFunctionAttrsPass(; foo=true, bar=2) is "forceattrs<foo;bar=2>", while false values become no- options.

FunctionImportPass(; options...) -> String

The function-import module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., FunctionImportPass(; foo=true, bar=2) is "function-import<foo;bar=2>", while false values become no- options.

FunctionSpecializationPass(; options...) -> String

The ipsccp<func-spec> module pass, as a string for use with add! or run!.

GCOVProfilerPass(; options...) -> String

The insert-gcov-profiling module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., GCOVProfilerPass(; foo=true, bar=2) is "insert-gcov-profiling<foo;bar=2>", while false values become no- options.

GlobalDCEPass(; options...) -> String

The globaldce module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., GlobalDCEPass(; foo=true, bar=2) is "globaldce<foo;bar=2>", while false values become no- options.

GlobalOptPass(; options...) -> String

The globalopt module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., GlobalOptPass(; foo=true, bar=2) is "globalopt<foo;bar=2>", while false values become no- options.

GlobalSplitPass(; options...) -> String

The globalsplit module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., GlobalSplitPass(; foo=true, bar=2) is "globalsplit<foo;bar=2>", while false values become no- options.

HWAddressSanitizerPass(; options...) -> String

The hwasan module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., HWAddressSanitizerPass(; foo=true, bar=2) is "hwasan<foo;bar=2>", while false values become no- options.

HotColdSplittingPass(; options...) -> String

The hotcoldsplit module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., HotColdSplittingPass(; foo=true, bar=2) is "hotcoldsplit<foo;bar=2>", while false values become no- options.

IPSCCPPass(; options...) -> String

The ipsccp module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., IPSCCPPass(; foo=true, bar=2) is "ipsccp<foo;bar=2>", while false values become no- options.

IROutlinerPass(; options...) -> String

The iroutliner module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., IROutlinerPass(; foo=true, bar=2) is "iroutliner<foo;bar=2>", while false values become no- options.

IRSimilarityAnalysisPrinterPass(; options...) -> String

The print-ir-similarity module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., IRSimilarityAnalysisPrinterPass(; foo=true, bar=2) is "print-ir-similarity<foo;bar=2>", while false values become no- options.

InferFunctionAttrsPass(; options...) -> String

The inferattrs module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., InferFunctionAttrsPass(; foo=true, bar=2) is "inferattrs<foo;bar=2>", while false values become no- options.

InlineAdvisorAnalysisPrinterPass(; options...) -> String

The print<inline-advisor> module pass, as a string for use with add! or run!.

InstrOrderFilePass(; options...) -> String

The instrorderfile module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., InstrOrderFilePass(; foo=true, bar=2) is "instrorderfile<foo;bar=2>", while false values become no- options.

InstrProfiling(; options...) -> String

The instrprof module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., InstrProfiling(; foo=true, bar=2) is "instrprof<foo;bar=2>", while false values become no- options.

InternalizePass(; preserved_gvs=String[], options...) -> String

The internalize module pass, as a string for use with add! or run!, which gives internal linkage to the global values of a module, except for the ones named in preserved_gvs. Other keyword arguments become options of the pass.

InvalidateAllAnalysesPass(; options...) -> String

The invalidate<all> module pass, as a string for use with add! or run!.

LazyCallGraphDOTPrinterPass(; options...) -> String

The print-lcg-dot module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LazyCallGraphDOTPrinterPass(; foo=true, bar=2) is "print-lcg-dot<foo;bar=2>", while false values become no- options.

LazyCallGraphPrinterPass(; options...) -> String

The print-lcg module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LazyCallGraphPrinterPass(; foo=true, bar=2) is "print-lcg<foo;bar=2>", while false values become no- options.

LoopExtractorPass(; options...) -> String

The loop-extract module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopExtractorPass(; foo=true, bar=2) is "loop-extract<foo;bar=2>", while false values become no- options.

LowerGlobalDtorsPass(; options...) -> String

The lower-global-dtors module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LowerGlobalDtorsPass(; foo=true, bar=2) is "lower-global-dtors<foo;bar=2>", while false values become no- options.

LowerTypeTestsPass(; options...) -> String

The lowertypetests module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LowerTypeTestsPass(; foo=true, bar=2) is "lowertypetests<foo;bar=2>", while false values become no- options.

MemorySanitizerPass(; options...) -> String

The msan module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., MemorySanitizerPass(; foo=true, bar=2) is "msan<foo;bar=2>", while false values become no- options.

MergeFunctionsPass(; options...) -> String

The mergefunc module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., MergeFunctionsPass(; foo=true, bar=2) is "mergefunc<foo;bar=2>", while false values become no- options.

MetaRenamerPass(; options...) -> String

The metarenamer module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., MetaRenamerPass(; foo=true, bar=2) is "metarenamer<foo;bar=2>", while false values become no- options.

ModuleDebugInfoPrinterPass(; options...) -> String

The print<module-debuginfo> module pass, as a string for use with add! or run!.

ModuleInlinerMLAdvisorReleasePass(; options...) -> String

The inliner-ml-advisor-release module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ModuleInlinerMLAdvisorReleasePass(; foo=true, bar=2) is "inliner-ml-advisor-release<foo;bar=2>", while false values become no- options.

ModuleInlinerPass(; options...) -> String

The module-inline module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ModuleInlinerPass(; foo=true, bar=2) is "module-inline<foo;bar=2>", while false values become no- options.

ModuleInlinerWrapperNoMandatoryFirstPass(; options...) -> String

The inliner-wrapper-no-mandatory-first module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ModuleInlinerWrapperNoMandatoryFirstPass(; foo=true, bar=2) is "inliner-wrapper-no-mandatory-first<foo;bar=2>", while false values become no- options.

ModuleInlinerWrapperPass(; options...) -> String

The inliner-wrapper module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ModuleInlinerWrapperPass(; foo=true, bar=2) is "inliner-wrapper<foo;bar=2>", while false values become no- options.

ModuleMemProfilerPass(; options...) -> String

The memprof-module module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ModuleMemProfilerPass(; foo=true, bar=2) is "memprof-module<foo;bar=2>", while false values become no- options.

ModuleThreadSanitizerPass(; options...) -> String

The tsan-module module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ModuleThreadSanitizerPass(; foo=true, bar=2) is "tsan-module<foo;bar=2>", while false values become no- options.

MustBeExecutedContextPrinterPass(; options...) -> String

The print-must-be-executed-contexts module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., MustBeExecutedContextPrinterPass(; foo=true, bar=2) is "print-must-be-executed-contexts<foo;bar=2>", while false values become no- options.

NameAnonGlobalPass(; options...) -> String

The name-anon-globals module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., NameAnonGlobalPass(; foo=true, bar=2) is "name-anon-globals<foo;bar=2>", while false values become no- options.

NoOpModulePass(; options...) -> String

The no-op-module module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., NoOpModulePass(; foo=true, bar=2) is "no-op-module<foo;bar=2>", while false values become no- options.

ObjCARCAPElimPass(; options...) -> String

The objc-arc-apelim module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ObjCARCAPElimPass(; foo=true, bar=2) is "objc-arc-apelim<foo;bar=2>", while false values become no- options.

OpenMPOptPass(; options...) -> String

The openmp-opt module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., OpenMPOptPass(; foo=true, bar=2) is "openmp-opt<foo;bar=2>", while false values become no- options.

PGOIndirectCallPromotion(; options...) -> String

The pgo-icall-prom module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PGOIndirectCallPromotion(; foo=true, bar=2) is "pgo-icall-prom<foo;bar=2>", while false values become no- options.

PGOInstrumentationGen(; options...) -> String

The pgo-instr-gen module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PGOInstrumentationGen(; foo=true, bar=2) is "pgo-instr-gen<foo;bar=2>", while false values become no- options.

PGOInstrumentationUse(; options...) -> String

The pgo-instr-use module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PGOInstrumentationUse(; foo=true, bar=2) is "pgo-instr-use<foo;bar=2>", while false values become no- options.

PartialInlinerPass(; options...) -> String

The partial-inliner module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PartialInlinerPass(; foo=true, bar=2) is "partial-inliner<foo;bar=2>", while false values become no- options.

PoisonCheckingPass(; options...) -> String

The poison-checking module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PoisonCheckingPass(; foo=true, bar=2) is "poison-checking<foo;bar=2>", while false values become no- options.

PrintModulePass(; options...) -> String

The print module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PrintModulePass(; foo=true, bar=2) is "print<foo;bar=2>", while false values become no- options.

ProfileSummaryPrinterPass(; options...) -> String

The print-profile-summary module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ProfileSummaryPrinterPass(; foo=true, bar=2) is "print-profile-summary<foo;bar=2>", while false values become no- options.

PseudoProbeUpdatePass(; options...) -> String

The pseudo-probe-update module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PseudoProbeUpdatePass(; foo=true, bar=2) is "pseudo-probe-update<foo;bar=2>", while false values become no- options.

RecomputeGlobalsAAPass(; options...) -> String

The recompute-globalsaa module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., RecomputeGlobalsAAPass(; foo=true, bar=2) is "recompute-globalsaa<foo;bar=2>", while false values become no- options.

RelLookupTableConverterPass(; options...) -> String

The rel-lookup-table-converter module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., RelLookupTableConverterPass(; foo=true, bar=2) is "rel-lookup-table-converter<foo;bar=2>", while false values become no- options.

ReversePostOrderFunctionAttrsPass(; options...) -> String

The rpo-function-attrs module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ReversePostOrderFunctionAttrsPass(; foo=true, bar=2) is "rpo-function-attrs<foo;bar=2>", while false values become no- options.

RewriteStatepointsForGC(; options...) -> String

The rewrite-statepoints-for-gc module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., RewriteStatepointsForGC(; foo=true, bar=2) is "rewrite-statepoints-for-gc<foo;bar=2>", while false values become no- options.

RewriteSymbolPass(; options...) -> String

The rewrite-symbols module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., RewriteSymbolPass(; foo=true, bar=2) is "rewrite-symbols<foo;bar=2>", while false values become no- options.

SampleProfileLoaderPass(; options...) -> String

The sample-profile module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SampleProfileLoaderPass(; foo=true, bar=2) is "sample-profile<foo;bar=2>", while false values become no- options.

SampleProfileProbePass(; options...) -> String

The pseudo-probe module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SampleProfileProbePass(; foo=true, bar=2) is "pseudo-probe<foo;bar=2>", while false values become no- options.

SanitizerCoveragePass(; options...) -> String

The sancov-module module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SanitizerCoveragePass(; foo=true, bar=2) is "sancov-module<foo;bar=2>", while false values become no- options.

StackSafetyGlobalPrinterPass(; options...) -> String

The print-stack-safety module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., StackSafetyGlobalPrinterPass(; foo=true, bar=2) is "print-stack-safety<foo;bar=2>", while false values become no- options.

StripDeadDebugInfoPass(; options...) -> String

The strip-dead-debug-info module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., StripDeadDebugInfoPass(; foo=true, bar=2) is "strip-dead-debug-info<foo;bar=2>", while false values become no- options.

StripDeadPrototypesPass(; options...) -> String

The strip-dead-prototypes module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., StripDeadPrototypesPass(; foo=true, bar=2) is "strip-dead-prototypes<foo;bar=2>", while false values become no- options.

StripDebugDeclarePass(; options...) -> String

The strip-debug-declare module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., StripDebugDeclarePass(; foo=true, bar=2) is "strip-debug-declare<foo;bar=2>", while false values become no- options.

StripNonDebugSymbolsPass(; options...) -> String

The strip-nondebug module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., StripNonDebugSymbolsPass(; foo=true, bar=2) is "strip-nondebug<foo;bar=2>", while false values become no- options.

StripNonLineTableDebugInfoPass(; options...) -> String

The strip-nonlinetable-debuginfo module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., StripNonLineTableDebugInfoPass(; foo=true, bar=2) is "strip-nonlinetable-debuginfo<foo;bar=2>", while false values become no- options.

StripSymbolsPass(; options...) -> String

The strip module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., StripSymbolsPass(; foo=true, bar=2) is "strip<foo;bar=2>", while false values become no- options.

SyntheticCountsPropagation(; options...) -> String

The synthetic-counts-propagation module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SyntheticCountsPropagation(; foo=true, bar=2) is "synthetic-counts-propagation<foo;bar=2>", while false values become no- options.

TriggerCrashPass(; options...) -> String

The trigger-crash module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., TriggerCrashPass(; foo=true, bar=2) is "trigger-crash<foo;bar=2>", while false values become no- options.

VerifierPass(; options...) -> String

The verify module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., VerifierPass(; foo=true, bar=2) is "verify<foo;bar=2>", while false values become no- options.

WholeProgramDevirtPass(; options...) -> String

The wholeprogramdevirt module pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., WholeProgramDevirtPass(; foo=true, bar=2) is "wholeprogramdevirt<foo;bar=2>", while false values become no- options.

ArgumentPromotionPass(; options...) -> String

The argpromotion CGSCC pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ArgumentPromotionPass(; foo=true, bar=2) is "argpromotion<foo;bar=2>", while false values become no- options.

AttributorCGSCCPass(; options...) -> String

The attributor-cgscc CGSCC pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AttributorCGSCCPass(; foo=true, bar=2) is "attributor-cgscc<foo;bar=2>", while false values become no- options.

CoroSplitPass(; options...) -> String

The coro-split CGSCC pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CoroSplitPass(; foo=true, bar=2) is "coro-split<foo;bar=2>", while false values become no- options.

InlinerPass(; options...) -> String

The inline CGSCC pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., InlinerPass(; foo=true, bar=2) is "inline<foo;bar=2>", while false values become no- options.

NoOpCGSCCPass(; options...) -> String

The no-op-cgscc CGSCC pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., NoOpCGSCCPass(; foo=true, bar=2) is "no-op-cgscc<foo;bar=2>", while false values become no- options.

OpenMPOptCGSCCPass(; options...) -> String

The openmp-opt-cgscc CGSCC pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., OpenMPOptCGSCCPass(; foo=true, bar=2) is "openmp-opt-cgscc<foo;bar=2>", while false values become no- options.

PostOrderFunctionAttrsPass(; options...) -> String

The function-attrs CGSCC pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PostOrderFunctionAttrsPass(; foo=true, bar=2) is "function-attrs<foo;bar=2>", while false values become no- options.

AAEvaluator(; options...) -> String

The aa-eval function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AAEvaluator(; foo=true, bar=2) is "aa-eval<foo;bar=2>", while false values become no- options.

ADCEPass(; options...) -> String

The adce function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ADCEPass(; foo=true, bar=2) is "adce<foo;bar=2>", while false values become no- options.

AddDiscriminatorsPass(; options...) -> String

The add-discriminators function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AddDiscriminatorsPass(; foo=true, bar=2) is "add-discriminators<foo;bar=2>", while false values become no- options.

AggressiveInstCombinePass(; options...) -> String

The aggressive-instcombine function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AggressiveInstCombinePass(; foo=true, bar=2) is "aggressive-instcombine<foo;bar=2>", while false values become no- options.

AliasSetsPrinterPass(; options...) -> String

The print-alias-sets function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AliasSetsPrinterPass(; foo=true, bar=2) is "print-alias-sets<foo;bar=2>", while false values become no- options.

AlignmentFromAssumptionsPass(; options...) -> String

The alignment-from-assumptions function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AlignmentFromAssumptionsPass(; foo=true, bar=2) is "alignment-from-assumptions<foo;bar=2>", while false values become no- options.

AnnotationRemarksPass(; options...) -> String

The annotation-remarks function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AnnotationRemarksPass(; foo=true, bar=2) is "annotation-remarks<foo;bar=2>", while false values become no- options.

AssumeBuilderPass(; options...) -> String

The assume-builder function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AssumeBuilderPass(; foo=true, bar=2) is "assume-builder<foo;bar=2>", while false values become no- options.

AssumeSimplifyPass(; options...) -> String

The assume-simplify function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., AssumeSimplifyPass(; foo=true, bar=2) is "assume-simplify<foo;bar=2>", while false values become no- options.

AssumptionPrinterPass(; options...) -> String

The print<assumptions> function pass, as a string for use with add! or run!.

BDCEPass(; options...) -> String

The bdce function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., BDCEPass(; foo=true, bar=2) is "bdce<foo;bar=2>", while false values become no- options.

BlockFrequencyPrinterPass(; options...) -> String

The print<block-freq> function pass, as a string for use with add! or run!.

BoundsCheckingPass(; options...) -> String

The bounds-checking function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., BoundsCheckingPass(; foo=true, bar=2) is "bounds-checking<foo;bar=2>", while false values become no- options.

BranchProbabilityPrinterPass(; options...) -> String

The print<branch-prob> function pass, as a string for use with add! or run!.

BreakCriticalEdgesPass(; options...) -> String

The break-crit-edges function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., BreakCriticalEdgesPass(; foo=true, bar=2) is "break-crit-edges<foo;bar=2>", while false values become no- options.

CFGOnlyPrinterPass(; options...) -> String

The dot-cfg-only function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CFGOnlyPrinterPass(; foo=true, bar=2) is "dot-cfg-only<foo;bar=2>", while false values become no- options.

CFGOnlyViewerPass(; options...) -> String

The view-cfg-only function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CFGOnlyViewerPass(; foo=true, bar=2) is "view-cfg-only<foo;bar=2>", while false values become no- options.

CFGPrinterPass(; options...) -> String

The dot-cfg function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CFGPrinterPass(; foo=true, bar=2) is "dot-cfg<foo;bar=2>", while false values become no- options.

CFGViewerPass(; options...) -> String

The view-cfg function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CFGViewerPass(; foo=true, bar=2) is "view-cfg<foo;bar=2>", while false values become no- options.

CallSiteSplittingPass(; options...) -> String

The callsite-splitting function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CallSiteSplittingPass(; foo=true, bar=2) is "callsite-splitting<foo;bar=2>", while false values become no- options.

ConstantHoistingPass(; options...) -> String

The consthoist function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ConstantHoistingPass(; foo=true, bar=2) is "consthoist<foo;bar=2>", while false values become no- options.

ConstraintEliminationPass(; options...) -> String

The constraint-elimination function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ConstraintEliminationPass(; foo=true, bar=2) is "constraint-elimination<foo;bar=2>", while false values become no- options.

ControlHeightReductionPass(; options...) -> String

The chr function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ControlHeightReductionPass(; foo=true, bar=2) is "chr<foo;bar=2>", while false values become no- options.

CoroElidePass(; options...) -> String

The coro-elide function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CoroElidePass(; foo=true, bar=2) is "coro-elide<foo;bar=2>", while false values become no- options.

CorrelatedValuePropagationPass(; options...) -> String

The correlated-propagation function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CorrelatedValuePropagationPass(; foo=true, bar=2) is "correlated-propagation<foo;bar=2>", while false values become no- options.

CostModelPrinterPass(; options...) -> String

The print<cost-model> function pass, as a string for use with add! or run!.

CycleInfoPrinterPass(; options...) -> String

The print<cycles> function pass, as a string for use with add! or run!.

DCEPass(; options...) -> String

The dce function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DCEPass(; foo=true, bar=2) is "dce<foo;bar=2>", while false values become no- options.

DFAJumpThreadingPass(; options...) -> String

The dfa-jump-threading function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DFAJumpThreadingPass(; foo=true, bar=2) is "dfa-jump-threading<foo;bar=2>", while false values become no- options.

DSEPass(; options...) -> String

The dse function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DSEPass(; foo=true, bar=2) is "dse<foo;bar=2>", while false values become no- options.

DelinearizationPrinterPass(; options...) -> String

The print<delinearization> function pass, as a string for use with add! or run!.

DemandedBitsPrinterPass(; options...) -> String

The print<demanded-bits> function pass, as a string for use with add! or run!.

DependenceAnalysisPrinterPass(; options...) -> String

The print<da> function pass, as a string for use with add! or run!.

DivRemPairsPass(; options...) -> String

The div-rem-pairs function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DivRemPairsPass(; foo=true, bar=2) is "div-rem-pairs<foo;bar=2>", while false values become no- options.

DomOnlyPrinter(; options...) -> String

The dot-dom-only function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DomOnlyPrinter(; foo=true, bar=2) is "dot-dom-only<foo;bar=2>", while false values become no- options.

DomOnlyViewer(; options...) -> String

The view-dom-only function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DomOnlyViewer(; foo=true, bar=2) is "view-dom-only<foo;bar=2>", while false values become no- options.

DomPrinter(; options...) -> String

The dot-dom function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DomPrinter(; foo=true, bar=2) is "dot-dom<foo;bar=2>", while false values become no- options.

DomViewer(; options...) -> String

The view-dom function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DomViewer(; foo=true, bar=2) is "view-dom<foo;bar=2>", while false values become no- options.

DominanceFrontierPrinterPass(; options...) -> String

The print<domfrontier> function pass, as a string for use with add! or run!.

DominatorTreePrinterPass(; options...) -> String

The print<domtree> function pass, as a string for use with add! or run!.

DominatorTreeVerifierPass(; options...) -> String

The verify<domtree> function pass, as a string for use with add! or run!.

EarlyCSEPass(; options...) -> String

The early-cse function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., EarlyCSEPass(; foo=true, bar=2) is "early-cse<foo;bar=2>", while false values become no- options.

EntryExitInstrumenterPass(; options...) -> String

The ee-instrument function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., EntryExitInstrumenterPass(; foo=true, bar=2) is "ee-instrument<foo;bar=2>", while false values become no- options.

ExpandReductionsPass(; options...) -> String

The expand-reductions function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ExpandReductionsPass(; foo=true, bar=2) is "expand-reductions<foo;bar=2>", while false values become no- options.

FixIrreduciblePass(; options...) -> String

The fix-irreducible function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., FixIrreduciblePass(; foo=true, bar=2) is "fix-irreducible<foo;bar=2>", while false values become no- options.

FlattenCFGPass(; options...) -> String

The flattencfg function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., FlattenCFGPass(; foo=true, bar=2) is "flattencfg<foo;bar=2>", while false values become no- options.

Float2IntPass(; options...) -> String

The float2int function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., Float2IntPass(; foo=true, bar=2) is "float2int<foo;bar=2>", while false values become no- options.

FunctionPropertiesPrinterPass(; options...) -> String

The print<func-properties> function pass, as a string for use with add! or run!.

GVNHoistPass(; options...) -> String

The gvn-hoist function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., GVNHoistPass(; foo=true, bar=2) is "gvn-hoist<foo;bar=2>", while false values become no- options.

GVNPass(; options...) -> String

The gvn function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., GVNPass(; foo=true, bar=2) is "gvn<foo;bar=2>", while false values become no- options.

GVNSinkPass(; options...) -> String

The gvn-sink function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., GVNSinkPass(; foo=true, bar=2) is "gvn-sink<foo;bar=2>", while false values become no- options.

GuardWideningPass(; options...) -> String

The guard-widening function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., GuardWideningPass(; foo=true, bar=2) is "guard-widening<foo;bar=2>", while false values become no- options.

HelloWorldPass(; options...) -> String

The helloworld function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., HelloWorldPass(; foo=true, bar=2) is "helloworld<foo;bar=2>", while false values become no- options.

IRCEPass(; options...) -> String

The irce function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., IRCEPass(; foo=true, bar=2) is "irce<foo;bar=2>", while false values become no- options.

InferAddressSpacesPass(; options...) -> String

The infer-address-spaces function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., InferAddressSpacesPass(; foo=true, bar=2) is "infer-address-spaces<foo;bar=2>", while false values become no- options.

InjectTLIMappings(; options...) -> String

The inject-tli-mappings function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., InjectTLIMappings(; foo=true, bar=2) is "inject-tli-mappings<foo;bar=2>", while false values become no- options.

InlineCostAnnotationPrinterPass(; options...) -> String

The print<inline-cost> function pass, as a string for use with add! or run!.

InstCombinePass(; options...) -> String

The instcombine function pass, as a string for use with add! or run!. Keyword arguments become options of the pass. Unlike LLVM's C API, LLVM.jl doesn't enable the verify-fixpoint option by default (on LLVM 18 and later).

InstCountPass(; options...) -> String

The instcount function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., InstCountPass(; foo=true, bar=2) is "instcount<foo;bar=2>", while false values become no- options.

InstSimplifyPass(; options...) -> String

The instsimplify function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., InstSimplifyPass(; foo=true, bar=2) is "instsimplify<foo;bar=2>", while false values become no- options.

InstructionNamerPass(; options...) -> String

The instnamer function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., InstructionNamerPass(; foo=true, bar=2) is "instnamer<foo;bar=2>", while false values become no- options.

JumpThreadingPass(; options...) -> String

The jump-threading function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., JumpThreadingPass(; foo=true, bar=2) is "jump-threading<foo;bar=2>", while false values become no- options.

LCSSAPass(; options...) -> String

The lcssa function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LCSSAPass(; foo=true, bar=2) is "lcssa<foo;bar=2>", while false values become no- options.

LibCallsShrinkWrapPass(; options...) -> String

The libcalls-shrinkwrap function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LibCallsShrinkWrapPass(; foo=true, bar=2) is "libcalls-shrinkwrap<foo;bar=2>", while false values become no- options.

LintPass(; options...) -> String

The lint function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LintPass(; foo=true, bar=2) is "lint<foo;bar=2>", while false values become no- options.

LoadStoreVectorizerPass(; options...) -> String

The load-store-vectorizer function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoadStoreVectorizerPass(; foo=true, bar=2) is "load-store-vectorizer<foo;bar=2>", while false values become no- options.

LoopAccessInfoPrinterPass(; options...) -> String

The print<access-info> function pass, as a string for use with add! or run!.

LoopDataPrefetchPass(; options...) -> String

The loop-data-prefetch function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopDataPrefetchPass(; foo=true, bar=2) is "loop-data-prefetch<foo;bar=2>", while false values become no- options.

LoopDistributePass(; options...) -> String

The loop-distribute function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopDistributePass(; foo=true, bar=2) is "loop-distribute<foo;bar=2>", while false values become no- options.

LoopFusePass(; options...) -> String

The loop-fusion function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopFusePass(; foo=true, bar=2) is "loop-fusion<foo;bar=2>", while false values become no- options.

LoopLoadEliminationPass(; options...) -> String

The loop-load-elim function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopLoadEliminationPass(; foo=true, bar=2) is "loop-load-elim<foo;bar=2>", while false values become no- options.

LoopPrinterPass(; options...) -> String

The print<loops> function pass, as a string for use with add! or run!.

LoopSimplifyPass(; options...) -> String

The loop-simplify function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopSimplifyPass(; foo=true, bar=2) is "loop-simplify<foo;bar=2>", while false values become no- options.

LoopSinkPass(; options...) -> String

The loop-sink function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopSinkPass(; foo=true, bar=2) is "loop-sink<foo;bar=2>", while false values become no- options.

LoopUnrollPass(; opt_level=0, options...) -> String

The loop-unroll function pass, as a string for use with add! or run!, for the optimization level opt_level. Other keyword arguments become options of the pass, e.g., LoopUnrollPass(; partial=true) is "loop-unroll<O0;partial>".

LoopVectorizePass(; options...) -> String

The loop-vectorize function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopVectorizePass(; foo=true, bar=2) is "loop-vectorize<foo;bar=2>", while false values become no- options.

LoopVerifierPass(; options...) -> String

The verify<loops> function pass, as a string for use with add! or run!.

LoopVersioningPass(; options...) -> String

The loop-versioning function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopVersioningPass(; foo=true, bar=2) is "loop-versioning<foo;bar=2>", while false values become no- options.

LowerAtomicPass(; options...) -> String

The loweratomic function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LowerAtomicPass(; foo=true, bar=2) is "loweratomic<foo;bar=2>", while false values become no- options.

LowerConstantIntrinsicsPass(; options...) -> String

The lower-constant-intrinsics function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LowerConstantIntrinsicsPass(; foo=true, bar=2) is "lower-constant-intrinsics<foo;bar=2>", while false values become no- options.

LowerExpectIntrinsicPass(; options...) -> String

The lower-expect function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LowerExpectIntrinsicPass(; foo=true, bar=2) is "lower-expect<foo;bar=2>", while false values become no- options.

LowerGuardIntrinsicPass(; options...) -> String

The lower-guard-intrinsic function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LowerGuardIntrinsicPass(; foo=true, bar=2) is "lower-guard-intrinsic<foo;bar=2>", while false values become no- options.

LowerInvokePass(; options...) -> String

The lowerinvoke function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LowerInvokePass(; foo=true, bar=2) is "lowerinvoke<foo;bar=2>", while false values become no- options.

LowerMatrixIntrinsicsPass(; options...) -> String

The lower-matrix-intrinsics function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LowerMatrixIntrinsicsPass(; foo=true, bar=2) is "lower-matrix-intrinsics<foo;bar=2>", while false values become no- options.

LowerSwitchPass(; options...) -> String

The lowerswitch function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LowerSwitchPass(; foo=true, bar=2) is "lowerswitch<foo;bar=2>", while false values become no- options.

LowerWidenableConditionPass(; options...) -> String

The lower-widenable-condition function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LowerWidenableConditionPass(; foo=true, bar=2) is "lower-widenable-condition<foo;bar=2>", while false values become no- options.

MakeGuardsExplicitPass(; options...) -> String

The make-guards-explicit function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., MakeGuardsExplicitPass(; foo=true, bar=2) is "make-guards-explicit<foo;bar=2>", while false values become no- options.

MemCpyOptPass(; options...) -> String

The memcpyopt function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., MemCpyOptPass(; foo=true, bar=2) is "memcpyopt<foo;bar=2>", while false values become no- options.

MemDerefPrinterPass(; options...) -> String

The print-memderefs function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., MemDerefPrinterPass(; foo=true, bar=2) is "print-memderefs<foo;bar=2>", while false values become no- options.

MemProfilerPass(; options...) -> String

The memprof function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., MemProfilerPass(; foo=true, bar=2) is "memprof<foo;bar=2>", while false values become no- options.

MemorySSAPrinterPass(; options...) -> String

The print<memoryssa> function pass, as a string for use with add! or run!.

MemorySSAVerifierPass(; options...) -> String

The verify<memoryssa> function pass, as a string for use with add! or run!.

MemorySSAWalkerPrinterPass(; options...) -> String

The print<memoryssa-walker> function pass, as a string for use with add! or run!.

MergeICmpsPass(; options...) -> String

The mergeicmps function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., MergeICmpsPass(; foo=true, bar=2) is "mergeicmps<foo;bar=2>", while false values become no- options.

MergedLoadStoreMotionPass(; options...) -> String

The mldst-motion function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., MergedLoadStoreMotionPass(; foo=true, bar=2) is "mldst-motion<foo;bar=2>", while false values become no- options.

MustExecutePrinterPass(; options...) -> String

The print-mustexecute function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., MustExecutePrinterPass(; foo=true, bar=2) is "print-mustexecute<foo;bar=2>", while false values become no- options.

NaryReassociatePass(; options...) -> String

The nary-reassociate function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., NaryReassociatePass(; foo=true, bar=2) is "nary-reassociate<foo;bar=2>", while false values become no- options.

NewGVNPass(; options...) -> String

The newgvn function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., NewGVNPass(; foo=true, bar=2) is "newgvn<foo;bar=2>", while false values become no- options.

NoOpFunctionPass(; options...) -> String

The no-op-function function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., NoOpFunctionPass(; foo=true, bar=2) is "no-op-function<foo;bar=2>", while false values become no- options.

ObjCARCContractPass(; options...) -> String

The objc-arc-contract function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ObjCARCContractPass(; foo=true, bar=2) is "objc-arc-contract<foo;bar=2>", while false values become no- options.

ObjCARCExpandPass(; options...) -> String

The objc-arc-expand function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ObjCARCExpandPass(; foo=true, bar=2) is "objc-arc-expand<foo;bar=2>", while false values become no- options.

ObjCARCOptPass(; options...) -> String

The objc-arc function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ObjCARCOptPass(; foo=true, bar=2) is "objc-arc<foo;bar=2>", while false values become no- options.

PGOMemOPSizeOpt(; options...) -> String

The pgo-memop-opt function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PGOMemOPSizeOpt(; foo=true, bar=2) is "pgo-memop-opt<foo;bar=2>", while false values become no- options.

PartiallyInlineLibCallsPass(; options...) -> String

The partially-inline-libcalls function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PartiallyInlineLibCallsPass(; foo=true, bar=2) is "partially-inline-libcalls<foo;bar=2>", while false values become no- options.

PhiValuesPrinterPass(; options...) -> String

The print<phi-values> function pass, as a string for use with add! or run!.

PostDomOnlyPrinter(; options...) -> String

The dot-post-dom-only function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PostDomOnlyPrinter(; foo=true, bar=2) is "dot-post-dom-only<foo;bar=2>", while false values become no- options.

PostDomOnlyViewer(; options...) -> String

The view-post-dom-only function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PostDomOnlyViewer(; foo=true, bar=2) is "view-post-dom-only<foo;bar=2>", while false values become no- options.

PostDomPrinter(; options...) -> String

The dot-post-dom function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PostDomPrinter(; foo=true, bar=2) is "dot-post-dom<foo;bar=2>", while false values become no- options.

PostDomViewer(; options...) -> String

The view-post-dom function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PostDomViewer(; foo=true, bar=2) is "view-post-dom<foo;bar=2>", while false values become no- options.

PostDominatorTreePrinterPass(; options...) -> String

The print<postdomtree> function pass, as a string for use with add! or run!.

PredicateInfoPrinterPass(; options...) -> String

The print-predicateinfo function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PredicateInfoPrinterPass(; foo=true, bar=2) is "print-predicateinfo<foo;bar=2>", while false values become no- options.

PrintFunctionPass(; options...) -> String

The print function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PrintFunctionPass(; foo=true, bar=2) is "print<foo;bar=2>", while false values become no- options.

PromotePass(; options...) -> String

The mem2reg function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PromotePass(; foo=true, bar=2) is "mem2reg<foo;bar=2>", while false values become no- options.

ReassociatePass(; options...) -> String

The reassociate function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ReassociatePass(; foo=true, bar=2) is "reassociate<foo;bar=2>", while false values become no- options.

RedundantDbgInstEliminationPass(; options...) -> String

The redundant-dbg-inst-elim function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., RedundantDbgInstEliminationPass(; foo=true, bar=2) is "redundant-dbg-inst-elim<foo;bar=2>", while false values become no- options.

RegToMemPass(; options...) -> String

The reg2mem function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., RegToMemPass(; foo=true, bar=2) is "reg2mem<foo;bar=2>", while false values become no- options.

RegionInfoPrinterPass(; options...) -> String

The print<regions> function pass, as a string for use with add! or run!.

RegionInfoVerifierPass(; options...) -> String

The verify<regions> function pass, as a string for use with add! or run!.

SCCPPass(; options...) -> String

The sccp function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SCCPPass(; foo=true, bar=2) is "sccp<foo;bar=2>", while false values become no- options.

SLPVectorizerPass(; options...) -> String

The slp-vectorizer function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SLPVectorizerPass(; foo=true, bar=2) is "slp-vectorizer<foo;bar=2>", while false values become no- options.

SROAPass(; options...) -> String

The sroa function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SROAPass(; foo=true, bar=2) is "sroa<foo;bar=2>", while false values become no- options.

SafepointIRVerifierPass(; options...) -> String

The verify<safepoint-ir> function pass, as a string for use with add! or run!.

ScalarEvolutionPrinterPass(; options...) -> String

The print<scalar-evolution> function pass, as a string for use with add! or run!.

ScalarEvolutionVerifierPass(; options...) -> String

The verify<scalar-evolution> function pass, as a string for use with add! or run!.

ScalarizeMaskedMemIntrinPass(; options...) -> String

The scalarize-masked-mem-intrin function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ScalarizeMaskedMemIntrinPass(; foo=true, bar=2) is "scalarize-masked-mem-intrin<foo;bar=2>", while false values become no- options.

ScalarizerPass(; options...) -> String

The scalarizer function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ScalarizerPass(; foo=true, bar=2) is "scalarizer<foo;bar=2>", while false values become no- options.

SeparateConstOffsetFromGEPPass(; options...) -> String

The separate-const-offset-from-gep function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SeparateConstOffsetFromGEPPass(; foo=true, bar=2) is "separate-const-offset-from-gep<foo;bar=2>", while false values become no- options.

SimplifyCFGPass(; options...) -> String

The simplifycfg function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SimplifyCFGPass(; foo=true, bar=2) is "simplifycfg<foo;bar=2>", while false values become no- options.

SinkingPass(; options...) -> String

The sink function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SinkingPass(; foo=true, bar=2) is "sink<foo;bar=2>", while false values become no- options.

SpeculativeExecutionPass(; options...) -> String

The speculative-execution function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SpeculativeExecutionPass(; foo=true, bar=2) is "speculative-execution<foo;bar=2>", while false values become no- options.

StackLifetimePrinterPass(; options...) -> String

The print<stack-lifetime> function pass, as a string for use with add! or run!.

StackSafetyPrinterPass(; options...) -> String

The print<stack-safety-local> function pass, as a string for use with add! or run!.

StraightLineStrengthReducePass(; options...) -> String

The slsr function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., StraightLineStrengthReducePass(; foo=true, bar=2) is "slsr<foo;bar=2>", while false values become no- options.

StripGCRelocates(; options...) -> String

The strip-gc-relocates function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., StripGCRelocates(; foo=true, bar=2) is "strip-gc-relocates<foo;bar=2>", while false values become no- options.

StructurizeCFGPass(; options...) -> String

The structurizecfg function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., StructurizeCFGPass(; foo=true, bar=2) is "structurizecfg<foo;bar=2>", while false values become no- options.

TLSVariableHoistPass(; options...) -> String

The tlshoist function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., TLSVariableHoistPass(; foo=true, bar=2) is "tlshoist<foo;bar=2>", while false values become no- options.

TailCallElimPass(; options...) -> String

The tailcallelim function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., TailCallElimPass(; foo=true, bar=2) is "tailcallelim<foo;bar=2>", while false values become no- options.

ThreadSanitizerPass(; options...) -> String

The tsan function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., ThreadSanitizerPass(; foo=true, bar=2) is "tsan<foo;bar=2>", while false values become no- options.

UnifyFunctionExitNodesPass(; options...) -> String

The mergereturn function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., UnifyFunctionExitNodesPass(; foo=true, bar=2) is "mergereturn<foo;bar=2>", while false values become no- options.

UnifyLoopExitsPass(; options...) -> String

The unify-loop-exits function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., UnifyLoopExitsPass(; foo=true, bar=2) is "unify-loop-exits<foo;bar=2>", while false values become no- options.

VectorCombinePass(; options...) -> String

The vector-combine function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., VectorCombinePass(; foo=true, bar=2) is "vector-combine<foo;bar=2>", while false values become no- options.

WarnMissedTransformationsPass(; options...) -> String

The transform-warning function pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., WarnMissedTransformationsPass(; foo=true, bar=2) is "transform-warning<foo;bar=2>", while false values become no- options.

CanonicalizeFreezeInLoopsPass(; options...) -> String

The canon-freeze loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., CanonicalizeFreezeInLoopsPass(; foo=true, bar=2) is "canon-freeze<foo;bar=2>", while false values become no- options.

DDGAnalysisPrinterPass(; options...) -> String

The print<ddg> loop pass, as a string for use with add! or run!.

DDGDotPrinterPass(; options...) -> String

The dot-ddg loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., DDGDotPrinterPass(; foo=true, bar=2) is "dot-ddg<foo;bar=2>", while false values become no- options.

IVUsersPrinterPass(; options...) -> String

The print<iv-users> loop pass, as a string for use with add! or run!.

IndVarSimplifyPass(; options...) -> String

The indvars loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., IndVarSimplifyPass(; foo=true, bar=2) is "indvars<foo;bar=2>", while false values become no- options.

LICMPass(; options...) -> String

The licm loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LICMPass(; foo=true, bar=2) is "licm<foo;bar=2>", while false values become no- options.

LNICMPass(; options...) -> String

The lnicm loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LNICMPass(; foo=true, bar=2) is "lnicm<foo;bar=2>", while false values become no- options.

LoopBoundSplitPass(; options...) -> String

The loop-bound-split loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopBoundSplitPass(; foo=true, bar=2) is "loop-bound-split<foo;bar=2>", while false values become no- options.

LoopCachePrinterPass(; options...) -> String

The print<loop-cache-cost> loop pass, as a string for use with add! or run!.

LoopDeletionPass(; options...) -> String

The loop-deletion loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopDeletionPass(; foo=true, bar=2) is "loop-deletion<foo;bar=2>", while false values become no- options.

LoopFlattenPass(; options...) -> String

The loop-flatten loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopFlattenPass(; foo=true, bar=2) is "loop-flatten<foo;bar=2>", while false values become no- options.

LoopFullUnrollPass(; options...) -> String

The loop-unroll-full loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopFullUnrollPass(; foo=true, bar=2) is "loop-unroll-full<foo;bar=2>", while false values become no- options.

LoopIdiomRecognizePass(; options...) -> String

The loop-idiom loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopIdiomRecognizePass(; foo=true, bar=2) is "loop-idiom<foo;bar=2>", while false values become no- options.

LoopInstSimplifyPass(; options...) -> String

The loop-instsimplify loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopInstSimplifyPass(; foo=true, bar=2) is "loop-instsimplify<foo;bar=2>", while false values become no- options.

LoopInterchangePass(; options...) -> String

The loop-interchange loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopInterchangePass(; foo=true, bar=2) is "loop-interchange<foo;bar=2>", while false values become no- options.

LoopNestPrinterPass(; options...) -> String

The print<loopnest> loop pass, as a string for use with add! or run!.

LoopPredicationPass(; options...) -> String

The loop-predication loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopPredicationPass(; foo=true, bar=2) is "loop-predication<foo;bar=2>", while false values become no- options.

LoopRerollPass(; options...) -> String

The loop-reroll loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopRerollPass(; foo=true, bar=2) is "loop-reroll<foo;bar=2>", while false values become no- options.

LoopRotatePass(; options...) -> String

The loop-rotate loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopRotatePass(; foo=true, bar=2) is "loop-rotate<foo;bar=2>", while false values become no- options.

LoopSimplifyCFGPass(; options...) -> String

The loop-simplifycfg loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopSimplifyCFGPass(; foo=true, bar=2) is "loop-simplifycfg<foo;bar=2>", while false values become no- options.

LoopStrengthReducePass(; options...) -> String

The loop-reduce loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopStrengthReducePass(; foo=true, bar=2) is "loop-reduce<foo;bar=2>", while false values become no- options.

LoopUnrollAndJamPass(; options...) -> String

The loop-unroll-and-jam loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopUnrollAndJamPass(; foo=true, bar=2) is "loop-unroll-and-jam<foo;bar=2>", while false values become no- options.

LoopVersioningLICMPass(; options...) -> String

The loop-versioning-licm loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., LoopVersioningLICMPass(; foo=true, bar=2) is "loop-versioning-licm<foo;bar=2>", while false values become no- options.

NoOpLoopNestPass(; options...) -> String

The no-op-loopnest loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., NoOpLoopNestPass(; foo=true, bar=2) is "no-op-loopnest<foo;bar=2>", while false values become no- options.

NoOpLoopPass(; options...) -> String

The no-op-loop loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., NoOpLoopPass(; foo=true, bar=2) is "no-op-loop<foo;bar=2>", while false values become no- options.

PrintLoopPass(; options...) -> String

The print loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., PrintLoopPass(; foo=true, bar=2) is "print<foo;bar=2>", while false values become no- options.

SimpleLoopUnswitchPass(; options...) -> String

The simple-loop-unswitch loop pass, as a string for use with add! or run!. Keyword arguments become options of the pass, e.g., SimpleLoopUnswitchPass(; foo=true, bar=2) is "simple-loop-unswitch<foo;bar=2>", while false values become no- options.

BasicAA(; options...) -> String

The basic-aa alias analysis, as a string for use with add! or run! (in an AAManager). Keyword arguments become options of the pass, e.g., BasicAA(; foo=true, bar=2) is "basic-aa<foo;bar=2>", while false values become no- options.

ObjCARCAA(; options...) -> String

The objc-arc-aa alias analysis, as a string for use with add! or run! (in an AAManager). Keyword arguments become options of the pass, e.g., ObjCARCAA(; foo=true, bar=2) is "objc-arc-aa<foo;bar=2>", while false values become no- options.

SCEVAA(; options...) -> String

The scev-aa alias analysis, as a string for use with add! or run! (in an AAManager). Keyword arguments become options of the pass, e.g., SCEVAA(; foo=true, bar=2) is "scev-aa<foo;bar=2>", while false values become no- options.

ScopedNoAliasAA(; options...) -> String

The scoped-noalias-aa alias analysis, as a string for use with add! or run! (in an AAManager). Keyword arguments become options of the pass, e.g., ScopedNoAliasAA(; foo=true, bar=2) is "scoped-noalias-aa<foo;bar=2>", while false values become no- options.

TypeBasedAA(; options...) -> String

The tbaa alias analysis, as a string for use with add! or run! (in an AAManager). Keyword arguments become options of the pass, e.g., TypeBasedAA(; foo=true, bar=2) is "tbaa<foo;bar=2>", while false values become no- options.

CGSCCOptimizerLateCallbacks(; opt_level=0) -> String

The cgscc-optimizer-late-callbacks pass, as a string for use with add! or run!. It runs the passes that pass builder callbacks (e.g., registered with register_callbacks!) add to the corresponding extension point of LLVM's default pipelines, for the optimization level opt_level. Requires LLVM 17+.

LateLoopOptimizationsCallbacks(; opt_level=0) -> String

The late-loop-optimizations-callbacks pass, as a string for use with add! or run!. It runs the passes that pass builder callbacks (e.g., registered with register_callbacks!) add to the corresponding extension point of LLVM's default pipelines, for the optimization level opt_level. Requires LLVM 17+.

LoopOptimizerEndCallbacks(; opt_level=0) -> String

The loop-optimizer-end-callbacks pass, as a string for use with add! or run!. It runs the passes that pass builder callbacks (e.g., registered with register_callbacks!) add to the corresponding extension point of LLVM's default pipelines, for the optimization level opt_level. Requires LLVM 17+.

OptimizerEarlyCallbacks(; opt_level=0) -> String

The optimizer-early-callbacks pass, as a string for use with add! or run!. It runs the passes that pass builder callbacks (e.g., registered with register_callbacks!) add to the corresponding extension point of LLVM's default pipelines, for the optimization level opt_level. Requires LLVM 17+.

OptimizerLastCallbacks(; opt_level=0) -> String

The optimizer-last-callbacks pass, as a string for use with add! or run!. It runs the passes that pass builder callbacks (e.g., registered with register_callbacks!) add to the corresponding extension point of LLVM's default pipelines, for the optimization level opt_level. Requires LLVM 17+.

PeepholeCallbacks(; opt_level=0) -> String

The peephole-callbacks pass, as a string for use with add! or run!. It runs the passes that pass builder callbacks (e.g., registered with register_callbacks!) add to the corresponding extension point of LLVM's default pipelines, for the optimization level opt_level. Requires LLVM 17+.

PipelineEarlySimplificationCallbacks(; opt_level=0) -> String

The pipeline-early-simplification-callbacks pass, as a string for use with add! or run!. It runs the passes that pass builder callbacks (e.g., registered with register_callbacks!) add to the corresponding extension point of LLVM's default pipelines, for the optimization level opt_level. Requires LLVM 17+.

PipelineStartCallbacks(; opt_level=0) -> String

The pipeline-start-callbacks pass, as a string for use with add! or run!. It runs the passes that pass builder callbacks (e.g., registered with register_callbacks!) add to the corresponding extension point of LLVM's default pipelines, for the optimization level opt_level. Requires LLVM 17+.

ScalarOptimizerLateCallbacks(; opt_level=0) -> String

The scalar-optimizer-late-callbacks pass, as a string for use with add! or run!. It runs the passes that pass builder callbacks (e.g., registered with register_callbacks!) add to the corresponding extension point of LLVM's default pipelines, for the optimization level opt_level. Requires LLVM 17+.

VectorizerStartCallbacks(; opt_level=0) -> String

The vectorizer-start-callbacks pass, as a string for use with add! or run!. It runs the passes that pass builder callbacks (e.g., registered with register_callbacks!) add to the corresponding extension point of LLVM's default pipelines, for the optimization level opt_level. Requires LLVM 17+.