1 //===---- Mips16HardFloat.cpp for Mips16 Hard Float --------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines a pass needed for Mips16 Hard Float
12 //===----------------------------------------------------------------------===//
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"
22 static void inlineAsmOut
23 (LLVMContext &C, StringRef AsmString, BasicBlock *BB ) {
24 std::vector<llvm::Type *> AsmArgTypes;
25 std::vector<llvm::Value*> AsmArgs;
26 llvm::FunctionType *AsmFTy =
27 llvm::FunctionType::get(Type::getVoidTy(C),
30 llvm::InlineAsm::get(AsmFTy, AsmString, "", true,
31 /* IsAlignStack */ false,
32 llvm::InlineAsm::AD_ATT);
33 CallInst::Create(IA, AsmArgs, "", BB);
38 class InlineAsmHelper {
42 InlineAsmHelper(LLVMContext &C_, BasicBlock *BB_) :
46 void Out(StringRef AsmString) {
47 inlineAsmOut(C, AsmString, BB);
53 // Return types that matter for hard float are:
54 // float, double, complex float, and complex double
56 enum FPReturnVariant {
57 FRet, DRet, CFRet, CDRet, NoFPRet
61 // Determine which FP return type this function has
63 static FPReturnVariant whichFPReturnVariant(Type *T) {
64 switch (T->getTypeID()) {
67 case Type::DoubleTyID:
69 case Type::StructTyID:
70 if (T->getStructNumElements() != 2)
72 if ((T->getContainedType(0)->isFloatTy()) &&
73 (T->getContainedType(1)->isFloatTy()))
75 if ((T->getContainedType(0)->isDoubleTy()) &&
76 (T->getContainedType(1)->isDoubleTy()))
86 // Parameter type that matter are float, (float, float), (float, double),
87 // double, (double, double), (double, float)
91 DSig, DDSig, DFSig, NoSig
94 // which floating point parameter signature variant we are dealing with
96 typedef Type::TypeID TypeID;
97 const Type::TypeID FloatTyID = Type::FloatTyID;
98 const Type::TypeID DoubleTyID = Type::DoubleTyID;
100 static FPParamVariant whichFPParamVariantNeeded(Function &F) {
101 switch (F.arg_size()) {
105 TypeID ArgTypeID = F.getFunctionType()->getParamType(0)->getTypeID();
116 TypeID ArgTypeID0 = F.getFunctionType()->getParamType(0)->getTypeID();
117 TypeID ArgTypeID1 = F.getFunctionType()->getParamType(1)->getTypeID();
120 switch (ArgTypeID1) {
130 switch (ArgTypeID1) {
144 llvm_unreachable("can't get here");
147 // Figure out if we need float point based on the function parameters.
148 // We need to move variables in and/or out of floating point
149 // registers because of the ABI
151 static bool needsFPStubFromParams(Function &F) {
152 if (F.arg_size() >=1) {
153 Type *ArgType = F.getFunctionType()->getParamType(0);
154 switch (ArgType->getTypeID()) {
155 case Type::FloatTyID:
156 case Type::DoubleTyID:
165 static bool needsFPReturnHelper(Function &F) {
166 Type* RetType = F.getReturnType();
167 return whichFPReturnVariant(RetType) != NoFPRet;
170 static bool needsFPHelperFromSig(Function &F) {
171 return needsFPStubFromParams(F) || needsFPReturnHelper(F);
175 // We swap between FP and Integer registers to allow Mips16 and Mips32 to
179 static void swapFPIntParams
180 (FPParamVariant PV, Module *M, InlineAsmHelper &IAH,
181 bool LE, bool ToFP) {
182 //LLVMContext &Context = M->getContext();
183 std::string MI = ToFP? "mtc1 ": "mfc1 ";
186 IAH.Out(MI + "$$4,$$f12");
189 IAH.Out(MI +"$$4,$$f12");
190 IAH.Out(MI + "$$5,$$f14");
193 IAH.Out(MI + "$$4,$$f12");
195 IAH.Out(MI + "$$6,$$f14");
196 IAH.Out(MI + "$$7,$$f15");
198 IAH.Out(MI + "$$7,$$f14");
199 IAH.Out(MI + "$$6,$$f15");
204 IAH.Out(MI + "$$4,$$f12");
205 IAH.Out(MI + "$$5,$$f13");
207 IAH.Out(MI + "$$5,$$f12");
208 IAH.Out(MI + "$$4,$$f13");
213 IAH.Out(MI + "$$4,$$f12");
214 IAH.Out(MI + "$$5,$$f13");
215 IAH.Out(MI + "$$6,$$f14");
216 IAH.Out(MI + "$$7,$$f15");
218 IAH.Out(MI + "$$5,$$f12");
219 IAH.Out(MI + "$$4,$$f13");
220 IAH.Out(MI + "$$7,$$f14");
221 IAH.Out(MI + "$$6,$$f15");
226 IAH.Out(MI + "$$4,$$f12");
227 IAH.Out(MI + "$$5,$$f13");
229 IAH.Out(MI + "$$5,$$f12");
230 IAH.Out(MI + "$$4,$$f13");
232 IAH.Out(MI + "$$6,$$f14");
239 // Make sure that we know we already need a stub for this function.
240 // Having called needsFPHelperFromSig
242 static void assureFPCallStub(Function &F, Module *M,
243 const MipsSubtarget &Subtarget){
244 // for now we only need them for static relocation
245 if (Subtarget.getRelocationModel() == Reloc::PIC_)
247 LLVMContext &Context = M->getContext();
248 bool LE = Subtarget.isLittle();
249 std::string Name = F.getName();
250 std::string SectionName = ".mips16.call.fp." + Name;
251 std::string StubName = "__call_stub_fp_" + Name;
253 // see if we already have the stub
255 Function *FStub = M->getFunction(StubName);
256 if (FStub && !FStub->isDeclaration()) return;
257 FStub = Function::Create(F.getFunctionType(),
258 Function::InternalLinkage, StubName, M);
259 FStub->addFnAttr("mips16_fp_stub");
260 FStub->addFnAttr(llvm::Attribute::Naked);
261 FStub->addFnAttr(llvm::Attribute::NoInline);
262 FStub->addFnAttr(llvm::Attribute::NoUnwind);
263 FStub->addFnAttr("nomips16");
264 FStub->setSection(SectionName);
265 BasicBlock *BB = BasicBlock::Create(Context, "entry", FStub);
266 InlineAsmHelper IAH(Context, BB);
267 IAH.Out(".set reorder");
268 FPReturnVariant RV = whichFPReturnVariant(FStub->getReturnType());
269 FPParamVariant PV = whichFPParamVariantNeeded(F);
270 swapFPIntParams(PV, M, IAH, LE, true);
272 IAH.Out("move $$18, $$31");
273 IAH.Out("jal " + Name);
275 IAH.Out("lui $$25,%hi(" + Name + ")");
276 IAH.Out("addiu $$25,$$25,%lo(" + Name + ")" );
280 IAH.Out("mfc1 $$2,$$f0");
284 IAH.Out("mfc1 $$2,$$f0");
285 IAH.Out("mfc1 $$3,$$f1");
287 IAH.Out("mfc1 $$3,$$f0");
288 IAH.Out("mfc1 $$2,$$f1");
293 IAH.Out("mfc1 $$2,$$f0");
294 IAH.Out("mfc1 $$3,$$f2");
296 IAH.Out("mfc1 $$3,$$f0");
297 IAH.Out("mfc1 $$3,$$f2");
302 IAH.Out("mfc1 $$4,$$f2");
303 IAH.Out("mfc1 $$5,$$f3");
304 IAH.Out("mfc1 $$2,$$f0");
305 IAH.Out("mfc1 $$3,$$f1");
308 IAH.Out("mfc1 $$5,$$f2");
309 IAH.Out("mfc1 $$4,$$f3");
310 IAH.Out("mfc1 $$3,$$f0");
311 IAH.Out("mfc1 $$2,$$f1");
321 new UnreachableInst(Context, BB);
325 // Functions that are llvm intrinsics and don't need helpers.
327 static const char *IntrinsicInline[] =
329 "llvm.ceil.f32", "llvm.ceil.f64",
330 "llvm.copysign.f32", "llvm.copysign.f64",
331 "llvm.cos.f32", "llvm.cos.f64",
332 "llvm.exp.f32", "llvm.exp.f64",
333 "llvm.exp2.f32", "llvm.exp2.f64",
334 "llvm.fabs.f32", "llvm.fabs.f64",
335 "llvm.floor.f32", "llvm.floor.f64",
336 "llvm.fma.f32", "llvm.fma.f64",
337 "llvm.log.f32", "llvm.log.f64",
338 "llvm.log10.f32", "llvm.log10.f64",
339 "llvm.nearbyint.f32", "llvm.nearbyint.f64",
340 "llvm.pow.f32", "llvm.pow.f64",
341 "llvm.powi.f32", "llvm.powi.f64",
342 "llvm.rint.f32", "llvm.rint.f64",
343 "llvm.round.f32", "llvm.round.f64",
344 "llvm.sin.f32", "llvm.sin.f64",
345 "llvm.sqrt.f32", "llvm.sqrt.f64",
346 "llvm.trunc.f32", "llvm.trunc.f64",
349 static bool isIntrinsicInline(Function *F) {
350 return std::binary_search(
351 IntrinsicInline, array_endof(IntrinsicInline),
355 // Returns of float, double and complex need to be handled with a helper
358 static bool fixupFPReturnAndCall
359 (Function &F, Module *M, const MipsSubtarget &Subtarget) {
360 bool Modified = false;
361 LLVMContext &C = M->getContext();
362 Type *MyVoid = Type::getVoidTy(C);
363 for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
364 for (BasicBlock::iterator I = BB->begin(), E = BB->end();
366 Instruction &Inst = *I;
367 if (const ReturnInst *RI = dyn_cast<ReturnInst>(I)) {
368 Value *RVal = RI->getReturnValue();
371 // If there is a return value and it needs a helper function,
372 // figure out which one and add a call before the actual
373 // return to this helper. The purpose of the helper is to move
374 // floating point values from their soft float return mapping to
375 // where they would have been mapped to in floating point registers.
377 Type *T = RVal->getType();
378 FPReturnVariant RV = whichFPReturnVariant(T);
379 if (RV == NoFPRet) continue;
380 static const char* Helper[NoFPRet] =
381 {"__mips16_ret_sf", "__mips16_ret_df", "__mips16_ret_sc",
383 const char *Name = Helper[RV];
385 Value *Params[] = {RVal};
388 // These helper functions have a different calling ABI so
389 // this __Mips16RetHelper indicates that so that later
390 // during call setup, the proper call lowering to the helper
391 // functions will take place.
393 A = A.addAttribute(C, AttributeSet::FunctionIndex,
394 "__Mips16RetHelper");
395 A = A.addAttribute(C, AttributeSet::FunctionIndex,
396 Attribute::ReadNone);
397 A = A.addAttribute(C, AttributeSet::FunctionIndex,
398 Attribute::NoInline);
399 Value *F = (M->getOrInsertFunction(Name, A, MyVoid, T, NULL));
400 CallInst::Create(F, Params, "", &Inst );
401 } else if (const CallInst *CI = dyn_cast<CallInst>(I)) {
402 // pic mode calls are handled by already defined
404 if (Subtarget.getRelocationModel() != Reloc::PIC_ ) {
405 Function *F_ = CI->getCalledFunction();
406 if (F_ && !isIntrinsicInline(F_) && needsFPHelperFromSig(*F_)) {
407 assureFPCallStub(*F_, M, Subtarget);
416 static void createFPFnStub(Function *F, Module *M, FPParamVariant PV,
417 const MipsSubtarget &Subtarget ) {
418 bool PicMode = Subtarget.getRelocationModel() == Reloc::PIC_;
419 bool LE = Subtarget.isLittle();
420 LLVMContext &Context = M->getContext();
421 std::string Name = F->getName();
422 std::string SectionName = ".mips16.fn." + Name;
423 std::string StubName = "__fn_stub_" + Name;
424 std::string LocalName = "__fn_local_" + Name;
425 Function *FStub = Function::Create
426 (F->getFunctionType(),
427 Function::InternalLinkage, StubName, M);
428 FStub->addFnAttr("mips16_fp_stub");
429 FStub->addFnAttr(llvm::Attribute::Naked);
430 FStub->addFnAttr(llvm::Attribute::NoUnwind);
431 FStub->addFnAttr(llvm::Attribute::NoInline);
432 FStub->addFnAttr("nomips16");
433 FStub->setSection(SectionName);
434 BasicBlock *BB = BasicBlock::Create(Context, "entry", FStub);
435 InlineAsmHelper IAH(Context, BB);
436 IAH.Out(" .set macro");
438 IAH.Out(".set noreorder");
439 IAH.Out(".cpload $$2");
440 IAH.Out(".set reorder");
441 IAH.Out(".reloc 0,R_MIPS_NONE," + Name);
442 IAH.Out("la $$25," + LocalName);
445 IAH.Out("la $$25, " + Name);
446 swapFPIntParams(PV, M, IAH, LE, false);
448 IAH.Out(LocalName + " = " + Name);
449 new UnreachableInst(FStub->getContext(), BB);
453 // remove the use-soft-float attribute
455 static void removeUseSoftFloat(Function &F) {
457 DEBUG(errs() << "removing -use-soft-float\n");
458 A = A.addAttribute(F.getContext(), AttributeSet::FunctionIndex,
459 "use-soft-float", "false");
460 F.removeAttributes(AttributeSet::FunctionIndex, A);
461 if (F.hasFnAttribute("use-soft-float")) {
462 DEBUG(errs() << "still has -use-soft-float\n");
464 F.addAttributes(AttributeSet::FunctionIndex, A);
470 // This pass only makes sense when the underlying chip has floating point but
471 // we are compiling as mips16.
472 // For all mips16 functions (that are not stubs we have already generated), or
473 // declared via attributes as nomips16, we must:
474 // 1) fixup all returns of float, double, single and double complex
475 // by calling a helper function before the actual return.
476 // 2) generate helper functions (stubs) that can be called by mips32 functions
477 // that will move parameters passed normally passed in floating point
478 // registers the soft float equivalents.
479 // 3) in the case of static relocation, generate helper functions so that
480 // mips16 functions can call extern functions of unknown type (mips16 or
482 // 4) TBD. For pic, calls to extern functions of unknown type are handled by
483 // predefined helper functions in libc but this work is currently done
484 // during call lowering but it should be moved here in the future.
486 bool Mips16HardFloat::runOnModule(Module &M) {
487 DEBUG(errs() << "Run on Module Mips16HardFloat\n");
488 bool Modified = false;
489 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
490 if (F->hasFnAttribute("nomips16") &&
491 F->hasFnAttribute("use-soft-float")) {
492 removeUseSoftFloat(*F);
495 if (F->isDeclaration() || F->hasFnAttribute("mips16_fp_stub") ||
496 F->hasFnAttribute("nomips16")) continue;
497 Modified |= fixupFPReturnAndCall(*F, &M, Subtarget);
498 FPParamVariant V = whichFPParamVariantNeeded(*F);
501 createFPFnStub(F, &M, V, Subtarget);
507 char Mips16HardFloat::ID = 0;
511 ModulePass *llvm::createMips16HardFloat(MipsTargetMachine &TM) {
512 return new Mips16HardFloat(TM);