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