1//===-- RISCV.h - Top-level interface for RISC-V ----------------*- 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// This file contains the entry points for global functions defined in the LLVM
10// RISC-V back-end.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_TARGET_RISCV_RISCV_H
15#define LLVM_LIB_TARGET_RISCV_RISCV_H
16
17#include "MCTargetDesc/RISCVBaseInfo.h"
18#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
19#include "llvm/CodeGen/SelectionDAGISel.h"
20#include "llvm/IR/Analysis.h"
21#include "llvm/IR/PassManager.h"
22#include "llvm/Target/TargetMachine.h"
23
24namespace llvm {
25class FunctionPass;
26class InstructionSelector;
27class ModulePass;
28class PassRegistry;
29class RISCVRegisterBankInfo;
30class RISCVSubtarget;
31class RISCVTargetMachine;
32
33class RISCVCodeGenPreparePass
34 : public OptionalPassInfoMixin<RISCVCodeGenPreparePass> {
35private:
36 const RISCVTargetMachine *TM;
37
38public:
39 RISCVCodeGenPreparePass(const RISCVTargetMachine *TM) : TM(TM) {}
40 PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
41};
42FunctionPass *createRISCVCodeGenPrepareLegacyPass();
43void initializeRISCVCodeGenPrepareLegacyPass(PassRegistry &);
44
45class RISCVDeadRegisterDefinitionsPass
46 : public OptionalPassInfoMixin<RISCVDeadRegisterDefinitionsPass> {
47public:
48 PreservedAnalyses run(MachineFunction &MF,
49 MachineFunctionAnalysisManager &MFAM);
50};
51FunctionPass *createRISCVDeadRegisterDefinitionsLegacyPass();
52void initializeRISCVDeadRegisterDefinitionsLegacyPass(PassRegistry &);
53
54class RISCVIndirectBranchTrackingPass
55 : public RequiredPassInfoMixin<RISCVIndirectBranchTrackingPass> {
56public:
57 PreservedAnalyses run(MachineFunction &MF,
58 MachineFunctionAnalysisManager &MFAM);
59};
60FunctionPass *createRISCVIndirectBranchTrackingLegacyPass();
61void initializeRISCVIndirectBranchTrackingLegacyPass(PassRegistry &);
62
63class RISCVLandingPadSetupPass
64 : public RequiredPassInfoMixin<RISCVLandingPadSetupPass> {
65public:
66 PreservedAnalyses run(MachineFunction &MF,
67 MachineFunctionAnalysisManager &MFAM);
68};
69FunctionPass *createRISCVLandingPadSetupLegacyPass();
70void initializeRISCVLandingPadSetupLegacyPass(PassRegistry &);
71
72FunctionPass *createRISCVISelDagLegacyPass(RISCVTargetMachine &TM,
73 CodeGenOptLevel OptLevel);
74
75class RISCVISelDAGToDAGPass : public SelectionDAGISelPass {
76public:
77 RISCVISelDAGToDAGPass(RISCVTargetMachine &TM, CodeGenOptLevel OptLevel);
78};
79
80class RISCVLateBranchOptPass
81 : public OptionalPassInfoMixin<RISCVLateBranchOptPass> {
82public:
83 PreservedAnalyses run(MachineFunction &MF,
84 MachineFunctionAnalysisManager &MFAM);
85};
86FunctionPass *createRISCVLateBranchOptLegacyPass();
87void initializeRISCVLateBranchOptLegacyPass(PassRegistry &);
88
89class RISCVMakeCompressiblePass
90 : public OptionalPassInfoMixin<RISCVMakeCompressiblePass> {
91public:
92 PreservedAnalyses run(MachineFunction &MF,
93 MachineFunctionAnalysisManager &MFAM);
94};
95FunctionPass *createRISCVMakeCompressibleLegacyPass();
96void initializeRISCVMakeCompressibleLegacyPass(PassRegistry &);
97
98class RISCVGatherScatterLoweringPass
99 : public OptionalPassInfoMixin<RISCVGatherScatterLoweringPass> {
100private:
101 const RISCVTargetMachine *TM;
102
103public:
104 RISCVGatherScatterLoweringPass(const RISCVTargetMachine *TM) : TM(TM) {}
105 PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
106};
107
108FunctionPass *createRISCVGatherScatterLoweringLegacyPass();
109void initializeRISCVGatherScatterLoweringLegacyPass(PassRegistry &);
110
111class RISCVVectorPeepholePass
112 : public OptionalPassInfoMixin<RISCVVectorPeepholePass> {
113public:
114 PreservedAnalyses run(MachineFunction &MF,
115 MachineFunctionAnalysisManager &MFAM);
116 MachineFunctionProperties getRequiredProperties() const {
117 return MachineFunctionProperties().setIsSSA();
118 }
119};
120
121FunctionPass *createRISCVVectorPeepholeLegacyPass();
122void initializeRISCVVectorPeepholeLegacyPass(PassRegistry &);
123
124class RISCVOptWInstrsPass : public OptionalPassInfoMixin<RISCVOptWInstrsPass> {
125public:
126 PreservedAnalyses run(MachineFunction &MF,
127 MachineFunctionAnalysisManager &MFAM);
128};
129
130FunctionPass *createRISCVOptWInstrsLegacyPass();
131void initializeRISCVOptWInstrsLegacyPass(PassRegistry &);
132
133class RISCVFoldMemOffsetPass
134 : public OptionalPassInfoMixin<RISCVFoldMemOffsetPass> {
135public:
136 PreservedAnalyses run(MachineFunction &MF,
137 MachineFunctionAnalysisManager &MFAM);
138};
139
140FunctionPass *createRISCVFoldMemOffsetLegacyPass();
141void initializeRISCVFoldMemOffsetLegacyPass(PassRegistry &);
142
143class RISCVMergeBaseOffsetPass
144 : public OptionalPassInfoMixin<RISCVMergeBaseOffsetPass> {
145public:
146 PreservedAnalyses run(MachineFunction &MF,
147 MachineFunctionAnalysisManager &MFAM);
148};
149
150FunctionPass *createRISCVMergeBaseOffsetLegacyPass();
151void initializeRISCVMergeBaseOffsetLegacyPass(PassRegistry &);
152
153class RISCVExpandPseudoPreRAPass
154 : public RequiredPassInfoMixin<RISCVExpandPseudoPreRAPass> {
155public:
156 PreservedAnalyses run(MachineFunction &MF,
157 MachineFunctionAnalysisManager &MFAM);
158 MachineFunctionProperties getRequiredProperties() const {
159 return MachineFunctionProperties().setIsSSA();
160 }
161};
162
163FunctionPass *createRISCVExpandPseudoPreRALegacyPass();
164void initializeRISCVExpandPseudoPreRALegacyPass(PassRegistry &);
165
166class RISCVExpandPseudoPostRAPass
167 : public RequiredPassInfoMixin<RISCVExpandPseudoPostRAPass> {
168public:
169 PreservedAnalyses run(MachineFunction &MF,
170 MachineFunctionAnalysisManager &MFAM);
171};
172
173FunctionPass *createRISCVExpandPseudoPostRALegacyPass();
174void initializeRISCVExpandPseudoPostRALegacyPass(PassRegistry &);
175
176class RISCVExpandPseudoPreEmitPass
177 : public RequiredPassInfoMixin<RISCVExpandPseudoPreEmitPass> {
178public:
179 PreservedAnalyses run(MachineFunction &MF,
180 MachineFunctionAnalysisManager &MFAM);
181};
182
183FunctionPass *createRISCVExpandPseudoPreEmitLegacyPass();
184void initializeRISCVExpandPseudoPreEmitLegacyPass(PassRegistry &);
185
186class RISCVExpandPseudoAtomicsPass
187 : public RequiredPassInfoMixin<RISCVExpandPseudoAtomicsPass> {
188public:
189 PreservedAnalyses run(MachineFunction &MF,
190 MachineFunctionAnalysisManager &MFAM);
191};
192
193FunctionPass *createRISCVExpandPseudoAtomicsLegacyPass();
194void initializeRISCVExpandPseudoAtomicsLegacyPass(PassRegistry &);
195
196class RISCVInsertVSETVLIPass
197 : public RequiredPassInfoMixin<RISCVInsertVSETVLIPass> {
198public:
199 PreservedAnalyses run(MachineFunction &MF,
200 MachineFunctionAnalysisManager &MFAM);
201};
202
203FunctionPass *createRISCVInsertVSETVLILegacyPass();
204void initializeRISCVInsertVSETVLILegacyPass(PassRegistry &);
205extern char &RISCVInsertVSETVLILegacyID;
206
207class RISCVInsertReadWriteCSRPass
208 : public RequiredPassInfoMixin<RISCVInsertReadWriteCSRPass> {
209public:
210 PreservedAnalyses run(MachineFunction &MF,
211 MachineFunctionAnalysisManager &MFAM);
212};
213
214FunctionPass *createRISCVInsertReadWriteCSRLegacyPass();
215void initializeRISCVInsertReadWriteCSRLegacyPass(PassRegistry &);
216
217class RISCVInsertWriteVXRMPass
218 : public RequiredPassInfoMixin<RISCVInsertWriteVXRMPass> {
219public:
220 PreservedAnalyses run(MachineFunction &MF,
221 MachineFunctionAnalysisManager &MFAM);
222};
223
224FunctionPass *createRISCVInsertWriteVXRMLegacyPass();
225void initializeRISCVInsertWriteVXRMLegacyPass(PassRegistry &);
226
227class RISCVRedundantCopyEliminationPass
228 : public OptionalPassInfoMixin<RISCVRedundantCopyEliminationPass> {
229public:
230 PreservedAnalyses run(MachineFunction &MF,
231 MachineFunctionAnalysisManager &MFAM);
232
233 MachineFunctionProperties getRequiredProperties() const {
234 return MachineFunctionProperties().setNoVRegs();
235 }
236};
237
238FunctionPass *createRISCVRedundantCopyEliminationLegacyPass();
239void initializeRISCVRedundantCopyEliminationLegacyPass(PassRegistry &);
240
241class RISCVMoveMergePass : public OptionalPassInfoMixin<RISCVMoveMergePass> {
242public:
243 PreservedAnalyses run(MachineFunction &MF,
244 MachineFunctionAnalysisManager &MFAM);
245};
246
247FunctionPass *createRISCVMoveMergeLegacyPass();
248void initializeRISCVMoveMergeLegacyPass(PassRegistry &);
249
250class RISCVPushPopOptPass : public OptionalPassInfoMixin<RISCVPushPopOptPass> {
251public:
252 PreservedAnalyses run(MachineFunction &MF,
253 MachineFunctionAnalysisManager &MFAM);
254};
255
256FunctionPass *createRISCVPushPopOptLegacyPass();
257void initializeRISCVPushPopOptLegacyPass(PassRegistry &);
258
259class RISCVLoadStoreOptPass
260 : public OptionalPassInfoMixin<RISCVLoadStoreOptPass> {
261public:
262 PreservedAnalyses run(MachineFunction &MF,
263 MachineFunctionAnalysisManager &MFAM);
264};
265
266FunctionPass *createRISCVLoadStoreOptLegacyPass();
267void initializeRISCVLoadStoreOptLegacyPass(PassRegistry &);
268
269class RISCVPreAllocZilsdOptPass
270 : public OptionalPassInfoMixin<RISCVPreAllocZilsdOptPass> {
271public:
272 PreservedAnalyses run(MachineFunction &MF,
273 MachineFunctionAnalysisManager &MFAM);
274};
275
276FunctionPass *createRISCVPreAllocZilsdOptLegacyPass();
277void initializeRISCVPreAllocZilsdOptLegacyPass(PassRegistry &);
278
279class RISCVZacasABIFixPass
280 : public RequiredPassInfoMixin<RISCVZacasABIFixPass> {
281private:
282 const RISCVTargetMachine *TM;
283
284public:
285 RISCVZacasABIFixPass(const RISCVTargetMachine *TM) : TM(TM) {}
286 PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
287};
288FunctionPass *createRISCVZacasABIFixLegacyPass();
289void initializeRISCVZacasABIFixLegacyPass(PassRegistry &);
290
291InstructionSelector *
292createRISCVInstructionSelector(const RISCVTargetMachine &,
293 const RISCVSubtarget &,
294 const RISCVRegisterBankInfo &);
295void initializeRISCVDAGToDAGISelLegacyPass(PassRegistry &);
296
297class RISCVPostLegalizerCombinerPass
298 : public RequiredPassInfoMixin<RISCVPostLegalizerCombinerPass> {
299public:
300 PreservedAnalyses run(MachineFunction &MF,
301 MachineFunctionAnalysisManager &MFAM);
302};
303
304FunctionPass *createRISCVPostLegalizerCombinerLegacyPass();
305void initializeRISCVPostLegalizerCombinerLegacyPass(PassRegistry &);
306
307class RISCVO0PreLegalizerCombinerPass
308 : public RequiredPassInfoMixin<RISCVO0PreLegalizerCombinerPass> {
309public:
310 PreservedAnalyses run(MachineFunction &MF,
311 MachineFunctionAnalysisManager &MFAM);
312};
313
314FunctionPass *createRISCVO0PreLegalizerCombinerLegacyPass();
315void initializeRISCVO0PreLegalizerCombinerLegacyPass(PassRegistry &);
316
317class RISCVPreLegalizerCombinerPass
318 : public RequiredPassInfoMixin<RISCVPreLegalizerCombinerPass> {
319public:
320 PreservedAnalyses run(MachineFunction &MF,
321 MachineFunctionAnalysisManager &MFAM);
322};
323
324FunctionPass *createRISCVPreLegalizerCombinerLegacyPass();
325void initializeRISCVPreLegalizerCombinerLegacyPass(PassRegistry &);
326
327class RISCVPromoteConstantPass
328 : public OptionalPassInfoMixin<RISCVPromoteConstantPass> {
329private:
330 const RISCVTargetMachine *TM;
331
332public:
333 RISCVPromoteConstantPass(const RISCVTargetMachine *TM) : TM(TM) {}
334 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
335};
336
337ModulePass *createRISCVPromoteConstantLegacyPass();
338void initializeRISCVPromoteConstantLegacyPass(PassRegistry &);
339
340class RISCVVLOptimizerPass
341 : public OptionalPassInfoMixin<RISCVVLOptimizerPass> {
342public:
343 PreservedAnalyses run(MachineFunction &MF,
344 MachineFunctionAnalysisManager &MFAM);
345};
346
347FunctionPass *createRISCVVLOptimizerLegacyPass();
348void initializeRISCVVLOptimizerLegacyPass(PassRegistry &);
349
350class RISCVVMV0EliminationPass
351 : public RequiredPassInfoMixin<RISCVVMV0EliminationPass> {
352public:
353 PreservedAnalyses run(MachineFunction &MF,
354 MachineFunctionAnalysisManager &MFAM);
355
356 MachineFunctionProperties getRequiredProperties() const {
357 return MachineFunctionProperties().setIsSSA();
358 }
359};
360
361FunctionPass *createRISCVVMV0EliminationLegacyPass();
362void initializeRISCVVMV0EliminationLegacyPass(PassRegistry &);
363
364class RISCVQCRelaxMarkingPass
365 : public OptionalPassInfoMixin<RISCVQCRelaxMarkingPass> {
366public:
367 PreservedAnalyses run(MachineFunction &MF,
368 MachineFunctionAnalysisManager &MFAM);
369};
370
371FunctionPass *createRISCVQCRelaxMarkingLegacyPass();
372void initializeRISCVQCRelaxMarkingLegacyPass(PassRegistry &);
373
374void initializeRISCVAsmPrinterPass(PassRegistry &);
375} // namespace llvm
376
377#endif
378