lib/Target/Mips/MipsFastISel.cpp

   1 //===-- MipsastISel.cpp - Mips FastISel implementation
   2 //---------------------===//
   3
   4 #include "llvm/CodeGen/FunctionLoweringInfo.h"
   5 #include "llvm/CodeGen/FastISel.h"
   6 #include "llvm/CodeGen/MachineInstrBuilder.h"
   7 #include "llvm/IR/GlobalAlias.h"
   8 #include "llvm/IR/GlobalVariable.h"
   9 #include "llvm/Target/TargetInstrInfo.h"
  10 #include "llvm/Target/TargetLibraryInfo.h"
  11 #include "MipsRegisterInfo.h"
  12 #include "MipsISelLowering.h"
  13 #include "MipsMachineFunction.h"
  14 #include "MipsSubtarget.h"
  15 #include "MipsTargetMachine.h"
  16
  17 using namespace llvm;
  18
  19 namespace {
  20
  21 class MipsFastISel final : public FastISel {
  22
  23   // All possible address modes.
  24   class Address {
  25   public:
  26     typedef enum { RegBase, FrameIndexBase } BaseKind;
  27
  28   private:
  29     BaseKind Kind;
  30     union {
  31       unsigned Reg;
  32       int FI;
  33     } Base;
  34
  35     int64_t Offset;
  36
  37     const GlobalValue *GV;
  38
  39   public:
  40     // Innocuous defaults for our address.
  41     Address() : Kind(RegBase), Offset(0), GV(0) { Base.Reg = 0; }
  42     void setKind(BaseKind K) { Kind = K; }
  43     BaseKind getKind() const { return Kind; }
  44     bool isRegBase() const { return Kind == RegBase; }
  45     void setReg(unsigned Reg) {
  46       assert(isRegBase() && "Invalid base register access!");
  47       Base.Reg = Reg;
  48     }
  49     unsigned getReg() const {
  50       assert(isRegBase() && "Invalid base register access!");
  51       return Base.Reg;
  52     }
  53     void setOffset(int64_t Offset_) { Offset = Offset_; }
  54     int64_t getOffset() const { return Offset; }
  55     void setGlobalValue(const GlobalValue *G) { GV = G; }
  56     const GlobalValue *getGlobalValue() { return GV; }
  57   };
  58
  59   /// Subtarget - Keep a pointer to the MipsSubtarget around so that we can
  60   /// make the right decision when generating code for different targets.
  61   Module &M;
  62   const TargetMachine &TM;
  63   const TargetInstrInfo &TII;
  64   const TargetLowering &TLI;
  65   const MipsSubtarget *Subtarget;
  66   MipsFunctionInfo *MFI;
  67
  68   // Convenience variables to avoid some queries.
  69   LLVMContext *Context;
  70
  71   bool TargetSupported;
  72   bool UnsupportedFPMode; // To allow fast-isel to proceed and just not handle
  73   // floating point but not reject doing fast-isel in other
  74   // situations
  75
  76 private:
  77   // Selection routines.
  78   bool selectLoad(const Instruction *I);
  79   bool selectStore(const Instruction *I);
  80   bool selectBranch(const Instruction *I);
  81   bool selectCmp(const Instruction *I);
  82   bool selectFPExt(const Instruction *I);
  83   bool selectFPTrunc(const Instruction *I);
  84   bool selectFPToInt(const Instruction *I, bool IsSigned);
  85   bool selectRet(const Instruction *I);
  86   bool selectTrunc(const Instruction *I);
  87   bool selectIntExt(const Instruction *I);
  88
  89   // Utility helper routines.
  90
  91   bool isTypeLegal(Type *Ty, MVT &VT);
  92   bool isLoadTypeLegal(Type *Ty, MVT &VT);
  93   bool computeAddress(const Value *Obj, Address &Addr);
  94
  95   // Emit helper routines.
  96   bool emitCmp(unsigned DestReg, const CmpInst *CI);
  97   bool emitLoad(MVT VT, unsigned &ResultReg, Address &Addr,
  98                 unsigned Alignment = 0);
  99   bool emitStore(MVT VT, unsigned SrcReg, Address &Addr,
 100                  unsigned Alignment = 0);
 101   bool emitIntExt(MVT SrcVT, unsigned SrcReg, MVT DestVT, unsigned DestReg,
 102
 103                   bool IsZExt);
 104   bool emitIntZExt(MVT SrcVT, unsigned SrcReg, MVT DestVT, unsigned DestReg);
 105
 106   bool emitIntSExt(MVT SrcVT, unsigned SrcReg, MVT DestVT, unsigned DestReg);
 107   bool emitIntSExt32r1(MVT SrcVT, unsigned SrcReg, MVT DestVT,
 108                        unsigned DestReg);
 109   bool emitIntSExt32r2(MVT SrcVT, unsigned SrcReg, MVT DestVT,
 110                        unsigned DestReg);
 111
 112   unsigned getRegEnsuringSimpleIntegerWidening(const Value *, bool IsUnsigned);
 113
 114   unsigned materializeFP(const ConstantFP *CFP, MVT VT);
 115   unsigned materializeGV(const GlobalValue *GV, MVT VT);
 116   unsigned materializeInt(const Constant *C, MVT VT);
 117   unsigned materialize32BitInt(int64_t Imm, const TargetRegisterClass *RC);
 118
 119   MachineInstrBuilder emitInst(unsigned Opc) {
 120     return BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc));
 121   }
 122   MachineInstrBuilder emitInst(unsigned Opc, unsigned DstReg) {
 123     return BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc),
 124                    DstReg);
 125   }
 126   MachineInstrBuilder emitInstStore(unsigned Opc, unsigned SrcReg,
 127                                     unsigned MemReg, int64_t MemOffset) {
 128     return emitInst(Opc).addReg(SrcReg).addReg(MemReg).addImm(MemOffset);
 129   }
 130   MachineInstrBuilder emitInstLoad(unsigned Opc, unsigned DstReg,
 131                                    unsigned MemReg, int64_t MemOffset) {
 132     return emitInst(Opc, DstReg).addReg(MemReg).addImm(MemOffset);
 133   }
 134   // for some reason, this default is not generated by tablegen
 135   // so we explicitly generate it here.
 136   //
 137   unsigned fastEmitInst_riir(uint64_t inst, const TargetRegisterClass *RC,
 138                              unsigned Op0, bool Op0IsKill, uint64_t imm1,
 139                              uint64_t imm2, unsigned Op3, bool Op3IsKill) {
 140     return 0;
 141   }
 142
 143 public:
 144   // Backend specific FastISel code.
 145
 146   explicit MipsFastISel(FunctionLoweringInfo &funcInfo,
 147                         const TargetLibraryInfo *libInfo)
 148       : FastISel(funcInfo, libInfo),
 149         M(const_cast<Module &>(*funcInfo.Fn->getParent())),
 150         TM(funcInfo.MF->getTarget()),
 151         TII(*TM.getSubtargetImpl()->getInstrInfo()),
 152         TLI(*TM.getSubtargetImpl()->getTargetLowering()),
 153         Subtarget(&TM.getSubtarget<MipsSubtarget>()) {
 154     MFI = funcInfo.MF->getInfo<MipsFunctionInfo>();
 155     Context = &funcInfo.Fn->getContext();
 156     TargetSupported = ((Subtarget->getRelocationModel() == Reloc::PIC_) &&
 157                        ((Subtarget->hasMips32r2() || Subtarget->hasMips32()) &&
 158                         (Subtarget->isABI_O32())));
 159     UnsupportedFPMode = Subtarget->isFP64bit();
 160   }
 161
 162   unsigned fastMaterializeConstant(const Constant *C) override;
 163   bool fastSelectInstruction(const Instruction *I) override;
 164
 165 #include "MipsGenFastISel.inc"
 166 };
 167 } // end anonymous namespace.
 168
 169 bool MipsFastISel::isTypeLegal(Type *Ty, MVT &VT) {
 170   EVT evt = TLI.getValueType(Ty, true);
 171   // Only handle simple types.
 172   if (evt == MVT::Other || !evt.isSimple())
 173     return false;
 174   VT = evt.getSimpleVT();
 175
 176   // Handle all legal types, i.e. a register that will directly hold this
 177   // value.
 178   return TLI.isTypeLegal(VT);
 179 }
 180
 181 bool MipsFastISel::isLoadTypeLegal(Type *Ty, MVT &VT) {
 182   if (isTypeLegal(Ty, VT))
 183     return true;
 184   // We will extend this in a later patch:
 185   //   If this is a type than can be sign or zero-extended to a basic operation
 186   //   go ahead and accept it now.
 187   if (VT == MVT::i8 || VT == MVT::i16)
 188     return true;
 189   return false;
 190 }
 191
 192 bool MipsFastISel::computeAddress(const Value *Obj, Address &Addr) {
 193   // This construct looks a big awkward but it is how other ports handle this
 194   // and as this function is more fully completed, these cases which
 195   // return false will have additional code in them.
 196   //
 197   if (isa<Instruction>(Obj))
 198     return false;
 199   else if (isa<ConstantExpr>(Obj))
 200     return false;
 201   Addr.setReg(getRegForValue(Obj));
 202   return Addr.getReg() != 0;
 203 }
 204
 205 unsigned MipsFastISel::getRegEnsuringSimpleIntegerWidening(const Value *V,
 206                                                            bool IsUnsigned) {
 207   unsigned VReg = getRegForValue(V);
 208   if (VReg == 0)
 209     return 0;
 210   MVT VMVT = TLI.getValueType(V->getType(), true).getSimpleVT();
 211   if ((VMVT == MVT::i8) || (VMVT == MVT::i16)) {
 212     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
 213     if (!emitIntExt(VMVT, VReg, MVT::i32, TempReg, IsUnsigned))
 214       return 0;
 215     VReg = TempReg;
 216   }
 217   return VReg;
 218 }
 219
 220 bool MipsFastISel::emitLoad(MVT VT, unsigned &ResultReg, Address &Addr,
 221                             unsigned Alignment) {
 222   //
 223   // more cases will be handled here in following patches.
 224   //
 225   unsigned Opc;
 226   switch (VT.SimpleTy) {
 227   case MVT::i32: {
 228     ResultReg = createResultReg(&Mips::GPR32RegClass);
 229     Opc = Mips::LW;
 230     break;
 231   }
 232   case MVT::i16: {
 233     ResultReg = createResultReg(&Mips::GPR32RegClass);
 234     Opc = Mips::LHu;
 235     break;
 236   }
 237   case MVT::i8: {
 238     ResultReg = createResultReg(&Mips::GPR32RegClass);
 239     Opc = Mips::LBu;
 240     break;
 241   }
 242   case MVT::f32: {
 243     if (UnsupportedFPMode)
 244       return false;
 245     ResultReg = createResultReg(&Mips::FGR32RegClass);
 246     Opc = Mips::LWC1;
 247     break;
 248   }
 249   case MVT::f64: {
 250     if (UnsupportedFPMode)
 251       return false;
 252     ResultReg = createResultReg(&Mips::AFGR64RegClass);
 253     Opc = Mips::LDC1;
 254     break;
 255   }
 256   default:
 257     return false;
 258   }
 259   emitInstLoad(Opc, ResultReg, Addr.getReg(), Addr.getOffset());
 260   return true;
 261 }
 262
 263 // Materialize a constant into a register, and return the register
 264 // number (or zero if we failed to handle it).
 265 unsigned MipsFastISel::fastMaterializeConstant(const Constant *C) {
 266   EVT CEVT = TLI.getValueType(C->getType(), true);
 267
 268   // Only handle simple types.
 269   if (!CEVT.isSimple())
 270     return 0;
 271   MVT VT = CEVT.getSimpleVT();
 272
 273   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C))
 274     return (UnsupportedFPMode) ? 0 : materializeFP(CFP, VT);
 275   else if (const GlobalValue *GV = dyn_cast<GlobalValue>(C))
 276     return materializeGV(GV, VT);
 277   else if (isa<ConstantInt>(C))
 278     return materializeInt(C, VT);
 279
 280   return 0;
 281 }
 282
 283 bool MipsFastISel::emitStore(MVT VT, unsigned SrcReg, Address &Addr,
 284                              unsigned Alignment) {
 285   //
 286   // more cases will be handled here in following patches.
 287   //
 288   unsigned Opc;
 289   switch (VT.SimpleTy) {
 290   case MVT::i8:
 291     Opc = Mips::SB;
 292     break;
 293   case MVT::i16:
 294     Opc = Mips::SH;
 295     break;
 296   case MVT::i32:
 297     Opc = Mips::SW;
 298     break;
 299   case MVT::f32:
 300     if (UnsupportedFPMode)
 301       return false;
 302     Opc = Mips::SWC1;
 303     break;
 304   case MVT::f64:
 305     if (UnsupportedFPMode)
 306       return false;
 307     Opc = Mips::SDC1;
 308     break;
 309   default:
 310     return false;
 311   }
 312   emitInstStore(Opc, SrcReg, Addr.getReg(), Addr.getOffset());
 313   return true;
 314 }
 315
 316 bool MipsFastISel::emitIntSExt32r1(MVT SrcVT, unsigned SrcReg, MVT DestVT,
 317                                    unsigned DestReg) {
 318   unsigned ShiftAmt;
 319   switch (SrcVT.SimpleTy) {
 320   default:
 321     return false;
 322   case MVT::i8:
 323     ShiftAmt = 24;
 324     break;
 325   case MVT::i16:
 326     ShiftAmt = 16;
 327     break;
 328   }
 329   unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
 330   emitInst(Mips::SLL, TempReg).addReg(SrcReg).addImm(ShiftAmt);
 331   emitInst(Mips::SRA, DestReg).addReg(TempReg).addImm(ShiftAmt);
 332   return true;
 333 }
 334
 335 bool MipsFastISel::emitIntSExt32r2(MVT SrcVT, unsigned SrcReg, MVT DestVT,
 336                                    unsigned DestReg) {
 337   switch (SrcVT.SimpleTy) {
 338   default:
 339     return false;
 340   case MVT::i8:
 341     emitInst(Mips::SEB, DestReg).addReg(SrcReg);
 342     break;
 343   case MVT::i16:
 344     emitInst(Mips::SEH, DestReg).addReg(SrcReg);
 345     break;
 346   }
 347   return true;
 348 }
 349
 350 bool MipsFastISel::emitIntExt(MVT SrcVT, unsigned SrcReg, MVT DestVT,
 351                               unsigned DestReg, bool IsZExt) {
 352   if (IsZExt)
 353     return emitIntZExt(SrcVT, SrcReg, DestVT, DestReg);
 354   return emitIntSExt(SrcVT, SrcReg, DestVT, DestReg);
 355 }
 356
 357 bool MipsFastISel::emitIntSExt(MVT SrcVT, unsigned SrcReg, MVT DestVT,
 358                                unsigned DestReg) {
 359   if ((DestVT != MVT::i32) && (DestVT != MVT::i16))
 360     return false;
 361   if (Subtarget->hasMips32r2())
 362     return emitIntSExt32r2(SrcVT, SrcReg, DestVT, DestReg);
 363   return emitIntSExt32r1(SrcVT, SrcReg, DestVT, DestReg);
 364 }
 365
 366 bool MipsFastISel::emitIntZExt(MVT SrcVT, unsigned SrcReg, MVT DestVT,
 367                                unsigned DestReg) {
 368   switch (SrcVT.SimpleTy) {
 369   default:
 370     return false;
 371   case MVT::i1:
 372     emitInst(Mips::ANDi, DestReg).addReg(SrcReg).addImm(1);
 373     break;
 374   case MVT::i8:
 375     emitInst(Mips::ANDi, DestReg).addReg(SrcReg).addImm(0xff);
 376     break;
 377   case MVT::i16:
 378     emitInst(Mips::ANDi, DestReg).addReg(SrcReg).addImm(0xffff);
 379     break;
 380   }
 381   return true;
 382 }
 383
 384 //
 385 // This can cause a redundant sltiu to be generated.
 386 // FIXME: try and eliminate this in a future patch.
 387 //
 388 bool MipsFastISel::selectBranch(const Instruction *I) {
 389   const BranchInst *BI = cast<BranchInst>(I);
 390   MachineBasicBlock *BrBB = FuncInfo.MBB;
 391   //
 392   // TBB is the basic block for the case where the comparison is true.
 393   // FBB is the basic block for the case where the comparison is false.
 394   // if (cond) goto TBB
 395   // goto FBB
 396   // TBB:
 397   //
 398   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
 399   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
 400   BI->getCondition();
 401   // For now, just try the simplest case where it's fed by a compare.
 402   if (const CmpInst *CI = dyn_cast<CmpInst>(BI->getCondition())) {
 403     unsigned CondReg = createResultReg(&Mips::GPR32RegClass);
 404     if (!emitCmp(CondReg, CI))
 405       return false;
 406     BuildMI(*BrBB, FuncInfo.InsertPt, DbgLoc, TII.get(Mips::BGTZ))
 407         .addReg(CondReg)
 408         .addMBB(TBB);
 409     fastEmitBranch(FBB, DbgLoc);
 410     FuncInfo.MBB->addSuccessor(TBB);
 411     return true;
 412   }
 413   return false;
 414 }
 415
 416 bool MipsFastISel::selectLoad(const Instruction *I) {
 417   // Atomic loads need special handling.
 418   if (cast<LoadInst>(I)->isAtomic())
 419     return false;
 420
 421   // Verify we have a legal type before going any further.
 422   MVT VT;
 423   if (!isLoadTypeLegal(I->getType(), VT))
 424     return false;
 425
 426   // See if we can handle this address.
 427   Address Addr;
 428   if (!computeAddress(I->getOperand(0), Addr))
 429     return false;
 430
 431   unsigned ResultReg;
 432   if (!emitLoad(VT, ResultReg, Addr, cast<LoadInst>(I)->getAlignment()))
 433     return false;
 434   updateValueMap(I, ResultReg);
 435   return true;
 436 }
 437
 438 bool MipsFastISel::selectStore(const Instruction *I) {
 439   Value *Op0 = I->getOperand(0);
 440   unsigned SrcReg = 0;
 441
 442   // Atomic stores need special handling.
 443   if (cast<StoreInst>(I)->isAtomic())
 444     return false;
 445
 446   // Verify we have a legal type before going any further.
 447   MVT VT;
 448   if (!isLoadTypeLegal(I->getOperand(0)->getType(), VT))
 449     return false;
 450
 451   // Get the value to be stored into a register.
 452   SrcReg = getRegForValue(Op0);
 453   if (SrcReg == 0)
 454     return false;
 455
 456   // See if we can handle this address.
 457   Address Addr;
 458   if (!computeAddress(I->getOperand(1), Addr))
 459     return false;
 460
 461   if (!emitStore(VT, SrcReg, Addr, cast<StoreInst>(I)->getAlignment()))
 462     return false;
 463   return true;
 464 }
 465
 466 bool MipsFastISel::selectRet(const Instruction *I) {
 467   const ReturnInst *Ret = cast<ReturnInst>(I);
 468
 469   if (!FuncInfo.CanLowerReturn)
 470     return false;
 471   if (Ret->getNumOperands() > 0) {
 472     return false;
 473   }
 474   emitInst(Mips::RetRA);
 475   return true;
 476 }
 477
 478 // Attempt to fast-select a floating-point extend instruction.
 479 bool MipsFastISel::selectFPExt(const Instruction *I) {
 480   if (UnsupportedFPMode)
 481     return false;
 482   Value *Src = I->getOperand(0);
 483   EVT SrcVT = TLI.getValueType(Src->getType(), true);
 484   EVT DestVT = TLI.getValueType(I->getType(), true);
 485
 486   if (SrcVT != MVT::f32 || DestVT != MVT::f64)
 487     return false;
 488
 489   unsigned SrcReg =
 490       getRegForValue(Src); // his must be a 32 bit floating point register class
 491                            // maybe we should handle this differently
 492   if (!SrcReg)
 493     return false;
 494
 495   unsigned DestReg = createResultReg(&Mips::AFGR64RegClass);
 496   emitInst(Mips::CVT_D32_S, DestReg).addReg(SrcReg);
 497   updateValueMap(I, DestReg);
 498   return true;
 499 }
 500
 501 // Attempt to fast-select a floating-point truncate instruction.
 502 bool MipsFastISel::selectFPTrunc(const Instruction *I) {
 503   if (UnsupportedFPMode)
 504     return false;
 505   Value *Src = I->getOperand(0);
 506   EVT SrcVT = TLI.getValueType(Src->getType(), true);
 507   EVT DestVT = TLI.getValueType(I->getType(), true);
 508
 509   if (SrcVT != MVT::f64 || DestVT != MVT::f32)
 510     return false;
 511
 512   unsigned SrcReg = getRegForValue(Src);
 513   if (!SrcReg)
 514     return false;
 515
 516   unsigned DestReg = createResultReg(&Mips::FGR32RegClass);
 517   if (!DestReg)
 518     return false;
 519
 520   emitInst(Mips::CVT_S_D32, DestReg).addReg(SrcReg);
 521   updateValueMap(I, DestReg);
 522   return true;
 523 }
 524
 525 bool MipsFastISel::selectIntExt(const Instruction *I) {
 526   Type *DestTy = I->getType();
 527   Value *Src = I->getOperand(0);
 528   Type *SrcTy = Src->getType();
 529
 530   bool isZExt = isa<ZExtInst>(I);
 531   unsigned SrcReg = getRegForValue(Src);
 532   if (!SrcReg)
 533     return false;
 534
 535   EVT SrcEVT, DestEVT;
 536   SrcEVT = TLI.getValueType(SrcTy, true);
 537   DestEVT = TLI.getValueType(DestTy, true);
 538   if (!SrcEVT.isSimple())
 539     return false;
 540   if (!DestEVT.isSimple())
 541     return false;
 542
 543   MVT SrcVT = SrcEVT.getSimpleVT();
 544   MVT DestVT = DestEVT.getSimpleVT();
 545   unsigned ResultReg = createResultReg(&Mips::GPR32RegClass);
 546
 547   if (!emitIntExt(SrcVT, SrcReg, DestVT, ResultReg, isZExt))
 548     return false;
 549   updateValueMap(I, ResultReg);
 550   return true;
 551 }
 552
 553 bool MipsFastISel::selectTrunc(const Instruction *I) {
 554   // The high bits for a type smaller than the register size are assumed to be
 555   // undefined.
 556   Value *Op = I->getOperand(0);
 557
 558   EVT SrcVT, DestVT;
 559   SrcVT = TLI.getValueType(Op->getType(), true);
 560   DestVT = TLI.getValueType(I->getType(), true);
 561
 562   if (SrcVT != MVT::i32 && SrcVT != MVT::i16 && SrcVT != MVT::i8)
 563     return false;
 564   if (DestVT != MVT::i16 && DestVT != MVT::i8 && DestVT != MVT::i1)
 565     return false;
 566
 567   unsigned SrcReg = getRegForValue(Op);
 568   if (!SrcReg)
 569     return false;
 570
 571   // Because the high bits are undefined, a truncate doesn't generate
 572   // any code.
 573   updateValueMap(I, SrcReg);
 574   return true;
 575 }
 576
 577 // Attempt to fast-select a floating-point-to-integer conversion.
 578 bool MipsFastISel::selectFPToInt(const Instruction *I, bool IsSigned) {
 579   if (UnsupportedFPMode)
 580     return false;
 581   MVT DstVT, SrcVT;
 582   if (!IsSigned)
 583     return false; // We don't handle this case yet. There is no native
 584                   // instruction for this but it can be synthesized.
 585   Type *DstTy = I->getType();
 586   if (!isTypeLegal(DstTy, DstVT))
 587     return false;
 588
 589   if (DstVT != MVT::i32)
 590     return false;
 591
 592   Value *Src = I->getOperand(0);
 593   Type *SrcTy = Src->getType();
 594   if (!isTypeLegal(SrcTy, SrcVT))
 595     return false;
 596
 597   if (SrcVT != MVT::f32 && SrcVT != MVT::f64)
 598     return false;
 599
 600   unsigned SrcReg = getRegForValue(Src);
 601   if (SrcReg == 0)
 602     return false;
 603
 604   // Determine the opcode for the conversion, which takes place
 605   // entirely within FPRs.
 606   unsigned DestReg = createResultReg(&Mips::GPR32RegClass);
 607   unsigned TempReg = createResultReg(&Mips::FGR32RegClass);
 608   unsigned Opc;
 609
 610   if (SrcVT == MVT::f32)
 611     Opc = Mips::TRUNC_W_S;
 612   else
 613     Opc = Mips::TRUNC_W_D32;
 614
 615   // Generate the convert.
 616   emitInst(Opc, TempReg).addReg(SrcReg);
 617
 618   emitInst(Mips::MFC1, DestReg).addReg(TempReg);
 619
 620   updateValueMap(I, DestReg);
 621   return true;
 622 }
 623 //
 624 // Because of how EmitCmp is called with fast-isel, you can
 625 // end up with redundant "andi" instructions after the sequences emitted below.
 626 // We should try and solve this issue in the future.
 627 //
 628 bool MipsFastISel::emitCmp(unsigned ResultReg, const CmpInst *CI) {
 629   const Value *Left = CI->getOperand(0), *Right = CI->getOperand(1);
 630   bool IsUnsigned = CI->isUnsigned();
 631   unsigned LeftReg = getRegEnsuringSimpleIntegerWidening(Left, IsUnsigned);
 632   if (LeftReg == 0)
 633     return false;
 634   unsigned RightReg = getRegEnsuringSimpleIntegerWidening(Right, IsUnsigned);
 635   if (RightReg == 0)
 636     return false;
 637   CmpInst::Predicate P = CI->getPredicate();
 638
 639   switch (P) {
 640   default:
 641     return false;
 642   case CmpInst::ICMP_EQ: {
 643     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
 644     emitInst(Mips::XOR, TempReg).addReg(LeftReg).addReg(RightReg);
 645     emitInst(Mips::SLTiu, ResultReg).addReg(TempReg).addImm(1);
 646     break;
 647   }
 648   case CmpInst::ICMP_NE: {
 649     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
 650     emitInst(Mips::XOR, TempReg).addReg(LeftReg).addReg(RightReg);
 651     emitInst(Mips::SLTu, ResultReg).addReg(Mips::ZERO).addReg(TempReg);
 652     break;
 653   }
 654   case CmpInst::ICMP_UGT: {
 655     emitInst(Mips::SLTu, ResultReg).addReg(RightReg).addReg(LeftReg);
 656     break;
 657   }
 658   case CmpInst::ICMP_ULT: {
 659     emitInst(Mips::SLTu, ResultReg).addReg(LeftReg).addReg(RightReg);
 660     break;
 661   }
 662   case CmpInst::ICMP_UGE: {
 663     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
 664     emitInst(Mips::SLTu, TempReg).addReg(LeftReg).addReg(RightReg);
 665     emitInst(Mips::XORi, ResultReg).addReg(TempReg).addImm(1);
 666     break;
 667   }
 668   case CmpInst::ICMP_ULE: {
 669     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
 670     emitInst(Mips::SLTu, TempReg).addReg(RightReg).addReg(LeftReg);
 671     emitInst(Mips::XORi, ResultReg).addReg(TempReg).addImm(1);
 672     break;
 673   }
 674   case CmpInst::ICMP_SGT: {
 675     emitInst(Mips::SLT, ResultReg).addReg(RightReg).addReg(LeftReg);
 676     break;
 677   }
 678   case CmpInst::ICMP_SLT: {
 679     emitInst(Mips::SLT, ResultReg).addReg(LeftReg).addReg(RightReg);
 680     break;
 681   }
 682   case CmpInst::ICMP_SGE: {
 683     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
 684     emitInst(Mips::SLT, TempReg).addReg(LeftReg).addReg(RightReg);
 685     emitInst(Mips::XORi, ResultReg).addReg(TempReg).addImm(1);
 686     break;
 687   }
 688   case CmpInst::ICMP_SLE: {
 689     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
 690     emitInst(Mips::SLT, TempReg).addReg(RightReg).addReg(LeftReg);
 691     emitInst(Mips::XORi, ResultReg).addReg(TempReg).addImm(1);
 692     break;
 693   }
 694   case CmpInst::FCMP_OEQ:
 695   case CmpInst::FCMP_UNE:
 696   case CmpInst::FCMP_OLT:
 697   case CmpInst::FCMP_OLE:
 698   case CmpInst::FCMP_OGT:
 699   case CmpInst::FCMP_OGE: {
 700     if (UnsupportedFPMode)
 701       return false;
 702     bool IsFloat = Left->getType()->isFloatTy();
 703     bool IsDouble = Left->getType()->isDoubleTy();
 704     if (!IsFloat && !IsDouble)
 705       return false;
 706     unsigned Opc, CondMovOpc;
 707     switch (P) {
 708     case CmpInst::FCMP_OEQ:
 709       Opc = IsFloat ? Mips::C_EQ_S : Mips::C_EQ_D32;
 710       CondMovOpc = Mips::MOVT_I;
 711       break;
 712     case CmpInst::FCMP_UNE:
 713       Opc = IsFloat ? Mips::C_EQ_S : Mips::C_EQ_D32;
 714       CondMovOpc = Mips::MOVF_I;
 715       break;
 716     case CmpInst::FCMP_OLT:
 717       Opc = IsFloat ? Mips::C_OLT_S : Mips::C_OLT_D32;
 718       CondMovOpc = Mips::MOVT_I;
 719       break;
 720     case CmpInst::FCMP_OLE:
 721       Opc = IsFloat ? Mips::C_OLE_S : Mips::C_OLE_D32;
 722       CondMovOpc = Mips::MOVT_I;
 723       break;
 724     case CmpInst::FCMP_OGT:
 725       Opc = IsFloat ? Mips::C_ULE_S : Mips::C_ULE_D32;
 726       CondMovOpc = Mips::MOVF_I;
 727       break;
 728     case CmpInst::FCMP_OGE:
 729       Opc = IsFloat ? Mips::C_ULT_S : Mips::C_ULT_D32;
 730       CondMovOpc = Mips::MOVF_I;
 731       break;
 732     default:
 733       llvm_unreachable("Only switching of a subset of CCs.");
 734     }
 735     unsigned RegWithZero = createResultReg(&Mips::GPR32RegClass);
 736     unsigned RegWithOne = createResultReg(&Mips::GPR32RegClass);
 737     emitInst(Mips::ADDiu, RegWithZero).addReg(Mips::ZERO).addImm(0);
 738     emitInst(Mips::ADDiu, RegWithOne).addReg(Mips::ZERO).addImm(1);
 739     emitInst(Opc).addReg(LeftReg).addReg(RightReg).addReg(
 740         Mips::FCC0, RegState::ImplicitDefine);
 741     MachineInstrBuilder MI = emitInst(CondMovOpc, ResultReg)
 742                                  .addReg(RegWithOne)
 743                                  .addReg(Mips::FCC0)
 744                                  .addReg(RegWithZero, RegState::Implicit);
 745     MI->tieOperands(0, 3);
 746     break;
 747   }
 748   }
 749   return true;
 750 }
 751
 752 bool MipsFastISel::selectCmp(const Instruction *I) {
 753   const CmpInst *CI = cast<CmpInst>(I);
 754   unsigned ResultReg = createResultReg(&Mips::GPR32RegClass);
 755   if (!emitCmp(ResultReg, CI))
 756     return false;
 757   updateValueMap(I, ResultReg);
 758   return true;
 759 }
 760
 761 bool MipsFastISel::fastSelectInstruction(const Instruction *I) {
 762   if (!TargetSupported)
 763     return false;
 764   switch (I->getOpcode()) {
 765   default:
 766     break;
 767   case Instruction::Load:
 768     return selectLoad(I);
 769   case Instruction::Store:
 770     return selectStore(I);
 771   case Instruction::Br:
 772     return selectBranch(I);
 773   case Instruction::Ret:
 774     return selectRet(I);
 775   case Instruction::Trunc:
 776     return selectTrunc(I);
 777   case Instruction::ZExt:
 778   case Instruction::SExt:
 779     return selectIntExt(I);
 780   case Instruction::FPTrunc:
 781     return selectFPTrunc(I);
 782   case Instruction::FPExt:
 783     return selectFPExt(I);
 784   case Instruction::FPToSI:
 785     return selectFPToInt(I, /*isSigned*/ true);
 786   case Instruction::FPToUI:
 787     return selectFPToInt(I, /*isSigned*/ false);
 788   case Instruction::ICmp:
 789   case Instruction::FCmp:
 790     return selectCmp(I);
 791   }
 792   return false;
 793 }
 794
 795 unsigned MipsFastISel::materializeFP(const ConstantFP *CFP, MVT VT) {
 796   if (UnsupportedFPMode)
 797     return 0;
 798   int64_t Imm = CFP->getValueAPF().bitcastToAPInt().getZExtValue();
 799   if (VT == MVT::f32) {
 800     const TargetRegisterClass *RC = &Mips::FGR32RegClass;
 801     unsigned DestReg = createResultReg(RC);
 802     unsigned TempReg = materialize32BitInt(Imm, &Mips::GPR32RegClass);
 803     emitInst(Mips::MTC1, DestReg).addReg(TempReg);
 804     return DestReg;
 805   } else if (VT == MVT::f64) {
 806     const TargetRegisterClass *RC = &Mips::AFGR64RegClass;
 807     unsigned DestReg = createResultReg(RC);
 808     unsigned TempReg1 = materialize32BitInt(Imm >> 32, &Mips::GPR32RegClass);
 809     unsigned TempReg2 =
 810         materialize32BitInt(Imm & 0xFFFFFFFF, &Mips::GPR32RegClass);
 811     emitInst(Mips::BuildPairF64, DestReg).addReg(TempReg2).addReg(TempReg1);
 812     return DestReg;
 813   }
 814   return 0;
 815 }
 816
 817 unsigned MipsFastISel::materializeGV(const GlobalValue *GV, MVT VT) {
 818   // For now 32-bit only.
 819   if (VT != MVT::i32)
 820     return 0;
 821   const TargetRegisterClass *RC = &Mips::GPR32RegClass;
 822   unsigned DestReg = createResultReg(RC);
 823   const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
 824   bool IsThreadLocal = GVar && GVar->isThreadLocal();
 825   // TLS not supported at this time.
 826   if (IsThreadLocal)
 827     return 0;
 828   emitInst(Mips::LW, DestReg)
 829       .addReg(MFI->getGlobalBaseReg())
 830       .addGlobalAddress(GV, 0, MipsII::MO_GOT);
 831   if ((GV->hasInternalLinkage() ||
 832        (GV->hasLocalLinkage() && !isa<Function>(GV)))) {
 833     unsigned TempReg = createResultReg(RC);
 834     emitInst(Mips::ADDiu, TempReg)
 835         .addReg(DestReg)
 836         .addGlobalAddress(GV, 0, MipsII::MO_ABS_LO);
 837     DestReg = TempReg;
 838   }
 839   return DestReg;
 840 }
 841
 842 unsigned MipsFastISel::materializeInt(const Constant *C, MVT VT) {
 843   if (VT != MVT::i32 && VT != MVT::i16 && VT != MVT::i8 && VT != MVT::i1)
 844     return 0;
 845   const TargetRegisterClass *RC = &Mips::GPR32RegClass;
 846   const ConstantInt *CI = cast<ConstantInt>(C);
 847   int64_t Imm;
 848   if ((VT != MVT::i1) && CI->isNegative())
 849     Imm = CI->getSExtValue();
 850   else
 851     Imm = CI->getZExtValue();
 852   return materialize32BitInt(Imm, RC);
 853 }
 854
 855 unsigned MipsFastISel::materialize32BitInt(int64_t Imm,
 856                                            const TargetRegisterClass *RC) {
 857   unsigned ResultReg = createResultReg(RC);
 858
 859   if (isInt<16>(Imm)) {
 860     unsigned Opc = Mips::ADDiu;
 861     emitInst(Opc, ResultReg).addReg(Mips::ZERO).addImm(Imm);
 862     return ResultReg;
 863   } else if (isUInt<16>(Imm)) {
 864     emitInst(Mips::ORi, ResultReg).addReg(Mips::ZERO).addImm(Imm);
 865     return ResultReg;
 866   }
 867   unsigned Lo = Imm & 0xFFFF;
 868   unsigned Hi = (Imm >> 16) & 0xFFFF;
 869   if (Lo) {
 870     // Both Lo and Hi have nonzero bits.
 871     unsigned TmpReg = createResultReg(RC);
 872     emitInst(Mips::LUi, TmpReg).addImm(Hi);
 873     emitInst(Mips::ORi, ResultReg).addReg(TmpReg).addImm(Lo);
 874   } else {
 875     emitInst(Mips::LUi, ResultReg).addImm(Hi);
 876   }
 877   return ResultReg;
 878 }
 879
 880 namespace llvm {
 881 FastISel *Mips::createFastISel(FunctionLoweringInfo &funcInfo,
 882                                const TargetLibraryInfo *libInfo) {
 883   return new MipsFastISel(funcInfo, libInfo);
 884 }
 885 }