1 //===- Mips16HardFloat.cpp for Mips16 Hard Float --------------------------===//
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 defines a pass needed for Mips16 Hard Float
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "MipsTargetMachine.h"
14 #include "llvm/CodeGen/TargetPassConfig.h"
15 #include "llvm/IR/Module.h"
16 #include "llvm/IR/Value.h"
17 #include "llvm/Support/Debug.h"
18 #include "llvm/Support/ModRef.h"
19 #include "llvm/Support/raw_ostream.h"
20 #include <algorithm>
21 #include <string>
22
23 using namespace llvm;
24
25 #define DEBUG_TYPE "mips16-hard-float"
26
27 namespace {
28
29 class Mips16HardFloat : public ModulePass {
30 public:
31 static char ID;
32
Mips16HardFloat()33 Mips16HardFloat() : ModulePass(ID) {}
34
getPassName() const35 StringRef getPassName() const override { return "MIPS16 Hard Float Pass"; }
36
getAnalysisUsage(AnalysisUsage & AU) const37 void getAnalysisUsage(AnalysisUsage &AU) const override {
38 AU.addRequired<TargetPassConfig>();
39 ModulePass::getAnalysisUsage(AU);
40 }
41
42 bool runOnModule(Module &M) override;
43 };
44
45 } // end anonymous namespace
46
emitInlineAsm(LLVMContext & C,BasicBlock * BB,StringRef AsmText)47 static void emitInlineAsm(LLVMContext &C, BasicBlock *BB, StringRef AsmText) {
48 std::vector<Type *> AsmArgTypes;
49 std::vector<Value *> AsmArgs;
50
51 FunctionType *AsmFTy =
52 FunctionType::get(Type::getVoidTy(C), AsmArgTypes, false);
53 InlineAsm *IA = InlineAsm::get(AsmFTy, AsmText, "", true,
54 /* IsAlignStack */ false, InlineAsm::AD_ATT);
55 CallInst::Create(IA, AsmArgs, "", BB);
56 }
57
58 char Mips16HardFloat::ID = 0;
59
60 //
61 // Return types that matter for hard float are:
62 // float, double, complex float, and complex double
63 //
64 enum FPReturnVariant {
65 FRet, DRet, CFRet, CDRet, NoFPRet
66 };
67
68 //
69 // Determine which FP return type this function has
70 //
whichFPReturnVariant(Type * T)71 static FPReturnVariant whichFPReturnVariant(Type *T) {
72 switch (T->getTypeID()) {
73 case Type::FloatTyID:
74 return FRet;
75 case Type::DoubleTyID:
76 return DRet;
77 case Type::StructTyID: {
78 StructType *ST = cast<StructType>(T);
79 if (ST->getNumElements() != 2)
80 break;
81 if ((ST->getElementType(0)->isFloatTy()) &&
82 (ST->getElementType(1)->isFloatTy()))
83 return CFRet;
84 if ((ST->getElementType(0)->isDoubleTy()) &&
85 (ST->getElementType(1)->isDoubleTy()))
86 return CDRet;
87 break;
88 }
89 default:
90 break;
91 }
92 return NoFPRet;
93 }
94
95 // Parameter type that matter are float, (float, float), (float, double),
96 // double, (double, double), (double, float)
97 enum FPParamVariant {
98 FSig, FFSig, FDSig,
99 DSig, DDSig, DFSig, NoSig
100 };
101
102 // which floating point parameter signature variant we are dealing with
103 using TypeID = Type::TypeID;
104 const Type::TypeID FloatTyID = Type::FloatTyID;
105 const Type::TypeID DoubleTyID = Type::DoubleTyID;
106
whichFPParamVariantNeeded(Function & F)107 static FPParamVariant whichFPParamVariantNeeded(Function &F) {
108 switch (F.arg_size()) {
109 case 0:
110 return NoSig;
111 case 1:{
112 TypeID ArgTypeID = F.getFunctionType()->getParamType(0)->getTypeID();
113 switch (ArgTypeID) {
114 case FloatTyID:
115 return FSig;
116 case DoubleTyID:
117 return DSig;
118 default:
119 return NoSig;
120 }
121 }
122 default: {
123 TypeID ArgTypeID0 = F.getFunctionType()->getParamType(0)->getTypeID();
124 TypeID ArgTypeID1 = F.getFunctionType()->getParamType(1)->getTypeID();
125 switch(ArgTypeID0) {
126 case FloatTyID: {
127 switch (ArgTypeID1) {
128 case FloatTyID:
129 return FFSig;
130 case DoubleTyID:
131 return FDSig;
132 default:
133 return FSig;
134 }
135 }
136 case DoubleTyID: {
137 switch (ArgTypeID1) {
138 case FloatTyID:
139 return DFSig;
140 case DoubleTyID:
141 return DDSig;
142 default:
143 return DSig;
144 }
145 }
146 default:
147 return NoSig;
148 }
149 }
150 }
151 llvm_unreachable("can't get here");
152 }
153
154 // Figure out if we need float point based on the function parameters.
155 // We need to move variables in and/or out of floating point
156 // registers because of the ABI
needsFPStubFromParams(Function & F)157 static bool needsFPStubFromParams(Function &F) {
158 if (F.arg_size() >=1) {
159 Type *ArgType = F.getFunctionType()->getParamType(0);
160 switch (ArgType->getTypeID()) {
161 case Type::FloatTyID:
162 case Type::DoubleTyID:
163 return true;
164 default:
165 break;
166 }
167 }
168 return false;
169 }
170
needsFPReturnHelper(Function & F)171 static bool needsFPReturnHelper(Function &F) {
172 Type* RetType = F.getReturnType();
173 return whichFPReturnVariant(RetType) != NoFPRet;
174 }
175
needsFPReturnHelper(FunctionType & FT)176 static bool needsFPReturnHelper(FunctionType &FT) {
177 Type* RetType = FT.getReturnType();
178 return whichFPReturnVariant(RetType) != NoFPRet;
179 }
180
needsFPHelperFromSig(Function & F)181 static bool needsFPHelperFromSig(Function &F) {
182 return needsFPStubFromParams(F) || needsFPReturnHelper(F);
183 }
184
185 // We swap between FP and Integer registers to allow Mips16 and Mips32 to
186 // interoperate
swapFPIntParams(FPParamVariant PV,Module * M,bool LE,bool ToFP)187 static std::string swapFPIntParams(FPParamVariant PV, Module *M, bool LE,
188 bool ToFP) {
189 std::string MI = ToFP ? "mtc1 ": "mfc1 ";
190 std::string AsmText;
191
192 switch (PV) {
193 case FSig:
194 AsmText += MI + "$$4, $$f12\n";
195 break;
196
197 case FFSig:
198 AsmText += MI + "$$4, $$f12\n";
199 AsmText += MI + "$$5, $$f14\n";
200 break;
201
202 case FDSig:
203 AsmText += MI + "$$4, $$f12\n";
204 if (LE) {
205 AsmText += MI + "$$6, $$f14\n";
206 AsmText += MI + "$$7, $$f15\n";
207 } else {
208 AsmText += MI + "$$7, $$f14\n";
209 AsmText += MI + "$$6, $$f15\n";
210 }
211 break;
212
213 case DSig:
214 if (LE) {
215 AsmText += MI + "$$4, $$f12\n";
216 AsmText += MI + "$$5, $$f13\n";
217 } else {
218 AsmText += MI + "$$5, $$f12\n";
219 AsmText += MI + "$$4, $$f13\n";
220 }
221 break;
222
223 case DDSig:
224 if (LE) {
225 AsmText += MI + "$$4, $$f12\n";
226 AsmText += MI + "$$5, $$f13\n";
227 AsmText += MI + "$$6, $$f14\n";
228 AsmText += MI + "$$7, $$f15\n";
229 } else {
230 AsmText += MI + "$$5, $$f12\n";
231 AsmText += MI + "$$4, $$f13\n";
232 AsmText += MI + "$$7, $$f14\n";
233 AsmText += MI + "$$6, $$f15\n";
234 }
235 break;
236
237 case DFSig:
238 if (LE) {
239 AsmText += MI + "$$4, $$f12\n";
240 AsmText += MI + "$$5, $$f13\n";
241 } else {
242 AsmText += MI + "$$5, $$f12\n";
243 AsmText += MI + "$$4, $$f13\n";
244 }
245 AsmText += MI + "$$6, $$f14\n";
246 break;
247
248 case NoSig:
249 break;
250 }
251
252 return AsmText;
253 }
254
255 // Make sure that we know we already need a stub for this function.
256 // Having called needsFPHelperFromSig
assureFPCallStub(Function & F,Module * M,const MipsTargetMachine & TM)257 static void assureFPCallStub(Function &F, Module *M,
258 const MipsTargetMachine &TM) {
259 // for now we only need them for static relocation
260 if (TM.isPositionIndependent())
261 return;
262 LLVMContext &Context = M->getContext();
263 bool LE = TM.isLittleEndian();
264 std::string Name(F.getName());
265 std::string SectionName = ".mips16.call.fp." + Name;
266 std::string StubName = "__call_stub_fp_" + Name;
267 //
268 // see if we already have the stub
269 //
270 Function *FStub = M->getFunction(StubName);
271 if (FStub && !FStub->isDeclaration()) return;
272 FStub = Function::Create(F.getFunctionType(),
273 Function::InternalLinkage, StubName, M);
274 FStub->addFnAttr("mips16_fp_stub");
275 FStub->addFnAttr(Attribute::Naked);
276 FStub->addFnAttr(Attribute::NoInline);
277 FStub->addFnAttr(Attribute::NoUnwind);
278 FStub->addFnAttr("nomips16");
279 FStub->setSection(SectionName);
280 BasicBlock *BB = BasicBlock::Create(Context, "entry", FStub);
281 FPReturnVariant RV = whichFPReturnVariant(FStub->getReturnType());
282 FPParamVariant PV = whichFPParamVariantNeeded(F);
283
284 std::string AsmText;
285 AsmText += ".set reorder\n";
286 AsmText += swapFPIntParams(PV, M, LE, true);
287 if (RV != NoFPRet) {
288 AsmText += "move $$18, $$31\n";
289 AsmText += "jal " + Name + "\n";
290 } else {
291 AsmText += "lui $$25, %hi(" + Name + ")\n";
292 AsmText += "addiu $$25, $$25, %lo(" + Name + ")\n";
293 }
294
295 switch (RV) {
296 case FRet:
297 AsmText += "mfc1 $$2, $$f0\n";
298 break;
299
300 case DRet:
301 if (LE) {
302 AsmText += "mfc1 $$2, $$f0\n";
303 AsmText += "mfc1 $$3, $$f1\n";
304 } else {
305 AsmText += "mfc1 $$3, $$f0\n";
306 AsmText += "mfc1 $$2, $$f1\n";
307 }
308 break;
309
310 case CFRet:
311 if (LE) {
312 AsmText += "mfc1 $$2, $$f0\n";
313 AsmText += "mfc1 $$3, $$f2\n";
314 } else {
315 AsmText += "mfc1 $$3, $$f0\n";
316 AsmText += "mfc1 $$3, $$f2\n";
317 }
318 break;
319
320 case CDRet:
321 if (LE) {
322 AsmText += "mfc1 $$4, $$f2\n";
323 AsmText += "mfc1 $$5, $$f3\n";
324 AsmText += "mfc1 $$2, $$f0\n";
325 AsmText += "mfc1 $$3, $$f1\n";
326
327 } else {
328 AsmText += "mfc1 $$5, $$f2\n";
329 AsmText += "mfc1 $$4, $$f3\n";
330 AsmText += "mfc1 $$3, $$f0\n";
331 AsmText += "mfc1 $$2, $$f1\n";
332 }
333 break;
334
335 case NoFPRet:
336 break;
337 }
338
339 if (RV != NoFPRet)
340 AsmText += "jr $$18\n";
341 else
342 AsmText += "jr $$25\n";
343 emitInlineAsm(Context, BB, AsmText);
344
345 new UnreachableInst(Context, BB);
346 }
347
348 // Functions that are llvm intrinsics and don't need helpers.
349 static const char *const IntrinsicInline[] = {
350 "fabs", "fabsf",
351 "llvm.ceil.f32", "llvm.ceil.f64",
352 "llvm.copysign.f32", "llvm.copysign.f64",
353 "llvm.cos.f32", "llvm.cos.f64",
354 "llvm.exp.f32", "llvm.exp.f64",
355 "llvm.exp2.f32", "llvm.exp2.f64",
356 "llvm.fabs.f32", "llvm.fabs.f64",
357 "llvm.floor.f32", "llvm.floor.f64",
358 "llvm.fma.f32", "llvm.fma.f64",
359 "llvm.log.f32", "llvm.log.f64",
360 "llvm.log10.f32", "llvm.log10.f64",
361 "llvm.nearbyint.f32", "llvm.nearbyint.f64",
362 "llvm.pow.f32", "llvm.pow.f64",
363 "llvm.powi.f32.i32", "llvm.powi.f64.i32",
364 "llvm.rint.f32", "llvm.rint.f64",
365 "llvm.round.f32", "llvm.round.f64",
366 "llvm.sin.f32", "llvm.sin.f64",
367 "llvm.sqrt.f32", "llvm.sqrt.f64",
368 "llvm.trunc.f32", "llvm.trunc.f64",
369 };
370
isIntrinsicInline(Function * F)371 static bool isIntrinsicInline(Function *F) {
372 return std::binary_search(std::begin(IntrinsicInline),
373 std::end(IntrinsicInline), F->getName());
374 }
375
376 // Returns of float, double and complex need to be handled with a helper
377 // function.
fixupFPReturnAndCall(Function & F,Module * M,const MipsTargetMachine & TM)378 static bool fixupFPReturnAndCall(Function &F, Module *M,
379 const MipsTargetMachine &TM) {
380 bool Modified = false;
381 LLVMContext &C = M->getContext();
382 Type *MyVoid = Type::getVoidTy(C);
383 for (auto &BB: F)
384 for (auto &I: BB) {
385 if (const ReturnInst *RI = dyn_cast<ReturnInst>(&I)) {
386 Value *RVal = RI->getReturnValue();
387 if (!RVal) continue;
388 //
389 // If there is a return value and it needs a helper function,
390 // figure out which one and add a call before the actual
391 // return to this helper. The purpose of the helper is to move
392 // floating point values from their soft float return mapping to
393 // where they would have been mapped to in floating point registers.
394 //
395 Type *T = RVal->getType();
396 FPReturnVariant RV = whichFPReturnVariant(T);
397 if (RV == NoFPRet) continue;
398 static const char *const Helper[NoFPRet] = {
399 "__mips16_ret_sf", "__mips16_ret_df", "__mips16_ret_sc",
400 "__mips16_ret_dc"
401 };
402 const char *Name = Helper[RV];
403 AttributeList A;
404 Value *Params[] = {RVal};
405 Modified = true;
406 //
407 // These helper functions have a different calling ABI so
408 // this __Mips16RetHelper indicates that so that later
409 // during call setup, the proper call lowering to the helper
410 // functions will take place.
411 //
412 A = A.addFnAttribute(C, "__Mips16RetHelper");
413 A = A.addFnAttribute(
414 C, Attribute::getWithMemoryEffects(C, MemoryEffects::none()));
415 A = A.addFnAttribute(C, Attribute::NoInline);
416 FunctionCallee F = (M->getOrInsertFunction(Name, A, MyVoid, T));
417 CallInst::Create(F, Params, "", I.getIterator());
418 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
419 FunctionType *FT = CI->getFunctionType();
420 Function *F_ = CI->getCalledFunction();
421 if (needsFPReturnHelper(*FT) &&
422 !(F_ && isIntrinsicInline(F_))) {
423 Modified=true;
424 F.addFnAttr("saveS2");
425 }
426 if (F_ && !isIntrinsicInline(F_)) {
427 // pic mode calls are handled by already defined
428 // helper functions
429 if (needsFPReturnHelper(*F_)) {
430 Modified=true;
431 F.addFnAttr("saveS2");
432 }
433 if (!TM.isPositionIndependent()) {
434 if (needsFPHelperFromSig(*F_)) {
435 assureFPCallStub(*F_, M, TM);
436 Modified=true;
437 }
438 }
439 }
440 }
441 }
442 return Modified;
443 }
444
createFPFnStub(Function * F,Module * M,FPParamVariant PV,const MipsTargetMachine & TM)445 static void createFPFnStub(Function *F, Module *M, FPParamVariant PV,
446 const MipsTargetMachine &TM) {
447 bool PicMode = TM.isPositionIndependent();
448 bool LE = TM.isLittleEndian();
449 LLVMContext &Context = M->getContext();
450 std::string Name(F->getName());
451 std::string SectionName = ".mips16.fn." + Name;
452 std::string StubName = "__fn_stub_" + Name;
453 std::string LocalName = "$$__fn_local_" + Name;
454 Function *FStub = Function::Create
455 (F->getFunctionType(),
456 Function::InternalLinkage, StubName, M);
457 FStub->addFnAttr("mips16_fp_stub");
458 FStub->addFnAttr(Attribute::Naked);
459 FStub->addFnAttr(Attribute::NoUnwind);
460 FStub->addFnAttr(Attribute::NoInline);
461 FStub->addFnAttr("nomips16");
462 FStub->setSection(SectionName);
463 BasicBlock *BB = BasicBlock::Create(Context, "entry", FStub);
464
465 std::string AsmText;
466 if (PicMode) {
467 AsmText += ".set noreorder\n";
468 AsmText += ".cpload $$25\n";
469 AsmText += ".set reorder\n";
470 AsmText += ".reloc 0, R_MIPS_NONE, " + Name + "\n";
471 AsmText += "la $$25, " + LocalName + "\n";
472 } else
473 AsmText += "la $$25, " + Name + "\n";
474 AsmText += swapFPIntParams(PV, M, LE, false);
475 AsmText += "jr $$25\n";
476 AsmText += LocalName + " = " + Name + "\n";
477 emitInlineAsm(Context, BB, AsmText);
478
479 new UnreachableInst(FStub->getContext(), BB);
480 }
481
482 // remove the use-soft-float attribute
removeUseSoftFloat(Function & F)483 static void removeUseSoftFloat(Function &F) {
484 LLVM_DEBUG(errs() << "removing -use-soft-float\n");
485 F.removeFnAttr("use-soft-float");
486 if (F.hasFnAttribute("use-soft-float")) {
487 LLVM_DEBUG(errs() << "still has -use-soft-float\n");
488 }
489 F.addFnAttr("use-soft-float", "false");
490 }
491
492 // This pass only makes sense when the underlying chip has floating point but
493 // we are compiling as mips16.
494 // For all mips16 functions (that are not stubs we have already generated), or
495 // declared via attributes as nomips16, we must:
496 // 1) fixup all returns of float, double, single and double complex
497 // by calling a helper function before the actual return.
498 // 2) generate helper functions (stubs) that can be called by mips32
499 // functions that will move parameters passed normally passed in
500 // floating point
501 // registers the soft float equivalents.
502 // 3) in the case of static relocation, generate helper functions so that
503 // mips16 functions can call extern functions of unknown type (mips16 or
504 // mips32).
505 // 4) TBD. For pic, calls to extern functions of unknown type are handled by
506 // predefined helper functions in libc but this work is currently done
507 // during call lowering but it should be moved here in the future.
runOnModule(Module & M)508 bool Mips16HardFloat::runOnModule(Module &M) {
509 auto &TM = static_cast<const MipsTargetMachine &>(
510 getAnalysis<TargetPassConfig>().getTM<TargetMachine>());
511 LLVM_DEBUG(errs() << "Run on Module Mips16HardFloat\n");
512 bool Modified = false;
513 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
514 if (F->hasFnAttribute("nomips16") &&
515 F->hasFnAttribute("use-soft-float")) {
516 removeUseSoftFloat(*F);
517 continue;
518 }
519 if (F->isDeclaration() || F->hasFnAttribute("mips16_fp_stub") ||
520 F->hasFnAttribute("nomips16")) continue;
521 Modified |= fixupFPReturnAndCall(*F, &M, TM);
522 FPParamVariant V = whichFPParamVariantNeeded(*F);
523 if (V != NoSig) {
524 Modified = true;
525 createFPFnStub(&*F, &M, V, TM);
526 }
527 }
528 return Modified;
529 }
530
createMips16HardFloatPass()531 ModulePass *llvm::createMips16HardFloatPass() {
532 return new Mips16HardFloat();
533 }
534