LLVM 24.0.0git
SPIRVCodeGenPassBuilder.cpp
Go to the documentation of this file.
1//===----------------------------------------------------------------------===//
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
10#include "SPIRV.h"
11#include "SPIRVAsmPrinter.h"
12#include "SPIRVModuleAnalysis.h"
13#include "SPIRVTargetMachine.h"
39
40using namespace llvm;
41
42namespace {
43
44class SPIRVCodeGenPassBuilder : public CodeGenPassBuilder {
45 using Base = CodeGenPassBuilder;
46
47 SPIRVTargetMachine &getTM() const {
48 return static_cast<SPIRVTargetMachine &>(TM);
49 }
50
51public:
52 explicit SPIRVCodeGenPassBuilder(SPIRVTargetMachine &TM,
53 const CGPassBuilderOption &Opts,
54 PassInstrumentationCallbacks *PIC)
55 : CodeGenPassBuilder(TM, Opts, PIC) {
56 // Disable passes that break from assuming no virtual registers exist.
57 disablePass<MachineCopyPropagationPass, PostRAMachineSinkingPass,
58 PostRASchedulerPass, FuncletLayoutPass, StackMapLivenessPass,
59 PatchableFunctionPass, ShrinkWrapPass, LiveDebugValuesPass,
60 MachineLateInstrsCleanupPass, RemoveLoadsIntoFakeUsesPass,
61 BranchFolderPass, MachineBlockPlacementPass>();
62 // Logical SPIR-V cannot express the pointer induction variables that loop
63 // strength reduction creates.
65 Opt.DisableLSR = true;
66 }
67
68protected:
69 void addIRPasses(PassManagerWrapper &PMW) override;
70 void addISelPrepare(PassManagerWrapper &PMW) override;
71 Error addIRTranslator(PassManagerWrapper &PMW) override;
72 void addPreLegalizeMachineIR(PassManagerWrapper &PMW) override;
73 Error addLegalizeMachineIR(PassManagerWrapper &PMW) override;
74 Error addRegBankSelect(PassManagerWrapper &PMW) override;
75 Error addGlobalInstructionSelect(PassManagerWrapper &PMW) override;
76
77 Error addFastRegAlloc(PassManagerWrapper &PMW) override;
78
79 Error addOptimizedRegAlloc(PassManagerWrapper &PMW) override;
80
81 void addPreEmitPass2(PassManagerWrapper &PMW) override;
82
83 void addAsmPrinterBegin(PassManagerWrapper &PMW) override;
84 void addAsmPrinter(PassManagerWrapper &PMW) override;
85 void addAsmPrinterEnd(PassManagerWrapper &PMW) override;
86};
87
88} // namespace
89
90void SPIRVCodeGenPassBuilder::addIRPasses(PassManagerWrapper &PMW) {
91 addFunctionPass(AtomicExpandPass(TM), PMW);
92
93 Base::addIRPasses(PMW);
94
95 flushFPMsToMPM(PMW);
96
97 if (getTM().getSubtargetImpl()->isShader()) {
98 if (getOptLevel() != CodeGenOptLevel::None) {
99 addModulePass(SPIRVFinalizeShaderLinkagePass(getTM()), PMW);
100 }
101 addModulePass(SPIRVRemoveUnusedResourcesPass(), PMW);
102 } else {
103 // Variadic function calls aren't supported in shader code.
104 // This needs to come before SPIRVPrepareFunctions because this
105 // may introduce intrinsic calls.
106 addModulePass(ExpandVariadicsPass(ExpandVariadicsMode::Lowering), PMW);
107 }
108
109 addFunctionPass(SPIRVRegularizerPass(), PMW);
110 flushFPMsToMPM(PMW);
111 addModulePass(SPIRVCtorDtorLoweringPass(), PMW);
112 addModulePass(SPIRVPrepareFunctionsPass(getTM()), PMW);
113 addModulePass(SPIRVPrepareGlobalsPass(), PMW);
114}
115
116void SPIRVCodeGenPassBuilder::addISelPrepare(PassManagerWrapper &PMW) {
117 SPIRVTargetMachine &TM = getTM();
118 if (getTM().getSubtargetImpl()->isShader()) {
119 // Vulkan does not allow address space casts. This pass is run to remove
120 // address space casts that can be removed.
121 // If an address space cast is not removed while targeting Vulkan, lowering
122 // will fail during MIR lowering.
123 addFunctionPass(InferAddressSpacesPass(), PMW);
124
125 // 1. Simplify loop for subsequent transformations. After this steps, loops
126 // have the following properties:
127 // - loops have a single entry edge (pre-header to loop header).
128 // - all loop exits are dominated by the loop pre-header.
129 // - loops have a single back-edge.
130 addFunctionPass(LoopSimplifyPass(), PMW);
131
132 // 2. Removes registers whose lifetime spans across basic blocks. Also
133 // removes phi nodes. This will greatly simplify the next steps.
134 addFunctionPass(RegToMemPass(), PMW);
135
136 // 3. Merge the convergence region exit nodes into one. After this step,
137 // regions are single-entry, single-exit. This will help determine the
138 // correct merge block.
139 addFunctionPass(SPIRVMergeRegionExitTargetsPass(), PMW);
140
141 // 4. Structurize.
142 addFunctionPass(SPIRVStructurizerPass(), PMW);
143
144 // 5. Reduce the amount of variables required by pushing some operations
145 // back to virtual registers.
146 addFunctionPass(PromotePass(), PMW);
147 } else {
148 // Canonicalize loops so they have a single latch and preheader.
149 // This enables OpLoopMerge emission for non-shader targets.
150 addFunctionPass(LoopSimplifyPass(), PMW);
151 }
152 addFunctionPass(StripConvergenceIntrinsicsPass(), PMW);
153 flushFPMsToMPM(PMW);
154 addModulePass(SPIRVLegalizeResourceBindingPass(), PMW);
155 addModulePass(SPIRVLegalizeZeroSizeArraysPass(getTM()), PMW);
156 addModulePass(SPIRVCBufferAccessPass(), PMW);
157 addModulePass(SPIRVPushConstantAccessPass(getTM()), PMW);
158 addModulePass(SPIRVEmitIntrinsicsPass(getTM()), PMW);
160 addFunctionPass(SPIRVLegalizePointerCastPass(getTM()), PMW);
161 Base::addISelPrepare(PMW);
162}
163
164Error SPIRVCodeGenPassBuilder::addIRTranslator(PassManagerWrapper &PMW) {
165 addMachineFunctionPass(IRTranslatorPass(getOptLevel()), PMW);
166 return Error::success();
167}
168
169void SPIRVCodeGenPassBuilder::addPreLegalizeMachineIR(PassManagerWrapper &PMW) {
170 addMachineFunctionPass(SPIRVPreLegalizerCombinerPass(), PMW);
171 addMachineFunctionPass(SPIRVPreLegalizerPass(), PMW);
172}
173
174Error SPIRVCodeGenPassBuilder::addLegalizeMachineIR(PassManagerWrapper &PMW) {
175 addMachineFunctionPass(LegalizerPass(), PMW);
176 addMachineFunctionPass(SPIRVPostLegalizerPass(), PMW);
177 return Error::success();
178}
179
180Error SPIRVCodeGenPassBuilder::addRegBankSelect(PassManagerWrapper &PMW) {
181 // We do not add RegBankSelectPass as we only ever need virtual registers.
182 return Error::success();
183}
184
185Error SPIRVCodeGenPassBuilder::addGlobalInstructionSelect(
186 PassManagerWrapper &PMW) {
187 addMachineFunctionPass(InstructionSelectPass(getOptLevel()), PMW);
188 return Error::success();
189}
190
191// We do nothing in register allocation as we keep virtual registers.
192Error SPIRVCodeGenPassBuilder::addFastRegAlloc(PassManagerWrapper &PMW) {
193 return Error::success();
194}
195
196Error SPIRVCodeGenPassBuilder::addOptimizedRegAlloc(PassManagerWrapper &PMW) {
197 return Error::success();
198}
199
200void SPIRVCodeGenPassBuilder::addPreEmitPass2(PassManagerWrapper &PMW) {
201 addMachineFunctionPass(SPIRVPrepareModuleAnalysisPass(), PMW);
202}
203
204void SPIRVCodeGenPassBuilder::addAsmPrinterBegin(PassManagerWrapper &PMW) {
205 addModulePass(SPIRVAsmPrinterBeginPass(), PMW, /*Force=*/true);
206}
207
208void SPIRVCodeGenPassBuilder::addAsmPrinter(PassManagerWrapper &PMW) {
209 // SPIRVModuleAnalysis needs every MachineFunction before printing starts.
210 if (CompletesPipeline) {
211 flushFPMsToMPM(PMW);
212 addModulePass(RequireAnalysisPass<SPIRVModuleAnalysis, Module>(), PMW,
213 /*Force=*/true);
214 }
215 addMachineFunctionPass(SPIRVAsmPrinterPass(), PMW);
216}
217
218void SPIRVCodeGenPassBuilder::addAsmPrinterEnd(PassManagerWrapper &PMW) {
219 addModulePass(SPIRVAsmPrinterEndPass(), PMW, /*Force=*/true);
220}
221
223#define GET_PASS_REGISTRY "SPIRVPassRegistry.def"
225}
226
229 raw_pwrite_stream *DwoOut, CodeGenFileType FileType,
230 const CGPassBuilderOption &Opt, MCContext &Ctx,
232 auto CGPB = SPIRVCodeGenPassBuilder(*this, Opt, PIC);
233 return CGPB.buildPipeline(MPM, MAM, Out, DwoOut, FileType, Ctx);
234}
Interfaces for producing common pass manager configurations.
This file declares the IRTranslator pass.
ModuleAnalysisManager MAM
PassBuilder PB(Mod->getContext(), Machine, PassOpts->PTO, std::nullopt, &PIC)
PassInstrumentationCallbacks PIC
This file defines the Pass Instrumentation classes that provide instrumentation points into the pass ...
const GCNTargetMachine & getTM(const GCNSubtarget *STI)
This pass strips convergence intrinsics and operand bundles as those are only useful when modifying t...
This class provides access to building LLVM's passes.
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
static ErrorSuccess success()
Create a success value.
Definition Error.h:336
Context object for machine code objects.
Definition MCContext.h:83
This class provides access to building LLVM's passes.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
bool isLogicalSPIRV() const
void registerPassBuilderCallbacks(PassBuilder &PB) override
Allow the target to modify the pass pipeline.
const SPIRVSubtarget * getSubtargetImpl() const
Error buildCodeGenPipeline(ModulePassManager &MPM, ModuleAnalysisManager &MAM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType, const CGPassBuilderOption &Opt, MCContext &Ctx, PassInstrumentationCallbacks *PIC) override
An abstract base class for streams implementations that also support a pwrite operation.
Interfaces for registering analysis passes, producing common pass manager configurations,...
LLVM_READNONE constexpr bool isShader(CallingConv::ID CC)
This is an optimization pass for GlobalISel generic memory operations.
CodeGenFileType
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit,...
Definition CodeGen.h:309
PassManager< Module > ModulePassManager
Convenience typedef for a pass manager over modules.
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
Definition MIRParser.h:39