1 //===-- MipsTargetMachine.cpp - Define TargetMachine for Mips -------------===//
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
7 //===----------------------------------------------------------------------===//
9 // Implements the info about Mips target spec.
11 //===----------------------------------------------------------------------===//
13 #include "MipsTargetMachine.h"
14 #include "MCTargetDesc/MipsABIInfo.h"
15 #include "MCTargetDesc/MipsMCTargetDesc.h"
17 #include "Mips16ISelDAGToDAG.h"
18 #include "MipsSEISelDAGToDAG.h"
19 #include "MipsSubtarget.h"
20 #include "MipsTargetObjectFile.h"
21 #include "TargetInfo/MipsTargetInfo.h"
22 #include "llvm/ADT/Optional.h"
23 #include "llvm/ADT/STLExtras.h"
24 #include "llvm/ADT/StringRef.h"
25 #include "llvm/Analysis/TargetTransformInfo.h"
26 #include "llvm/CodeGen/GlobalISel/IRTranslator.h"
27 #include "llvm/CodeGen/GlobalISel/Legalizer.h"
28 #include "llvm/CodeGen/GlobalISel/RegBankSelect.h"
29 #include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
30 #include "llvm/CodeGen/BasicTTIImpl.h"
31 #include "llvm/CodeGen/MachineFunction.h"
32 #include "llvm/CodeGen/Passes.h"
33 #include "llvm/CodeGen/TargetPassConfig.h"
34 #include "llvm/IR/Attributes.h"
35 #include "llvm/IR/Function.h"
36 #include "llvm/Support/CodeGen.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/TargetRegistry.h"
39 #include "llvm/Support/raw_ostream.h"
40 #include "llvm/Target/TargetOptions.h"
45 #define DEBUG_TYPE "mips"
47 extern "C" void LLVMInitializeMipsTarget() {
48 // Register the target.
49 RegisterTargetMachine
<MipsebTargetMachine
> X(getTheMipsTarget());
50 RegisterTargetMachine
<MipselTargetMachine
> Y(getTheMipselTarget());
51 RegisterTargetMachine
<MipsebTargetMachine
> A(getTheMips64Target());
52 RegisterTargetMachine
<MipselTargetMachine
> B(getTheMips64elTarget());
54 PassRegistry
*PR
= PassRegistry::getPassRegistry();
55 initializeGlobalISel(*PR
);
56 initializeMipsDelaySlotFillerPass(*PR
);
57 initializeMipsBranchExpansionPass(*PR
);
58 initializeMicroMipsSizeReducePass(*PR
);
59 initializeMipsPreLegalizerCombinerPass(*PR
);
62 static std::string
computeDataLayout(const Triple
&TT
, StringRef CPU
,
63 const TargetOptions
&Options
,
66 MipsABIInfo ABI
= MipsABIInfo::computeTargetABI(TT
, CPU
, Options
.MCOptions
);
68 // There are both little and big endian mips.
79 // Pointers are 32 bit on some ABIs.
83 // 8 and 16 bit integers only need to have natural alignment, but try to
84 // align them to 32 bits. 64 bit integers have natural alignment.
85 Ret
+= "-i8:8:32-i16:16:32-i64:64";
87 // 32 bit registers are always available and the stack is at least 64 bit
88 // aligned. On N64 64 bit registers are also available and the stack is
90 if (ABI
.IsN64() || ABI
.IsN32())
91 Ret
+= "-n32:64-S128";
98 static Reloc::Model
getEffectiveRelocModel(bool JIT
,
99 Optional
<Reloc::Model
> RM
) {
100 if (!RM
.hasValue() || JIT
)
101 return Reloc::Static
;
105 // On function prologue, the stack is created by decrementing
106 // its pointer. Once decremented, all references are done with positive
107 // offset from the stack/frame pointer, using StackGrowsUp enables
108 // an easier handling.
109 // Using CodeModel::Large enables different CALL behavior.
110 MipsTargetMachine::MipsTargetMachine(const Target
&T
, const Triple
&TT
,
111 StringRef CPU
, StringRef FS
,
112 const TargetOptions
&Options
,
113 Optional
<Reloc::Model
> RM
,
114 Optional
<CodeModel::Model
> CM
,
115 CodeGenOpt::Level OL
, bool JIT
,
117 : LLVMTargetMachine(T
, computeDataLayout(TT
, CPU
, Options
, isLittle
), TT
,
118 CPU
, FS
, Options
, getEffectiveRelocModel(JIT
, RM
),
119 getEffectiveCodeModel(CM
, CodeModel::Small
), OL
),
120 isLittle(isLittle
), TLOF(std::make_unique
<MipsTargetObjectFile
>()),
121 ABI(MipsABIInfo::computeTargetABI(TT
, CPU
, Options
.MCOptions
)),
123 DefaultSubtarget(TT
, CPU
, FS
, isLittle
, *this,
124 MaybeAlign(Options
.StackAlignmentOverride
)),
125 NoMips16Subtarget(TT
, CPU
, FS
.empty() ? "-mips16" : FS
.str() + ",-mips16",
127 MaybeAlign(Options
.StackAlignmentOverride
)),
128 Mips16Subtarget(TT
, CPU
, FS
.empty() ? "+mips16" : FS
.str() + ",+mips16",
130 MaybeAlign(Options
.StackAlignmentOverride
)) {
131 Subtarget
= &DefaultSubtarget
;
135 MipsTargetMachine::~MipsTargetMachine() = default;
137 void MipsebTargetMachine::anchor() {}
139 MipsebTargetMachine::MipsebTargetMachine(const Target
&T
, const Triple
&TT
,
140 StringRef CPU
, StringRef FS
,
141 const TargetOptions
&Options
,
142 Optional
<Reloc::Model
> RM
,
143 Optional
<CodeModel::Model
> CM
,
144 CodeGenOpt::Level OL
, bool JIT
)
145 : MipsTargetMachine(T
, TT
, CPU
, FS
, Options
, RM
, CM
, OL
, JIT
, false) {}
147 void MipselTargetMachine::anchor() {}
149 MipselTargetMachine::MipselTargetMachine(const Target
&T
, const Triple
&TT
,
150 StringRef CPU
, StringRef FS
,
151 const TargetOptions
&Options
,
152 Optional
<Reloc::Model
> RM
,
153 Optional
<CodeModel::Model
> CM
,
154 CodeGenOpt::Level OL
, bool JIT
)
155 : MipsTargetMachine(T
, TT
, CPU
, FS
, Options
, RM
, CM
, OL
, JIT
, true) {}
157 const MipsSubtarget
*
158 MipsTargetMachine::getSubtargetImpl(const Function
&F
) const {
159 Attribute CPUAttr
= F
.getFnAttribute("target-cpu");
160 Attribute FSAttr
= F
.getFnAttribute("target-features");
162 std::string CPU
= !CPUAttr
.hasAttribute(Attribute::None
)
163 ? CPUAttr
.getValueAsString().str()
165 std::string FS
= !FSAttr
.hasAttribute(Attribute::None
)
166 ? FSAttr
.getValueAsString().str()
169 !F
.getFnAttribute("mips16").hasAttribute(Attribute::None
);
170 bool hasNoMips16Attr
=
171 !F
.getFnAttribute("nomips16").hasAttribute(Attribute::None
);
173 bool HasMicroMipsAttr
=
174 !F
.getFnAttribute("micromips").hasAttribute(Attribute::None
);
175 bool HasNoMicroMipsAttr
=
176 !F
.getFnAttribute("nomicromips").hasAttribute(Attribute::None
);
178 // FIXME: This is related to the code below to reset the target options,
179 // we need to know whether or not the soft float flag is set on the
180 // function, so we can enable it as a subtarget feature.
182 F
.hasFnAttribute("use-soft-float") &&
183 F
.getFnAttribute("use-soft-float").getValueAsString() == "true";
186 FS
+= FS
.empty() ? "+mips16" : ",+mips16";
187 else if (hasNoMips16Attr
)
188 FS
+= FS
.empty() ? "-mips16" : ",-mips16";
189 if (HasMicroMipsAttr
)
190 FS
+= FS
.empty() ? "+micromips" : ",+micromips";
191 else if (HasNoMicroMipsAttr
)
192 FS
+= FS
.empty() ? "-micromips" : ",-micromips";
194 FS
+= FS
.empty() ? "+soft-float" : ",+soft-float";
196 auto &I
= SubtargetMap
[CPU
+ FS
];
198 // This needs to be done before we create a new subtarget since any
199 // creation will depend on the TM and the code generation flags on the
200 // function that reside in TargetOptions.
201 resetTargetOptions(F
);
202 I
= std::make_unique
<MipsSubtarget
>(
203 TargetTriple
, CPU
, FS
, isLittle
, *this,
204 MaybeAlign(Options
.StackAlignmentOverride
));
209 void MipsTargetMachine::resetSubtarget(MachineFunction
*MF
) {
210 LLVM_DEBUG(dbgs() << "resetSubtarget\n");
212 Subtarget
= &MF
->getSubtarget
<MipsSubtarget
>();
217 /// Mips Code Generator Pass Configuration Options.
218 class MipsPassConfig
: public TargetPassConfig
{
220 MipsPassConfig(MipsTargetMachine
&TM
, PassManagerBase
&PM
)
221 : TargetPassConfig(TM
, PM
) {
222 // The current implementation of long branch pass requires a scratch
223 // register ($at) to be available before branch instructions. Tail merging
224 // can break this requirement, so disable it when long branch pass is
226 EnableTailMerge
= !getMipsSubtarget().enableLongBranchPass();
229 MipsTargetMachine
&getMipsTargetMachine() const {
230 return getTM
<MipsTargetMachine
>();
233 const MipsSubtarget
&getMipsSubtarget() const {
234 return *getMipsTargetMachine().getSubtargetImpl();
237 void addIRPasses() override
;
238 bool addInstSelector() override
;
239 void addPreEmitPass() override
;
240 void addPreRegAlloc() override
;
241 bool addIRTranslator() override
;
242 void addPreLegalizeMachineIR() override
;
243 bool addLegalizeMachineIR() override
;
244 bool addRegBankSelect() override
;
245 bool addGlobalInstructionSelect() override
;
247 std::unique_ptr
<CSEConfigBase
> getCSEConfig() const override
;
250 } // end anonymous namespace
252 TargetPassConfig
*MipsTargetMachine::createPassConfig(PassManagerBase
&PM
) {
253 return new MipsPassConfig(*this, PM
);
256 std::unique_ptr
<CSEConfigBase
> MipsPassConfig::getCSEConfig() const {
257 return getStandardCSEConfigForOpt(TM
->getOptLevel());
260 void MipsPassConfig::addIRPasses() {
261 TargetPassConfig::addIRPasses();
262 addPass(createAtomicExpandPass());
263 if (getMipsSubtarget().os16())
264 addPass(createMipsOs16Pass());
265 if (getMipsSubtarget().inMips16HardFloat())
266 addPass(createMips16HardFloatPass());
268 // Install an instruction selector pass using
269 // the ISelDag to gen Mips code.
270 bool MipsPassConfig::addInstSelector() {
271 addPass(createMipsModuleISelDagPass());
272 addPass(createMips16ISelDag(getMipsTargetMachine(), getOptLevel()));
273 addPass(createMipsSEISelDag(getMipsTargetMachine(), getOptLevel()));
277 void MipsPassConfig::addPreRegAlloc() {
278 addPass(createMipsOptimizePICCallPass());
282 MipsTargetMachine::getTargetTransformInfo(const Function
&F
) {
283 if (Subtarget
->allowMixed16_32()) {
284 LLVM_DEBUG(errs() << "No Target Transform Info Pass Added\n");
285 // FIXME: This is no longer necessary as the TTI returned is per-function.
286 return TargetTransformInfo(F
.getParent()->getDataLayout());
289 LLVM_DEBUG(errs() << "Target Transform Info Pass Added\n");
290 return TargetTransformInfo(BasicTTIImpl(this, F
));
293 // Implemented by targets that want to run passes immediately before
294 // machine code is emitted. return true if -print-machineinstrs should
295 // print out the code after the passes.
296 void MipsPassConfig::addPreEmitPass() {
297 // Expand pseudo instructions that are sensitive to register allocation.
298 addPass(createMipsExpandPseudoPass());
300 // The microMIPS size reduction pass performs instruction reselection for
301 // instructions which can be remapped to a 16 bit instruction.
302 addPass(createMicroMipsSizeReducePass());
304 // The delay slot filler pass can potientially create forbidden slot hazards
305 // for MIPSR6 and therefore it should go before MipsBranchExpansion pass.
306 addPass(createMipsDelaySlotFillerPass());
308 // This pass expands branches and takes care about the forbidden slot hazards.
309 // Expanding branches may potentially create forbidden slot hazards for
310 // MIPSR6, and fixing such hazard may potentially break a branch by extending
311 // its offset out of range. That's why this pass combine these two tasks, and
312 // runs them alternately until one of them finishes without any changes. Only
313 // then we can be sure that all branches are expanded properly and no hazards
315 // Any new pass should go before this pass.
316 addPass(createMipsBranchExpansion());
318 addPass(createMipsConstantIslandPass());
321 bool MipsPassConfig::addIRTranslator() {
322 addPass(new IRTranslator());
326 void MipsPassConfig::addPreLegalizeMachineIR() {
327 addPass(createMipsPreLegalizeCombiner());
330 bool MipsPassConfig::addLegalizeMachineIR() {
331 addPass(new Legalizer());
335 bool MipsPassConfig::addRegBankSelect() {
336 addPass(new RegBankSelect());
340 bool MipsPassConfig::addGlobalInstructionSelect() {
341 addPass(new InstructionSelect());