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