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
9#include "BPF.h"
10#include "BPFAsmPrinter.h"
11#include "BPFSubtarget.h"
12#include "BPFTargetMachine.h"
13#include "llvm/CodeGen/AtomicExpand.h"
14#include "llvm/CodeGen/GlobalISel/IRTranslator.h"
15#include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
16#include "llvm/CodeGen/GlobalISel/Legalizer.h"
17#include "llvm/CodeGen/GlobalISel/RegBankSelect.h"
18#include "llvm/IR/PassInstrumentation.h"
19#include "llvm/MC/MCStreamer.h"
20#include "llvm/Passes/CodeGenPassBuilder.h"
21#include "llvm/Passes/PassBuilder.h"
22#include "llvm/Support/Error.h"
23#include "llvm/Target/CGPassBuilderOption.h"
24#include "llvm/Transforms/Scalar/SimplifyCFG.h"
25#include "llvm/Transforms/Utils/SimplifyCFGOptions.h"
26
27using namespace llvm;
28
29extern cl::opt<bool> DisableMIPeephole;
30
31namespace {
32
33class BPFCodeGenPassBuilder : public CodeGenPassBuilder {
34 using Base = CodeGenPassBuilder;
35
36 BPFTargetMachine &getTM() const {
37 return static_cast<BPFTargetMachine &>(TM);
38 }
39
40public:
41 explicit BPFCodeGenPassBuilder(BPFTargetMachine &TM,
42 const CGPassBuilderOption &Opts,
43 PassInstrumentationCallbacks *PIC)
44 : CodeGenPassBuilder(TM, Opts, PIC) {}
45
46 void addIRPasses(PassManagerWrapper &PMW) override;
47
48 Error addInstSelector(PassManagerWrapper &PMW) override;
49
50 Error addIRTranslator(PassManagerWrapper &PMW) override;
51 Error addLegalizeMachineIR(PassManagerWrapper &PMW) override;
52 Error addRegBankSelect(PassManagerWrapper &PMW) override;
53 Error addGlobalInstructionSelect(PassManagerWrapper &PMW) override;
54
55 void addMachineSSAOptimization(PassManagerWrapper &PMW) override;
56 void addPreEmitPass(PassManagerWrapper &PMW) override;
57 void addAsmPrinterBegin(PassManagerWrapper &PMW) override;
58 void addAsmPrinter(PassManagerWrapper &PMW) override;
59 void addAsmPrinterEnd(PassManagerWrapper &PMW) override;
60};
61
62void BPFCodeGenPassBuilder::addIRPasses(PassManagerWrapper &PMW) {
63 const BPFSubtarget *Subtarget = getTM().getSubtargetImpl();
64
65 addFunctionPass(Pass: AtomicExpandPass(TM), PMW);
66 flushFPMsToMPM(PMW);
67 addModulePass(Pass: BPFCheckAndAdjustIRPass(), PMW);
68 if (Subtarget->hasFuncTable())
69 addModulePass(Pass: BPFFuncTablePass(), PMW);
70
71 Base::addIRPasses(PMW);
72}
73
74Error BPFCodeGenPassBuilder::addInstSelector(PassManagerWrapper &PMW) {
75 addMachineFunctionPass(Pass: BPFISelDAGToDAGPass(getTM()), PMW);
76 return Error::success();
77}
78
79Error BPFCodeGenPassBuilder::addIRTranslator(PassManagerWrapper &PMW) {
80 addMachineFunctionPass(Pass: IRTranslatorPass(getOptLevel()), PMW);
81 return Error::success();
82}
83
84Error BPFCodeGenPassBuilder::addLegalizeMachineIR(PassManagerWrapper &PMW) {
85 addMachineFunctionPass(Pass: LegalizerPass(), PMW);
86 return Error::success();
87}
88
89Error BPFCodeGenPassBuilder::addRegBankSelect(PassManagerWrapper &PMW) {
90 addMachineFunctionPass(Pass: RegBankSelectPass(), PMW);
91 return Error::success();
92}
93
94Error BPFCodeGenPassBuilder::addGlobalInstructionSelect(
95 PassManagerWrapper &PMW) {
96 addMachineFunctionPass(Pass: InstructionSelectPass(), PMW);
97 return Error::success();
98}
99
100void BPFCodeGenPassBuilder::addMachineSSAOptimization(PassManagerWrapper &PMW) {
101 addMachineFunctionPass(Pass: BPFMISimplifyPatchablePass(), PMW);
102
103 Base::addMachineSSAOptimization(PMW);
104
105 const BPFSubtarget *Subtarget = getTM().getSubtargetImpl();
106 if (!DisableMIPeephole) {
107 if (Subtarget->getHasAlu32())
108 addMachineFunctionPass(Pass: BPFMIPeepholePass(), PMW);
109 }
110}
111
112void BPFCodeGenPassBuilder::addPreEmitPass(PassManagerWrapper &PMW) {
113 addMachineFunctionPass(Pass: BPFMIPreEmitCheckingPass(), PMW);
114 if (!DisableMIPeephole) {
115 addMachineFunctionPass(Pass: BPFMIExpandStackArgPseudosPass(), PMW);
116 addMachineFunctionPass(Pass: BPFMIPreEmitPeepholePass(), PMW);
117 }
118}
119
120void BPFCodeGenPassBuilder::addAsmPrinterBegin(PassManagerWrapper &PMW) {
121 addModulePass(Pass: BPFAsmPrinterBeginPass(), PMW, /*Force=*/true);
122}
123
124void BPFCodeGenPassBuilder::addAsmPrinter(PassManagerWrapper &PMW) {
125 addMachineFunctionPass(Pass: BPFAsmPrinterPass(), PMW);
126}
127
128void BPFCodeGenPassBuilder::addAsmPrinterEnd(PassManagerWrapper &PMW) {
129 addModulePass(Pass: BPFAsmPrinterEndPass(), PMW);
130}
131
132} // namespace
133
134static Expected<bool> parseBPFPreserveStaticOffsetOptions(StringRef Params) {
135 return PassBuilder::parseSinglePassOption(Params, OptionName: "allow-partial",
136 PassName: "BPFPreserveStaticOffsetPass");
137}
138
139void BPFTargetMachine::registerPassBuilderCallbacks(PassBuilder &PB) {
140#define GET_PASS_REGISTRY "BPFPassRegistry.def"
141#include "llvm/Passes/TargetPassRegistry.inc"
142
143 PB.registerPipelineStartEPCallback(
144 C: [=](ModulePassManager &MPM, OptimizationLevel) {
145 FunctionPassManager FPM;
146 FPM.addPass(Pass: BPFPreserveStaticOffsetPass(true));
147 FPM.addPass(Pass: BPFAbstractMemberAccessPass(this));
148 FPM.addPass(Pass: BPFPreserveDITypePass());
149 FPM.addPass(Pass: BPFIRPeepholePass());
150 MPM.addPass(Pass: createModuleToFunctionPassAdaptor(Pass: std::move(FPM)));
151 });
152 PB.registerPeepholeEPCallback(C: [=](FunctionPassManager &FPM,
153 OptimizationLevel Level) {
154 FPM.addPass(Pass: SimplifyCFGPass(SimplifyCFGOptions().hoistCommonInsts(B: true)));
155 FPM.addPass(Pass: BPFASpaceCastSimplifyPass());
156 });
157 PB.registerScalarOptimizerLateEPCallback(
158 C: [=](FunctionPassManager &FPM, OptimizationLevel Level) {
159 // Run this after loop unrolling but before
160 // SimplifyCFGPass(... .sinkCommonInsts(true))
161 FPM.addPass(Pass: BPFPreserveStaticOffsetPass(false));
162 });
163 PB.registerPipelineEarlySimplificationEPCallback(
164 C: [=](ModulePassManager &MPM, OptimizationLevel, ThinOrFullLTOPhase) {
165 MPM.addPass(Pass: BPFAdjustOptPass());
166 });
167}
168
169Error BPFTargetMachine::buildCodeGenPipeline(
170 ModulePassManager &MPM, ModuleAnalysisManager &MAM, raw_pwrite_stream &Out,
171 raw_pwrite_stream *DwoOut, CodeGenFileType FileType,
172 const CGPassBuilderOption &Opt, MCContext &Ctx,
173 PassInstrumentationCallbacks *PIC) {
174 auto CGPB = BPFCodeGenPassBuilder(*this, Opt, PIC);
175 return CGPB.buildPipeline(MPM, MAM, Out, DwoOut, FileType, Ctx);
176}
177