1//===-- BPFAsmPrinter.cpp - BPF LLVM assembly writer ----------------------===//
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// This file contains a printer that converts from our internal representation
10// of machine-dependent LLVM code to the BPF assembly language.
11//
12//===----------------------------------------------------------------------===//
13
14#include "BPFAsmPrinter.h"
15#include "BPF.h"
16#include "BPFInstrInfo.h"
17#include "BPFMCInstLower.h"
18#include "BTFDebug.h"
19#include "MCTargetDesc/BPFInstPrinter.h"
20#include "TargetInfo/BPFTargetInfo.h"
21#include "llvm/BinaryFormat/ELF.h"
22#include "llvm/CodeGen/AsmPrinter.h"
23#include "llvm/CodeGen/AsmPrinterAnalysis.h"
24#include "llvm/CodeGen/MachineConstantPool.h"
25#include "llvm/CodeGen/MachineFunction.h"
26#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
27#include "llvm/CodeGen/MachineInstr.h"
28#include "llvm/CodeGen/MachineJumpTableInfo.h"
29#include "llvm/CodeGen/MachineModuleInfo.h"
30#include "llvm/CodeGen/MachinePassManager.h"
31#include "llvm/CodeGen/TargetLowering.h"
32#include "llvm/IR/Analysis.h"
33#include "llvm/IR/DiagnosticInfo.h"
34#include "llvm/IR/Module.h"
35#include "llvm/IR/PassManager.h"
36#include "llvm/MC/MCAsmInfo.h"
37#include "llvm/MC/MCExpr.h"
38#include "llvm/MC/MCInst.h"
39#include "llvm/MC/MCStreamer.h"
40#include "llvm/MC/MCSymbol.h"
41#include "llvm/MC/MCSymbolELF.h"
42#include "llvm/MC/TargetRegistry.h"
43#include "llvm/Support/Compiler.h"
44#include "llvm/Support/raw_ostream.h"
45#include "llvm/Target/TargetLoweringObjectFile.h"
46using namespace llvm;
47
48#define DEBUG_TYPE "asm-printer"
49
50BPFAsmPrinter::BPFAsmPrinter(TargetMachine &TM,
51 std::unique_ptr<MCStreamer> Streamer)
52 : AsmPrinter(TM, std::move(Streamer), ID), BTF(nullptr), TM(TM) {}
53
54BPFAsmPrinter::~BPFAsmPrinter() = default;
55
56bool BPFAsmPrinter::doInitialization(Module &M) {
57 AsmPrinter::doInitialization(M);
58
59 // Only emit BTF when debuginfo available.
60 if (MAI.doesSupportDebugInformation() && !M.debug_compile_units().empty()) {
61 BTF = new BTFDebug(this);
62 Handlers.push_back(Elt: std::unique_ptr<BTFDebug>(BTF));
63 }
64
65 return false;
66}
67
68const BPFTargetMachine &BPFAsmPrinter::getBTM() const {
69 return static_cast<const BPFTargetMachine &>(TM);
70}
71
72bool BPFAsmPrinter::doFinalization(Module &M) {
73 // Remove unused globals which are previously used for jump table.
74 const BPFSubtarget *Subtarget = getBTM().getSubtargetImpl();
75 if (Subtarget->hasGotox()) {
76 std::vector<GlobalVariable *> Targets;
77 for (GlobalVariable &Global : M.globals()) {
78 if (Global.getLinkage() != GlobalValue::PrivateLinkage)
79 continue;
80 if (!Global.isConstant() || !Global.hasInitializer())
81 continue;
82
83 Constant *CV = dyn_cast<Constant>(Val: Global.getInitializer());
84 if (!CV)
85 continue;
86 ConstantArray *CA = dyn_cast<ConstantArray>(Val: CV);
87 if (!CA)
88 continue;
89
90 if (!all_of(Range: CA->operands(),
91 P: [](const Use &Op) { return isa<BlockAddress>(Val: Op); }))
92 continue;
93 Targets.push_back(x: &Global);
94 }
95
96 for (GlobalVariable *GV : Targets) {
97 GV->replaceAllUsesWith(V: PoisonValue::get(T: GV->getType()));
98 GV->dropAllReferences();
99 GV->eraseFromParent();
100 }
101 }
102
103 for (GlobalObject &GO : M.global_objects()) {
104 if (!GO.hasExternalWeakLinkage())
105 continue;
106
107 if (!SawTrapCall && GO.getName() == BPF_TRAP) {
108 GO.eraseFromParent();
109 break;
110 }
111 }
112
113 return AsmPrinter::doFinalization(M);
114}
115
116void BPFAsmPrinter::printOperand(const MachineInstr *MI, int OpNum,
117 raw_ostream &O) {
118 const MachineOperand &MO = MI->getOperand(i: OpNum);
119
120 switch (MO.getType()) {
121 case MachineOperand::MO_Register:
122 O << BPFInstPrinter::getRegisterName(Reg: MO.getReg());
123 break;
124
125 case MachineOperand::MO_Immediate:
126 O << MO.getImm();
127 break;
128
129 case MachineOperand::MO_MachineBasicBlock:
130 O << *MO.getMBB()->getSymbol();
131 break;
132
133 case MachineOperand::MO_GlobalAddress:
134 O << *getSymbol(GV: MO.getGlobal());
135 break;
136
137 case MachineOperand::MO_BlockAddress: {
138 MCSymbol *BA = GetBlockAddressSymbol(BA: MO.getBlockAddress());
139 O << BA->getName();
140 break;
141 }
142
143 case MachineOperand::MO_ExternalSymbol:
144 O << *GetExternalSymbolSymbol(Sym: MO.getSymbolName());
145 break;
146
147 case MachineOperand::MO_JumpTableIndex:
148 case MachineOperand::MO_ConstantPoolIndex:
149 default:
150 llvm_unreachable("<unknown operand type>");
151 }
152}
153
154bool BPFAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
155 const char *ExtraCode, raw_ostream &O) {
156 if (ExtraCode && ExtraCode[0])
157 return AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, OS&: O);
158
159 printOperand(MI, OpNum: OpNo, O);
160 return false;
161}
162
163bool BPFAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
164 unsigned OpNum, const char *ExtraCode,
165 raw_ostream &O) {
166 assert(OpNum + 1 < MI->getNumOperands() && "Insufficient operands");
167 const MachineOperand &BaseMO = MI->getOperand(i: OpNum);
168 const MachineOperand &OffsetMO = MI->getOperand(i: OpNum + 1);
169 assert(BaseMO.isReg() && "Unexpected base pointer for inline asm memory operand.");
170 assert(OffsetMO.isImm() && "Unexpected offset for inline asm memory operand.");
171 int Offset = OffsetMO.getImm();
172
173 if (ExtraCode)
174 return true; // Unknown modifier.
175
176 if (Offset < 0)
177 O << "(" << BPFInstPrinter::getRegisterName(Reg: BaseMO.getReg()) << " - " << -Offset << ")";
178 else
179 O << "(" << BPFInstPrinter::getRegisterName(Reg: BaseMO.getReg()) << " + " << Offset << ")";
180
181 return false;
182}
183
184void BPFAsmPrinter::emitInstruction(const MachineInstr *MI) {
185 if (MI->isCall()) {
186 for (const MachineOperand &Op : MI->operands()) {
187 if (Op.isGlobal()) {
188 if (const GlobalValue *GV = Op.getGlobal())
189 if (GV->getName() == BPF_TRAP)
190 SawTrapCall = true;
191 }
192 }
193 }
194
195 BPF_MC::verifyInstructionPredicates(Opcode: MI->getOpcode(),
196 Features: getSubtargetInfo().getFeatureBits());
197
198 MCInst TmpInst;
199
200 if (!BTF || !BTF->InstLower(MI, OutMI&: TmpInst)) {
201 BPFMCInstLower MCInstLowering(OutContext, *this);
202 MCInstLowering.Lower(MI, OutMI&: TmpInst);
203 }
204 EmitToStreamer(S&: *OutStreamer, Inst: TmpInst);
205}
206
207MCSymbol *BPFAsmPrinter::getJTPublicSymbol(unsigned JTI) {
208 SmallString<60> Name;
209 raw_svector_ostream(Name)
210 << "BPF.JT." << MF->getFunctionNumber() << '.' << JTI;
211 MCSymbol *S = OutContext.getOrCreateSymbol(Name);
212 if (auto *ES = static_cast<MCSymbolELF *>(S)) {
213 ES->setBinding(ELF::STB_GLOBAL);
214 ES->setType(ELF::STT_OBJECT);
215 }
216 return S;
217}
218
219void BPFAsmPrinter::emitJumpTableInfo() {
220 const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
221 if (!MJTI)
222 return;
223
224 const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
225 if (JT.empty())
226 return;
227
228 const TargetLoweringObjectFile &TLOF = getObjFileLowering();
229 const Function &F = MF->getFunction();
230
231 MCSection *Sec = OutStreamer->getCurrentSectionOnly();
232 MCSymbol *SecStart = Sec->getBeginSymbol();
233
234 MCSection *JTS = TLOF.getSectionForJumpTable(F, TM);
235 assert(MJTI->getEntryKind() == MachineJumpTableInfo::EK_BlockAddress);
236 unsigned EntrySize = MJTI->getEntrySize(TD: getDataLayout());
237 OutStreamer->switchSection(Section: JTS);
238 for (unsigned JTI = 0; JTI < JT.size(); JTI++) {
239 ArrayRef<MachineBasicBlock *> JTBBs = JT[JTI].MBBs;
240 if (JTBBs.empty())
241 continue;
242
243 MCSymbol *JTStart = getJTPublicSymbol(JTI);
244 OutStreamer->emitLabel(Symbol: JTStart);
245 for (const MachineBasicBlock *MBB : JTBBs) {
246 const MCExpr *Diff = MCBinaryExpr::createSub(
247 LHS: MCSymbolRefExpr::create(Symbol: MBB->getSymbol(), Ctx&: OutContext),
248 RHS: MCSymbolRefExpr::create(Symbol: SecStart, Ctx&: OutContext), Ctx&: OutContext);
249 OutStreamer->emitValue(Value: Diff, Size: EntrySize);
250 }
251 const MCExpr *JTSize =
252 MCConstantExpr::create(Value: JTBBs.size() * EntrySize, Ctx&: OutContext);
253 OutStreamer->emitELFSize(Symbol: JTStart, Value: JTSize);
254 }
255}
256
257char BPFAsmPrinter::ID = 0;
258
259INITIALIZE_PASS(BPFAsmPrinter, "bpf-asm-printer", "BPF Assembly Printer", false,
260 false)
261
262// Force static initialization.
263extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void
264LLVMInitializeBPFAsmPrinter() {
265 RegisterAsmPrinter<BPFAsmPrinter> X(getTheBPFleTarget());
266 RegisterAsmPrinter<BPFAsmPrinter> Y(getTheBPFbeTarget());
267 RegisterAsmPrinter<BPFAsmPrinter> Z(getTheBPFTarget());
268}
269
270PreservedAnalyses BPFAsmPrinterBeginPass::run(Module &M,
271 ModuleAnalysisManager &MAM) {
272 BPFAsmPrinter &AsmPrinter = static_cast<BPFAsmPrinter &>(
273 MAM.getResult<AsmPrinterAnalysis>(IR&: M).getPrinter());
274 setupModuleAsmPrinter(M, MAM, AsmPrinter);
275 AsmPrinter.doInitialization(M);
276 return PreservedAnalyses::all();
277}
278
279PreservedAnalyses BPFAsmPrinterPass::run(MachineFunction &MF,
280 MachineFunctionAnalysisManager &MFAM) {
281 BPFAsmPrinter &AsmPrinter = static_cast<BPFAsmPrinter &>(
282 MFAM.getResult<ModuleAnalysisManagerMachineFunctionProxy>(IR&: MF)
283 .getCachedResult<AsmPrinterAnalysis>(IR&: *MF.getFunction().getParent())
284 ->getPrinter());
285 setupMachineFunctionAsmPrinter(MFAM, MF, AsmPrinter);
286 AsmPrinter.runOnMachineFunction(MF);
287 return PreservedAnalyses::all();
288}
289
290PreservedAnalyses BPFAsmPrinterEndPass::run(Module &M,
291 ModuleAnalysisManager &MAM) {
292 BPFAsmPrinter &AsmPrinter = static_cast<BPFAsmPrinter &>(
293 MAM.getResult<AsmPrinterAnalysis>(IR&: M).getPrinter());
294 setupModuleAsmPrinter(M, MAM, AsmPrinter);
295 AsmPrinter.doFinalization(M);
296 return PreservedAnalyses::all();
297}
298