1//===-- BPFTargetMachine.cpp - Define TargetMachine for BPF ---------------===//
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// Implements the info about BPF target spec.
10//
11//===----------------------------------------------------------------------===//
12
13#include "BPFTargetMachine.h"
14#include "BPF.h"
15#include "BPFTargetLoweringObjectFile.h"
16#include "BPFTargetTransformInfo.h"
17#include "MCTargetDesc/BPFMCAsmInfo.h"
18#include "TargetInfo/BPFTargetInfo.h"
19#include "llvm/CodeGen/GlobalISel/IRTranslator.h"
20#include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
21#include "llvm/CodeGen/GlobalISel/Legalizer.h"
22#include "llvm/CodeGen/GlobalISel/RegBankSelect.h"
23#include "llvm/CodeGen/Passes.h"
24#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
25#include "llvm/CodeGen/TargetPassConfig.h"
26#include "llvm/IR/PassManager.h"
27#include "llvm/InitializePasses.h"
28#include "llvm/MC/TargetRegistry.h"
29#include "llvm/Passes/PassBuilder.h"
30#include "llvm/Support/Compiler.h"
31#include "llvm/Target/TargetOptions.h"
32#include "llvm/Transforms/Scalar.h"
33#include <optional>
34using namespace llvm;
35
36cl::opt<bool> DisableMIPeephole("disable-bpf-peephole", cl::Hidden,
37 cl::desc("Disable machine peepholes for BPF"));
38
39static cl::opt<bool>
40 DisableCheckUnreachable("bpf-disable-trap-unreachable", cl::Hidden,
41 cl::desc("Disable Trap Unreachable for BPF"));
42
43extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void LLVMInitializeBPFTarget() {
44 // Register the target.
45 RegisterTargetMachine<BPFTargetMachine> X(getTheBPFleTarget());
46 RegisterTargetMachine<BPFTargetMachine> Y(getTheBPFbeTarget());
47 RegisterTargetMachine<BPFTargetMachine> Z(getTheBPFTarget());
48
49 PassRegistry &PR = *PassRegistry::getPassRegistry();
50 initializeGlobalISel(PR);
51 initializeBPFAsmPrinterPass(PR);
52 initializeBPFCheckAndAdjustIRLegacyPass(PR);
53 initializeBPFMIPeepholeLegacyPass(PR);
54 initializeBPFMIExpandStackArgPseudosLegacyPass(PR);
55 initializeBPFMIPreEmitPeepholeLegacyPass(PR);
56 initializeBPFDAGToDAGISelLegacyPass(PR);
57 initializeBPFMISimplifyPatchableLegacyPass(PR);
58 initializeBPFMIPreEmitCheckingLegacyPass(PR);
59}
60
61static Reloc::Model getEffectiveRelocModel(std::optional<Reloc::Model> RM) {
62 return RM.value_or(u: Reloc::PIC_);
63}
64
65BPFTargetMachine::BPFTargetMachine(const Target &T, const Triple &TT,
66 StringRef CPU, StringRef FS,
67 const TargetOptions &Options,
68 std::optional<Reloc::Model> RM,
69 std::optional<CodeModel::Model> CM,
70 CodeGenOptLevel OL, bool JIT)
71 : CodeGenTargetMachineImpl(T, TT.computeDataLayout(), TT, CPU, FS, Options,
72 getEffectiveRelocModel(RM),
73 getEffectiveCodeModel(CM, Default: CodeModel::Small), OL),
74 TLOF(std::make_unique<BPFTargetLoweringObjectFileELF>()),
75 Subtarget(TT, std::string(CPU), std::string(FS), *this) {
76 if (!DisableCheckUnreachable) {
77 this->Options.TrapUnreachable = true;
78 this->Options.NoTrapAfterNoreturn = true;
79 }
80
81 initAsmInfo();
82
83 BPFMCAsmInfo *MAI =
84 static_cast<BPFMCAsmInfo *>(const_cast<MCAsmInfo *>(AsmInfo.get()));
85 MAI->setDwarfUsesRelocationsAcrossSections(!Subtarget.getUseDwarfRIS());
86}
87
88namespace {
89// BPF Code Generator Pass Configuration Options.
90class BPFPassConfig : public TargetPassConfig {
91public:
92 BPFPassConfig(BPFTargetMachine &TM, PassManagerBase &PM)
93 : TargetPassConfig(TM, PM) {}
94
95 BPFTargetMachine &getBPFTargetMachine() const {
96 return getTM<BPFTargetMachine>();
97 }
98
99 void addIRPasses() override;
100 bool addInstSelector() override;
101 void addMachineSSAOptimization() override;
102 void addPreEmitPass() override;
103
104 bool addIRTranslator() override;
105 bool addLegalizeMachineIR() override;
106 bool addRegBankSelect() override;
107 bool addGlobalInstructionSelect() override;
108};
109}
110
111TargetPassConfig *BPFTargetMachine::createPassConfig(PassManagerBase &PM) {
112 return new BPFPassConfig(*this, PM);
113}
114
115void BPFPassConfig::addIRPasses() {
116 addPass(P: createAtomicExpandLegacyPass());
117 addPass(P: createBPFCheckAndAdjustIRLegacyPass());
118
119 TargetPassConfig::addIRPasses();
120}
121
122TargetTransformInfo
123BPFTargetMachine::getTargetTransformInfo(const Function &F) const {
124 return TargetTransformInfo(std::make_unique<BPFTTIImpl>(args: this, args: F));
125}
126
127// Install an instruction selector pass using
128// the ISelDag to gen BPF code.
129bool BPFPassConfig::addInstSelector() {
130 addPass(P: createBPFISelDag(TM&: getBPFTargetMachine()));
131
132 return false;
133}
134
135void BPFPassConfig::addMachineSSAOptimization() {
136 addPass(P: createBPFMISimplifyPatchableLegacyPass());
137
138 // The default implementation must be called first as we want eBPF
139 // Peephole ran at last.
140 TargetPassConfig::addMachineSSAOptimization();
141
142 const BPFSubtarget *Subtarget = getBPFTargetMachine().getSubtargetImpl();
143 if (!DisableMIPeephole) {
144 if (Subtarget->getHasAlu32())
145 addPass(P: createBPFMIPeepholeLegacyPass());
146 }
147}
148
149void BPFPassConfig::addPreEmitPass() {
150 addPass(P: createBPFMIPreEmitCheckingLegacyPass());
151 if (!DisableMIPeephole) {
152 addPass(P: createBPFMIExpandStackArgPseudosLegacyPass());
153 addPass(P: createBPFMIPreEmitPeepholeLegacyPass());
154 }
155}
156
157bool BPFPassConfig::addIRTranslator() {
158 addPass(P: new IRTranslatorLegacy());
159 return false;
160}
161
162bool BPFPassConfig::addLegalizeMachineIR() {
163 addPass(P: new LegalizerLegacy());
164 return false;
165}
166
167bool BPFPassConfig::addRegBankSelect() {
168 addPass(P: new RegBankSelectLegacy());
169 return false;
170}
171
172bool BPFPassConfig::addGlobalInstructionSelect() {
173 addPass(P: new InstructionSelectLegacy(getOptLevel()));
174 return false;
175}
176