LLVM 20.0.0git
PassBuilderBindings.cpp
Go to the documentation of this file.
1//===-------------- PassBuilder bindings for LLVM-C -----------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9///
10/// This file defines the C bindings to the new pass manager
11///
12//===----------------------------------------------------------------------===//
13
16#include "llvm/IR/Module.h"
17#include "llvm/IR/Verifier.h"
21
22using namespace llvm;
23
24namespace llvm {
25/// Helper struct for holding a set of builder options for LLVMRunPasses. This
26/// structure is used to keep LLVMRunPasses backwards compatible with future
27/// versions in case we modify the options the new Pass Manager utilizes.
29public:
31 bool DebugLogging = false, bool VerifyEach = false,
32 const char *AAPipeline = nullptr,
36
39 const char *AAPipeline;
41};
42} // namespace llvm
43
45 return reinterpret_cast<TargetMachine *>(P);
46}
47
50
58
61 PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC);
62
68 // If we have a custom AA pipeline, we need to register it _before_ calling
69 // registerFunctionAnalyses, or the default alias analysis pipeline is used.
70 AAManager AA;
71 if (auto Err = PB.parseAAPipeline(AA, PassOpts->AAPipeline))
72 return wrap(std::move(Err));
73 FAM.registerPass([&] { return std::move(AA); });
74 }
80
82 SI.registerCallbacks(PIC, &MAM);
86 }
87 if (auto Err = PB.parsePassPipeline(MPM, Passes)) {
88 return wrap(std::move(Err));
89 }
90
91 MPM.run(*Mod, MAM);
93}
94
96 return wrap(new LLVMPassBuilderOptions());
97}
98
101 unwrap(Options)->VerifyEach = VerifyEach;
102}
103
105 LLVMBool DebugLogging) {
106 unwrap(Options)->DebugLogging = DebugLogging;
107}
108
110 const char *AAPipeline) {
111 unwrap(Options)->AAPipeline = AAPipeline;
112}
113
115 LLVMPassBuilderOptionsRef Options, LLVMBool LoopInterleaving) {
116 unwrap(Options)->PTO.LoopInterleaving = LoopInterleaving;
117}
118
120 LLVMPassBuilderOptionsRef Options, LLVMBool LoopVectorization) {
121 unwrap(Options)->PTO.LoopVectorization = LoopVectorization;
122}
123
125 LLVMPassBuilderOptionsRef Options, LLVMBool SLPVectorization) {
126 unwrap(Options)->PTO.SLPVectorization = SLPVectorization;
127}
128
130 LLVMBool LoopUnrolling) {
131 unwrap(Options)->PTO.LoopUnrolling = LoopUnrolling;
132}
133
135 LLVMPassBuilderOptionsRef Options, LLVMBool ForgetAllSCEVInLoopUnroll) {
136 unwrap(Options)->PTO.ForgetAllSCEVInLoopUnroll = ForgetAllSCEVInLoopUnroll;
137}
138
140 unsigned LicmMssaOptCap) {
141 unwrap(Options)->PTO.LicmMssaOptCap = LicmMssaOptCap;
142}
143
145 LLVMPassBuilderOptionsRef Options, unsigned LicmMssaNoAccForPromotionCap) {
146 unwrap(Options)->PTO.LicmMssaNoAccForPromotionCap =
147 LicmMssaNoAccForPromotionCap;
148}
149
151 LLVMPassBuilderOptionsRef Options, LLVMBool CallGraphProfile) {
152 unwrap(Options)->PTO.CallGraphProfile = CallGraphProfile;
153}
154
156 LLVMBool MergeFunctions) {
157 unwrap(Options)->PTO.MergeFunctions = MergeFunctions;
158}
159
161 LLVMPassBuilderOptionsRef Options, int Threshold) {
162 unwrap(Options)->PTO.InlinerThreshold = Threshold;
163}
164
166 delete unwrap(Options);
167}
aarch64 promote const
#define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:371
Module.h This file contains the declarations for the Module class.
#define P(N)
CGSCCAnalysisManager CGAM
static TargetMachine * unwrap(LLVMTargetMachineRef P)
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
ModulePassManager MPM
LLVMPassBuilderOptions * PassOpts
Module * Mod
LoopAnalysisManager LAM
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
return LLVMErrorSuccess
const char LLVMTargetMachineRef TM
bool Debug
bool VerifyEach
PassInstrumentationCallbacks PIC
const char * Passes
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
This header defines a class that provides bookkeeping for all standard (i.e in-tree) pass instrumenta...
A manager for alias analyses.
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:253
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition: PassManager.h:467
Helper struct for holding a set of builder options for LLVMRunPasses.
LLVMPassBuilderOptions(bool DebugLogging=false, bool VerifyEach=false, const char *AAPipeline=nullptr, PipelineTuningOptions PTO=PipelineTuningOptions())
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:299
This class provides access to building LLVM's passes.
Definition: PassBuilder.h:106
Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM, MachineFunctionAnalysisManager *MFAM=nullptr)
Cross register the analysis managers through their proxies.
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)
Definition: PassManager.h:195
PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs)
Run all of the passes in this manager over the given unit of IR.
Tunable parameters for passes in the default pipelines.
Definition: PassBuilder.h:44
This class provides an interface to register all the standard pass instrumentations and manages their...
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:77
Create a verifier pass.
Definition: Verifier.h:132
void LLVMPassBuilderOptionsSetMergeFunctions(LLVMPassBuilderOptionsRef Options, LLVMBool MergeFunctions)
void LLVMPassBuilderOptionsSetDebugLogging(LLVMPassBuilderOptionsRef Options, LLVMBool DebugLogging)
Toggle debug logging when running the PassBuilder.
LLVMPassBuilderOptionsRef LLVMCreatePassBuilderOptions()
Create a new set of options for a PassBuilder.
void LLVMPassBuilderOptionsSetVerifyEach(LLVMPassBuilderOptionsRef Options, LLVMBool VerifyEach)
Toggle adding the VerifierPass for the PassBuilder, ensuring all functions inside the module is valid...
void LLVMPassBuilderOptionsSetLicmMssaOptCap(LLVMPassBuilderOptionsRef Options, unsigned LicmMssaOptCap)
void LLVMDisposePassBuilderOptions(LLVMPassBuilderOptionsRef Options)
Dispose of a heap-allocated PassBuilderOptions instance.
void LLVMPassBuilderOptionsSetLicmMssaNoAccForPromotionCap(LLVMPassBuilderOptionsRef Options, unsigned LicmMssaNoAccForPromotionCap)
void LLVMPassBuilderOptionsSetInlinerThreshold(LLVMPassBuilderOptionsRef Options, int Threshold)
void LLVMPassBuilderOptionsSetSLPVectorization(LLVMPassBuilderOptionsRef Options, LLVMBool SLPVectorization)
void LLVMPassBuilderOptionsSetCallGraphProfile(LLVMPassBuilderOptionsRef Options, LLVMBool CallGraphProfile)
void LLVMPassBuilderOptionsSetLoopVectorization(LLVMPassBuilderOptionsRef Options, LLVMBool LoopVectorization)
void LLVMPassBuilderOptionsSetLoopUnrolling(LLVMPassBuilderOptionsRef Options, LLVMBool LoopUnrolling)
void LLVMPassBuilderOptionsSetAAPipeline(LLVMPassBuilderOptionsRef Options, const char *AAPipeline)
Specify a custom alias analysis pipeline for the PassBuilder to be used instead of the default one.
typedefLLVM_C_EXTERN_C_BEGIN struct LLVMOpaquePassBuilderOptions * LLVMPassBuilderOptionsRef
A set of options passed which are attached to the Pass Manager upon run.
Definition: PassBuilder.h:38
void LLVMPassBuilderOptionsSetForgetAllSCEVInLoopUnroll(LLVMPassBuilderOptionsRef Options, LLVMBool ForgetAllSCEVInLoopUnroll)
void LLVMPassBuilderOptionsSetLoopInterleaving(LLVMPassBuilderOptionsRef Options, LLVMBool LoopInterleaving)
LLVMErrorRef LLVMRunPasses(LLVMModuleRef M, const char *Passes, LLVMTargetMachineRef TM, LLVMPassBuilderOptionsRef Options)
Construct and run a set of passes over a module.
struct LLVMOpaqueError * LLVMErrorRef
Opaque reference to an error instance.
Definition: Error.h:33
int LLVMBool
Definition: Types.h:28
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
Definition: Types.h:61
struct LLVMOpaqueTargetMachine * LLVMTargetMachineRef
Definition: TargetMachine.h:35
Interfaces for registering analysis passes, producing common pass manager configurations,...
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:315