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   bool isFloat = false;
 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     case MVT::f32:
 575       Opc = ARM::VLDRS;
 576       isFloat = true;
 577       break;
 578     case MVT::f64:
 579       Opc = ARM::VLDRD;
 580       isFloat = true;
 581       break;
 582   }
 583
 584   ResultReg = createResultReg(TLI.getRegClassFor(VT));
 585
 586   // TODO: Fix the Addressing modes so that these can share some code.
 587   // Since this is a Thumb1 load this will work in Thumb1 or 2 mode.
 588   // The thumb addressing mode has operands swapped from the arm addressing
 589   // mode, the floating point one only has two operands.
 590   if (isFloat)
 591     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 592                             TII.get(Opc), ResultReg)
 593                     .addReg(Reg).addImm(Offset));
 594   else if (isThumb)
 595     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 596                             TII.get(Opc), ResultReg)
 597                     .addReg(Reg).addImm(Offset).addReg(0));
 598   else
 599     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 600                             TII.get(Opc), ResultReg)
 601                     .addReg(Reg).addReg(0).addImm(Offset));
 602   return true;
 603 }
 604
 605 bool ARMFastISel::ARMSelectLoad(const Instruction *I) {
 606   // Verify we have a legal type before going any further.
 607   EVT VT;
 608   if (!isLoadTypeLegal(I->getType(), VT))
 609     return false;
 610
 611   // If we're an alloca we know we have a frame index and can emit the load
 612   // directly in short order.
 613   if (ARMLoadAlloca(I, VT))
 614     return true;
 615
 616   // Our register and offset with innocuous defaults.
 617   unsigned Reg = 0;
 618   int Offset = 0;
 619
 620   // See if we can handle this as Reg + Offset
 621   if (!ARMComputeRegOffset(I->getOperand(0), Reg, Offset))
 622     return false;
 623
 624   unsigned ResultReg;
 625   if (!ARMEmitLoad(VT, ResultReg, Reg, Offset /* 0 */)) return false;
 626
 627   UpdateValueMap(I, ResultReg);
 628   return true;
 629 }
 630
 631 bool ARMFastISel::ARMStoreAlloca(const Instruction *I, unsigned SrcReg, EVT VT){
 632   Value *Op1 = I->getOperand(1);
 633
 634   // Verify it's an alloca.
 635   if (const AllocaInst *AI = dyn_cast<AllocaInst>(Op1)) {
 636     DenseMap<const AllocaInst*, int>::iterator SI =
 637       FuncInfo.StaticAllocaMap.find(AI);
 638
 639     if (SI != FuncInfo.StaticAllocaMap.end()) {
 640       TargetRegisterClass* RC = TLI.getRegClassFor(VT);
 641       assert(SrcReg != 0 && "Nothing to store!");
 642       TII.storeRegToStackSlot(*FuncInfo.MBB, *FuncInfo.InsertPt,
 643                               SrcReg, true /*isKill*/, SI->second, RC,
 644                               TM.getRegisterInfo());
 645       return true;
 646     }
 647   }
 648   return false;
 649 }
 650
 651 bool ARMFastISel::ARMEmitStore(EVT VT, unsigned SrcReg,
 652                                unsigned DstReg, int Offset) {
 653   unsigned StrOpc;
 654   bool isFloat = false;
 655   switch (VT.getSimpleVT().SimpleTy) {
 656     default: return false;
 657     case MVT::i1:
 658     case MVT::i8: StrOpc = isThumb ? ARM::tSTRB : ARM::STRB; break;
 659     case MVT::i16: StrOpc = isThumb ? ARM::tSTRH : ARM::STRH; break;
 660     case MVT::i32: StrOpc = isThumb ? ARM::tSTR : ARM::STR; break;
 661     case MVT::f32:
 662       if (!Subtarget->hasVFP2()) return false;
 663       StrOpc = ARM::VSTRS;
 664       isFloat = true;
 665       break;
 666     case MVT::f64:
 667       if (!Subtarget->hasVFP2()) return false;
 668       StrOpc = ARM::VSTRD;
 669       isFloat = true;
 670       break;
 671   }
 672
 673   // The thumb addressing mode has operands swapped from the arm addressing
 674   // mode, the floating point one only has two operands.
 675   if (isFloat)
 676     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 677                             TII.get(StrOpc), SrcReg)
 678                     .addReg(DstReg).addImm(Offset));
 679   else if (isThumb)
 680     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 681                             TII.get(StrOpc), SrcReg)
 682                     .addReg(DstReg).addImm(Offset).addReg(0));
 683
 684   else
 685     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 686                             TII.get(StrOpc), SrcReg)
 687                     .addReg(DstReg).addReg(0).addImm(Offset));
 688
 689   return true;
 690 }
 691
 692 bool ARMFastISel::ARMSelectStore(const Instruction *I) {
 693   Value *Op0 = I->getOperand(0);
 694   unsigned SrcReg = 0;
 695
 696   // Yay type legalization
 697   EVT VT;
 698   if (!isLoadTypeLegal(I->getOperand(0)->getType(), VT))
 699     return false;
 700
 701   // Get the value to be stored into a register.
 702   SrcReg = getRegForValue(Op0);
 703   if (SrcReg == 0)
 704     return false;
 705
 706   // If we're an alloca we know we have a frame index and can emit the store
 707   // quickly.
 708   if (ARMStoreAlloca(I, SrcReg, VT))
 709     return true;
 710
 711   // Our register and offset with innocuous defaults.
 712   unsigned Reg = 0;
 713   int Offset = 0;
 714
 715   // See if we can handle this as Reg + Offset
 716   if (!ARMComputeRegOffset(I->getOperand(1), Reg, Offset))
 717     return false;
 718
 719   if (!ARMEmitStore(VT, SrcReg, Reg, Offset /* 0 */)) return false;
 720
 721   return true;
 722 }
 723
 724 static ARMCC::CondCodes getComparePred(CmpInst::Predicate Pred) {
 725   switch (Pred) {
 726     // Needs two compares...
 727     case CmpInst::FCMP_ONE:
 728     case CmpInst::FCMP_UEQ:
 729     default:
 730       assert(false && "Unhandled CmpInst::Predicate!");
 731       return ARMCC::AL;
 732     case CmpInst::ICMP_EQ:
 733     case CmpInst::FCMP_OEQ:
 734       return ARMCC::EQ;
 735     case CmpInst::ICMP_SGT:
 736     case CmpInst::FCMP_OGT:
 737       return ARMCC::GT;
 738     case CmpInst::ICMP_SGE:
 739     case CmpInst::FCMP_OGE:
 740       return ARMCC::GE;
 741     case CmpInst::ICMP_UGT:
 742     case CmpInst::FCMP_UGT:
 743       return ARMCC::HI;
 744     case CmpInst::FCMP_OLT:
 745       return ARMCC::MI;
 746     case CmpInst::ICMP_ULE:
 747     case CmpInst::FCMP_OLE:
 748       return ARMCC::LS;
 749     case CmpInst::FCMP_ORD:
 750       return ARMCC::VC;
 751     case CmpInst::FCMP_UNO:
 752       return ARMCC::VS;
 753     case CmpInst::FCMP_UGE:
 754       return ARMCC::PL;
 755     case CmpInst::ICMP_SLT:
 756     case CmpInst::FCMP_ULT:
 757       return ARMCC::LT;
 758     case CmpInst::ICMP_SLE:
 759     case CmpInst::FCMP_ULE:
 760       return ARMCC::LE;
 761     case CmpInst::FCMP_UNE:
 762     case CmpInst::ICMP_NE:
 763       return ARMCC::NE;
 764     case CmpInst::ICMP_UGE:
 765       return ARMCC::HS;
 766     case CmpInst::ICMP_ULT:
 767       return ARMCC::LO;
 768   }
 769 }
 770
 771 bool ARMFastISel::ARMSelectBranch(const Instruction *I) {
 772   const BranchInst *BI = cast<BranchInst>(I);
 773   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
 774   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
 775
 776   // Simple branch support.
 777   // TODO: Hopefully we've already handled the condition since we won't
 778   // have left an update in the value map. See the TODO below in ARMSelectCMP.
 779   Value *Cond = BI->getCondition();
 780   unsigned CondReg = getRegForValue(Cond);
 781   if (CondReg == 0) return false;
 782
 783   ARMCC::CondCodes ARMPred = ARMCC::NE;
 784   CmpInst *CI = dyn_cast<CmpInst>(Cond);
 785   if (!CI) return false;
 786
 787   // Get the compare predicate.
 788   ARMPred = getComparePred(CI->getPredicate());
 789
 790   // We may not handle every CC for now.
 791   if (ARMPred == ARMCC::AL) return false;
 792
 793   unsigned BrOpc = isThumb ? ARM::t2Bcc : ARM::Bcc;
 794   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(BrOpc))
 795                   .addMBB(TBB).addImm(ARMPred).addReg(CondReg);
 796   FastEmitBranch(FBB, DL);
 797   FuncInfo.MBB->addSuccessor(TBB);
 798   return true;
 799 }
 800
 801 bool ARMFastISel::ARMSelectCmp(const Instruction *I) {
 802   const CmpInst *CI = cast<CmpInst>(I);
 803
 804   EVT VT;
 805   const Type *Ty = CI->getOperand(0)->getType();
 806   if (!isTypeLegal(Ty, VT))
 807     return false;
 808
 809   bool isFloat = (Ty->isDoubleTy() || Ty->isFloatTy());
 810   if (isFloat && !Subtarget->hasVFP2())
 811     return false;
 812
 813   unsigned CmpOpc;
 814   unsigned DestReg;
 815   switch (VT.getSimpleVT().SimpleTy) {
 816     default: return false;
 817     // TODO: Verify compares.
 818     case MVT::f32:
 819       CmpOpc = ARM::VCMPES;
 820       DestReg = ARM::FPSCR;
 821       break;
 822     case MVT::f64:
 823       CmpOpc = ARM::VCMPED;
 824       DestReg = ARM::FPSCR;
 825       break;
 826     case MVT::i32:
 827       CmpOpc = isThumb ? ARM::t2CMPrr : ARM::CMPrr;
 828       DestReg = ARM::CPSR;
 829       break;
 830   }
 831
 832   unsigned Arg1 = getRegForValue(CI->getOperand(0));
 833   if (Arg1 == 0) return false;
 834
 835   unsigned Arg2 = getRegForValue(CI->getOperand(1));
 836   if (Arg2 == 0) return false;
 837
 838   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(CmpOpc))
 839                   .addReg(Arg1).addReg(Arg2));
 840
 841   // For floating point we need to move the result to a comparison register
 842   // that we can then use for branches.
 843   if (isFloat)
 844     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 845                             TII.get(ARM::FMSTAT)));
 846
 847   // Update the value to the implicit def reg.
 848   UpdateValueMap(I, DestReg);
 849   return true;
 850 }
 851
 852 bool ARMFastISel::ARMSelectFPExt(const Instruction *I) {
 853   // Make sure we have VFP and that we're extending float to double.
 854   if (!Subtarget->hasVFP2()) return false;
 855
 856   Value *V = I->getOperand(0);
 857   if (!I->getType()->isDoubleTy() ||
 858       !V->getType()->isFloatTy()) return false;
 859
 860   unsigned Op = getRegForValue(V);
 861   if (Op == 0) return false;
 862
 863   unsigned Result = createResultReg(ARM::DPRRegisterClass);
 864   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 865                           TII.get(ARM::VCVTDS), Result)
 866                   .addReg(Op));
 867   UpdateValueMap(I, Result);
 868   return true;
 869 }
 870
 871 bool ARMFastISel::ARMSelectFPTrunc(const Instruction *I) {
 872   // Make sure we have VFP and that we're truncating double to float.
 873   if (!Subtarget->hasVFP2()) return false;
 874
 875   Value *V = I->getOperand(0);
 876   if (!I->getType()->isFloatTy() ||
 877       !V->getType()->isDoubleTy()) return false;
 878
 879   unsigned Op = getRegForValue(V);
 880   if (Op == 0) return false;
 881
 882   unsigned Result = createResultReg(ARM::SPRRegisterClass);
 883   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 884                           TII.get(ARM::VCVTSD), Result)
 885                   .addReg(Op));
 886   UpdateValueMap(I, Result);
 887   return true;
 888 }
 889
 890 bool ARMFastISel::ARMSelectSIToFP(const Instruction *I) {
 891   // Make sure we have VFP.
 892   if (!Subtarget->hasVFP2()) return false;
 893
 894   EVT DstVT;
 895   const Type *Ty = I->getType();
 896   if (!isTypeLegal(Ty, DstVT))
 897     return false;
 898
 899   unsigned Op = getRegForValue(I->getOperand(0));
 900   if (Op == 0) return false;
 901
 902   // The conversion routine works on fp-reg to fp-reg and the operand above
 903   // was an integer, move it to the fp registers if possible.
 904   unsigned FP = ARMMoveToFPReg(DstVT, Op);
 905   if (FP == 0) return false;
 906
 907   unsigned Opc;
 908   if (Ty->isFloatTy()) Opc = ARM::VSITOS;
 909   else if (Ty->isDoubleTy()) Opc = ARM::VSITOD;
 910   else return 0;
 911
 912   unsigned ResultReg = createResultReg(TLI.getRegClassFor(DstVT));
 913   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc),
 914                           ResultReg)
 915                   .addReg(FP));
 916   UpdateValueMap(I, ResultReg);
 917   return true;
 918 }
 919
 920 bool ARMFastISel::ARMSelectFPToSI(const Instruction *I) {
 921   // Make sure we have VFP.
 922   if (!Subtarget->hasVFP2()) return false;
 923
 924   EVT DstVT;
 925   const Type *RetTy = I->getType();
 926   if (!isTypeLegal(RetTy, DstVT))
 927     return false;
 928
 929   unsigned Op = getRegForValue(I->getOperand(0));
 930   if (Op == 0) return false;
 931
 932   unsigned Opc;
 933   const Type *OpTy = I->getOperand(0)->getType();
 934   if (OpTy->isFloatTy()) Opc = ARM::VTOSIZS;
 935   else if (OpTy->isDoubleTy()) Opc = ARM::VTOSIZD;
 936   else return 0;
 937   EVT OpVT = TLI.getValueType(OpTy, true);
 938
 939   unsigned ResultReg = createResultReg(TLI.getRegClassFor(OpVT));
 940   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(Opc),
 941                           ResultReg)
 942                   .addReg(Op));
 943
 944   // This result needs to be in an integer register, but the conversion only
 945   // takes place in fp-regs.
 946   unsigned IntReg = ARMMoveToIntReg(DstVT, ResultReg);
 947   if (IntReg == 0) return false;
 948
 949   UpdateValueMap(I, IntReg);
 950   return true;
 951 }
 952
 953 bool ARMFastISel::ARMSelectBinaryOp(const Instruction *I, unsigned ISDOpcode) {
 954   EVT VT  = TLI.getValueType(I->getType(), true);
 955
 956   // We can get here in the case when we want to use NEON for our fp
 957   // operations, but can't figure out how to. Just use the vfp instructions
 958   // if we have them.
 959   // FIXME: It'd be nice to use NEON instructions.
 960   const Type *Ty = I->getType();
 961   bool isFloat = (Ty->isDoubleTy() || Ty->isFloatTy());
 962   if (isFloat && !Subtarget->hasVFP2())
 963     return false;
 964
 965   unsigned Op1 = getRegForValue(I->getOperand(0));
 966   if (Op1 == 0) return false;
 967
 968   unsigned Op2 = getRegForValue(I->getOperand(1));
 969   if (Op2 == 0) return false;
 970
 971   unsigned Opc;
 972   bool is64bit = VT.getSimpleVT().SimpleTy == MVT::f64 ||
 973                  VT.getSimpleVT().SimpleTy == MVT::i64;
 974   switch (ISDOpcode) {
 975     default: return false;
 976     case ISD::FADD:
 977       Opc = is64bit ? ARM::VADDD : ARM::VADDS;
 978       break;
 979     case ISD::FSUB:
 980       Opc = is64bit ? ARM::VSUBD : ARM::VSUBS;
 981       break;
 982     case ISD::FMUL:
 983       Opc = is64bit ? ARM::VMULD : ARM::VMULS;
 984       break;
 985   }
 986   unsigned ResultReg = createResultReg(TLI.getRegClassFor(VT));
 987   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 988                           TII.get(Opc), ResultReg)
 989                   .addReg(Op1).addReg(Op2));
 990   UpdateValueMap(I, ResultReg);
 991   return true;
 992 }
 993
 994 // Call Handling Code
 995
 996 // This is largely taken directly from CCAssignFnForNode - we don't support
 997 // varargs in FastISel so that part has been removed.
 998 // TODO: We may not support all of this.
 999 CCAssignFn *ARMFastISel::CCAssignFnForCall(CallingConv::ID CC, bool Return) {
1000   switch (CC) {
1001   default:
1002     llvm_unreachable("Unsupported calling convention");
1003   case CallingConv::C:
1004   case CallingConv::Fast:
1005     // Use target triple & subtarget features to do actual dispatch.
1006     if (Subtarget->isAAPCS_ABI()) {
1007       if (Subtarget->hasVFP2() &&
1008           FloatABIType == FloatABI::Hard)
1009         return (Return ? RetCC_ARM_AAPCS_VFP: CC_ARM_AAPCS_VFP);
1010       else
1011         return (Return ? RetCC_ARM_AAPCS: CC_ARM_AAPCS);
1012     } else
1013         return (Return ? RetCC_ARM_APCS: CC_ARM_APCS);
1014   case CallingConv::ARM_AAPCS_VFP:
1015     return (Return ? RetCC_ARM_AAPCS_VFP: CC_ARM_AAPCS_VFP);
1016   case CallingConv::ARM_AAPCS:
1017     return (Return ? RetCC_ARM_AAPCS: CC_ARM_AAPCS);
1018   case CallingConv::ARM_APCS:
1019     return (Return ? RetCC_ARM_APCS: CC_ARM_APCS);
1020   }
1021 }
1022
1023 // A quick function that will emit a call for a named libcall in F with the
1024 // vector of passed arguments for the Instruction in I. We can assume that we
1025 // can emit a call for any libcall we can produce. This is an abridged version
1026 // of the full call infrastructure since we won't need to worry about things
1027 // like computed function pointers or strange arguments at call sites.
1028 // TODO: Try to unify this and the normal call bits for ARM, then try to unify
1029 // with X86.
1030 bool ARMFastISel::ARMEmitLibcall(const Instruction *I, Function *F) {
1031   CallingConv::ID CC = F->getCallingConv();
1032
1033   // Handle *simple* calls for now.
1034   const Type *RetTy = F->getReturnType();
1035   EVT RetVT;
1036   if (RetTy->isVoidTy())
1037     RetVT = MVT::isVoid;
1038   else if (!isTypeLegal(RetTy, RetVT))
1039     return false;
1040
1041   assert(!F->isVarArg() && "Vararg libcall?!");
1042
1043   // Abridged from the X86 FastISel call selection mechanism
1044   SmallVector<Value*, 8> Args;
1045   SmallVector<unsigned, 8> ArgRegs;
1046   SmallVector<EVT, 8> ArgVTs;
1047   SmallVector<ISD::ArgFlagsTy, 8> ArgFlags;
1048   Args.reserve(I->getNumOperands());
1049   ArgRegs.reserve(I->getNumOperands());
1050   ArgVTs.reserve(I->getNumOperands());
1051   ArgFlags.reserve(I->getNumOperands());
1052   for (unsigned i = 0; i < Args.size(); ++i) {
1053     Value *Op = I->getOperand(i);
1054     unsigned Arg = getRegForValue(Op);
1055     if (Arg == 0) return false;
1056
1057     const Type *ArgTy = Op->getType();
1058     EVT ArgVT;
1059     if (!isTypeLegal(ArgTy, ArgVT)) return false;
1060
1061     ISD::ArgFlagsTy Flags;
1062     unsigned OriginalAlignment = TD.getABITypeAlignment(ArgTy);
1063     Flags.setOrigAlign(OriginalAlignment);
1064
1065     Args.push_back(Op);
1066     ArgRegs.push_back(Arg);
1067     ArgVTs.push_back(ArgVT);
1068     ArgFlags.push_back(Flags);
1069   }
1070
1071   SmallVector<CCValAssign, 16> ArgLocs;
1072   CCState CCInfo(CC, false, TM, ArgLocs, F->getContext());
1073   CCInfo.AnalyzeCallOperands(ArgVTs, ArgFlags, CCAssignFnForCall(CC, false));
1074
1075   // Process the args.
1076   SmallVector<unsigned, 4> RegArgs;
1077   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1078     CCValAssign &VA = ArgLocs[i];
1079     unsigned Arg = ArgRegs[VA.getValNo()];
1080     EVT ArgVT = ArgVTs[VA.getValNo()];
1081
1082     // Should we ever have to promote?
1083     switch (VA.getLocInfo()) {
1084       case CCValAssign::Full: break;
1085       default:
1086         assert(false && "Handle arg promotion for libcalls?");
1087         return false;
1088     }
1089
1090     // Now copy/store arg to correct locations.
1091     if (VA.isRegLoc()) {
1092       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY),
1093         VA.getLocReg()).addReg(Arg);
1094       RegArgs.push_back(VA.getLocReg());
1095     } else {
1096       // Need to store
1097       return false;
1098     }
1099   }
1100
1101   // Issue the call, BLr9 for darwin, BL otherwise.
1102   MachineInstrBuilder MIB;
1103   unsigned CallOpc = Subtarget->isTargetDarwin() ? ARM::BLr9 : ARM::BL;
1104   MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(CallOpc))
1105         .addGlobalAddress(F, 0, 0);
1106
1107   // Add implicit physical register uses to the call.
1108   for (unsigned i = 0, e = RegArgs.size(); i != e; ++i)
1109     MIB.addReg(RegArgs[i]);
1110
1111   // Now the return value.
1112   SmallVector<unsigned, 4> UsedRegs;
1113   if (RetVT.getSimpleVT().SimpleTy != MVT::isVoid) {
1114     SmallVector<CCValAssign, 16> RVLocs;
1115     CCState CCInfo(CC, false, TM, RVLocs, F->getContext());
1116     CCInfo.AnalyzeCallResult(RetVT, CCAssignFnForCall(CC, true));
1117
1118     // Copy all of the result registers out of their specified physreg.
1119     assert(RVLocs.size() == 1 && "Can't handle multi-value calls!");
1120     EVT CopyVT = RVLocs[0].getValVT();
1121     TargetRegisterClass* DstRC = TLI.getRegClassFor(CopyVT);
1122
1123     unsigned ResultReg = createResultReg(DstRC);
1124     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY),
1125             ResultReg).addReg(RVLocs[0].getLocReg());
1126     UsedRegs.push_back(RVLocs[0].getLocReg());
1127
1128     // Finally update the result.
1129     UpdateValueMap(I, ResultReg);
1130   }
1131
1132   // Set all unused physreg defs as dead.
1133   static_cast<MachineInstr *>(MIB)->setPhysRegsDeadExcept(UsedRegs, TRI);
1134
1135   return true;
1136 }
1137
1138 bool ARMFastISel::ARMSelectSDiv(const Instruction *I) {
1139   EVT VT;
1140   const Type *Ty = I->getType();
1141   if (!isTypeLegal(Ty, VT))
1142     return false;
1143
1144   // If we have integer div support we should have gotten already, emit a
1145   // libcall.
1146   RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
1147   if (VT == MVT::i16)
1148     LC = RTLIB::SDIV_I16;
1149   else if (VT == MVT::i32)
1150     LC = RTLIB::SDIV_I32;
1151   else if (VT == MVT::i64)
1152     LC = RTLIB::SDIV_I64;
1153   else if (VT == MVT::i128)
1154     LC = RTLIB::SDIV_I128;
1155   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported SDIV!");
1156
1157   // Binary operand with all the same type.
1158   std::vector<const Type*> ArgTys;
1159   ArgTys.push_back(Ty);
1160   ArgTys.push_back(Ty);
1161   const FunctionType *FTy = FunctionType::get(Ty, ArgTys, false);
1162   Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage,
1163                                  TLI.getLibcallName(LC));
1164   if (Subtarget->isAAPCS_ABI())
1165     F->setCallingConv(CallingConv::ARM_AAPCS);
1166   else
1167     F->setCallingConv(I->getParent()->getParent()->getCallingConv());
1168
1169   return ARMEmitLibcall(I, F);
1170 }
1171
1172 // TODO: SoftFP support.
1173 bool ARMFastISel::TargetSelectInstruction(const Instruction *I) {
1174   // No Thumb-1 for now.
1175   if (isThumb && !AFI->isThumb2Function()) return false;
1176
1177   switch (I->getOpcode()) {
1178     case Instruction::Load:
1179       return ARMSelectLoad(I);
1180     case Instruction::Store:
1181       return ARMSelectStore(I);
1182     case Instruction::Br:
1183       return ARMSelectBranch(I);
1184     case Instruction::ICmp:
1185     case Instruction::FCmp:
1186       return ARMSelectCmp(I);
1187     case Instruction::FPExt:
1188       return ARMSelectFPExt(I);
1189     case Instruction::FPTrunc:
1190       return ARMSelectFPTrunc(I);
1191     case Instruction::SIToFP:
1192       return ARMSelectSIToFP(I);
1193     case Instruction::FPToSI:
1194       return ARMSelectFPToSI(I);
1195     case Instruction::FAdd:
1196       return ARMSelectBinaryOp(I, ISD::FADD);
1197     case Instruction::FSub:
1198       return ARMSelectBinaryOp(I, ISD::FSUB);
1199     case Instruction::FMul:
1200       return ARMSelectBinaryOp(I, ISD::FMUL);
1201     case Instruction::SDiv:
1202       return ARMSelectSDiv(I);
1203     default: break;
1204   }
1205   return false;
1206 }
1207
1208 namespace llvm {
1209   llvm::FastISel *ARM::createFastISel(FunctionLoweringInfo &funcInfo) {
1210     if (EnableARMFastISel) return new ARMFastISel(funcInfo);
1211     return 0;
1212   }
1213 }