lib/Target/ARM/ARMFastISel.cpp

   1 //===-- ARMFastISel.cpp - ARM FastISel implementation ---------------------===//
   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 the ARM-specific support for the FastISel class. Some
  11 // of the target-specific code is generated by tablegen in the file
  12 // ARMGenFastISel.inc, which is #included here.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "ARM.h"
  17 #include "ARMBaseInstrInfo.h"
  18 #include "ARMCallingConv.h"
  19 #include "ARMRegisterInfo.h"
  20 #include "ARMTargetMachine.h"
  21 #include "ARMSubtarget.h"
  22 #include "ARMConstantPoolValue.h"
  23 #include "llvm/CallingConv.h"
  24 #include "llvm/DerivedTypes.h"
  25 #include "llvm/GlobalVariable.h"
  26 #include "llvm/Instructions.h"
  27 #include "llvm/IntrinsicInst.h"
  28 #include "llvm/Module.h"
  29 #include "llvm/Operator.h"
  30 #include "llvm/CodeGen/Analysis.h"
  31 #include "llvm/CodeGen/FastISel.h"
  32 #include "llvm/CodeGen/FunctionLoweringInfo.h"
  33 #include "llvm/CodeGen/MachineInstrBuilder.h"
  34 #include "llvm/CodeGen/MachineModuleInfo.h"
  35 #include "llvm/CodeGen/MachineConstantPool.h"
  36 #include "llvm/CodeGen/MachineFrameInfo.h"
  37 #include "llvm/CodeGen/MachineMemOperand.h"
  38 #include "llvm/CodeGen/MachineRegisterInfo.h"
  39 #include "llvm/CodeGen/PseudoSourceValue.h"
  40 #include "llvm/Support/CallSite.h"
  41 #include "llvm/Support/CommandLine.h"
  42 #include "llvm/Support/ErrorHandling.h"
  43 #include "llvm/Support/GetElementPtrTypeIterator.h"
  44 #include "llvm/Target/TargetData.h"
  45 #include "llvm/Target/TargetInstrInfo.h"
  46 #include "llvm/Target/TargetLowering.h"
  47 #include "llvm/Target/TargetMachine.h"
  48 #include "llvm/Target/TargetOptions.h"
  49 using namespace llvm;
  50
  51 static cl::opt<bool>
  52 DisableARMFastISel("disable-arm-fast-isel",
  53                     cl::desc("Turn off experimental ARM fast-isel support"),
  54                     cl::init(false), cl::Hidden);
  55
  56 extern cl::opt<bool> EnableARMLongCalls;
  57
  58 namespace {
  59
  60   // All possible address modes, plus some.
  61   typedef struct Address {
  62     enum {
  63       RegBase,
  64       FrameIndexBase
  65     } BaseType;
  66
  67     union {
  68       unsigned Reg;
  69       int FI;
  70     } Base;
  71
  72     int Offset;
  73     unsigned Scale;
  74     unsigned PlusReg;
  75
  76     // Innocuous defaults for our address.
  77     Address()
  78      : BaseType(RegBase), Offset(0), Scale(0), PlusReg(0) {
  79        Base.Reg = 0;
  80      }
  81   } Address;
  82
  83 class ARMFastISel : public FastISel {
  84
  85   /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can
  86   /// make the right decision when generating code for different targets.
  87   const ARMSubtarget *Subtarget;
  88   const TargetMachine &TM;
  89   const TargetInstrInfo &TII;
  90   const TargetLowering &TLI;
  91   ARMFunctionInfo *AFI;
  92
  93   // Convenience variables to avoid some queries.
  94   bool isThumb;
  95   LLVMContext *Context;
  96
  97   public:
  98     explicit ARMFastISel(FunctionLoweringInfo &funcInfo)
  99     : FastISel(funcInfo),
 100       TM(funcInfo.MF->getTarget()),
 101       TII(*TM.getInstrInfo()),
 102       TLI(*TM.getTargetLowering()) {
 103       Subtarget = &TM.getSubtarget<ARMSubtarget>();
 104       AFI = funcInfo.MF->getInfo<ARMFunctionInfo>();
 105       isThumb = AFI->isThumbFunction();
 106       Context = &funcInfo.Fn->getContext();
 107     }
 108
 109     // Code from FastISel.cpp.
 110     virtual unsigned FastEmitInst_(unsigned MachineInstOpcode,
 111                                    const TargetRegisterClass *RC);
 112     virtual unsigned FastEmitInst_r(unsigned MachineInstOpcode,
 113                                     const TargetRegisterClass *RC,
 114                                     unsigned Op0, bool Op0IsKill);
 115     virtual unsigned FastEmitInst_rr(unsigned MachineInstOpcode,
 116                                      const TargetRegisterClass *RC,
 117                                      unsigned Op0, bool Op0IsKill,
 118                                      unsigned Op1, bool Op1IsKill);
 119     virtual unsigned FastEmitInst_rrr(unsigned MachineInstOpcode,
 120                                       const TargetRegisterClass *RC,
 121                                       unsigned Op0, bool Op0IsKill,
 122                                       unsigned Op1, bool Op1IsKill,
 123                                       unsigned Op2, bool Op2IsKill);
 124     virtual unsigned FastEmitInst_ri(unsigned MachineInstOpcode,
 125                                      const TargetRegisterClass *RC,
 126                                      unsigned Op0, bool Op0IsKill,
 127                                      uint64_t Imm);
 128     virtual unsigned FastEmitInst_rf(unsigned MachineInstOpcode,
 129                                      const TargetRegisterClass *RC,
 130                                      unsigned Op0, bool Op0IsKill,
 131                                      const ConstantFP *FPImm);
 132     virtual unsigned FastEmitInst_rri(unsigned MachineInstOpcode,
 133                                       const TargetRegisterClass *RC,
 134                                       unsigned Op0, bool Op0IsKill,
 135                                       unsigned Op1, bool Op1IsKill,
 136                                       uint64_t Imm);
 137     virtual unsigned FastEmitInst_i(unsigned MachineInstOpcode,
 138                                     const TargetRegisterClass *RC,
 139                                     uint64_t Imm);
 140     virtual unsigned FastEmitInst_ii(unsigned MachineInstOpcode,
 141                                      const TargetRegisterClass *RC,
 142                                      uint64_t Imm1, uint64_t Imm2);
 143
 144     virtual unsigned FastEmitInst_extractsubreg(MVT RetVT,
 145                                                 unsigned Op0, bool Op0IsKill,
 146                                                 uint32_t Idx);
 147
 148     // Backend specific FastISel code.
 149     virtual bool TargetSelectInstruction(const Instruction *I);
 150     virtual unsigned TargetMaterializeConstant(const Constant *C);
 151     virtual unsigned TargetMaterializeAlloca(const AllocaInst *AI);
 152
 153   #include "ARMGenFastISel.inc"
 154
 155     // Instruction selection routines.
 156   private:
 157     bool SelectLoad(const Instruction *I);
 158     bool SelectStore(const Instruction *I);
 159     bool SelectBranch(const Instruction *I);
 160     bool SelectCmp(const Instruction *I);
 161     bool SelectFPExt(const Instruction *I);
 162     bool SelectFPTrunc(const Instruction *I);
 163     bool SelectBinaryOp(const Instruction *I, unsigned ISDOpcode);
 164     bool SelectSIToFP(const Instruction *I);
 165     bool SelectFPToSI(const Instruction *I);
 166     bool SelectSDiv(const Instruction *I);
 167     bool SelectSRem(const Instruction *I);
 168     bool SelectCall(const Instruction *I);
 169     bool SelectSelect(const Instruction *I);
 170     bool SelectRet(const Instruction *I);
 171
 172     // Utility routines.
 173   private:
 174     bool isTypeLegal(const Type *Ty, MVT &VT);
 175     bool isLoadTypeLegal(const Type *Ty, MVT &VT);
 176     bool ARMEmitLoad(EVT VT, unsigned &ResultReg, Address &Addr);
 177     bool ARMEmitStore(EVT VT, unsigned SrcReg, Address &Addr);
 178     bool ARMComputeAddress(const Value *Obj, Address &Addr);
 179     void ARMSimplifyAddress(Address &Addr, EVT VT);
 180     unsigned ARMMaterializeFP(const ConstantFP *CFP, EVT VT);
 181     unsigned ARMMaterializeInt(const Constant *C, EVT VT);
 182     unsigned ARMMaterializeGV(const GlobalValue *GV, EVT VT);
 183     unsigned ARMMoveToFPReg(EVT VT, unsigned SrcReg);
 184     unsigned ARMMoveToIntReg(EVT VT, unsigned SrcReg);
 185     unsigned ARMSelectCallOp(const GlobalValue *GV);
 186
 187     // Call handling routines.
 188   private:
 189     bool FastEmitExtend(ISD::NodeType Opc, EVT DstVT, unsigned Src, EVT SrcVT,
 190                         unsigned &ResultReg);
 191     CCAssignFn *CCAssignFnForCall(CallingConv::ID CC, bool Return);
 192     bool ProcessCallArgs(SmallVectorImpl<Value*> &Args,
 193                          SmallVectorImpl<unsigned> &ArgRegs,
 194                          SmallVectorImpl<MVT> &ArgVTs,
 195                          SmallVectorImpl<ISD::ArgFlagsTy> &ArgFlags,
 196                          SmallVectorImpl<unsigned> &RegArgs,
 197                          CallingConv::ID CC,
 198                          unsigned &NumBytes);
 199     bool FinishCall(MVT RetVT, SmallVectorImpl<unsigned> &UsedRegs,
 200                     const Instruction *I, CallingConv::ID CC,
 201                     unsigned &NumBytes);
 202     bool ARMEmitLibcall(const Instruction *I, RTLIB::Libcall Call);
 203
 204     // OptionalDef handling routines.
 205   private:
 206     bool isARMNEONPred(const MachineInstr *MI);
 207     bool DefinesOptionalPredicate(MachineInstr *MI, bool *CPSR);
 208     const MachineInstrBuilder &AddOptionalDefs(const MachineInstrBuilder &MIB);
 209     void AddLoadStoreOperands(EVT VT, Address &Addr,
 210                               const MachineInstrBuilder &MIB);
 211 };
 212
 213 } // end anonymous namespace
 214
 215 #include "ARMGenCallingConv.inc"
 216
 217 // DefinesOptionalPredicate - This is different from DefinesPredicate in that
 218 // we don't care about implicit defs here, just places we'll need to add a
 219 // default CCReg argument. Sets CPSR if we're setting CPSR instead of CCR.
 220 bool ARMFastISel::DefinesOptionalPredicate(MachineInstr *MI, bool *CPSR) {
 221   const TargetInstrDesc &TID = MI->getDesc();
 222   if (!TID.hasOptionalDef())
 223     return false;
 224
 225   // Look to see if our OptionalDef is defining CPSR or CCR.
 226   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 227     const MachineOperand &MO = MI->getOperand(i);
 228     if (!MO.isReg() || !MO.isDef()) continue;
 229     if (MO.getReg() == ARM::CPSR)
 230       *CPSR = true;
 231   }
 232   return true;
 233 }
 234
 235 bool ARMFastISel::isARMNEONPred(const MachineInstr *MI) {
 236   const TargetInstrDesc &TID = MI->getDesc();
 237
 238   // If we're a thumb2 or not NEON function we were handled via isPredicable.
 239   if ((TID.TSFlags & ARMII::DomainMask) != ARMII::DomainNEON ||
 240        AFI->isThumb2Function())
 241     return false;
 242
 243   for (unsigned i = 0, e = TID.getNumOperands(); i != e; ++i)
 244     if (TID.OpInfo[i].isPredicate())
 245       return true;
 246
 247   return false;
 248 }
 249
 250 // If the machine is predicable go ahead and add the predicate operands, if
 251 // it needs default CC operands add those.
 252 // TODO: If we want to support thumb1 then we'll need to deal with optional
 253 // CPSR defs that need to be added before the remaining operands. See s_cc_out
 254 // for descriptions why.
 255 const MachineInstrBuilder &
 256 ARMFastISel::AddOptionalDefs(const MachineInstrBuilder &MIB) {
 257   MachineInstr *MI = &*MIB;
 258
 259   // Do we use a predicate? or...
 260   // Are we NEON in ARM mode and have a predicate operand? If so, I know
 261   // we're not predicable but add it anyways.
 262   if (TII.isPredicable(MI) || isARMNEONPred(MI))
 263     AddDefaultPred(MIB);
 264
 265   // Do we optionally set a predicate?  Preds is size > 0 iff the predicate
 266   // defines CPSR. All other OptionalDefines in ARM are the CCR register.
 267   bool CPSR = false;
 268   if (DefinesOptionalPredicate(MI, &CPSR)) {
 269     if (CPSR)
 270       AddDefaultT1CC(MIB);
 271     else
 272       AddDefaultCC(MIB);
 273   }
 274   return MIB;
 275 }
 276
 277 unsigned ARMFastISel::FastEmitInst_(unsigned MachineInstOpcode,
 278                                     const TargetRegisterClass* RC) {
 279   unsigned ResultReg = createResultReg(RC);
 280   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 281
 282   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg));
 283   return ResultReg;
 284 }
 285
 286 unsigned ARMFastISel::FastEmitInst_r(unsigned MachineInstOpcode,
 287                                      const TargetRegisterClass *RC,
 288                                      unsigned Op0, bool Op0IsKill) {
 289   unsigned ResultReg = createResultReg(RC);
 290   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 291
 292   if (II.getNumDefs() >= 1)
 293     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 294                    .addReg(Op0, Op0IsKill * RegState::Kill));
 295   else {
 296     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 297                    .addReg(Op0, Op0IsKill * RegState::Kill));
 298     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 299                    TII.get(TargetOpcode::COPY), ResultReg)
 300                    .addReg(II.ImplicitDefs[0]));
 301   }
 302   return ResultReg;
 303 }
 304
 305 unsigned ARMFastISel::FastEmitInst_rr(unsigned MachineInstOpcode,
 306                                       const TargetRegisterClass *RC,
 307                                       unsigned Op0, bool Op0IsKill,
 308                                       unsigned Op1, bool Op1IsKill) {
 309   unsigned ResultReg = createResultReg(RC);
 310   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 311
 312   if (II.getNumDefs() >= 1)
 313     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 314                    .addReg(Op0, Op0IsKill * RegState::Kill)
 315                    .addReg(Op1, Op1IsKill * RegState::Kill));
 316   else {
 317     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 318                    .addReg(Op0, Op0IsKill * RegState::Kill)
 319                    .addReg(Op1, Op1IsKill * RegState::Kill));
 320     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 321                            TII.get(TargetOpcode::COPY), ResultReg)
 322                    .addReg(II.ImplicitDefs[0]));
 323   }
 324   return ResultReg;
 325 }
 326
 327 unsigned ARMFastISel::FastEmitInst_rrr(unsigned MachineInstOpcode,
 328                                        const TargetRegisterClass *RC,
 329                                        unsigned Op0, bool Op0IsKill,
 330                                        unsigned Op1, bool Op1IsKill,
 331                                        unsigned Op2, bool Op2IsKill) {
 332   unsigned ResultReg = createResultReg(RC);
 333   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 334
 335   if (II.getNumDefs() >= 1)
 336     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 337                    .addReg(Op0, Op0IsKill * RegState::Kill)
 338                    .addReg(Op1, Op1IsKill * RegState::Kill)
 339                    .addReg(Op2, Op2IsKill * RegState::Kill));
 340   else {
 341     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 342                    .addReg(Op0, Op0IsKill * RegState::Kill)
 343                    .addReg(Op1, Op1IsKill * RegState::Kill)
 344                    .addReg(Op2, Op2IsKill * RegState::Kill));
 345     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 346                            TII.get(TargetOpcode::COPY), ResultReg)
 347                    .addReg(II.ImplicitDefs[0]));
 348   }
 349   return ResultReg;
 350 }
 351
 352 unsigned ARMFastISel::FastEmitInst_ri(unsigned MachineInstOpcode,
 353                                       const TargetRegisterClass *RC,
 354                                       unsigned Op0, bool Op0IsKill,
 355                                       uint64_t Imm) {
 356   unsigned ResultReg = createResultReg(RC);
 357   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 358
 359   if (II.getNumDefs() >= 1)
 360     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 361                    .addReg(Op0, Op0IsKill * RegState::Kill)
 362                    .addImm(Imm));
 363   else {
 364     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 365                    .addReg(Op0, Op0IsKill * RegState::Kill)
 366                    .addImm(Imm));
 367     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 368                            TII.get(TargetOpcode::COPY), ResultReg)
 369                    .addReg(II.ImplicitDefs[0]));
 370   }
 371   return ResultReg;
 372 }
 373
 374 unsigned ARMFastISel::FastEmitInst_rf(unsigned MachineInstOpcode,
 375                                       const TargetRegisterClass *RC,
 376                                       unsigned Op0, bool Op0IsKill,
 377                                       const ConstantFP *FPImm) {
 378   unsigned ResultReg = createResultReg(RC);
 379   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 380
 381   if (II.getNumDefs() >= 1)
 382     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 383                    .addReg(Op0, Op0IsKill * RegState::Kill)
 384                    .addFPImm(FPImm));
 385   else {
 386     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 387                    .addReg(Op0, Op0IsKill * RegState::Kill)
 388                    .addFPImm(FPImm));
 389     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 390                            TII.get(TargetOpcode::COPY), ResultReg)
 391                    .addReg(II.ImplicitDefs[0]));
 392   }
 393   return ResultReg;
 394 }
 395
 396 unsigned ARMFastISel::FastEmitInst_rri(unsigned MachineInstOpcode,
 397                                        const TargetRegisterClass *RC,
 398                                        unsigned Op0, bool Op0IsKill,
 399                                        unsigned Op1, bool Op1IsKill,
 400                                        uint64_t Imm) {
 401   unsigned ResultReg = createResultReg(RC);
 402   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 403
 404   if (II.getNumDefs() >= 1)
 405     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 406                    .addReg(Op0, Op0IsKill * RegState::Kill)
 407                    .addReg(Op1, Op1IsKill * RegState::Kill)
 408                    .addImm(Imm));
 409   else {
 410     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 411                    .addReg(Op0, Op0IsKill * RegState::Kill)
 412                    .addReg(Op1, Op1IsKill * RegState::Kill)
 413                    .addImm(Imm));
 414     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 415                            TII.get(TargetOpcode::COPY), ResultReg)
 416                    .addReg(II.ImplicitDefs[0]));
 417   }
 418   return ResultReg;
 419 }
 420
 421 unsigned ARMFastISel::FastEmitInst_i(unsigned MachineInstOpcode,
 422                                      const TargetRegisterClass *RC,
 423                                      uint64_t Imm) {
 424   unsigned ResultReg = createResultReg(RC);
 425   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 426
 427   if (II.getNumDefs() >= 1)
 428     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 429                    .addImm(Imm));
 430   else {
 431     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 432                    .addImm(Imm));
 433     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 434                            TII.get(TargetOpcode::COPY), ResultReg)
 435                    .addReg(II.ImplicitDefs[0]));
 436   }
 437   return ResultReg;
 438 }
 439
 440 unsigned ARMFastISel::FastEmitInst_ii(unsigned MachineInstOpcode,
 441                                       const TargetRegisterClass *RC,
 442                                       uint64_t Imm1, uint64_t Imm2) {
 443   unsigned ResultReg = createResultReg(RC);
 444   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 445
 446   if (II.getNumDefs() >= 1)
 447     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 448                     .addImm(Imm1).addImm(Imm2));
 449   else {
 450     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 451                     .addImm(Imm1).addImm(Imm2));
 452     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 453                             TII.get(TargetOpcode::COPY),
 454                             ResultReg)
 455                     .addReg(II.ImplicitDefs[0]));
 456   }
 457   return ResultReg;
 458 }
 459
 460 unsigned ARMFastISel::FastEmitInst_extractsubreg(MVT RetVT,
 461                                                  unsigned Op0, bool Op0IsKill,
 462                                                  uint32_t Idx) {
 463   unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT));
 464   assert(TargetRegisterInfo::isVirtualRegister(Op0) &&
 465          "Cannot yet extract from physregs");
 466   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt,
 467                          DL, TII.get(TargetOpcode::COPY), ResultReg)
 468                  .addReg(Op0, getKillRegState(Op0IsKill), Idx));
 469   return ResultReg;
 470 }
 471
 472 // TODO: Don't worry about 64-bit now, but when this is fixed remove the
 473 // checks from the various callers.
 474 unsigned ARMFastISel::ARMMoveToFPReg(EVT VT, unsigned SrcReg) {
 475   if (VT == MVT::f64) return 0;
 476
 477   unsigned MoveReg = createResultReg(TLI.getRegClassFor(VT));
 478   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 479                           TII.get(ARM::VMOVRS), MoveReg)
 480                   .addReg(SrcReg));
 481   return MoveReg;
 482 }
 483
 484 unsigned ARMFastISel::ARMMoveToIntReg(EVT VT, unsigned SrcReg) {
 485   if (VT == MVT::i64) return 0;
 486
 487   unsigned MoveReg = createResultReg(TLI.getRegClassFor(VT));
 488   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 489                           TII.get(ARM::VMOVSR), MoveReg)
 490                   .addReg(SrcReg));
 491   return MoveReg;
 492 }
 493
 494 // For double width floating point we need to materialize two constants
 495 // (the high and the low) into integer registers then use a move to get
 496 // the combined constant into an FP reg.
 497 unsigned ARMFastISel::ARMMaterializeFP(const ConstantFP *CFP, EVT VT) {
 498   const APFloat Val = CFP->getValueAPF();
 499   bool is64bit = VT == MVT::f64;
 500
 501   // This checks to see if we can use VFP3 instructions to materialize
 502   // a constant, otherwise we have to go through the constant pool.
 503   if (TLI.isFPImmLegal(Val, VT)) {
 504     unsigned Opc = is64bit ? ARM::FCONSTD : ARM::FCONSTS;
 505     unsigned DestReg = createResultReg(TLI.getRegClassFor(VT));
 506     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc),
 507                             DestReg)
 508                     .addFPImm(CFP));
 509     return DestReg;
 510   }
 511
 512   // Require VFP2 for loading fp constants.
 513   if (!Subtarget->hasVFP2()) return false;
 514
 515   // MachineConstantPool wants an explicit alignment.
 516   unsigned Align = TD.getPrefTypeAlignment(CFP->getType());
 517   if (Align == 0) {
 518     // TODO: Figure out if this is correct.
 519     Align = TD.getTypeAllocSize(CFP->getType());
 520   }
 521   unsigned Idx = MCP.getConstantPoolIndex(cast<Constant>(CFP), Align);
 522   unsigned DestReg = createResultReg(TLI.getRegClassFor(VT));
 523   unsigned Opc = is64bit ? ARM::VLDRD : ARM::VLDRS;
 524
 525   // The extra reg is for addrmode5.
 526   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc),
 527                           DestReg)
 528                   .addConstantPoolIndex(Idx)
 529                   .addReg(0));
 530   return DestReg;
 531 }
 532
 533 unsigned ARMFastISel::ARMMaterializeInt(const Constant *C, EVT VT) {
 534
 535   // For now 32-bit only.
 536   if (VT != MVT::i32) return false;
 537
 538   unsigned DestReg = createResultReg(TLI.getRegClassFor(VT));
 539
 540   // If we can do this in a single instruction without a constant pool entry
 541   // do so now.
 542   const ConstantInt *CI = cast<ConstantInt>(C);
 543   if (Subtarget->hasV6T2Ops() && isUInt<16>(CI->getSExtValue())) {
 544     unsigned Opc = isThumb ? ARM::t2MOVi16 : ARM::MOVi16;
 545     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 546                             TII.get(Opc), DestReg)
 547                     .addImm(CI->getSExtValue()));
 548     return DestReg;
 549   }
 550
 551   // MachineConstantPool wants an explicit alignment.
 552   unsigned Align = TD.getPrefTypeAlignment(C->getType());
 553   if (Align == 0) {
 554     // TODO: Figure out if this is correct.
 555     Align = TD.getTypeAllocSize(C->getType());
 556   }
 557   unsigned Idx = MCP.getConstantPoolIndex(C, Align);
 558
 559   if (isThumb)
 560     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 561                             TII.get(ARM::t2LDRpci), DestReg)
 562                     .addConstantPoolIndex(Idx));
 563   else
 564     // The extra immediate is for addrmode2.
 565     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 566                             TII.get(ARM::LDRcp), DestReg)
 567                     .addConstantPoolIndex(Idx)
 568                     .addImm(0));
 569
 570   return DestReg;
 571 }
 572
 573 unsigned ARMFastISel::ARMMaterializeGV(const GlobalValue *GV, EVT VT) {
 574   // For now 32-bit only.
 575   if (VT != MVT::i32) return 0;
 576
 577   Reloc::Model RelocM = TM.getRelocationModel();
 578
 579   // TODO: No external globals for now.
 580   if (Subtarget->GVIsIndirectSymbol(GV, RelocM)) return 0;
 581
 582   // TODO: Need more magic for ARM PIC.
 583   if (!isThumb && (RelocM == Reloc::PIC_)) return 0;
 584
 585   // MachineConstantPool wants an explicit alignment.
 586   unsigned Align = TD.getPrefTypeAlignment(GV->getType());
 587   if (Align == 0) {
 588     // TODO: Figure out if this is correct.
 589     Align = TD.getTypeAllocSize(GV->getType());
 590   }
 591
 592   // Grab index.
 593   unsigned PCAdj = (RelocM != Reloc::PIC_) ? 0 : (Subtarget->isThumb() ? 4 : 8);
 594   unsigned Id = AFI->createPICLabelUId();
 595   ARMConstantPoolValue *CPV = new ARMConstantPoolValue(GV, Id,
 596                                                        ARMCP::CPValue, PCAdj);
 597   unsigned Idx = MCP.getConstantPoolIndex(CPV, Align);
 598
 599   // Load value.
 600   MachineInstrBuilder MIB;
 601   unsigned DestReg = createResultReg(TLI.getRegClassFor(VT));
 602   if (isThumb) {
 603     unsigned Opc = (RelocM != Reloc::PIC_) ? ARM::t2LDRpci : ARM::t2LDRpci_pic;
 604     MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc), DestReg)
 605           .addConstantPoolIndex(Idx);
 606     if (RelocM == Reloc::PIC_)
 607       MIB.addImm(Id);
 608   } else {
 609     // The extra immediate is for addrmode2.
 610     MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(ARM::LDRcp),
 611                   DestReg)
 612           .addConstantPoolIndex(Idx)
 613           .addImm(0);
 614   }
 615   AddOptionalDefs(MIB);
 616   return DestReg;
 617 }
 618
 619 unsigned ARMFastISel::TargetMaterializeConstant(const Constant *C) {
 620   EVT VT = TLI.getValueType(C->getType(), true);
 621
 622   // Only handle simple types.
 623   if (!VT.isSimple()) return 0;
 624
 625   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C))
 626     return ARMMaterializeFP(CFP, VT);
 627   else if (const GlobalValue *GV = dyn_cast<GlobalValue>(C))
 628     return ARMMaterializeGV(GV, VT);
 629   else if (isa<ConstantInt>(C))
 630     return ARMMaterializeInt(C, VT);
 631
 632   return 0;
 633 }
 634
 635 unsigned ARMFastISel::TargetMaterializeAlloca(const AllocaInst *AI) {
 636   // Don't handle dynamic allocas.
 637   if (!FuncInfo.StaticAllocaMap.count(AI)) return 0;
 638
 639   MVT VT;
 640   if (!isLoadTypeLegal(AI->getType(), VT)) return false;
 641
 642   DenseMap<const AllocaInst*, int>::iterator SI =
 643     FuncInfo.StaticAllocaMap.find(AI);
 644
 645   // This will get lowered later into the correct offsets and registers
 646   // via rewriteXFrameIndex.
 647   if (SI != FuncInfo.StaticAllocaMap.end()) {
 648     TargetRegisterClass* RC = TLI.getRegClassFor(VT);
 649     unsigned ResultReg = createResultReg(RC);
 650     unsigned Opc = isThumb ? ARM::t2ADDri : ARM::ADDri;
 651     AddOptionalDefs(BuildMI(*FuncInfo.MBB, *FuncInfo.InsertPt, DL,
 652                             TII.get(Opc), ResultReg)
 653                             .addFrameIndex(SI->second)
 654                             .addImm(0));
 655     return ResultReg;
 656   }
 657
 658   return 0;
 659 }
 660
 661 bool ARMFastISel::isTypeLegal(const Type *Ty, MVT &VT) {
 662   EVT evt = TLI.getValueType(Ty, true);
 663
 664   // Only handle simple types.
 665   if (evt == MVT::Other || !evt.isSimple()) return false;
 666   VT = evt.getSimpleVT();
 667
 668   // Handle all legal types, i.e. a register that will directly hold this
 669   // value.
 670   return TLI.isTypeLegal(VT);
 671 }
 672
 673 bool ARMFastISel::isLoadTypeLegal(const Type *Ty, MVT &VT) {
 674   if (isTypeLegal(Ty, VT)) return true;
 675
 676   // If this is a type than can be sign or zero-extended to a basic operation
 677   // go ahead and accept it now.
 678   if (VT == MVT::i8 || VT == MVT::i16)
 679     return true;
 680
 681   return false;
 682 }
 683
 684 // Computes the address to get to an object.
 685 bool ARMFastISel::ARMComputeAddress(const Value *Obj, Address &Addr) {
 686   // Some boilerplate from the X86 FastISel.
 687   const User *U = NULL;
 688   unsigned Opcode = Instruction::UserOp1;
 689   if (const Instruction *I = dyn_cast<Instruction>(Obj)) {
 690     // Don't walk into other basic blocks unless the object is an alloca from
 691     // another block, otherwise it may not have a virtual register assigned.
 692     if (FuncInfo.StaticAllocaMap.count(static_cast<const AllocaInst *>(Obj)) ||
 693         FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB) {
 694       Opcode = I->getOpcode();
 695       U = I;
 696     }
 697   } else if (const ConstantExpr *C = dyn_cast<ConstantExpr>(Obj)) {
 698     Opcode = C->getOpcode();
 699     U = C;
 700   }
 701
 702   if (const PointerType *Ty = dyn_cast<PointerType>(Obj->getType()))
 703     if (Ty->getAddressSpace() > 255)
 704       // Fast instruction selection doesn't support the special
 705       // address spaces.
 706       return false;
 707
 708   switch (Opcode) {
 709     default:
 710     break;
 711     case Instruction::BitCast: {
 712       // Look through bitcasts.
 713       return ARMComputeAddress(U->getOperand(0), Addr);
 714     }
 715     case Instruction::IntToPtr: {
 716       // Look past no-op inttoptrs.
 717       if (TLI.getValueType(U->getOperand(0)->getType()) == TLI.getPointerTy())
 718         return ARMComputeAddress(U->getOperand(0), Addr);
 719       break;
 720     }
 721     case Instruction::PtrToInt: {
 722       // Look past no-op ptrtoints.
 723       if (TLI.getValueType(U->getType()) == TLI.getPointerTy())
 724         return ARMComputeAddress(U->getOperand(0), Addr);
 725       break;
 726     }
 727     case Instruction::GetElementPtr: {
 728       Address SavedAddr = Addr;
 729       int TmpOffset = Addr.Offset;
 730
 731       // Iterate through the GEP folding the constants into offsets where
 732       // we can.
 733       gep_type_iterator GTI = gep_type_begin(U);
 734       for (User::const_op_iterator i = U->op_begin() + 1, e = U->op_end();
 735            i != e; ++i, ++GTI) {
 736         const Value *Op = *i;
 737         if (const StructType *STy = dyn_cast<StructType>(*GTI)) {
 738           const StructLayout *SL = TD.getStructLayout(STy);
 739           unsigned Idx = cast<ConstantInt>(Op)->getZExtValue();
 740           TmpOffset += SL->getElementOffset(Idx);
 741         } else {
 742           uint64_t S = TD.getTypeAllocSize(GTI.getIndexedType());
 743           for (;;) {
 744             if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
 745               // Constant-offset addressing.
 746               TmpOffset += CI->getSExtValue() * S;
 747               break;
 748             }
 749             if (isa<AddOperator>(Op) &&
 750                 (!isa<Instruction>(Op) ||
 751                  FuncInfo.MBBMap[cast<Instruction>(Op)->getParent()]
 752                  == FuncInfo.MBB) &&
 753                 isa<ConstantInt>(cast<AddOperator>(Op)->getOperand(1))) {
 754               // An add (in the same block) with a constant operand. Fold the
 755               // constant.
 756               ConstantInt *CI =
 757               cast<ConstantInt>(cast<AddOperator>(Op)->getOperand(1));
 758               TmpOffset += CI->getSExtValue() * S;
 759               // Iterate on the other operand.
 760               Op = cast<AddOperator>(Op)->getOperand(0);
 761               continue;
 762             }
 763             // Unsupported
 764             goto unsupported_gep;
 765           }
 766         }
 767       }
 768
 769       // Try to grab the base operand now.
 770       Addr.Offset = TmpOffset;
 771       if (ARMComputeAddress(U->getOperand(0), Addr)) return true;
 772
 773       // We failed, restore everything and try the other options.
 774       Addr = SavedAddr;
 775
 776       unsupported_gep:
 777       break;
 778     }
 779     case Instruction::Alloca: {
 780       const AllocaInst *AI = cast<AllocaInst>(Obj);
 781       DenseMap<const AllocaInst*, int>::iterator SI =
 782         FuncInfo.StaticAllocaMap.find(AI);
 783       if (SI != FuncInfo.StaticAllocaMap.end()) {
 784         Addr.BaseType = Address::FrameIndexBase;
 785         Addr.Base.FI = SI->second;
 786         return true;
 787       }
 788       break;
 789     }
 790   }
 791
 792   // Materialize the global variable's address into a reg which can
 793   // then be used later to load the variable.
 794   if (const GlobalValue *GV = dyn_cast<GlobalValue>(Obj)) {
 795     unsigned Tmp = ARMMaterializeGV(GV, TLI.getValueType(Obj->getType()));
 796     if (Tmp == 0) return false;
 797
 798     Addr.Base.Reg = Tmp;
 799     return true;
 800   }
 801
 802   // Try to get this in a register if nothing else has worked.
 803   if (Addr.Base.Reg == 0) Addr.Base.Reg = getRegForValue(Obj);
 804   return Addr.Base.Reg != 0;
 805 }
 806
 807 void ARMFastISel::ARMSimplifyAddress(Address &Addr, EVT VT) {
 808
 809   assert(VT.isSimple() && "Non-simple types are invalid here!");
 810
 811   bool needsLowering = false;
 812   switch (VT.getSimpleVT().SimpleTy) {
 813     default:
 814       assert(false && "Unhandled load/store type!");
 815     case MVT::i1:
 816     case MVT::i8:
 817     case MVT::i16:
 818     case MVT::i32:
 819       // Integer loads/stores handle 12-bit offsets.
 820       needsLowering = ((Addr.Offset & 0xfff) != Addr.Offset);
 821       break;
 822     case MVT::f32:
 823     case MVT::f64:
 824       // Floating point operands handle 8-bit offsets.
 825       needsLowering = ((Addr.Offset & 0xff) != Addr.Offset);
 826       break;
 827   }
 828
 829   // If this is a stack pointer and the offset needs to be simplified then
 830   // put the alloca address into a register, set the base type back to
 831   // register and continue. This should almost never happen.
 832   if (needsLowering && Addr.BaseType == Address::FrameIndexBase) {
 833     TargetRegisterClass *RC = isThumb ? ARM::tGPRRegisterClass :
 834                               ARM::GPRRegisterClass;
 835     unsigned ResultReg = createResultReg(RC);
 836     unsigned Opc = isThumb ? ARM::t2ADDri : ARM::ADDri;
 837     AddOptionalDefs(BuildMI(*FuncInfo.MBB, *FuncInfo.InsertPt, DL,
 838                             TII.get(Opc), ResultReg)
 839                             .addFrameIndex(Addr.Base.FI)
 840                             .addImm(0));
 841     Addr.Base.Reg = ResultReg;
 842     Addr.BaseType = Address::RegBase;
 843   }
 844
 845   // Since the offset is too large for the load/store instruction
 846   // get the reg+offset into a register.
 847   if (needsLowering) {
 848     Addr.Base.Reg = FastEmit_ri_(MVT::i32, ISD::ADD, Addr.Base.Reg,
 849                                  /*Op0IsKill*/false, Addr.Offset, MVT::i32);
 850     Addr.Offset = 0;
 851   }
 852 }
 853
 854 void ARMFastISel::AddLoadStoreOperands(EVT VT, Address &Addr,
 855                                        const MachineInstrBuilder &MIB) {
 856   // addrmode5 output depends on the selection dag addressing dividing the
 857   // offset by 4 that it then later multiplies. Do this here as well.
 858   if (VT.getSimpleVT().SimpleTy == MVT::f32 ||
 859       VT.getSimpleVT().SimpleTy == MVT::f64)
 860     Addr.Offset /= 4;
 861
 862   // Frame base works a bit differently. Handle it separately.
 863   if (Addr.BaseType == Address::FrameIndexBase) {
 864     int FI = Addr.Base.FI;
 865     int Offset = Addr.Offset;
 866     MachineMemOperand *MMO =
 867           FuncInfo.MF->getMachineMemOperand(
 868                                   MachinePointerInfo::getFixedStack(FI, Offset),
 869                                   MachineMemOperand::MOLoad,
 870                                   MFI.getObjectSize(FI),
 871                                   MFI.getObjectAlignment(FI));
 872     // Now add the rest of the operands.
 873     MIB.addFrameIndex(FI);
 874
 875     // ARM halfword load/stores need an additional operand.
 876     if (!isThumb && VT.getSimpleVT().SimpleTy == MVT::i16) MIB.addReg(0);
 877
 878     MIB.addImm(Addr.Offset);
 879     MIB.addMemOperand(MMO);
 880   } else {
 881     // Now add the rest of the operands.
 882     MIB.addReg(Addr.Base.Reg);
 883
 884     // ARM halfword load/stores need an additional operand.
 885     if (!isThumb && VT.getSimpleVT().SimpleTy == MVT::i16) MIB.addReg(0);
 886
 887     MIB.addImm(Addr.Offset);
 888   }
 889   AddOptionalDefs(MIB);
 890 }
 891
 892 bool ARMFastISel::ARMEmitLoad(EVT VT, unsigned &ResultReg, Address &Addr) {
 893
 894   assert(VT.isSimple() && "Non-simple types are invalid here!");
 895   unsigned Opc;
 896   TargetRegisterClass *RC;
 897   switch (VT.getSimpleVT().SimpleTy) {
 898     // This is mostly going to be Neon/vector support.
 899     default: return false;
 900     case MVT::i16:
 901       Opc = isThumb ? ARM::t2LDRHi12 : ARM::LDRH;
 902       RC = ARM::GPRRegisterClass;
 903       break;
 904     case MVT::i8:
 905       Opc = isThumb ? ARM::t2LDRBi12 : ARM::LDRBi12;
 906       RC = ARM::GPRRegisterClass;
 907       break;
 908     case MVT::i32:
 909       Opc = isThumb ? ARM::t2LDRi12 : ARM::LDRi12;
 910       RC = ARM::GPRRegisterClass;
 911       break;
 912     case MVT::f32:
 913       Opc = ARM::VLDRS;
 914       RC = TLI.getRegClassFor(VT);
 915       break;
 916     case MVT::f64:
 917       Opc = ARM::VLDRD;
 918       RC = TLI.getRegClassFor(VT);
 919       break;
 920   }
 921   // Simplify this down to something we can handle.
 922   ARMSimplifyAddress(Addr, VT);
 923
 924   // Create the base instruction, then add the operands.
 925   ResultReg = createResultReg(RC);
 926   MachineInstrBuilder MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 927                                     TII.get(Opc), ResultReg);
 928   AddLoadStoreOperands(VT, Addr, MIB);
 929   return true;
 930 }
 931
 932 bool ARMFastISel::SelectLoad(const Instruction *I) {
 933   // Verify we have a legal type before going any further.
 934   MVT VT;
 935   if (!isLoadTypeLegal(I->getType(), VT))
 936     return false;
 937
 938   // See if we can handle this address.
 939   Address Addr;
 940   if (!ARMComputeAddress(I->getOperand(0), Addr)) return false;
 941
 942   unsigned ResultReg;
 943   if (!ARMEmitLoad(VT, ResultReg, Addr)) return false;
 944   UpdateValueMap(I, ResultReg);
 945   return true;
 946 }
 947
 948 bool ARMFastISel::ARMEmitStore(EVT VT, unsigned SrcReg, Address &Addr) {
 949   unsigned StrOpc;
 950   switch (VT.getSimpleVT().SimpleTy) {
 951     // This is mostly going to be Neon/vector support.
 952     default: return false;
 953     case MVT::i1: {
 954       unsigned Res = createResultReg(isThumb ? ARM::tGPRRegisterClass :
 955                                                ARM::GPRRegisterClass);
 956       unsigned Opc = isThumb ? ARM::t2ANDri : ARM::ANDri;
 957       AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 958                               TII.get(Opc), Res)
 959                       .addReg(SrcReg).addImm(1));
 960       SrcReg = Res;
 961     } // Fallthrough here.
 962     case MVT::i8:
 963       StrOpc = isThumb ? ARM::t2STRBi12 : ARM::STRBi12;
 964       break;
 965     case MVT::i16:
 966       StrOpc = isThumb ? ARM::t2STRHi12 : ARM::STRH;
 967       break;
 968     case MVT::i32:
 969       StrOpc = isThumb ? ARM::t2STRi12 : ARM::STRi12;
 970       break;
 971     case MVT::f32:
 972       if (!Subtarget->hasVFP2()) return false;
 973       StrOpc = ARM::VSTRS;
 974       break;
 975     case MVT::f64:
 976       if (!Subtarget->hasVFP2()) return false;
 977       StrOpc = ARM::VSTRD;
 978       break;
 979   }
 980   // Simplify this down to something we can handle.
 981   ARMSimplifyAddress(Addr, VT);
 982
 983   // Create the base instruction, then add the operands.
 984   MachineInstrBuilder MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 985                                     TII.get(StrOpc))
 986                             .addReg(SrcReg, getKillRegState(true));
 987   AddLoadStoreOperands(VT, Addr, MIB);
 988   return true;
 989 }
 990
 991 bool ARMFastISel::SelectStore(const Instruction *I) {
 992   Value *Op0 = I->getOperand(0);
 993   unsigned SrcReg = 0;
 994
 995   // Verify we have a legal type before going any further.
 996   MVT VT;
 997   if (!isLoadTypeLegal(I->getOperand(0)->getType(), VT))
 998     return false;
 999
1000   // Get the value to be stored into a register.
1001   SrcReg = getRegForValue(Op0);
1002   if (SrcReg == 0) return false;
1003
1004   // See if we can handle this address.
1005   Address Addr;
1006   if (!ARMComputeAddress(I->getOperand(1), Addr))
1007     return false;
1008
1009   if (!ARMEmitStore(VT, SrcReg, Addr)) return false;
1010   return true;
1011 }
1012
1013 static ARMCC::CondCodes getComparePred(CmpInst::Predicate Pred) {
1014   switch (Pred) {
1015     // Needs two compares...
1016     case CmpInst::FCMP_ONE:
1017     case CmpInst::FCMP_UEQ:
1018     default:
1019       // AL is our "false" for now. The other two need more compares.
1020       return ARMCC::AL;
1021     case CmpInst::ICMP_EQ:
1022     case CmpInst::FCMP_OEQ:
1023       return ARMCC::EQ;
1024     case CmpInst::ICMP_SGT:
1025     case CmpInst::FCMP_OGT:
1026       return ARMCC::GT;
1027     case CmpInst::ICMP_SGE:
1028     case CmpInst::FCMP_OGE:
1029       return ARMCC::GE;
1030     case CmpInst::ICMP_UGT:
1031     case CmpInst::FCMP_UGT:
1032       return ARMCC::HI;
1033     case CmpInst::FCMP_OLT:
1034       return ARMCC::MI;
1035     case CmpInst::ICMP_ULE:
1036     case CmpInst::FCMP_OLE:
1037       return ARMCC::LS;
1038     case CmpInst::FCMP_ORD:
1039       return ARMCC::VC;
1040     case CmpInst::FCMP_UNO:
1041       return ARMCC::VS;
1042     case CmpInst::FCMP_UGE:
1043       return ARMCC::PL;
1044     case CmpInst::ICMP_SLT:
1045     case CmpInst::FCMP_ULT:
1046       return ARMCC::LT;
1047     case CmpInst::ICMP_SLE:
1048     case CmpInst::FCMP_ULE:
1049       return ARMCC::LE;
1050     case CmpInst::FCMP_UNE:
1051     case CmpInst::ICMP_NE:
1052       return ARMCC::NE;
1053     case CmpInst::ICMP_UGE:
1054       return ARMCC::HS;
1055     case CmpInst::ICMP_ULT:
1056       return ARMCC::LO;
1057   }
1058 }
1059
1060 bool ARMFastISel::SelectBranch(const Instruction *I) {
1061   const BranchInst *BI = cast<BranchInst>(I);
1062   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
1063   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
1064
1065   // Simple branch support.
1066
1067   // If we can, avoid recomputing the compare - redoing it could lead to wonky
1068   // behavior.
1069   // TODO: Factor this out.
1070   if (const CmpInst *CI = dyn_cast<CmpInst>(BI->getCondition())) {
1071     MVT SourceVT;
1072     const Type *Ty = CI->getOperand(0)->getType();
1073     if (CI->hasOneUse() && (CI->getParent() == I->getParent())
1074         && isTypeLegal(Ty, SourceVT)) {
1075       bool isFloat = (Ty->isDoubleTy() || Ty->isFloatTy());
1076       if (isFloat && !Subtarget->hasVFP2())
1077         return false;
1078
1079       unsigned CmpOpc;
1080       switch (SourceVT.SimpleTy) {
1081         default: return false;
1082         // TODO: Verify compares.
1083         case MVT::f32:
1084           CmpOpc = ARM::VCMPES;
1085           break;
1086         case MVT::f64:
1087           CmpOpc = ARM::VCMPED;
1088           break;
1089         case MVT::i32:
1090           CmpOpc = isThumb ? ARM::t2CMPrr : ARM::CMPrr;
1091           break;
1092       }
1093
1094       // Get the compare predicate.
1095       // Try to take advantage of fallthrough opportunities.
1096       CmpInst::Predicate Predicate = CI->getPredicate();
1097       if (FuncInfo.MBB->isLayoutSuccessor(TBB)) {
1098         std::swap(TBB, FBB);
1099         Predicate = CmpInst::getInversePredicate(Predicate);
1100       }
1101
1102       ARMCC::CondCodes ARMPred = getComparePred(Predicate);
1103
1104       // We may not handle every CC for now.
1105       if (ARMPred == ARMCC::AL) return false;
1106
1107       unsigned Arg1 = getRegForValue(CI->getOperand(0));
1108       if (Arg1 == 0) return false;
1109
1110       unsigned Arg2 = getRegForValue(CI->getOperand(1));
1111       if (Arg2 == 0) return false;
1112
1113       AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1114                               TII.get(CmpOpc))
1115                       .addReg(Arg1).addReg(Arg2));
1116
1117       // For floating point we need to move the result to a comparison register
1118       // that we can then use for branches.
1119       if (isFloat)
1120         AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1121                                 TII.get(ARM::FMSTAT)));
1122
1123       unsigned BrOpc = isThumb ? ARM::t2Bcc : ARM::Bcc;
1124       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(BrOpc))
1125       .addMBB(TBB).addImm(ARMPred).addReg(ARM::CPSR);
1126       FastEmitBranch(FBB, DL);
1127       FuncInfo.MBB->addSuccessor(TBB);
1128       return true;
1129     }
1130   } else if (TruncInst *TI = dyn_cast<TruncInst>(BI->getCondition())) {
1131     MVT SourceVT;
1132     if (TI->hasOneUse() && TI->getParent() == I->getParent() &&
1133         (isTypeLegal(TI->getOperand(0)->getType(), SourceVT))) {
1134       unsigned TstOpc = isThumb ? ARM::t2TSTri : ARM::TSTri;
1135       unsigned OpReg = getRegForValue(TI->getOperand(0));
1136       AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1137                               TII.get(TstOpc))
1138                       .addReg(OpReg).addImm(1));
1139
1140       unsigned CCMode = ARMCC::NE;
1141       if (FuncInfo.MBB->isLayoutSuccessor(TBB)) {
1142         std::swap(TBB, FBB);
1143         CCMode = ARMCC::EQ;
1144       }
1145
1146       unsigned BrOpc = isThumb ? ARM::t2Bcc : ARM::Bcc;
1147       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(BrOpc))
1148       .addMBB(TBB).addImm(CCMode).addReg(ARM::CPSR);
1149
1150       FastEmitBranch(FBB, DL);
1151       FuncInfo.MBB->addSuccessor(TBB);
1152       return true;
1153     }
1154   }
1155
1156   unsigned CmpReg = getRegForValue(BI->getCondition());
1157   if (CmpReg == 0) return false;
1158
1159   // We've been divorced from our compare!  Our block was split, and
1160   // now our compare lives in a predecessor block.  We musn't
1161   // re-compare here, as the children of the compare aren't guaranteed
1162   // live across the block boundary (we *could* check for this).
1163   // Regardless, the compare has been done in the predecessor block,
1164   // and it left a value for us in a virtual register.  Ergo, we test
1165   // the one-bit value left in the virtual register.
1166   unsigned TstOpc = isThumb ? ARM::t2TSTri : ARM::TSTri;
1167   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TstOpc))
1168                   .addReg(CmpReg).addImm(1));
1169
1170   unsigned CCMode = ARMCC::NE;
1171   if (FuncInfo.MBB->isLayoutSuccessor(TBB)) {
1172     std::swap(TBB, FBB);
1173     CCMode = ARMCC::EQ;
1174   }
1175
1176   unsigned BrOpc = isThumb ? ARM::t2Bcc : ARM::Bcc;
1177   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(BrOpc))
1178                   .addMBB(TBB).addImm(CCMode).addReg(ARM::CPSR);
1179   FastEmitBranch(FBB, DL);
1180   FuncInfo.MBB->addSuccessor(TBB);
1181   return true;
1182 }
1183
1184 bool ARMFastISel::SelectCmp(const Instruction *I) {
1185   const CmpInst *CI = cast<CmpInst>(I);
1186
1187   MVT VT;
1188   const Type *Ty = CI->getOperand(0)->getType();
1189   if (!isTypeLegal(Ty, VT))
1190     return false;
1191
1192   bool isFloat = (Ty->isDoubleTy() || Ty->isFloatTy());
1193   if (isFloat && !Subtarget->hasVFP2())
1194     return false;
1195
1196   unsigned CmpOpc;
1197   unsigned CondReg;
1198   switch (VT.SimpleTy) {
1199     default: return false;
1200     // TODO: Verify compares.
1201     case MVT::f32:
1202       CmpOpc = ARM::VCMPES;
1203       CondReg = ARM::FPSCR;
1204       break;
1205     case MVT::f64:
1206       CmpOpc = ARM::VCMPED;
1207       CondReg = ARM::FPSCR;
1208       break;
1209     case MVT::i32:
1210       CmpOpc = isThumb ? ARM::t2CMPrr : ARM::CMPrr;
1211       CondReg = ARM::CPSR;
1212       break;
1213   }
1214
1215   // Get the compare predicate.
1216   ARMCC::CondCodes ARMPred = getComparePred(CI->getPredicate());
1217
1218   // We may not handle every CC for now.
1219   if (ARMPred == ARMCC::AL) return false;
1220
1221   unsigned Arg1 = getRegForValue(CI->getOperand(0));
1222   if (Arg1 == 0) return false;
1223
1224   unsigned Arg2 = getRegForValue(CI->getOperand(1));
1225   if (Arg2 == 0) return false;
1226
1227   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(CmpOpc))
1228                   .addReg(Arg1).addReg(Arg2));
1229
1230   // For floating point we need to move the result to a comparison register
1231   // that we can then use for branches.
1232   if (isFloat)
1233     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1234                             TII.get(ARM::FMSTAT)));
1235
1236   // Now set a register based on the comparison. Explicitly set the predicates
1237   // here.
1238   unsigned MovCCOpc = isThumb ? ARM::t2MOVCCi : ARM::MOVCCi;
1239   TargetRegisterClass *RC = isThumb ? ARM::rGPRRegisterClass
1240                                     : ARM::GPRRegisterClass;
1241   unsigned DestReg = createResultReg(RC);
1242   Constant *Zero
1243     = ConstantInt::get(Type::getInt32Ty(*Context), 0);
1244   unsigned ZeroReg = TargetMaterializeConstant(Zero);
1245   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(MovCCOpc), DestReg)
1246           .addReg(ZeroReg).addImm(1)
1247           .addImm(ARMPred).addReg(CondReg);
1248
1249   UpdateValueMap(I, DestReg);
1250   return true;
1251 }
1252
1253 bool ARMFastISel::SelectFPExt(const Instruction *I) {
1254   // Make sure we have VFP and that we're extending float to double.
1255   if (!Subtarget->hasVFP2()) return false;
1256
1257   Value *V = I->getOperand(0);
1258   if (!I->getType()->isDoubleTy() ||
1259       !V->getType()->isFloatTy()) return false;
1260
1261   unsigned Op = getRegForValue(V);
1262   if (Op == 0) return false;
1263
1264   unsigned Result = createResultReg(ARM::DPRRegisterClass);
1265   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1266                           TII.get(ARM::VCVTDS), Result)
1267                   .addReg(Op));
1268   UpdateValueMap(I, Result);
1269   return true;
1270 }
1271
1272 bool ARMFastISel::SelectFPTrunc(const Instruction *I) {
1273   // Make sure we have VFP and that we're truncating double to float.
1274   if (!Subtarget->hasVFP2()) return false;
1275
1276   Value *V = I->getOperand(0);
1277   if (!(I->getType()->isFloatTy() &&
1278         V->getType()->isDoubleTy())) return false;
1279
1280   unsigned Op = getRegForValue(V);
1281   if (Op == 0) return false;
1282
1283   unsigned Result = createResultReg(ARM::SPRRegisterClass);
1284   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1285                           TII.get(ARM::VCVTSD), Result)
1286                   .addReg(Op));
1287   UpdateValueMap(I, Result);
1288   return true;
1289 }
1290
1291 bool ARMFastISel::SelectSIToFP(const Instruction *I) {
1292   // Make sure we have VFP.
1293   if (!Subtarget->hasVFP2()) return false;
1294
1295   MVT DstVT;
1296   const Type *Ty = I->getType();
1297   if (!isTypeLegal(Ty, DstVT))
1298     return false;
1299
1300   unsigned Op = getRegForValue(I->getOperand(0));
1301   if (Op == 0) return false;
1302
1303   // The conversion routine works on fp-reg to fp-reg and the operand above
1304   // was an integer, move it to the fp registers if possible.
1305   unsigned FP = ARMMoveToFPReg(MVT::f32, Op);
1306   if (FP == 0) return false;
1307
1308   unsigned Opc;
1309   if (Ty->isFloatTy()) Opc = ARM::VSITOS;
1310   else if (Ty->isDoubleTy()) Opc = ARM::VSITOD;
1311   else return 0;
1312
1313   unsigned ResultReg = createResultReg(TLI.getRegClassFor(DstVT));
1314   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc),
1315                           ResultReg)
1316                   .addReg(FP));
1317   UpdateValueMap(I, ResultReg);
1318   return true;
1319 }
1320
1321 bool ARMFastISel::SelectFPToSI(const Instruction *I) {
1322   // Make sure we have VFP.
1323   if (!Subtarget->hasVFP2()) return false;
1324
1325   MVT DstVT;
1326   const Type *RetTy = I->getType();
1327   if (!isTypeLegal(RetTy, DstVT))
1328     return false;
1329
1330   unsigned Op = getRegForValue(I->getOperand(0));
1331   if (Op == 0) return false;
1332
1333   unsigned Opc;
1334   const Type *OpTy = I->getOperand(0)->getType();
1335   if (OpTy->isFloatTy()) Opc = ARM::VTOSIZS;
1336   else if (OpTy->isDoubleTy()) Opc = ARM::VTOSIZD;
1337   else return 0;
1338
1339   // f64->s32 or f32->s32 both need an intermediate f32 reg.
1340   unsigned ResultReg = createResultReg(TLI.getRegClassFor(MVT::f32));
1341   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc),
1342                           ResultReg)
1343                   .addReg(Op));
1344
1345   // This result needs to be in an integer register, but the conversion only
1346   // takes place in fp-regs.
1347   unsigned IntReg = ARMMoveToIntReg(DstVT, ResultReg);
1348   if (IntReg == 0) return false;
1349
1350   UpdateValueMap(I, IntReg);
1351   return true;
1352 }
1353
1354 bool ARMFastISel::SelectSelect(const Instruction *I) {
1355   MVT VT;
1356   if (!isTypeLegal(I->getType(), VT))
1357     return false;
1358
1359   // Things need to be register sized for register moves.
1360   if (VT != MVT::i32) return false;
1361   const TargetRegisterClass *RC = TLI.getRegClassFor(VT);
1362
1363   unsigned CondReg = getRegForValue(I->getOperand(0));
1364   if (CondReg == 0) return false;
1365   unsigned Op1Reg = getRegForValue(I->getOperand(1));
1366   if (Op1Reg == 0) return false;
1367   unsigned Op2Reg = getRegForValue(I->getOperand(2));
1368   if (Op2Reg == 0) return false;
1369
1370   unsigned CmpOpc = isThumb ? ARM::t2TSTri : ARM::TSTri;
1371   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(CmpOpc))
1372                   .addReg(CondReg).addImm(1));
1373   unsigned ResultReg = createResultReg(RC);
1374   unsigned MovCCOpc = isThumb ? ARM::t2MOVCCr : ARM::MOVCCr;
1375   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(MovCCOpc), ResultReg)
1376     .addReg(Op1Reg).addReg(Op2Reg)
1377     .addImm(ARMCC::EQ).addReg(ARM::CPSR);
1378   UpdateValueMap(I, ResultReg);
1379   return true;
1380 }
1381
1382 bool ARMFastISel::SelectSDiv(const Instruction *I) {
1383   MVT VT;
1384   const Type *Ty = I->getType();
1385   if (!isTypeLegal(Ty, VT))
1386     return false;
1387
1388   // If we have integer div support we should have selected this automagically.
1389   // In case we have a real miss go ahead and return false and we'll pick
1390   // it up later.
1391   if (Subtarget->hasDivide()) return false;
1392
1393   // Otherwise emit a libcall.
1394   RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
1395   if (VT == MVT::i8)
1396     LC = RTLIB::SDIV_I8;
1397   else if (VT == MVT::i16)
1398     LC = RTLIB::SDIV_I16;
1399   else if (VT == MVT::i32)
1400     LC = RTLIB::SDIV_I32;
1401   else if (VT == MVT::i64)
1402     LC = RTLIB::SDIV_I64;
1403   else if (VT == MVT::i128)
1404     LC = RTLIB::SDIV_I128;
1405   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported SDIV!");
1406
1407   return ARMEmitLibcall(I, LC);
1408 }
1409
1410 bool ARMFastISel::SelectSRem(const Instruction *I) {
1411   MVT VT;
1412   const Type *Ty = I->getType();
1413   if (!isTypeLegal(Ty, VT))
1414     return false;
1415
1416   RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
1417   if (VT == MVT::i8)
1418     LC = RTLIB::SREM_I8;
1419   else if (VT == MVT::i16)
1420     LC = RTLIB::SREM_I16;
1421   else if (VT == MVT::i32)
1422     LC = RTLIB::SREM_I32;
1423   else if (VT == MVT::i64)
1424     LC = RTLIB::SREM_I64;
1425   else if (VT == MVT::i128)
1426     LC = RTLIB::SREM_I128;
1427   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported SREM!");
1428
1429   return ARMEmitLibcall(I, LC);
1430 }
1431
1432 bool ARMFastISel::SelectBinaryOp(const Instruction *I, unsigned ISDOpcode) {
1433   EVT VT  = TLI.getValueType(I->getType(), true);
1434
1435   // We can get here in the case when we want to use NEON for our fp
1436   // operations, but can't figure out how to. Just use the vfp instructions
1437   // if we have them.
1438   // FIXME: It'd be nice to use NEON instructions.
1439   const Type *Ty = I->getType();
1440   bool isFloat = (Ty->isDoubleTy() || Ty->isFloatTy());
1441   if (isFloat && !Subtarget->hasVFP2())
1442     return false;
1443
1444   unsigned Op1 = getRegForValue(I->getOperand(0));
1445   if (Op1 == 0) return false;
1446
1447   unsigned Op2 = getRegForValue(I->getOperand(1));
1448   if (Op2 == 0) return false;
1449
1450   unsigned Opc;
1451   bool is64bit = VT == MVT::f64 || VT == MVT::i64;
1452   switch (ISDOpcode) {
1453     default: return false;
1454     case ISD::FADD:
1455       Opc = is64bit ? ARM::VADDD : ARM::VADDS;
1456       break;
1457     case ISD::FSUB:
1458       Opc = is64bit ? ARM::VSUBD : ARM::VSUBS;
1459       break;
1460     case ISD::FMUL:
1461       Opc = is64bit ? ARM::VMULD : ARM::VMULS;
1462       break;
1463   }
1464   unsigned ResultReg = createResultReg(TLI.getRegClassFor(VT));
1465   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1466                           TII.get(Opc), ResultReg)
1467                   .addReg(Op1).addReg(Op2));
1468   UpdateValueMap(I, ResultReg);
1469   return true;
1470 }
1471
1472 // Call Handling Code
1473
1474 bool ARMFastISel::FastEmitExtend(ISD::NodeType Opc, EVT DstVT, unsigned Src,
1475                                  EVT SrcVT, unsigned &ResultReg) {
1476   unsigned RR = FastEmit_r(SrcVT.getSimpleVT(), DstVT.getSimpleVT(), Opc,
1477                            Src, /*TODO: Kill=*/false);
1478
1479   if (RR != 0) {
1480     ResultReg = RR;
1481     return true;
1482   } else
1483     return false;
1484 }
1485
1486 // This is largely taken directly from CCAssignFnForNode - we don't support
1487 // varargs in FastISel so that part has been removed.
1488 // TODO: We may not support all of this.
1489 CCAssignFn *ARMFastISel::CCAssignFnForCall(CallingConv::ID CC, bool Return) {
1490   switch (CC) {
1491   default:
1492     llvm_unreachable("Unsupported calling convention");
1493   case CallingConv::Fast:
1494     // Ignore fastcc. Silence compiler warnings.
1495     (void)RetFastCC_ARM_APCS;
1496     (void)FastCC_ARM_APCS;
1497     // Fallthrough
1498   case CallingConv::C:
1499     // Use target triple & subtarget features to do actual dispatch.
1500     if (Subtarget->isAAPCS_ABI()) {
1501       if (Subtarget->hasVFP2() &&
1502           FloatABIType == FloatABI::Hard)
1503         return (Return ? RetCC_ARM_AAPCS_VFP: CC_ARM_AAPCS_VFP);
1504       else
1505         return (Return ? RetCC_ARM_AAPCS: CC_ARM_AAPCS);
1506     } else
1507         return (Return ? RetCC_ARM_APCS: CC_ARM_APCS);
1508   case CallingConv::ARM_AAPCS_VFP:
1509     return (Return ? RetCC_ARM_AAPCS_VFP: CC_ARM_AAPCS_VFP);
1510   case CallingConv::ARM_AAPCS:
1511     return (Return ? RetCC_ARM_AAPCS: CC_ARM_AAPCS);
1512   case CallingConv::ARM_APCS:
1513     return (Return ? RetCC_ARM_APCS: CC_ARM_APCS);
1514   }
1515 }
1516
1517 bool ARMFastISel::ProcessCallArgs(SmallVectorImpl<Value*> &Args,
1518                                   SmallVectorImpl<unsigned> &ArgRegs,
1519                                   SmallVectorImpl<MVT> &ArgVTs,
1520                                   SmallVectorImpl<ISD::ArgFlagsTy> &ArgFlags,
1521                                   SmallVectorImpl<unsigned> &RegArgs,
1522                                   CallingConv::ID CC,
1523                                   unsigned &NumBytes) {
1524   SmallVector<CCValAssign, 16> ArgLocs;
1525   CCState CCInfo(CC, false, TM, ArgLocs, *Context);
1526   CCInfo.AnalyzeCallOperands(ArgVTs, ArgFlags, CCAssignFnForCall(CC, false));
1527
1528   // Get a count of how many bytes are to be pushed on the stack.
1529   NumBytes = CCInfo.getNextStackOffset();
1530
1531   // Issue CALLSEQ_START
1532   unsigned AdjStackDown = TM.getRegisterInfo()->getCallFrameSetupOpcode();
1533   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1534                           TII.get(AdjStackDown))
1535                   .addImm(NumBytes));
1536
1537   // Process the args.
1538   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1539     CCValAssign &VA = ArgLocs[i];
1540     unsigned Arg = ArgRegs[VA.getValNo()];
1541     MVT ArgVT = ArgVTs[VA.getValNo()];
1542
1543     // We don't handle NEON/vector parameters yet.
1544     if (ArgVT.isVector() || ArgVT.getSizeInBits() > 64)
1545       return false;
1546
1547     // Handle arg promotion, etc.
1548     switch (VA.getLocInfo()) {
1549       case CCValAssign::Full: break;
1550       case CCValAssign::SExt: {
1551         bool Emitted = FastEmitExtend(ISD::SIGN_EXTEND, VA.getLocVT(),
1552                                          Arg, ArgVT, Arg);
1553         assert(Emitted && "Failed to emit a sext!"); (void)Emitted;
1554         Emitted = true;
1555         ArgVT = VA.getLocVT();
1556         break;
1557       }
1558       case CCValAssign::ZExt: {
1559         bool Emitted = FastEmitExtend(ISD::ZERO_EXTEND, VA.getLocVT(),
1560                                          Arg, ArgVT, Arg);
1561         assert(Emitted && "Failed to emit a zext!"); (void)Emitted;
1562         Emitted = true;
1563         ArgVT = VA.getLocVT();
1564         break;
1565       }
1566       case CCValAssign::AExt: {
1567         bool Emitted = FastEmitExtend(ISD::ANY_EXTEND, VA.getLocVT(),
1568                                          Arg, ArgVT, Arg);
1569         if (!Emitted)
1570           Emitted = FastEmitExtend(ISD::ZERO_EXTEND, VA.getLocVT(),
1571                                       Arg, ArgVT, Arg);
1572         if (!Emitted)
1573           Emitted = FastEmitExtend(ISD::SIGN_EXTEND, VA.getLocVT(),
1574                                       Arg, ArgVT, Arg);
1575
1576         assert(Emitted && "Failed to emit a aext!"); (void)Emitted;
1577         ArgVT = VA.getLocVT();
1578         break;
1579       }
1580       case CCValAssign::BCvt: {
1581         unsigned BC = FastEmit_r(ArgVT, VA.getLocVT(), ISD::BITCAST, Arg,
1582                                  /*TODO: Kill=*/false);
1583         assert(BC != 0 && "Failed to emit a bitcast!");
1584         Arg = BC;
1585         ArgVT = VA.getLocVT();
1586         break;
1587       }
1588       default: llvm_unreachable("Unknown arg promotion!");
1589     }
1590
1591     // Now copy/store arg to correct locations.
1592     if (VA.isRegLoc() && !VA.needsCustom()) {
1593       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY),
1594               VA.getLocReg())
1595       .addReg(Arg);
1596       RegArgs.push_back(VA.getLocReg());
1597     } else if (VA.needsCustom()) {
1598       // TODO: We need custom lowering for vector (v2f64) args.
1599       if (VA.getLocVT() != MVT::f64) return false;
1600
1601       CCValAssign &NextVA = ArgLocs[++i];
1602
1603       // TODO: Only handle register args for now.
1604       if(!(VA.isRegLoc() && NextVA.isRegLoc())) return false;
1605
1606       AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1607                               TII.get(ARM::VMOVRRD), VA.getLocReg())
1608                       .addReg(NextVA.getLocReg(), RegState::Define)
1609                       .addReg(Arg));
1610       RegArgs.push_back(VA.getLocReg());
1611       RegArgs.push_back(NextVA.getLocReg());
1612     } else {
1613       assert(VA.isMemLoc());
1614       // Need to store on the stack.
1615       Address Addr;
1616       Addr.BaseType = Address::RegBase;
1617       Addr.Base.Reg = ARM::SP;
1618       Addr.Offset = VA.getLocMemOffset();
1619
1620       if (!ARMEmitStore(ArgVT, Arg, Addr)) return false;
1621     }
1622   }
1623   return true;
1624 }
1625
1626 bool ARMFastISel::FinishCall(MVT RetVT, SmallVectorImpl<unsigned> &UsedRegs,
1627                              const Instruction *I, CallingConv::ID CC,
1628                              unsigned &NumBytes) {
1629   // Issue CALLSEQ_END
1630   unsigned AdjStackUp = TM.getRegisterInfo()->getCallFrameDestroyOpcode();
1631   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1632                           TII.get(AdjStackUp))
1633                   .addImm(NumBytes).addImm(0));
1634
1635   // Now the return value.
1636   if (RetVT != MVT::isVoid) {
1637     SmallVector<CCValAssign, 16> RVLocs;
1638     CCState CCInfo(CC, false, TM, RVLocs, *Context);
1639     CCInfo.AnalyzeCallResult(RetVT, CCAssignFnForCall(CC, true));
1640
1641     // Copy all of the result registers out of their specified physreg.
1642     if (RVLocs.size() == 2 && RetVT == MVT::f64) {
1643       // For this move we copy into two registers and then move into the
1644       // double fp reg we want.
1645       EVT DestVT = RVLocs[0].getValVT();
1646       TargetRegisterClass* DstRC = TLI.getRegClassFor(DestVT);
1647       unsigned ResultReg = createResultReg(DstRC);
1648       AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1649                               TII.get(ARM::VMOVDRR), ResultReg)
1650                       .addReg(RVLocs[0].getLocReg())
1651                       .addReg(RVLocs[1].getLocReg()));
1652
1653       UsedRegs.push_back(RVLocs[0].getLocReg());
1654       UsedRegs.push_back(RVLocs[1].getLocReg());
1655
1656       // Finally update the result.
1657       UpdateValueMap(I, ResultReg);
1658     } else {
1659       assert(RVLocs.size() == 1 &&"Can't handle non-double multi-reg retvals!");
1660       EVT CopyVT = RVLocs[0].getValVT();
1661       TargetRegisterClass* DstRC = TLI.getRegClassFor(CopyVT);
1662
1663       unsigned ResultReg = createResultReg(DstRC);
1664       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY),
1665               ResultReg).addReg(RVLocs[0].getLocReg());
1666       UsedRegs.push_back(RVLocs[0].getLocReg());
1667
1668       // Finally update the result.
1669       UpdateValueMap(I, ResultReg);
1670     }
1671   }
1672
1673   return true;
1674 }
1675
1676 bool ARMFastISel::SelectRet(const Instruction *I) {
1677   const ReturnInst *Ret = cast<ReturnInst>(I);
1678   const Function &F = *I->getParent()->getParent();
1679
1680   if (!FuncInfo.CanLowerReturn)
1681     return false;
1682
1683   if (F.isVarArg())
1684     return false;
1685
1686   CallingConv::ID CC = F.getCallingConv();
1687   if (Ret->getNumOperands() > 0) {
1688     SmallVector<ISD::OutputArg, 4> Outs;
1689     GetReturnInfo(F.getReturnType(), F.getAttributes().getRetAttributes(),
1690                   Outs, TLI);
1691
1692     // Analyze operands of the call, assigning locations to each operand.
1693     SmallVector<CCValAssign, 16> ValLocs;
1694     CCState CCInfo(CC, F.isVarArg(), TM, ValLocs, I->getContext());
1695     CCInfo.AnalyzeReturn(Outs, CCAssignFnForCall(CC, true /* is Ret */));
1696
1697     const Value *RV = Ret->getOperand(0);
1698     unsigned Reg = getRegForValue(RV);
1699     if (Reg == 0)
1700       return false;
1701
1702     // Only handle a single return value for now.
1703     if (ValLocs.size() != 1)
1704       return false;
1705
1706     CCValAssign &VA = ValLocs[0];
1707
1708     // Don't bother handling odd stuff for now.
1709     if (VA.getLocInfo() != CCValAssign::Full)
1710       return false;
1711     // Only handle register returns for now.
1712     if (!VA.isRegLoc())
1713       return false;
1714     // TODO: For now, don't try to handle cases where getLocInfo()
1715     // says Full but the types don't match.
1716     if (TLI.getValueType(RV->getType()) != VA.getValVT())
1717       return false;
1718
1719     // Make the copy.
1720     unsigned SrcReg = Reg + VA.getValNo();
1721     unsigned DstReg = VA.getLocReg();
1722     const TargetRegisterClass* SrcRC = MRI.getRegClass(SrcReg);
1723     // Avoid a cross-class copy. This is very unlikely.
1724     if (!SrcRC->contains(DstReg))
1725       return false;
1726     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY),
1727             DstReg).addReg(SrcReg);
1728
1729     // Mark the register as live out of the function.
1730     MRI.addLiveOut(VA.getLocReg());
1731   }
1732
1733   unsigned RetOpc = isThumb ? ARM::tBX_RET : ARM::BX_RET;
1734   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1735                           TII.get(RetOpc)));
1736   return true;
1737 }
1738
1739 unsigned ARMFastISel::ARMSelectCallOp(const GlobalValue *GV) {
1740
1741   // Darwin needs the r9 versions of the opcodes.
1742   bool isDarwin = Subtarget->isTargetDarwin();
1743   if (isThumb) {
1744     return isDarwin ? ARM::tBLr9 : ARM::tBL;
1745   } else  {
1746     return isDarwin ? ARM::BLr9 : ARM::BL;
1747   }
1748 }
1749
1750 // A quick function that will emit a call for a named libcall in F with the
1751 // vector of passed arguments for the Instruction in I. We can assume that we
1752 // can emit a call for any libcall we can produce. This is an abridged version
1753 // of the full call infrastructure since we won't need to worry about things
1754 // like computed function pointers or strange arguments at call sites.
1755 // TODO: Try to unify this and the normal call bits for ARM, then try to unify
1756 // with X86.
1757 bool ARMFastISel::ARMEmitLibcall(const Instruction *I, RTLIB::Libcall Call) {
1758   CallingConv::ID CC = TLI.getLibcallCallingConv(Call);
1759
1760   // Handle *simple* calls for now.
1761   const Type *RetTy = I->getType();
1762   MVT RetVT;
1763   if (RetTy->isVoidTy())
1764     RetVT = MVT::isVoid;
1765   else if (!isTypeLegal(RetTy, RetVT))
1766     return false;
1767
1768   // TODO: For now if we have long calls specified we don't handle the call.
1769   if (EnableARMLongCalls) return false;
1770
1771   // Set up the argument vectors.
1772   SmallVector<Value*, 8> Args;
1773   SmallVector<unsigned, 8> ArgRegs;
1774   SmallVector<MVT, 8> ArgVTs;
1775   SmallVector<ISD::ArgFlagsTy, 8> ArgFlags;
1776   Args.reserve(I->getNumOperands());
1777   ArgRegs.reserve(I->getNumOperands());
1778   ArgVTs.reserve(I->getNumOperands());
1779   ArgFlags.reserve(I->getNumOperands());
1780   for (unsigned i = 0; i < I->getNumOperands(); ++i) {
1781     Value *Op = I->getOperand(i);
1782     unsigned Arg = getRegForValue(Op);
1783     if (Arg == 0) return false;
1784
1785     const Type *ArgTy = Op->getType();
1786     MVT ArgVT;
1787     if (!isTypeLegal(ArgTy, ArgVT)) return false;
1788
1789     ISD::ArgFlagsTy Flags;
1790     unsigned OriginalAlignment = TD.getABITypeAlignment(ArgTy);
1791     Flags.setOrigAlign(OriginalAlignment);
1792
1793     Args.push_back(Op);
1794     ArgRegs.push_back(Arg);
1795     ArgVTs.push_back(ArgVT);
1796     ArgFlags.push_back(Flags);
1797   }
1798
1799   // Handle the arguments now that we've gotten them.
1800   SmallVector<unsigned, 4> RegArgs;
1801   unsigned NumBytes;
1802   if (!ProcessCallArgs(Args, ArgRegs, ArgVTs, ArgFlags, RegArgs, CC, NumBytes))
1803     return false;
1804
1805   // Issue the call, BLr9 for darwin, BL otherwise.
1806   // TODO: Turn this into the table of arm call ops.
1807   MachineInstrBuilder MIB;
1808   unsigned CallOpc = ARMSelectCallOp(NULL);
1809   if(isThumb)
1810     // Explicitly adding the predicate here.
1811     MIB = AddDefaultPred(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1812                          TII.get(CallOpc)))
1813                          .addExternalSymbol(TLI.getLibcallName(Call));
1814   else
1815     // Explicitly adding the predicate here.
1816     MIB = AddDefaultPred(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1817                          TII.get(CallOpc))
1818           .addExternalSymbol(TLI.getLibcallName(Call)));
1819
1820   // Add implicit physical register uses to the call.
1821   for (unsigned i = 0, e = RegArgs.size(); i != e; ++i)
1822     MIB.addReg(RegArgs[i]);
1823
1824   // Finish off the call including any return values.
1825   SmallVector<unsigned, 4> UsedRegs;
1826   if (!FinishCall(RetVT, UsedRegs, I, CC, NumBytes)) return false;
1827
1828   // Set all unused physreg defs as dead.
1829   static_cast<MachineInstr *>(MIB)->setPhysRegsDeadExcept(UsedRegs, TRI);
1830
1831   return true;
1832 }
1833
1834 bool ARMFastISel::SelectCall(const Instruction *I) {
1835   const CallInst *CI = cast<CallInst>(I);
1836   const Value *Callee = CI->getCalledValue();
1837
1838   // Can't handle inline asm or worry about intrinsics yet.
1839   if (isa<InlineAsm>(Callee) || isa<IntrinsicInst>(CI)) return false;
1840
1841   // Only handle global variable Callees that are direct calls.
1842   const GlobalValue *GV = dyn_cast<GlobalValue>(Callee);
1843   if (!GV || Subtarget->GVIsIndirectSymbol(GV, TM.getRelocationModel()))
1844     return false;
1845
1846   // Check the calling convention.
1847   ImmutableCallSite CS(CI);
1848   CallingConv::ID CC = CS.getCallingConv();
1849
1850   // TODO: Avoid some calling conventions?
1851
1852   // Let SDISel handle vararg functions.
1853   const PointerType *PT = cast<PointerType>(CS.getCalledValue()->getType());
1854   const FunctionType *FTy = cast<FunctionType>(PT->getElementType());
1855   if (FTy->isVarArg())
1856     return false;
1857
1858   // Handle *simple* calls for now.
1859   const Type *RetTy = I->getType();
1860   MVT RetVT;
1861   if (RetTy->isVoidTy())
1862     RetVT = MVT::isVoid;
1863   else if (!isTypeLegal(RetTy, RetVT))
1864     return false;
1865
1866   // TODO: For now if we have long calls specified we don't handle the call.
1867   if (EnableARMLongCalls) return false;
1868
1869   // Set up the argument vectors.
1870   SmallVector<Value*, 8> Args;
1871   SmallVector<unsigned, 8> ArgRegs;
1872   SmallVector<MVT, 8> ArgVTs;
1873   SmallVector<ISD::ArgFlagsTy, 8> ArgFlags;
1874   Args.reserve(CS.arg_size());
1875   ArgRegs.reserve(CS.arg_size());
1876   ArgVTs.reserve(CS.arg_size());
1877   ArgFlags.reserve(CS.arg_size());
1878   for (ImmutableCallSite::arg_iterator i = CS.arg_begin(), e = CS.arg_end();
1879        i != e; ++i) {
1880     unsigned Arg = getRegForValue(*i);
1881
1882     if (Arg == 0)
1883       return false;
1884     ISD::ArgFlagsTy Flags;
1885     unsigned AttrInd = i - CS.arg_begin() + 1;
1886     if (CS.paramHasAttr(AttrInd, Attribute::SExt))
1887       Flags.setSExt();
1888     if (CS.paramHasAttr(AttrInd, Attribute::ZExt))
1889       Flags.setZExt();
1890
1891          // FIXME: Only handle *easy* calls for now.
1892     if (CS.paramHasAttr(AttrInd, Attribute::InReg) ||
1893         CS.paramHasAttr(AttrInd, Attribute::StructRet) ||
1894         CS.paramHasAttr(AttrInd, Attribute::Nest) ||
1895         CS.paramHasAttr(AttrInd, Attribute::ByVal))
1896       return false;
1897
1898     const Type *ArgTy = (*i)->getType();
1899     MVT ArgVT;
1900     if (!isTypeLegal(ArgTy, ArgVT))
1901       return false;
1902     unsigned OriginalAlignment = TD.getABITypeAlignment(ArgTy);
1903     Flags.setOrigAlign(OriginalAlignment);
1904
1905     Args.push_back(*i);
1906     ArgRegs.push_back(Arg);
1907     ArgVTs.push_back(ArgVT);
1908     ArgFlags.push_back(Flags);
1909   }
1910
1911   // Handle the arguments now that we've gotten them.
1912   SmallVector<unsigned, 4> RegArgs;
1913   unsigned NumBytes;
1914   if (!ProcessCallArgs(Args, ArgRegs, ArgVTs, ArgFlags, RegArgs, CC, NumBytes))
1915     return false;
1916
1917   // Issue the call, BLr9 for darwin, BL otherwise.
1918   // TODO: Turn this into the table of arm call ops.
1919   MachineInstrBuilder MIB;
1920   unsigned CallOpc = ARMSelectCallOp(GV);
1921   // Explicitly adding the predicate here.
1922   if(isThumb)
1923     // Explicitly adding the predicate here.
1924     MIB = AddDefaultPred(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1925                          TII.get(CallOpc)))
1926           .addGlobalAddress(GV, 0, 0);
1927   else
1928     // Explicitly adding the predicate here.
1929     MIB = AddDefaultPred(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
1930                          TII.get(CallOpc))
1931           .addGlobalAddress(GV, 0, 0));
1932
1933   // Add implicit physical register uses to the call.
1934   for (unsigned i = 0, e = RegArgs.size(); i != e; ++i)
1935     MIB.addReg(RegArgs[i]);
1936
1937   // Finish off the call including any return values.
1938   SmallVector<unsigned, 4> UsedRegs;
1939   if (!FinishCall(RetVT, UsedRegs, I, CC, NumBytes)) return false;
1940
1941   // Set all unused physreg defs as dead.
1942   static_cast<MachineInstr *>(MIB)->setPhysRegsDeadExcept(UsedRegs, TRI);
1943
1944   return true;
1945
1946 }
1947
1948 // TODO: SoftFP support.
1949 bool ARMFastISel::TargetSelectInstruction(const Instruction *I) {
1950
1951   switch (I->getOpcode()) {
1952     case Instruction::Load:
1953       return SelectLoad(I);
1954     case Instruction::Store:
1955       return SelectStore(I);
1956     case Instruction::Br:
1957       return SelectBranch(I);
1958     case Instruction::ICmp:
1959     case Instruction::FCmp:
1960       return SelectCmp(I);
1961     case Instruction::FPExt:
1962       return SelectFPExt(I);
1963     case Instruction::FPTrunc:
1964       return SelectFPTrunc(I);
1965     case Instruction::SIToFP:
1966       return SelectSIToFP(I);
1967     case Instruction::FPToSI:
1968       return SelectFPToSI(I);
1969     case Instruction::FAdd:
1970       return SelectBinaryOp(I, ISD::FADD);
1971     case Instruction::FSub:
1972       return SelectBinaryOp(I, ISD::FSUB);
1973     case Instruction::FMul:
1974       return SelectBinaryOp(I, ISD::FMUL);
1975     case Instruction::SDiv:
1976       return SelectSDiv(I);
1977     case Instruction::SRem:
1978       return SelectSRem(I);
1979     case Instruction::Call:
1980       return SelectCall(I);
1981     case Instruction::Select:
1982       return SelectSelect(I);
1983     case Instruction::Ret:
1984       return SelectRet(I);
1985     default: break;
1986   }
1987   return false;
1988 }
1989
1990 namespace llvm {
1991   llvm::FastISel *ARM::createFastISel(FunctionLoweringInfo &funcInfo) {
1992     // Completely untested on non-darwin.
1993     const TargetMachine &TM = funcInfo.MF->getTarget();
1994
1995     // Darwin and thumb1 only for now.
1996     const ARMSubtarget *Subtarget = &TM.getSubtarget<ARMSubtarget>();
1997     if (Subtarget->isTargetDarwin() && !Subtarget->isThumb1Only() &&
1998         !DisableARMFastISel)
1999       return new ARMFastISel(funcInfo);
2000     return 0;
2001   }
2002 }