1//===-- BPF.h - Top-level interface for BPF representation ------*- 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
9#ifndef LLVM_LIB_TARGET_BPF_BPF_H
10#define LLVM_LIB_TARGET_BPF_BPF_H
11
12#include "MCTargetDesc/BPFMCTargetDesc.h"
13#include "llvm/CodeGen/MachineFunction.h"
14#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
15#include "llvm/CodeGen/SelectionDAGISel.h"
16#include "llvm/IR/Analysis.h"
17#include "llvm/IR/Instructions.h"
18#include "llvm/IR/PassManager.h"
19#include "llvm/Pass.h"
20#include "llvm/Target/TargetMachine.h"
21
22namespace llvm {
23class BPFRegisterBankInfo;
24class BPFSubtarget;
25class BPFTargetMachine;
26class InstructionSelector;
27class PassRegistry;
28
29#define BPF_TRAP "__bpf_trap"
30
31class BPFCheckAndAdjustIRPass
32 : public RequiredPassInfoMixin<BPFCheckAndAdjustIRPass> {
33public:
34 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
35};
36
37ModulePass *createBPFCheckAndAdjustIRLegacyPass();
38ModulePass *createBPFUnwindPreparePass();
39FunctionPass *createBPFUnwindLowerPass();
40
41class BPFFuncTablePass : public RequiredPassInfoMixin<BPFFuncTablePass> {
42public:
43 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
44};
45
46ModulePass *createBPFFuncTablePass();
47
48class BPFISelDAGToDAGPass : public SelectionDAGISelPass {
49public:
50 BPFISelDAGToDAGPass(BPFTargetMachine &TM);
51};
52
53FunctionPass *createBPFISelDag(BPFTargetMachine &TM);
54
55class BPFMISimplifyPatchablePass
56 : public OptionalPassInfoMixin<BPFMISimplifyPatchablePass> {
57public:
58 PreservedAnalyses run(MachineFunction &MF,
59 MachineFunctionAnalysisManager &MFAM);
60};
61
62FunctionPass *createBPFMISimplifyPatchableLegacyPass();
63
64class BPFMIPeepholePass : public OptionalPassInfoMixin<BPFMIPeepholePass> {
65public:
66 PreservedAnalyses run(MachineFunction &MF,
67 MachineFunctionAnalysisManager &MFAM);
68};
69
70FunctionPass *createBPFMIPeepholeLegacyPass();
71
72class BPFMIExpandStackArgPseudosPass
73 : public RequiredPassInfoMixin<BPFMIExpandStackArgPseudosPass> {
74public:
75 PreservedAnalyses run(MachineFunction &MF,
76 MachineFunctionAnalysisManager &MFAM);
77};
78
79FunctionPass *createBPFMIExpandStackArgPseudosLegacyPass();
80
81class BPFMIPreEmitPeepholePass
82 : public OptionalPassInfoMixin<BPFMIPreEmitPeepholePass> {
83public:
84 PreservedAnalyses run(MachineFunction &MF,
85 MachineFunctionAnalysisManager &MFAM);
86};
87
88FunctionPass *createBPFMIPreEmitPeepholeLegacyPass();
89
90class BPFMIPreEmitCheckingPass
91 : public OptionalPassInfoMixin<BPFMIPreEmitCheckingPass> {
92public:
93 PreservedAnalyses run(MachineFunction &MF,
94 MachineFunctionAnalysisManager &MFAM);
95};
96
97FunctionPass *createBPFMIPreEmitCheckingLegacyPass();
98
99InstructionSelector *createBPFInstructionSelector(const BPFTargetMachine &,
100 const BPFSubtarget &,
101 const BPFRegisterBankInfo &);
102
103void initializeBPFAsmPrinterPass(PassRegistry &);
104void initializeBPFCheckAndAdjustIRLegacyPass(PassRegistry &);
105void initializeBPFDAGToDAGISelLegacyPass(PassRegistry &);
106void initializeBPFFuncTableLegacyPass(PassRegistry &);
107void initializeBPFMIPeepholeLegacyPass(PassRegistry &);
108void initializeBPFMIPreEmitCheckingLegacyPass(PassRegistry &);
109void initializeBPFMIExpandStackArgPseudosLegacyPass(PassRegistry &);
110void initializeBPFMIPreEmitPeepholeLegacyPass(PassRegistry &);
111void initializeBPFMISimplifyPatchableLegacyPass(PassRegistry &);
112void initializeBPFUnwindLowerPass(PassRegistry &);
113void initializeBPFUnwindPreparePass(PassRegistry &);
114
115class BPFAbstractMemberAccessPass
116 : public RequiredPassInfoMixin<BPFAbstractMemberAccessPass> {
117 BPFTargetMachine *TM;
118
119public:
120 BPFAbstractMemberAccessPass(BPFTargetMachine *TM) : TM(TM) {}
121 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
122};
123
124class BPFPreserveDITypePass
125 : public RequiredPassInfoMixin<BPFPreserveDITypePass> {
126public:
127 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
128};
129
130class BPFIRPeepholePass : public RequiredPassInfoMixin<BPFIRPeepholePass> {
131public:
132 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
133};
134
135class BPFASpaceCastSimplifyPass
136 : public RequiredPassInfoMixin<BPFASpaceCastSimplifyPass> {
137public:
138 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
139};
140
141class BPFAdjustOptPass : public OptionalPassInfoMixin<BPFAdjustOptPass> {
142public:
143 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
144};
145
146class BPFPreserveStaticOffsetPass
147 : public RequiredPassInfoMixin<BPFPreserveStaticOffsetPass> {
148 bool AllowPartial;
149
150public:
151 BPFPreserveStaticOffsetPass(bool AllowPartial) : AllowPartial(AllowPartial) {}
152 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
153
154 static std::pair<GetElementPtrInst *, LoadInst *>
155 reconstructLoad(CallInst *Call);
156
157 static std::pair<GetElementPtrInst *, StoreInst *>
158 reconstructStore(CallInst *Call);
159};
160
161} // namespace llvm
162
163#endif
164