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 
33     Mips16HardFloat() : ModulePass(ID) {}
34 
35     StringRef getPassName() const override { return "MIPS16 Hard Float Pass"; }
36 
37     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 
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 //
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 
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
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 
171 static bool needsFPReturnHelper(Function &F) {
172   Type* RetType = F.getReturnType();
173   return whichFPReturnVariant(RetType) != NoFPRet;
174 }
175 
176 static bool needsFPReturnHelper(FunctionType &FT) {
177   Type* RetType = FT.getReturnType();
178   return whichFPReturnVariant(RetType) != NoFPRet;
179 }
180 
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
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
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 
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.
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 
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
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.
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 
535 ModulePass *llvm::createMips16HardFloatPass() {
536   return new Mips16HardFloat();
537 }
538