1//===-- Mips.h - Top-level interface for Mips 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// This file contains the entry points for global functions defined in
10// the LLVM Mips back-end.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_TARGET_MIPS_MIPS_H
15#define LLVM_LIB_TARGET_MIPS_MIPS_H
16
17#include "MCTargetDesc/MipsMCTargetDesc.h"
18#include "llvm/CodeGen/MachineFunction.h"
19#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
20#include "llvm/CodeGen/SelectionDAGISel.h"
21#include "llvm/IR/Analysis.h"
22#include "llvm/IR/PassManager.h"
23#include "llvm/Support/CodeGen.h"
24#include "llvm/Target/TargetMachine.h"
25
26#define IsMFLOMFHI(instr) \
27 (instr == Mips::MFLO || instr == Mips::MFLO64 || instr == Mips::MFHI || \
28 instr == Mips::MFHI64)
29#define IsDIVMULT(instr) \
30 (instr == Mips::SDIV || instr == Mips::PseudoSDIV || instr == Mips::DSDIV || \
31 instr == Mips::PseudoDSDIV || instr == Mips::UDIV || \
32 instr == Mips::PseudoUDIV || instr == Mips::DUDIV || \
33 instr == Mips::PseudoDUDIV || instr == Mips::MULT || \
34 instr == Mips::PseudoMULT || instr == Mips::DMULT || \
35 instr == Mips::PseudoDMULT)
36
37namespace llvm {
38class FunctionPass;
39class InstructionSelector;
40class MipsRegisterBankInfo;
41class MipsSubtarget;
42class MipsTargetMachine;
43class MipsTargetMachine;
44class ModulePass;
45class PassRegistry;
46
47class Mips16ISelDAGPass : public SelectionDAGISelPass {
48public:
49 Mips16ISelDAGPass(MipsTargetMachine &TM, CodeGenOptLevel OptLevel);
50 static StringRef name() { return "Mips16ISelDAGPass"; }
51 void printPipeline(raw_ostream &OS,
52 function_ref<StringRef(StringRef)> MapClassName2PassName) {
53 StringRef ClassName = name();
54 auto PassName = MapClassName2PassName(ClassName);
55 OS << PassName;
56 }
57};
58
59FunctionPass *createMips16ISelDAGLegacyPass(MipsTargetMachine &TM,
60 CodeGenOptLevel OptLevel);
61
62class MipsOs16Pass : public RequiredPassInfoMixin<MipsOs16Pass> {
63public:
64 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
65};
66
67ModulePass *createMipsOs16LegacyPass();
68
69class Mips16HardFloatPass : public RequiredPassInfoMixin<Mips16HardFloatPass> {
70 MipsTargetMachine &TM;
71
72public:
73 Mips16HardFloatPass(MipsTargetMachine &TM) : TM(TM) {}
74 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
75};
76
77ModulePass *createMips16HardFloatLegacyPass();
78
79class MipsSEISelDAGPass : public SelectionDAGISelPass {
80public:
81 MipsSEISelDAGPass(MipsTargetMachine &TM, CodeGenOptLevel OptLevel);
82 static StringRef name() { return "MipsSEISelDAGPass"; }
83 void printPipeline(raw_ostream &OS,
84 function_ref<StringRef(StringRef)> MapClassName2PassName) {
85 StringRef ClassName = name();
86 auto PassName = MapClassName2PassName(ClassName);
87 OS << PassName;
88 }
89};
90
91FunctionPass *createMipsSEISelDAGLegacyPass(MipsTargetMachine &TM,
92 CodeGenOptLevel OptLevel);
93
94class MipsOptimizePICCallPass
95 : public RequiredPassInfoMixin<MipsOptimizePICCallPass> {
96public:
97 PreservedAnalyses run(MachineFunction &MF,
98 MachineFunctionAnalysisManager &MFAM);
99};
100
101FunctionPass *createMipsOptimizePICCallLegacyPass();
102
103class MipsDelaySlotFillerPass
104 : public RequiredPassInfoMixin<MipsDelaySlotFillerPass> {
105public:
106 PreservedAnalyses run(MachineFunction &MF,
107 MachineFunctionAnalysisManager &MFAM);
108
109 MachineFunctionProperties getRequiredProperties() const {
110 return MachineFunctionProperties().setNoVRegs();
111 }
112};
113
114FunctionPass *createMipsDelaySlotFillerLegacyPass();
115
116class MipsBranchExpansionPass
117 : public RequiredPassInfoMixin<MipsBranchExpansionPass> {
118public:
119 PreservedAnalyses run(MachineFunction &MF,
120 MachineFunctionAnalysisManager &MFAM);
121
122 MachineFunctionProperties getRequiredProperties() const {
123 return MachineFunctionProperties().setNoVRegs();
124 }
125};
126
127FunctionPass *createMipsBranchExpansionLegacyPass();
128
129class MipsConstantIslandPass
130 : public RequiredPassInfoMixin<MipsConstantIslandPass> {
131public:
132 PreservedAnalyses run(MachineFunction &MF,
133 MachineFunctionAnalysisManager &MFAM);
134
135 MachineFunctionProperties getRequiredProperties() const {
136 return MachineFunctionProperties().setNoVRegs();
137 }
138};
139
140FunctionPass *createMipsConstantIslandLegacyPass();
141
142class MicroMipsSizeReducePass
143 : public RequiredPassInfoMixin<MicroMipsSizeReducePass> {
144public:
145 PreservedAnalyses run(MachineFunction &MF,
146 MachineFunctionAnalysisManager &MFAM);
147};
148
149FunctionPass *createMicroMipsSizeReduceLegacyPass();
150
151class MipsExpandPseudoPass
152 : public RequiredPassInfoMixin<MipsExpandPseudoPass> {
153public:
154 PreservedAnalyses run(MachineFunction &MF,
155 MachineFunctionAnalysisManager &MFAM);
156};
157
158FunctionPass *createMipsExpandPseudoLegacyPass();
159
160class MipsPreLegalizerCombinerPass
161 : public RequiredPassInfoMixin<MipsPreLegalizerCombinerPass> {
162public:
163 PreservedAnalyses run(MachineFunction &MF,
164 MachineFunctionAnalysisManager &MFAM);
165};
166
167FunctionPass *createMipsPreLegalizeCombinerLegacyPass();
168
169class MipsPostLegalizerCombinerPass
170 : public RequiredPassInfoMixin<MipsPostLegalizerCombinerPass> {
171 bool IsOptNone;
172
173public:
174 MipsPostLegalizerCombinerPass(bool IsOptNone = false)
175 : IsOptNone(IsOptNone) {}
176 PreservedAnalyses run(MachineFunction &MF,
177 MachineFunctionAnalysisManager &MFAM);
178};
179
180FunctionPass *createMipsPostLegalizeCombinerLegacyPass(bool IsOptNone);
181
182class MipsMulMulBugFixPass
183 : public RequiredPassInfoMixin<MipsMulMulBugFixPass> {
184public:
185 PreservedAnalyses run(MachineFunction &MF,
186 MachineFunctionAnalysisManager &MFAM);
187};
188
189FunctionPass *createMipsMulMulBugFixLegacyPass();
190
191InstructionSelector *
192createMipsInstructionSelector(const MipsTargetMachine &, const MipsSubtarget &,
193 const MipsRegisterBankInfo &);
194
195void initializeMicroMipsSizeReduceLegacyPass(PassRegistry &);
196void initializeMipsAsmPrinterPass(PassRegistry &);
197void initializeMipsBranchExpansionLegacyPass(PassRegistry &);
198void initializeMipsDAGToDAGISelLegacyPass(PassRegistry &);
199void initializeMipsDelaySlotFillerLegacyPass(PassRegistry &);
200void initializeMipsMulMulBugFixLegacyPass(PassRegistry &);
201void initializeMipsPostLegalizerCombinerLegacyPass(PassRegistry &);
202void initializeMipsPreLegalizerCombinerLegacyPass(PassRegistry &);
203} // namespace llvm
204
205#endif
206