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