lib/Target/Mips/Mips16HardFloat.cpp

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