1 //===- Mips16HardFloat.cpp for Mips16 Hard Float --------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines a pass needed for Mips16 Hard Float
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "MipsTargetMachine.h"
15 #include "llvm/CodeGen/TargetPassConfig.h"
16 #include "llvm/IR/Module.h"
17 #include "llvm/IR/Value.h"
18 #include "llvm/Support/Debug.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", "llvm.powi.f64",
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.addAttribute(C, AttributeList::FunctionIndex,
413 "__Mips16RetHelper");
414 A = A.addAttribute(C, AttributeList::FunctionIndex,
415 Attribute::ReadNone);
416 A = A.addAttribute(C, AttributeList::FunctionIndex,
417 Attribute::NoInline);
418 Value *F = (M->getOrInsertFunction(Name, A, MyVoid, T));
419 CallInst::Create(F, Params, "", &I);
420 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
421 FunctionType *FT = CI->getFunctionType();
422 Function *F_ = CI->getCalledFunction();
423 if (needsFPReturnHelper(*FT) &&
424 !(F_ && isIntrinsicInline(F_))) {
425 Modified=true;
426 F.addFnAttr("saveS2");
427 }
428 if (F_ && !isIntrinsicInline(F_)) {
429 // pic mode calls are handled by already defined
430 // helper functions
431 if (needsFPReturnHelper(*F_)) {
432 Modified=true;
433 F.addFnAttr("saveS2");
434 }
435 if (!TM.isPositionIndependent()) {
436 if (needsFPHelperFromSig(*F_)) {
437 assureFPCallStub(*F_, M, TM);
438 Modified=true;
439 }
440 }
441 }
442 }
443 }
444 return Modified;
445 }
446
createFPFnStub(Function * F,Module * M,FPParamVariant PV,const MipsTargetMachine & TM)447 static void createFPFnStub(Function *F, Module *M, FPParamVariant PV,
448 const MipsTargetMachine &TM) {
449 bool PicMode = TM.isPositionIndependent();
450 bool LE = TM.isLittleEndian();
451 LLVMContext &Context = M->getContext();
452 std::string Name = F->getName();
453 std::string SectionName = ".mips16.fn." + Name;
454 std::string StubName = "__fn_stub_" + Name;
455 std::string LocalName = "$$__fn_local_" + Name;
456 Function *FStub = Function::Create
457 (F->getFunctionType(),
458 Function::InternalLinkage, StubName, M);
459 FStub->addFnAttr("mips16_fp_stub");
460 FStub->addFnAttr(Attribute::Naked);
461 FStub->addFnAttr(Attribute::NoUnwind);
462 FStub->addFnAttr(Attribute::NoInline);
463 FStub->addFnAttr("nomips16");
464 FStub->setSection(SectionName);
465 BasicBlock *BB = BasicBlock::Create(Context, "entry", FStub);
466
467 std::string AsmText;
468 if (PicMode) {
469 AsmText += ".set noreorder\n";
470 AsmText += ".cpload $$25\n";
471 AsmText += ".set reorder\n";
472 AsmText += ".reloc 0, R_MIPS_NONE, " + Name + "\n";
473 AsmText += "la $$25, " + LocalName + "\n";
474 } else
475 AsmText += "la $$25, " + Name + "\n";
476 AsmText += swapFPIntParams(PV, M, LE, false);
477 AsmText += "jr $$25\n";
478 AsmText += LocalName + " = " + Name + "\n";
479 EmitInlineAsm(Context, BB, AsmText);
480
481 new UnreachableInst(FStub->getContext(), BB);
482 }
483
484 // remove the use-soft-float attribute
removeUseSoftFloat(Function & F)485 static void removeUseSoftFloat(Function &F) {
486 AttrBuilder B;
487 LLVM_DEBUG(errs() << "removing -use-soft-float\n");
488 B.addAttribute("use-soft-float", "false");
489 F.removeAttributes(AttributeList::FunctionIndex, B);
490 if (F.hasFnAttribute("use-soft-float")) {
491 LLVM_DEBUG(errs() << "still has -use-soft-float\n");
492 }
493 F.addAttributes(AttributeList::FunctionIndex, B);
494 }
495
496 // This pass only makes sense when the underlying chip has floating point but
497 // we are compiling as mips16.
498 // For all mips16 functions (that are not stubs we have already generated), or
499 // declared via attributes as nomips16, we must:
500 // 1) fixup all returns of float, double, single and double complex
501 // by calling a helper function before the actual return.
502 // 2) generate helper functions (stubs) that can be called by mips32
503 // functions that will move parameters passed normally passed in
504 // floating point
505 // registers the soft float equivalents.
506 // 3) in the case of static relocation, generate helper functions so that
507 // mips16 functions can call extern functions of unknown type (mips16 or
508 // mips32).
509 // 4) TBD. For pic, calls to extern functions of unknown type are handled by
510 // predefined helper functions in libc but this work is currently done
511 // during call lowering but it should be moved here in the future.
runOnModule(Module & M)512 bool Mips16HardFloat::runOnModule(Module &M) {
513 auto &TM = static_cast<const MipsTargetMachine &>(
514 getAnalysis<TargetPassConfig>().getTM<TargetMachine>());
515 LLVM_DEBUG(errs() << "Run on Module Mips16HardFloat\n");
516 bool Modified = false;
517 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
518 if (F->hasFnAttribute("nomips16") &&
519 F->hasFnAttribute("use-soft-float")) {
520 removeUseSoftFloat(*F);
521 continue;
522 }
523 if (F->isDeclaration() || F->hasFnAttribute("mips16_fp_stub") ||
524 F->hasFnAttribute("nomips16")) continue;
525 Modified |= fixupFPReturnAndCall(*F, &M, TM);
526 FPParamVariant V = whichFPParamVariantNeeded(*F);
527 if (V != NoSig) {
528 Modified = true;
529 createFPFnStub(&*F, &M, V, TM);
530 }
531 }
532 return Modified;
533 }
534
createMips16HardFloatPass()535 ModulePass *llvm::createMips16HardFloatPass() {
536 return new Mips16HardFloat();
537 }
538