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 "llvm/CallingConv.h"
  23 #include "llvm/DerivedTypes.h"
  24 #include "llvm/GlobalVariable.h"
  25 #include "llvm/Instructions.h"
  26 #include "llvm/IntrinsicInst.h"
  27 #include "llvm/Module.h"
  28 #include "llvm/CodeGen/Analysis.h"
  29 #include "llvm/CodeGen/FastISel.h"
  30 #include "llvm/CodeGen/FunctionLoweringInfo.h"
  31 #include "llvm/CodeGen/MachineInstrBuilder.h"
  32 #include "llvm/CodeGen/MachineModuleInfo.h"
  33 #include "llvm/CodeGen/MachineConstantPool.h"
  34 #include "llvm/CodeGen/MachineFrameInfo.h"
  35 #include "llvm/CodeGen/MachineRegisterInfo.h"
  36 #include "llvm/Support/CallSite.h"
  37 #include "llvm/Support/CommandLine.h"
  38 #include "llvm/Support/ErrorHandling.h"
  39 #include "llvm/Support/GetElementPtrTypeIterator.h"
  40 #include "llvm/Target/TargetData.h"
  41 #include "llvm/Target/TargetInstrInfo.h"
  42 #include "llvm/Target/TargetLowering.h"
  43 #include "llvm/Target/TargetMachine.h"
  44 #include "llvm/Target/TargetOptions.h"
  45 using namespace llvm;
  46
  47 static cl::opt<bool>
  48 EnableARMFastISel("arm-fast-isel",
  49                   cl::desc("Turn on experimental ARM fast-isel support"),
  50                   cl::init(false), cl::Hidden);
  51
  52 namespace {
  53
  54 class ARMFastISel : public FastISel {
  55
  56   /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can
  57   /// make the right decision when generating code for different targets.
  58   const ARMSubtarget *Subtarget;
  59   const TargetMachine &TM;
  60   const TargetInstrInfo &TII;
  61   const TargetLowering &TLI;
  62   const ARMFunctionInfo *AFI;
  63
  64   // Convenience variable to avoid checking all the time.
  65   bool isThumb;
  66
  67   public:
  68     explicit ARMFastISel(FunctionLoweringInfo &funcInfo)
  69     : FastISel(funcInfo),
  70       TM(funcInfo.MF->getTarget()),
  71       TII(*TM.getInstrInfo()),
  72       TLI(*TM.getTargetLowering()) {
  73       Subtarget = &TM.getSubtarget<ARMSubtarget>();
  74       AFI = funcInfo.MF->getInfo<ARMFunctionInfo>();
  75       isThumb = AFI->isThumbFunction();
  76     }
  77
  78     // Code from FastISel.cpp.
  79     virtual unsigned FastEmitInst_(unsigned MachineInstOpcode,
  80                                    const TargetRegisterClass *RC);
  81     virtual unsigned FastEmitInst_r(unsigned MachineInstOpcode,
  82                                     const TargetRegisterClass *RC,
  83                                     unsigned Op0, bool Op0IsKill);
  84     virtual unsigned FastEmitInst_rr(unsigned MachineInstOpcode,
  85                                      const TargetRegisterClass *RC,
  86                                      unsigned Op0, bool Op0IsKill,
  87                                      unsigned Op1, bool Op1IsKill);
  88     virtual unsigned FastEmitInst_ri(unsigned MachineInstOpcode,
  89                                      const TargetRegisterClass *RC,
  90                                      unsigned Op0, bool Op0IsKill,
  91                                      uint64_t Imm);
  92     virtual unsigned FastEmitInst_rf(unsigned MachineInstOpcode,
  93                                      const TargetRegisterClass *RC,
  94                                      unsigned Op0, bool Op0IsKill,
  95                                      const ConstantFP *FPImm);
  96     virtual unsigned FastEmitInst_i(unsigned MachineInstOpcode,
  97                                     const TargetRegisterClass *RC,
  98                                     uint64_t Imm);
  99     virtual unsigned FastEmitInst_rri(unsigned MachineInstOpcode,
 100                                       const TargetRegisterClass *RC,
 101                                       unsigned Op0, bool Op0IsKill,
 102                                       unsigned Op1, bool Op1IsKill,
 103                                       uint64_t Imm);
 104     virtual unsigned FastEmitInst_extractsubreg(MVT RetVT,
 105                                                 unsigned Op0, bool Op0IsKill,
 106                                                 uint32_t Idx);
 107
 108     // Backend specific FastISel code.
 109     virtual bool TargetSelectInstruction(const Instruction *I);
 110     virtual unsigned TargetMaterializeConstant(const Constant *C);
 111
 112   #include "ARMGenFastISel.inc"
 113
 114     // Instruction selection routines.
 115   private:
 116     virtual bool ARMSelectLoad(const Instruction *I);
 117     virtual bool ARMSelectStore(const Instruction *I);
 118     virtual bool ARMSelectBranch(const Instruction *I);
 119     virtual bool ARMSelectCmp(const Instruction *I);
 120     virtual bool ARMSelectFPExt(const Instruction *I);
 121     virtual bool ARMSelectFPTrunc(const Instruction *I);
 122     virtual bool ARMSelectBinaryOp(const Instruction *I, unsigned ISDOpcode);
 123     virtual bool ARMSelectSIToFP(const Instruction *I);
 124     virtual bool ARMSelectFPToSI(const Instruction *I);
 125     virtual bool ARMSelectSDiv(const Instruction *I);
 126
 127     // Utility routines.
 128   private:
 129     bool isTypeLegal(const Type *Ty, EVT &VT);
 130     bool isLoadTypeLegal(const Type *Ty, EVT &VT);
 131     bool ARMEmitLoad(EVT VT, unsigned &ResultReg, unsigned Reg, int Offset);
 132     bool ARMEmitStore(EVT VT, unsigned SrcReg, unsigned Reg, int Offset);
 133     bool ARMLoadAlloca(const Instruction *I, EVT VT);
 134     bool ARMStoreAlloca(const Instruction *I, unsigned SrcReg, EVT VT);
 135     bool ARMComputeRegOffset(const Value *Obj, unsigned &Reg, int &Offset);
 136     unsigned ARMMaterializeFP(const ConstantFP *CFP, EVT VT);
 137     unsigned ARMMaterializeInt(const Constant *C);
 138     unsigned ARMMoveToFPReg(EVT VT, unsigned SrcReg);
 139     unsigned ARMMoveToIntReg(EVT VT, unsigned SrcReg);
 140
 141     // Call handling routines.
 142   private:
 143     CCAssignFn *CCAssignFnForCall(CallingConv::ID CC, bool Return);
 144     bool ARMEmitLibcall(const Instruction *I, Function *F);
 145
 146     // OptionalDef handling routines.
 147   private:
 148     bool DefinesOptionalPredicate(MachineInstr *MI, bool *CPSR);
 149     const MachineInstrBuilder &AddOptionalDefs(const MachineInstrBuilder &MIB);
 150 };
 151
 152 } // end anonymous namespace
 153
 154 #include "ARMGenCallingConv.inc"
 155
 156 // DefinesOptionalPredicate - This is different from DefinesPredicate in that
 157 // we don't care about implicit defs here, just places we'll need to add a
 158 // default CCReg argument. Sets CPSR if we're setting CPSR instead of CCR.
 159 bool ARMFastISel::DefinesOptionalPredicate(MachineInstr *MI, bool *CPSR) {
 160   const TargetInstrDesc &TID = MI->getDesc();
 161   if (!TID.hasOptionalDef())
 162     return false;
 163
 164   // Look to see if our OptionalDef is defining CPSR or CCR.
 165   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 166     const MachineOperand &MO = MI->getOperand(i);
 167     if (!MO.isReg() || !MO.isDef()) continue;
 168     if (MO.getReg() == ARM::CPSR)
 169       *CPSR = true;
 170   }
 171   return true;
 172 }
 173
 174 // If the machine is predicable go ahead and add the predicate operands, if
 175 // it needs default CC operands add those.
 176 const MachineInstrBuilder &
 177 ARMFastISel::AddOptionalDefs(const MachineInstrBuilder &MIB) {
 178   MachineInstr *MI = &*MIB;
 179
 180   // Do we use a predicate?
 181   if (TII.isPredicable(MI))
 182     AddDefaultPred(MIB);
 183
 184   // Do we optionally set a predicate?  Preds is size > 0 iff the predicate
 185   // defines CPSR. All other OptionalDefines in ARM are the CCR register.
 186   bool CPSR = false;
 187   if (DefinesOptionalPredicate(MI, &CPSR)) {
 188     if (CPSR)
 189       AddDefaultT1CC(MIB);
 190     else
 191       AddDefaultCC(MIB);
 192   }
 193   return MIB;
 194 }
 195
 196 unsigned ARMFastISel::FastEmitInst_(unsigned MachineInstOpcode,
 197                                     const TargetRegisterClass* RC) {
 198   unsigned ResultReg = createResultReg(RC);
 199   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 200
 201   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg));
 202   return ResultReg;
 203 }
 204
 205 unsigned ARMFastISel::FastEmitInst_r(unsigned MachineInstOpcode,
 206                                      const TargetRegisterClass *RC,
 207                                      unsigned Op0, bool Op0IsKill) {
 208   unsigned ResultReg = createResultReg(RC);
 209   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 210
 211   if (II.getNumDefs() >= 1)
 212     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 213                    .addReg(Op0, Op0IsKill * RegState::Kill));
 214   else {
 215     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 216                    .addReg(Op0, Op0IsKill * RegState::Kill));
 217     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 218                    TII.get(TargetOpcode::COPY), ResultReg)
 219                    .addReg(II.ImplicitDefs[0]));
 220   }
 221   return ResultReg;
 222 }
 223
 224 unsigned ARMFastISel::FastEmitInst_rr(unsigned MachineInstOpcode,
 225                                       const TargetRegisterClass *RC,
 226                                       unsigned Op0, bool Op0IsKill,
 227                                       unsigned Op1, bool Op1IsKill) {
 228   unsigned ResultReg = createResultReg(RC);
 229   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 230
 231   if (II.getNumDefs() >= 1)
 232     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 233                    .addReg(Op0, Op0IsKill * RegState::Kill)
 234                    .addReg(Op1, Op1IsKill * RegState::Kill));
 235   else {
 236     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 237                    .addReg(Op0, Op0IsKill * RegState::Kill)
 238                    .addReg(Op1, Op1IsKill * RegState::Kill));
 239     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 240                            TII.get(TargetOpcode::COPY), ResultReg)
 241                    .addReg(II.ImplicitDefs[0]));
 242   }
 243   return ResultReg;
 244 }
 245
 246 unsigned ARMFastISel::FastEmitInst_ri(unsigned MachineInstOpcode,
 247                                       const TargetRegisterClass *RC,
 248                                       unsigned Op0, bool Op0IsKill,
 249                                       uint64_t Imm) {
 250   unsigned ResultReg = createResultReg(RC);
 251   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 252
 253   if (II.getNumDefs() >= 1)
 254     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 255                    .addReg(Op0, Op0IsKill * RegState::Kill)
 256                    .addImm(Imm));
 257   else {
 258     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 259                    .addReg(Op0, Op0IsKill * RegState::Kill)
 260                    .addImm(Imm));
 261     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 262                            TII.get(TargetOpcode::COPY), ResultReg)
 263                    .addReg(II.ImplicitDefs[0]));
 264   }
 265   return ResultReg;
 266 }
 267
 268 unsigned ARMFastISel::FastEmitInst_rf(unsigned MachineInstOpcode,
 269                                       const TargetRegisterClass *RC,
 270                                       unsigned Op0, bool Op0IsKill,
 271                                       const ConstantFP *FPImm) {
 272   unsigned ResultReg = createResultReg(RC);
 273   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 274
 275   if (II.getNumDefs() >= 1)
 276     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 277                    .addReg(Op0, Op0IsKill * RegState::Kill)
 278                    .addFPImm(FPImm));
 279   else {
 280     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 281                    .addReg(Op0, Op0IsKill * RegState::Kill)
 282                    .addFPImm(FPImm));
 283     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 284                            TII.get(TargetOpcode::COPY), ResultReg)
 285                    .addReg(II.ImplicitDefs[0]));
 286   }
 287   return ResultReg;
 288 }
 289
 290 unsigned ARMFastISel::FastEmitInst_rri(unsigned MachineInstOpcode,
 291                                        const TargetRegisterClass *RC,
 292                                        unsigned Op0, bool Op0IsKill,
 293                                        unsigned Op1, bool Op1IsKill,
 294                                        uint64_t Imm) {
 295   unsigned ResultReg = createResultReg(RC);
 296   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 297
 298   if (II.getNumDefs() >= 1)
 299     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 300                    .addReg(Op0, Op0IsKill * RegState::Kill)
 301                    .addReg(Op1, Op1IsKill * RegState::Kill)
 302                    .addImm(Imm));
 303   else {
 304     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 305                    .addReg(Op0, Op0IsKill * RegState::Kill)
 306                    .addReg(Op1, Op1IsKill * RegState::Kill)
 307                    .addImm(Imm));
 308     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 309                            TII.get(TargetOpcode::COPY), ResultReg)
 310                    .addReg(II.ImplicitDefs[0]));
 311   }
 312   return ResultReg;
 313 }
 314
 315 unsigned ARMFastISel::FastEmitInst_i(unsigned MachineInstOpcode,
 316                                      const TargetRegisterClass *RC,
 317                                      uint64_t Imm) {
 318   unsigned ResultReg = createResultReg(RC);
 319   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 320
 321   if (II.getNumDefs() >= 1)
 322     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 323                    .addImm(Imm));
 324   else {
 325     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 326                    .addImm(Imm));
 327     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 328                            TII.get(TargetOpcode::COPY), ResultReg)
 329                    .addReg(II.ImplicitDefs[0]));
 330   }
 331   return ResultReg;
 332 }
 333
 334 unsigned ARMFastISel::FastEmitInst_extractsubreg(MVT RetVT,
 335                                                  unsigned Op0, bool Op0IsKill,
 336                                                  uint32_t Idx) {
 337   unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT));
 338   assert(TargetRegisterInfo::isVirtualRegister(Op0) &&
 339          "Cannot yet extract from physregs");
 340   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt,
 341                          DL, TII.get(TargetOpcode::COPY), ResultReg)
 342                  .addReg(Op0, getKillRegState(Op0IsKill), Idx));
 343   return ResultReg;
 344 }
 345
 346 // TODO: Don't worry about 64-bit now, but when this is fixed remove the
 347 // checks from the various callers.
 348 unsigned ARMFastISel::ARMMoveToFPReg(EVT VT, unsigned SrcReg) {
 349   if (VT.getSimpleVT().SimpleTy == MVT::f64) return 0;
 350
 351   unsigned MoveReg = createResultReg(TLI.getRegClassFor(VT));
 352   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 353                           TII.get(ARM::VMOVRS), MoveReg)
 354                   .addReg(SrcReg));
 355   return MoveReg;
 356 }
 357
 358 unsigned ARMFastISel::ARMMoveToIntReg(EVT VT, unsigned SrcReg) {
 359   if (VT.getSimpleVT().SimpleTy == MVT::i64) return 0;
 360
 361   unsigned MoveReg = createResultReg(TLI.getRegClassFor(VT));
 362   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 363                           TII.get(ARM::VMOVSR), MoveReg)
 364                   .addReg(SrcReg));
 365   return MoveReg;
 366 }
 367
 368 // For double width floating point we need to materialize two constants
 369 // (the high and the low) into integer registers then use a move to get
 370 // the combined constant into an FP reg.
 371 unsigned ARMFastISel::ARMMaterializeFP(const ConstantFP *CFP, EVT VT) {
 372   const APFloat Val = CFP->getValueAPF();
 373   bool is64bit = VT.getSimpleVT().SimpleTy == MVT::f64;
 374
 375   // This checks to see if we can use VFP3 instructions to materialize
 376   // a constant, otherwise we have to go through the constant pool.
 377   if (TLI.isFPImmLegal(Val, VT)) {
 378     unsigned Opc = is64bit ? ARM::FCONSTD : ARM::FCONSTS;
 379     unsigned DestReg = createResultReg(TLI.getRegClassFor(VT));
 380     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc),
 381                             DestReg)
 382                     .addFPImm(CFP));
 383     return DestReg;
 384   }
 385
 386   // Require VFP2 for loading fp constants.
 387   if (!Subtarget->hasVFP2()) return false;
 388
 389   // MachineConstantPool wants an explicit alignment.
 390   unsigned Align = TD.getPrefTypeAlignment(CFP->getType());
 391   if (Align == 0) {
 392     // TODO: Figure out if this is correct.
 393     Align = TD.getTypeAllocSize(CFP->getType());
 394   }
 395   unsigned Idx = MCP.getConstantPoolIndex(cast<Constant>(CFP), Align);
 396   unsigned DestReg = createResultReg(TLI.getRegClassFor(VT));
 397   unsigned Opc = is64bit ? ARM::VLDRD : ARM::VLDRS;
 398
 399   // The extra reg is for addrmode5.
 400   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc))
 401                   .addReg(DestReg).addConstantPoolIndex(Idx)
 402                   .addReg(0));
 403   return DestReg;
 404 }
 405
 406 // TODO: Verify 64-bit.
 407 unsigned ARMFastISel::ARMMaterializeInt(const Constant *C) {
 408   // MachineConstantPool wants an explicit alignment.
 409   unsigned Align = TD.getPrefTypeAlignment(C->getType());
 410   if (Align == 0) {
 411     // TODO: Figure out if this is correct.
 412     Align = TD.getTypeAllocSize(C->getType());
 413   }
 414   unsigned Idx = MCP.getConstantPoolIndex(C, Align);
 415   unsigned DestReg = createResultReg(TLI.getRegClassFor(MVT::i32));
 416
 417   if (isThumb)
 418     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 419                             TII.get(ARM::t2LDRpci))
 420                     .addReg(DestReg).addConstantPoolIndex(Idx));
 421   else
 422     // The extra reg and immediate are for addrmode2.
 423     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 424                             TII.get(ARM::LDRcp))
 425                             .addReg(DestReg).addConstantPoolIndex(Idx)
 426                     .addReg(0).addImm(0));
 427
 428   return DestReg;
 429 }
 430
 431 unsigned ARMFastISel::TargetMaterializeConstant(const Constant *C) {
 432   EVT VT = TLI.getValueType(C->getType(), true);
 433
 434   // Only handle simple types.
 435   if (!VT.isSimple()) return 0;
 436
 437   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C))
 438     return ARMMaterializeFP(CFP, VT);
 439   return ARMMaterializeInt(C);
 440 }
 441
 442 bool ARMFastISel::isTypeLegal(const Type *Ty, EVT &VT) {
 443   VT = TLI.getValueType(Ty, true);
 444
 445   // Only handle simple types.
 446   if (VT == MVT::Other || !VT.isSimple()) return false;
 447
 448   // Handle all legal types, i.e. a register that will directly hold this
 449   // value.
 450   return TLI.isTypeLegal(VT);
 451 }
 452
 453 bool ARMFastISel::isLoadTypeLegal(const Type *Ty, EVT &VT) {
 454   if (isTypeLegal(Ty, VT)) return true;
 455
 456   // If this is a type than can be sign or zero-extended to a basic operation
 457   // go ahead and accept it now.
 458   if (VT == MVT::i8 || VT == MVT::i16)
 459     return true;
 460
 461   return false;
 462 }
 463
 464 // Computes the Reg+Offset to get to an object.
 465 bool ARMFastISel::ARMComputeRegOffset(const Value *Obj, unsigned &Reg,
 466                                       int &Offset) {
 467   // Some boilerplate from the X86 FastISel.
 468   const User *U = NULL;
 469   unsigned Opcode = Instruction::UserOp1;
 470   if (const Instruction *I = dyn_cast<Instruction>(Obj)) {
 471     // Don't walk into other basic blocks; it's possible we haven't
 472     // visited them yet, so the instructions may not yet be assigned
 473     // virtual registers.
 474     if (FuncInfo.MBBMap[I->getParent()] != FuncInfo.MBB)
 475       return false;
 476     Opcode = I->getOpcode();
 477     U = I;
 478   } else if (const ConstantExpr *C = dyn_cast<ConstantExpr>(Obj)) {
 479     Opcode = C->getOpcode();
 480     U = C;
 481   }
 482
 483   if (const PointerType *Ty = dyn_cast<PointerType>(Obj->getType()))
 484     if (Ty->getAddressSpace() > 255)
 485       // Fast instruction selection doesn't support the special
 486       // address spaces.
 487       return false;
 488
 489   switch (Opcode) {
 490     default:
 491     break;
 492     case Instruction::Alloca: {
 493       assert(false && "Alloca should have been handled earlier!");
 494       return false;
 495     }
 496   }
 497
 498   // FIXME: Handle global variables.
 499   if (const GlobalValue *GV = dyn_cast<GlobalValue>(Obj)) {
 500     (void)GV;
 501     return false;
 502   }
 503
 504   // Try to get this in a register if nothing else has worked.
 505   Reg = getRegForValue(Obj);
 506   if (Reg == 0) return false;
 507
 508   // Since the offset may be too large for the load instruction
 509   // get the reg+offset into a register.
 510   // TODO: Verify the additions work, otherwise we'll need to add the
 511   // offset instead of 0 to the instructions and do all sorts of operand
 512   // munging.
 513   // TODO: Optimize this somewhat.
 514   if (Offset != 0) {
 515     ARMCC::CondCodes Pred = ARMCC::AL;
 516     unsigned PredReg = 0;
 517
 518     if (!isThumb)
 519       emitARMRegPlusImmediate(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 520                               Reg, Reg, Offset, Pred, PredReg,
 521                               static_cast<const ARMBaseInstrInfo&>(TII));
 522     else {
 523       assert(AFI->isThumb2Function());
 524       emitT2RegPlusImmediate(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 525                              Reg, Reg, Offset, Pred, PredReg,
 526                              static_cast<const ARMBaseInstrInfo&>(TII));
 527     }
 528   }
 529   return true;
 530 }
 531
 532 bool ARMFastISel::ARMLoadAlloca(const Instruction *I, EVT VT) {
 533   Value *Op0 = I->getOperand(0);
 534
 535   // Verify it's an alloca.
 536   if (const AllocaInst *AI = dyn_cast<AllocaInst>(Op0)) {
 537     DenseMap<const AllocaInst*, int>::iterator SI =
 538       FuncInfo.StaticAllocaMap.find(AI);
 539
 540     if (SI != FuncInfo.StaticAllocaMap.end()) {
 541       TargetRegisterClass* RC = TLI.getRegClassFor(VT);
 542       unsigned ResultReg = createResultReg(RC);
 543       TII.loadRegFromStackSlot(*FuncInfo.MBB, *FuncInfo.InsertPt,
 544                                ResultReg, SI->second, RC,
 545                                TM.getRegisterInfo());
 546       UpdateValueMap(I, ResultReg);
 547       return true;
 548     }
 549   }
 550   return false;
 551 }
 552
 553 bool ARMFastISel::ARMEmitLoad(EVT VT, unsigned &ResultReg,
 554                               unsigned Reg, int Offset) {
 555
 556   assert(VT.isSimple() && "Non-simple types are invalid here!");
 557   unsigned Opc;
 558
 559   switch (VT.getSimpleVT().SimpleTy) {
 560     default:
 561       assert(false && "Trying to emit for an unhandled type!");
 562       return false;
 563     case MVT::i16:
 564       Opc = isThumb ? ARM::tLDRH : ARM::LDRH;
 565       VT = MVT::i32;
 566       break;
 567     case MVT::i8:
 568       Opc = isThumb ? ARM::tLDRB : ARM::LDRB;
 569       VT = MVT::i32;
 570       break;
 571     case MVT::i32:
 572       Opc = isThumb ? ARM::tLDR : ARM::LDR;
 573       break;
 574   }
 575
 576   ResultReg = createResultReg(TLI.getRegClassFor(VT));
 577
 578   // TODO: Fix the Addressing modes so that these can share some code.
 579   // Since this is a Thumb1 load this will work in Thumb1 or 2 mode.
 580   if (isThumb)
 581     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 582                             TII.get(Opc), ResultReg)
 583                     .addReg(Reg).addImm(Offset).addReg(0));
 584   else
 585     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 586                             TII.get(Opc), ResultReg)
 587                     .addReg(Reg).addReg(0).addImm(Offset));
 588   return true;
 589 }
 590
 591 bool ARMFastISel::ARMSelectLoad(const Instruction *I) {
 592   // Verify we have a legal type before going any further.
 593   EVT VT;
 594   if (!isLoadTypeLegal(I->getType(), VT))
 595     return false;
 596
 597   // If we're an alloca we know we have a frame index and can emit the load
 598   // directly in short order.
 599   if (ARMLoadAlloca(I, VT))
 600     return true;
 601
 602   // Our register and offset with innocuous defaults.
 603   unsigned Reg = 0;
 604   int Offset = 0;
 605
 606   // See if we can handle this as Reg + Offset
 607   if (!ARMComputeRegOffset(I->getOperand(0), Reg, Offset))
 608     return false;
 609
 610   unsigned ResultReg;
 611   if (!ARMEmitLoad(VT, ResultReg, Reg, Offset /* 0 */)) return false;
 612
 613   UpdateValueMap(I, ResultReg);
 614   return true;
 615 }
 616
 617 bool ARMFastISel::ARMStoreAlloca(const Instruction *I, unsigned SrcReg, EVT VT){
 618   Value *Op1 = I->getOperand(1);
 619
 620   // Verify it's an alloca.
 621   if (const AllocaInst *AI = dyn_cast<AllocaInst>(Op1)) {
 622     DenseMap<const AllocaInst*, int>::iterator SI =
 623       FuncInfo.StaticAllocaMap.find(AI);
 624
 625     if (SI != FuncInfo.StaticAllocaMap.end()) {
 626       TargetRegisterClass* RC = TLI.getRegClassFor(VT);
 627       assert(SrcReg != 0 && "Nothing to store!");
 628       TII.storeRegToStackSlot(*FuncInfo.MBB, *FuncInfo.InsertPt,
 629                               SrcReg, true /*isKill*/, SI->second, RC,
 630                               TM.getRegisterInfo());
 631       return true;
 632     }
 633   }
 634   return false;
 635 }
 636
 637 bool ARMFastISel::ARMEmitStore(EVT VT, unsigned SrcReg,
 638                                unsigned DstReg, int Offset) {
 639   unsigned StrOpc;
 640   switch (VT.getSimpleVT().SimpleTy) {
 641     default: return false;
 642     case MVT::i1:
 643     case MVT::i8: StrOpc = isThumb ? ARM::tSTRB : ARM::STRB; break;
 644     case MVT::i16: StrOpc = isThumb ? ARM::tSTRH : ARM::STRH; break;
 645     case MVT::i32: StrOpc = isThumb ? ARM::tSTR : ARM::STR; break;
 646     case MVT::f32:
 647       if (!Subtarget->hasVFP2()) return false;
 648       StrOpc = ARM::VSTRS;
 649       break;
 650     case MVT::f64:
 651       if (!Subtarget->hasVFP2()) return false;
 652       StrOpc = ARM::VSTRD;
 653       break;
 654   }
 655
 656   if (isThumb)
 657     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 658                             TII.get(StrOpc), SrcReg)
 659                     .addReg(DstReg).addImm(Offset).addReg(0));
 660   else
 661     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 662                             TII.get(StrOpc), SrcReg)
 663                     .addReg(DstReg).addReg(0).addImm(Offset));
 664
 665   return true;
 666 }
 667
 668 bool ARMFastISel::ARMSelectStore(const Instruction *I) {
 669   Value *Op0 = I->getOperand(0);
 670   unsigned SrcReg = 0;
 671
 672   // Yay type legalization
 673   EVT VT;
 674   if (!isLoadTypeLegal(I->getOperand(0)->getType(), VT))
 675     return false;
 676
 677   // Get the value to be stored into a register.
 678   SrcReg = getRegForValue(Op0);
 679   if (SrcReg == 0)
 680     return false;
 681
 682   // If we're an alloca we know we have a frame index and can emit the store
 683   // quickly.
 684   if (ARMStoreAlloca(I, SrcReg, VT))
 685     return true;
 686
 687   // Our register and offset with innocuous defaults.
 688   unsigned Reg = 0;
 689   int Offset = 0;
 690
 691   // See if we can handle this as Reg + Offset
 692   if (!ARMComputeRegOffset(I->getOperand(1), Reg, Offset))
 693     return false;
 694
 695   if (!ARMEmitStore(VT, SrcReg, Reg, Offset /* 0 */)) return false;
 696
 697   return true;
 698 }
 699
 700 static ARMCC::CondCodes getComparePred(CmpInst::Predicate Pred) {
 701   switch (Pred) {
 702     // Needs two compares...
 703     case CmpInst::FCMP_ONE:
 704     case CmpInst::FCMP_UEQ:
 705     default:
 706       assert(false && "Unhandled CmpInst::Predicate!");
 707       return ARMCC::AL;
 708     case CmpInst::ICMP_EQ:
 709     case CmpInst::FCMP_OEQ:
 710       return ARMCC::EQ;
 711     case CmpInst::ICMP_SGT:
 712     case CmpInst::FCMP_OGT:
 713       return ARMCC::GT;
 714     case CmpInst::ICMP_SGE:
 715     case CmpInst::FCMP_OGE:
 716       return ARMCC::GE;
 717     case CmpInst::ICMP_UGT:
 718     case CmpInst::FCMP_UGT:
 719       return ARMCC::HI;
 720     case CmpInst::FCMP_OLT:
 721       return ARMCC::MI;
 722     case CmpInst::ICMP_ULE:
 723     case CmpInst::FCMP_OLE:
 724       return ARMCC::LS;
 725     case CmpInst::FCMP_ORD:
 726       return ARMCC::VC;
 727     case CmpInst::FCMP_UNO:
 728       return ARMCC::VS;
 729     case CmpInst::FCMP_UGE:
 730       return ARMCC::PL;
 731     case CmpInst::ICMP_SLT:
 732     case CmpInst::FCMP_ULT:
 733       return ARMCC::LT;
 734     case CmpInst::ICMP_SLE:
 735     case CmpInst::FCMP_ULE:
 736       return ARMCC::LE;
 737     case CmpInst::FCMP_UNE:
 738     case CmpInst::ICMP_NE:
 739       return ARMCC::NE;
 740     case CmpInst::ICMP_UGE:
 741       return ARMCC::HS;
 742     case CmpInst::ICMP_ULT:
 743       return ARMCC::LO;
 744   }
 745 }
 746
 747 bool ARMFastISel::ARMSelectBranch(const Instruction *I) {
 748   const BranchInst *BI = cast<BranchInst>(I);
 749   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
 750   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
 751
 752   // Simple branch support.
 753   // TODO: Hopefully we've already handled the condition since we won't
 754   // have left an update in the value map. See the TODO below in ARMSelectCMP.
 755   Value *Cond = BI->getCondition();
 756   unsigned CondReg = getRegForValue(Cond);
 757   if (CondReg == 0) return false;
 758
 759   ARMCC::CondCodes ARMPred = ARMCC::NE;
 760   CmpInst *CI = dyn_cast<CmpInst>(Cond);
 761   if (!CI) return false;
 762
 763   // Get the compare predicate.
 764   ARMPred = getComparePred(CI->getPredicate());
 765
 766   // We may not handle every CC for now.
 767   if (ARMPred == ARMCC::AL) return false;
 768
 769   unsigned BrOpc = isThumb ? ARM::t2Bcc : ARM::Bcc;
 770   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(BrOpc))
 771                   .addMBB(TBB).addImm(ARMPred).addReg(CondReg);
 772   FastEmitBranch(FBB, DL);
 773   FuncInfo.MBB->addSuccessor(TBB);
 774   return true;
 775 }
 776
 777 bool ARMFastISel::ARMSelectCmp(const Instruction *I) {
 778   const CmpInst *CI = cast<CmpInst>(I);
 779
 780   EVT VT;
 781   const Type *Ty = CI->getOperand(0)->getType();
 782   if (!isTypeLegal(Ty, VT))
 783     return false;
 784
 785   bool isFloat = (Ty->isDoubleTy() || Ty->isFloatTy());
 786   if (isFloat && !Subtarget->hasVFP2())
 787     return false;
 788
 789   unsigned CmpOpc;
 790   unsigned DestReg;
 791   switch (VT.getSimpleVT().SimpleTy) {
 792     default: return false;
 793     // TODO: Verify compares.
 794     case MVT::f32:
 795       CmpOpc = ARM::VCMPES;
 796       DestReg = ARM::FPSCR;
 797       break;
 798     case MVT::f64:
 799       CmpOpc = ARM::VCMPED;
 800       DestReg = ARM::FPSCR;
 801       break;
 802     case MVT::i32:
 803       CmpOpc = isThumb ? ARM::t2CMPrr : ARM::CMPrr;
 804       DestReg = ARM::CPSR;
 805       break;
 806   }
 807
 808   unsigned Arg1 = getRegForValue(CI->getOperand(0));
 809   if (Arg1 == 0) return false;
 810
 811   unsigned Arg2 = getRegForValue(CI->getOperand(1));
 812   if (Arg2 == 0) return false;
 813
 814   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(CmpOpc))
 815                   .addReg(Arg1).addReg(Arg2));
 816
 817   // For floating point we need to move the result to a comparison register
 818   // that we can then use for branches.
 819   if (isFloat)
 820     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 821                             TII.get(ARM::FMSTAT)));
 822
 823   // Update the value to the implicit def reg.
 824   UpdateValueMap(I, DestReg);
 825   return true;
 826 }
 827
 828 bool ARMFastISel::ARMSelectFPExt(const Instruction *I) {
 829   // Make sure we have VFP and that we're extending float to double.
 830   if (!Subtarget->hasVFP2()) return false;
 831
 832   Value *V = I->getOperand(0);
 833   if (!I->getType()->isDoubleTy() ||
 834       !V->getType()->isFloatTy()) return false;
 835
 836   unsigned Op = getRegForValue(V);
 837   if (Op == 0) return false;
 838
 839   unsigned Result = createResultReg(ARM::DPRRegisterClass);
 840   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 841                           TII.get(ARM::VCVTDS), Result)
 842                   .addReg(Op));
 843   UpdateValueMap(I, Result);
 844   return true;
 845 }
 846
 847 bool ARMFastISel::ARMSelectFPTrunc(const Instruction *I) {
 848   // Make sure we have VFP and that we're truncating double to float.
 849   if (!Subtarget->hasVFP2()) return false;
 850
 851   Value *V = I->getOperand(0);
 852   if (!I->getType()->isFloatTy() ||
 853       !V->getType()->isDoubleTy()) return false;
 854
 855   unsigned Op = getRegForValue(V);
 856   if (Op == 0) return false;
 857
 858   unsigned Result = createResultReg(ARM::SPRRegisterClass);
 859   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 860                           TII.get(ARM::VCVTSD), Result)
 861                   .addReg(Op));
 862   UpdateValueMap(I, Result);
 863   return true;
 864 }
 865
 866 bool ARMFastISel::ARMSelectSIToFP(const Instruction *I) {
 867   // Make sure we have VFP.
 868   if (!Subtarget->hasVFP2()) return false;
 869
 870   EVT DstVT;
 871   const Type *Ty = I->getType();
 872   if (!isTypeLegal(Ty, DstVT))
 873     return false;
 874
 875   unsigned Op = getRegForValue(I->getOperand(0));
 876   if (Op == 0) return false;
 877
 878   // The conversion routine works on fp-reg to fp-reg and the operand above
 879   // was an integer, move it to the fp registers if possible.
 880   unsigned FP = ARMMoveToFPReg(DstVT, Op);
 881   if (FP == 0) return false;
 882
 883   unsigned Opc;
 884   if (Ty->isFloatTy()) Opc = ARM::VSITOS;
 885   else if (Ty->isDoubleTy()) Opc = ARM::VSITOD;
 886   else return 0;
 887
 888   unsigned ResultReg = createResultReg(TLI.getRegClassFor(DstVT));
 889   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc),
 890                           ResultReg)
 891                   .addReg(FP));
 892   UpdateValueMap(I, ResultReg);
 893   return true;
 894 }
 895
 896 bool ARMFastISel::ARMSelectFPToSI(const Instruction *I) {
 897   // Make sure we have VFP.
 898   if (!Subtarget->hasVFP2()) return false;
 899
 900   EVT DstVT;
 901   const Type *RetTy = I->getType();
 902   if (!isTypeLegal(RetTy, DstVT))
 903     return false;
 904
 905   unsigned Op = getRegForValue(I->getOperand(0));
 906   if (Op == 0) return false;
 907
 908   unsigned Opc;
 909   const Type *OpTy = I->getOperand(0)->getType();
 910   if (OpTy->isFloatTy()) Opc = ARM::VTOSIZS;
 911   else if (OpTy->isDoubleTy()) Opc = ARM::VTOSIZD;
 912   else return 0;
 913   EVT OpVT = TLI.getValueType(OpTy, true);
 914
 915   unsigned ResultReg = createResultReg(TLI.getRegClassFor(OpVT));
 916   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc),
 917                           ResultReg)
 918                   .addReg(Op));
 919
 920   // This result needs to be in an integer register, but the conversion only
 921   // takes place in fp-regs.
 922   unsigned IntReg = ARMMoveToIntReg(DstVT, ResultReg);
 923   if (IntReg == 0) return false;
 924
 925   UpdateValueMap(I, IntReg);
 926   return true;
 927 }
 928
 929 bool ARMFastISel::ARMSelectBinaryOp(const Instruction *I, unsigned ISDOpcode) {
 930   EVT VT  = TLI.getValueType(I->getType(), true);
 931
 932   // We can get here in the case when we want to use NEON for our fp
 933   // operations, but can't figure out how to. Just use the vfp instructions
 934   // if we have them.
 935   // FIXME: It'd be nice to use NEON instructions.
 936   const Type *Ty = I->getType();
 937   bool isFloat = (Ty->isDoubleTy() || Ty->isFloatTy());
 938   if (isFloat && !Subtarget->hasVFP2())
 939     return false;
 940
 941   unsigned Op1 = getRegForValue(I->getOperand(0));
 942   if (Op1 == 0) return false;
 943
 944   unsigned Op2 = getRegForValue(I->getOperand(1));
 945   if (Op2 == 0) return false;
 946
 947   unsigned Opc;
 948   bool is64bit = VT.getSimpleVT().SimpleTy == MVT::f64 ||
 949                  VT.getSimpleVT().SimpleTy == MVT::i64;
 950   switch (ISDOpcode) {
 951     default: return false;
 952     case ISD::FADD:
 953       Opc = is64bit ? ARM::VADDD : ARM::VADDS;
 954       break;
 955     case ISD::FSUB:
 956       Opc = is64bit ? ARM::VSUBD : ARM::VSUBS;
 957       break;
 958     case ISD::FMUL:
 959       Opc = is64bit ? ARM::VMULD : ARM::VMULS;
 960       break;
 961   }
 962   unsigned ResultReg = createResultReg(TLI.getRegClassFor(VT));
 963   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 964                           TII.get(Opc), ResultReg)
 965                   .addReg(Op1).addReg(Op2));
 966   UpdateValueMap(I, ResultReg);
 967   return true;
 968 }
 969
 970 // Call Handling Code
 971
 972 // This is largely taken directly from CCAssignFnForNode - we don't support
 973 // varargs in FastISel so that part has been removed.
 974 // TODO: We may not support all of this.
 975 CCAssignFn *ARMFastISel::CCAssignFnForCall(CallingConv::ID CC, bool Return) {
 976   switch (CC) {
 977   default:
 978     llvm_unreachable("Unsupported calling convention");
 979   case CallingConv::C:
 980   case CallingConv::Fast:
 981     // Use target triple & subtarget features to do actual dispatch.
 982     if (Subtarget->isAAPCS_ABI()) {
 983       if (Subtarget->hasVFP2() &&
 984           FloatABIType == FloatABI::Hard)
 985         return (Return ? RetCC_ARM_AAPCS_VFP: CC_ARM_AAPCS_VFP);
 986       else
 987         return (Return ? RetCC_ARM_AAPCS: CC_ARM_AAPCS);
 988     } else
 989         return (Return ? RetCC_ARM_APCS: CC_ARM_APCS);
 990   case CallingConv::ARM_AAPCS_VFP:
 991     return (Return ? RetCC_ARM_AAPCS_VFP: CC_ARM_AAPCS_VFP);
 992   case CallingConv::ARM_AAPCS:
 993     return (Return ? RetCC_ARM_AAPCS: CC_ARM_AAPCS);
 994   case CallingConv::ARM_APCS:
 995     return (Return ? RetCC_ARM_APCS: CC_ARM_APCS);
 996   }
 997 }
 998
 999 // A quick function that will emit a call for a named libcall in F with the
