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