1000 // vector of passed arguments for the Instruction in I. We can assume that we
1001 // can emit a call for any libcall we can produce. This is an abridged version
1002 // of the full call infrastructure since we won't need to worry about things
1003 // like computed function pointers or strange arguments at call sites.
1004 // TODO: Try to unify this and the normal call bits for ARM, then try to unify
1005 // with X86.
1006 bool ARMFastISel::ARMEmitLibcall(const Instruction *I, Function *F) {
1007   CallingConv::ID CC = F->getCallingConv();
1008
1009   // Handle *simple* calls for now.
1010   const Type *RetTy = F->getReturnType();
1011   EVT RetVT;
1012   if (RetTy->isVoidTy())
1013     RetVT = MVT::isVoid;
1014   else if (!isTypeLegal(RetTy, RetVT))
1015     return false;
1016
1017   assert(!F->isVarArg() && "Vararg libcall?!");
1018
1019   // Abridged from the X86 FastISel call selection mechanism
1020   SmallVector<Value*, 8> Args;
1021   SmallVector<unsigned, 8> ArgRegs;
1022   SmallVector<EVT, 8> ArgVTs;
1023   SmallVector<ISD::ArgFlagsTy, 8> ArgFlags;
1024   Args.reserve(I->getNumOperands());
1025   ArgRegs.reserve(I->getNumOperands());
1026   ArgVTs.reserve(I->getNumOperands());
1027   ArgFlags.reserve(I->getNumOperands());
1028   for (unsigned i = 0; i < Args.size(); ++i) {
1029     Value *Op = I->getOperand(i);
1030     unsigned Arg = getRegForValue(Op);
1031     if (Arg == 0) return false;
1032
1033     const Type *ArgTy = Op->getType();
1034     EVT ArgVT;
1035     if (!isTypeLegal(ArgTy, ArgVT)) return false;
1036
1037     ISD::ArgFlagsTy Flags;
1038     unsigned OriginalAlignment = TD.getABITypeAlignment(ArgTy);
1039     Flags.setOrigAlign(OriginalAlignment);
1040
1041     Args.push_back(Op);
1042     ArgRegs.push_back(Arg);
1043     ArgVTs.push_back(ArgVT);
1044     ArgFlags.push_back(Flags);
1045   }
1046
1047   SmallVector<CCValAssign, 16> ArgLocs;
1048   CCState CCInfo(CC, false, TM, ArgLocs, F->getContext());
1049   CCInfo.AnalyzeCallOperands(ArgVTs, ArgFlags, CCAssignFnForCall(CC, false));
1050
1051   // Process the args.
1052   SmallVector<unsigned, 4> RegArgs;
1053   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1054     CCValAssign &VA = ArgLocs[i];
1055     unsigned Arg = ArgRegs[VA.getValNo()];
1056     EVT ArgVT = ArgVTs[VA.getValNo()];
1057
1058     // Should we ever have to promote?
1059     switch (VA.getLocInfo()) {
1060       case CCValAssign::Full: break;
1061       default:
1062         assert(false && "Handle arg promotion for libcalls?");
1063         return false;
1064     }
1065
1066     // Now copy/store arg to correct locations.
1067     if (VA.isRegLoc()) {
1068       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY),
1069         VA.getLocReg()).addReg(Arg);
1070       RegArgs.push_back(VA.getLocReg());
1071     } else {
1072       // Need to store
1073       return false;
1074     }
1075   }
1076
1077   // Issue the call, BLr9 for darwin, BL otherwise.
1078   MachineInstrBuilder MIB;
1079   unsigned CallOpc = Subtarget->isTargetDarwin() ? ARM::BLr9 : ARM::BL;
1080   MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(CallOpc))
1081         .addGlobalAddress(F, 0, 0);
1082
1083   // Add implicit physical register uses to the call.
1084   for (unsigned i = 0, e = RegArgs.size(); i != e; ++i)
1085     MIB.addReg(RegArgs[i]);
1086
1087   // Now the return value.
1088   SmallVector<unsigned, 4> UsedRegs;
1089   if (RetVT.getSimpleVT().SimpleTy != MVT::isVoid) {
1090     SmallVector<CCValAssign, 16> RVLocs;
1091     CCState CCInfo(CC, false, TM, RVLocs, F->getContext());
1092     CCInfo.AnalyzeCallResult(RetVT, CCAssignFnForCall(CC, true));
1093
1094     // Copy all of the result registers out of their specified physreg.
1095     assert(RVLocs.size() == 1 && "Can't handle multi-value calls!");
1096     EVT CopyVT = RVLocs[0].getValVT();
1097     TargetRegisterClass* DstRC = TLI.getRegClassFor(CopyVT);
1098
1099     unsigned ResultReg = createResultReg(DstRC);
1100     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY),
1101             ResultReg).addReg(RVLocs[0].getLocReg());
1102     UsedRegs.push_back(RVLocs[0].getLocReg());
1103
1104     // Finally update the result.
1105     UpdateValueMap(I, ResultReg);
1106   }
1107
1108   // Set all unused physreg defs as dead.
1109   static_cast<MachineInstr *>(MIB)->setPhysRegsDeadExcept(UsedRegs, TRI);
1110
1111   return true;
1112 }
1113
1114 bool ARMFastISel::ARMSelectSDiv(const Instruction *I) {
1115   EVT VT;
1116   const Type *Ty = I->getType();
1117   if (!isTypeLegal(Ty, VT))
1118     return false;
1119
1120   // If we have integer div support we should have gotten already, emit a
1121   // libcall.
1122   RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
1123   if (VT == MVT::i16)
1124     LC = RTLIB::SDIV_I16;
1125   else if (VT == MVT::i32)
1126     LC = RTLIB::SDIV_I32;
1127   else if (VT == MVT::i64)
1128     LC = RTLIB::SDIV_I64;
1129   else if (VT == MVT::i128)
1130     LC = RTLIB::SDIV_I128;
1131   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported SDIV!");
1132
1133   // Binary operand with all the same type.
1134   std::vector<const Type*> ArgTys;
1135   ArgTys.push_back(Ty);
1136   ArgTys.push_back(Ty);
1137   const FunctionType *FTy = FunctionType::get(Ty, ArgTys, false);
1138   Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage,
1139                                  TLI.getLibcallName(LC));
1140   if (Subtarget->isAAPCS_ABI())
1141     F->setCallingConv(CallingConv::ARM_AAPCS);
1142   else
1143     F->setCallingConv(I->getParent()->getParent()->getCallingConv());
1144
1145   return ARMEmitLibcall(I, F);
1146 }
1147
1148 // TODO: SoftFP support.
1149 bool ARMFastISel::TargetSelectInstruction(const Instruction *I) {
1150   // No Thumb-1 for now.
1151   if (isThumb && !AFI->isThumb2Function()) return false;
1152
1153   switch (I->getOpcode()) {
1154     case Instruction::Load:
1155       return ARMSelectLoad(I);
1156     case Instruction::Store:
1157       return ARMSelectStore(I);
1158     case Instruction::Br:
1159       return ARMSelectBranch(I);
1160     case Instruction::ICmp:
1161     case Instruction::FCmp:
1162       return ARMSelectCmp(I);
1163     case Instruction::FPExt:
1164       return ARMSelectFPExt(I);
1165     case Instruction::FPTrunc:
1166       return ARMSelectFPTrunc(I);
1167     case Instruction::SIToFP:
1168       return ARMSelectSIToFP(I);
1169     case Instruction::FPToSI:
1170       return ARMSelectFPToSI(I);
1171     case Instruction::FAdd:
1172       return ARMSelectBinaryOp(I, ISD::FADD);
1173     case Instruction::FSub:
1174       return ARMSelectBinaryOp(I, ISD::FSUB);
1175     case Instruction::FMul:
1176       return ARMSelectBinaryOp(I, ISD::FMUL);
1177     case Instruction::SDiv:
1178       return ARMSelectSDiv(I);
1179     default: break;
1180   }
1181   return false;
1182 }
1183
1184 namespace llvm {
1185   llvm::FastISel *ARM::createFastISel(FunctionLoweringInfo &funcInfo) {
1186     if (EnableARMFastISel) return new ARMFastISel(funcInfo);
1187     return 0;
1188   }
1189 }