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 "ARMRegisterInfo.h"
  19 #include "ARMTargetMachine.h"
  20 #include "ARMSubtarget.h"
  21 #include "llvm/CallingConv.h"
  22 #include "llvm/DerivedTypes.h"
  23 #include "llvm/GlobalVariable.h"
  24 #include "llvm/Instructions.h"
  25 #include "llvm/IntrinsicInst.h"
  26 #include "llvm/CodeGen/Analysis.h"
  27 #include "llvm/CodeGen/FastISel.h"
  28 #include "llvm/CodeGen/FunctionLoweringInfo.h"
  29 #include "llvm/CodeGen/MachineInstrBuilder.h"
  30 #include "llvm/CodeGen/MachineModuleInfo.h"
  31 #include "llvm/CodeGen/MachineConstantPool.h"
  32 #include "llvm/CodeGen/MachineFrameInfo.h"
  33 #include "llvm/CodeGen/MachineRegisterInfo.h"
  34 #include "llvm/Support/CallSite.h"
  35 #include "llvm/Support/CommandLine.h"
  36 #include "llvm/Support/ErrorHandling.h"
  37 #include "llvm/Support/GetElementPtrTypeIterator.h"
  38 #include "llvm/Target/TargetData.h"
  39 #include "llvm/Target/TargetInstrInfo.h"
  40 #include "llvm/Target/TargetLowering.h"
  41 #include "llvm/Target/TargetMachine.h"
  42 #include "llvm/Target/TargetOptions.h"
  43 using namespace llvm;
  44
  45 static cl::opt<bool>
  46 EnableARMFastISel("arm-fast-isel",
  47                   cl::desc("Turn on experimental ARM fast-isel support"),
  48                   cl::init(false), cl::Hidden);
  49
  50 namespace {
  51
  52 class ARMFastISel : public FastISel {
  53
  54   /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can
  55   /// make the right decision when generating code for different targets.
  56   const ARMSubtarget *Subtarget;
  57   const TargetMachine &TM;
  58   const TargetInstrInfo &TII;
  59   const TargetLowering &TLI;
  60   const ARMFunctionInfo *AFI;
  61
  62   // Convenience variable to avoid checking all the time.
  63   bool isThumb;
  64
  65   public:
  66     explicit ARMFastISel(FunctionLoweringInfo &funcInfo)
  67     : FastISel(funcInfo),
  68       TM(funcInfo.MF->getTarget()),
  69       TII(*TM.getInstrInfo()),
  70       TLI(*TM.getTargetLowering()) {
  71       Subtarget = &TM.getSubtarget<ARMSubtarget>();
  72       AFI = funcInfo.MF->getInfo<ARMFunctionInfo>();
  73       isThumb = AFI->isThumbFunction();
  74     }
  75
  76     // Code from FastISel.cpp.
  77     virtual unsigned FastEmitInst_(unsigned MachineInstOpcode,
  78                                    const TargetRegisterClass *RC);
  79     virtual unsigned FastEmitInst_r(unsigned MachineInstOpcode,
  80                                     const TargetRegisterClass *RC,
  81                                     unsigned Op0, bool Op0IsKill);
  82     virtual unsigned FastEmitInst_rr(unsigned MachineInstOpcode,
  83                                      const TargetRegisterClass *RC,
  84                                      unsigned Op0, bool Op0IsKill,
  85                                      unsigned Op1, bool Op1IsKill);
  86     virtual unsigned FastEmitInst_ri(unsigned MachineInstOpcode,
  87                                      const TargetRegisterClass *RC,
  88                                      unsigned Op0, bool Op0IsKill,
  89                                      uint64_t Imm);
  90     virtual unsigned FastEmitInst_rf(unsigned MachineInstOpcode,
  91                                      const TargetRegisterClass *RC,
  92                                      unsigned Op0, bool Op0IsKill,
  93                                      const ConstantFP *FPImm);
  94     virtual unsigned FastEmitInst_i(unsigned MachineInstOpcode,
  95                                     const TargetRegisterClass *RC,
  96                                     uint64_t Imm);
  97     virtual unsigned FastEmitInst_rri(unsigned MachineInstOpcode,
  98                                       const TargetRegisterClass *RC,
  99                                       unsigned Op0, bool Op0IsKill,
 100                                       unsigned Op1, bool Op1IsKill,
 101                                       uint64_t Imm);
 102     virtual unsigned FastEmitInst_extractsubreg(MVT RetVT,
 103                                                 unsigned Op0, bool Op0IsKill,
 104                                                 uint32_t Idx);
 105
 106     // Backend specific FastISel code.
 107     virtual bool TargetSelectInstruction(const Instruction *I);
 108     virtual unsigned TargetMaterializeConstant(const Constant *C);
 109
 110   #include "ARMGenFastISel.inc"
 111
 112     // Instruction selection routines.
 113     virtual bool ARMSelectLoad(const Instruction *I);
 114     virtual bool ARMSelectStore(const Instruction *I);
 115     virtual bool ARMSelectBranch(const Instruction *I);
 116
 117     // Utility routines.
 118   private:
 119     bool isTypeLegal(const Type *Ty, EVT &VT);
 120     bool isLoadTypeLegal(const Type *Ty, EVT &VT);
 121     bool ARMEmitLoad(EVT VT, unsigned &ResultReg, unsigned Reg, int Offset);
 122     bool ARMEmitStore(EVT VT, unsigned SrcReg, unsigned Reg, int Offset);
 123     bool ARMLoadAlloca(const Instruction *I, EVT VT);
 124     bool ARMStoreAlloca(const Instruction *I, unsigned SrcReg, EVT VT);
 125     bool ARMComputeRegOffset(const Value *Obj, unsigned &Reg, int &Offset);
 126
 127     bool DefinesOptionalPredicate(MachineInstr *MI, bool *CPSR);
 128     const MachineInstrBuilder &AddOptionalDefs(const MachineInstrBuilder &MIB);
 129 };
 130
 131 } // end anonymous namespace
 132
 133 // #include "ARMGenCallingConv.inc"
 134
 135 // DefinesOptionalPredicate - This is different from DefinesPredicate in that
 136 // we don't care about implicit defs here, just places we'll need to add a
 137 // default CCReg argument. Sets CPSR if we're setting CPSR instead of CCR.
 138 bool ARMFastISel::DefinesOptionalPredicate(MachineInstr *MI, bool *CPSR) {
 139   const TargetInstrDesc &TID = MI->getDesc();
 140   if (!TID.hasOptionalDef())
 141     return false;
 142
 143   // Look to see if our OptionalDef is defining CPSR or CCR.
 144   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 145     const MachineOperand &MO = MI->getOperand(i);
 146     if (!MO.isReg() || !MO.isDef()) continue;
 147     if (MO.getReg() == ARM::CPSR)
 148       *CPSR = true;
 149   }
 150   return true;
 151 }
 152
 153 // If the machine is predicable go ahead and add the predicate operands, if
 154 // it needs default CC operands add those.
 155 const MachineInstrBuilder &
 156 ARMFastISel::AddOptionalDefs(const MachineInstrBuilder &MIB) {
 157   MachineInstr *MI = &*MIB;
 158
 159   // Do we use a predicate?
 160   if (TII.isPredicable(MI))
 161     AddDefaultPred(MIB);
 162
 163   // Do we optionally set a predicate?  Preds is size > 0 iff the predicate
 164   // defines CPSR. All other OptionalDefines in ARM are the CCR register.
 165   bool CPSR = false;
 166   if (DefinesOptionalPredicate(MI, &CPSR)) {
 167     if (CPSR)
 168       AddDefaultT1CC(MIB);
 169     else
 170       AddDefaultCC(MIB);
 171   }
 172   return MIB;
 173 }
 174
 175 unsigned ARMFastISel::FastEmitInst_(unsigned MachineInstOpcode,
 176                                     const TargetRegisterClass* RC) {
 177   unsigned ResultReg = createResultReg(RC);
 178   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 179
 180   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg));
 181   return ResultReg;
 182 }
 183
 184 unsigned ARMFastISel::FastEmitInst_r(unsigned MachineInstOpcode,
 185                                      const TargetRegisterClass *RC,
 186                                      unsigned Op0, bool Op0IsKill) {
 187   unsigned ResultReg = createResultReg(RC);
 188   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 189
 190   if (II.getNumDefs() >= 1)
 191     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 192                    .addReg(Op0, Op0IsKill * RegState::Kill));
 193   else {
 194     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 195                    .addReg(Op0, Op0IsKill * RegState::Kill));
 196     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 197                    TII.get(TargetOpcode::COPY), ResultReg)
 198                    .addReg(II.ImplicitDefs[0]));
 199   }
 200   return ResultReg;
 201 }
 202
 203 unsigned ARMFastISel::FastEmitInst_rr(unsigned MachineInstOpcode,
 204                                       const TargetRegisterClass *RC,
 205                                       unsigned Op0, bool Op0IsKill,
 206                                       unsigned Op1, bool Op1IsKill) {
 207   unsigned ResultReg = createResultReg(RC);
 208   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 209
 210   if (II.getNumDefs() >= 1)
 211     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 212                    .addReg(Op0, Op0IsKill * RegState::Kill)
 213                    .addReg(Op1, Op1IsKill * RegState::Kill));
 214   else {
 215     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 216                    .addReg(Op0, Op0IsKill * RegState::Kill)
 217                    .addReg(Op1, Op1IsKill * RegState::Kill));
 218     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 219                            TII.get(TargetOpcode::COPY), ResultReg)
 220                    .addReg(II.ImplicitDefs[0]));
 221   }
 222   return ResultReg;
 223 }
 224
 225 unsigned ARMFastISel::FastEmitInst_ri(unsigned MachineInstOpcode,
 226                                       const TargetRegisterClass *RC,
 227                                       unsigned Op0, bool Op0IsKill,
 228                                       uint64_t Imm) {
 229   unsigned ResultReg = createResultReg(RC);
 230   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 231
 232   if (II.getNumDefs() >= 1)
 233     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 234                    .addReg(Op0, Op0IsKill * RegState::Kill)
 235                    .addImm(Imm));
 236   else {
 237     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 238                    .addReg(Op0, Op0IsKill * RegState::Kill)
 239                    .addImm(Imm));
 240     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 241                            TII.get(TargetOpcode::COPY), ResultReg)
 242                    .addReg(II.ImplicitDefs[0]));
 243   }
 244   return ResultReg;
 245 }
 246
 247 unsigned ARMFastISel::FastEmitInst_rf(unsigned MachineInstOpcode,
 248                                       const TargetRegisterClass *RC,
 249                                       unsigned Op0, bool Op0IsKill,
 250                                       const ConstantFP *FPImm) {
 251   unsigned ResultReg = createResultReg(RC);
 252   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 253
 254   if (II.getNumDefs() >= 1)
 255     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 256                    .addReg(Op0, Op0IsKill * RegState::Kill)
 257                    .addFPImm(FPImm));
 258   else {
 259     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 260                    .addReg(Op0, Op0IsKill * RegState::Kill)
 261                    .addFPImm(FPImm));
 262     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 263                            TII.get(TargetOpcode::COPY), ResultReg)
 264                    .addReg(II.ImplicitDefs[0]));
 265   }
 266   return ResultReg;
 267 }
 268
 269 unsigned ARMFastISel::FastEmitInst_rri(unsigned MachineInstOpcode,
 270                                        const TargetRegisterClass *RC,
 271                                        unsigned Op0, bool Op0IsKill,
 272                                        unsigned Op1, bool Op1IsKill,
 273                                        uint64_t Imm) {
 274   unsigned ResultReg = createResultReg(RC);
 275   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 276
 277   if (II.getNumDefs() >= 1)
 278     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 279                    .addReg(Op0, Op0IsKill * RegState::Kill)
 280                    .addReg(Op1, Op1IsKill * RegState::Kill)
 281                    .addImm(Imm));
 282   else {
 283     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 284                    .addReg(Op0, Op0IsKill * RegState::Kill)
 285                    .addReg(Op1, Op1IsKill * RegState::Kill)
 286                    .addImm(Imm));
 287     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 288                            TII.get(TargetOpcode::COPY), ResultReg)
 289                    .addReg(II.ImplicitDefs[0]));
 290   }
 291   return ResultReg;
 292 }
 293
 294 unsigned ARMFastISel::FastEmitInst_i(unsigned MachineInstOpcode,
 295                                      const TargetRegisterClass *RC,
 296                                      uint64_t Imm) {
 297   unsigned ResultReg = createResultReg(RC);
 298   const TargetInstrDesc &II = TII.get(MachineInstOpcode);
 299
 300   if (II.getNumDefs() >= 1)
 301     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg)
 302                    .addImm(Imm));
 303   else {
 304     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II)
 305                    .addImm(Imm));
 306     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 307                            TII.get(TargetOpcode::COPY), ResultReg)
 308                    .addReg(II.ImplicitDefs[0]));
 309   }
 310   return ResultReg;
 311 }
 312
 313 unsigned ARMFastISel::FastEmitInst_extractsubreg(MVT RetVT,
 314                                                  unsigned Op0, bool Op0IsKill,
 315                                                  uint32_t Idx) {
 316   unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT));
 317   assert(TargetRegisterInfo::isVirtualRegister(Op0) &&
 318          "Cannot yet extract from physregs");
 319   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt,
 320                          DL, TII.get(TargetOpcode::COPY), ResultReg)
 321                  .addReg(Op0, getKillRegState(Op0IsKill), Idx));
 322   return ResultReg;
 323 }
 324
 325 unsigned ARMFastISel::TargetMaterializeConstant(const Constant *C) {
 326   EVT VT = TLI.getValueType(C->getType(), true);
 327
 328   // Only handle simple types.
 329   if (!VT.isSimple()) return 0;
 330
 331   // Handle double width floating point?
 332   if (VT.getSimpleVT().SimpleTy == MVT::f64) return 0;
 333
 334   // TODO: Theoretically we could materialize fp constants directly with
 335   // instructions from VFP3.
 336
 337   // MachineConstantPool wants an explicit alignment.
 338   unsigned Align = TD.getPrefTypeAlignment(C->getType());
 339   if (Align == 0) {
 340     // TODO: Figure out if this is correct.
 341     Align = TD.getTypeAllocSize(C->getType());
 342   }
 343   unsigned Idx = MCP.getConstantPoolIndex(C, Align);
 344
 345   unsigned DestReg = createResultReg(TLI.getRegClassFor(MVT::i32));
 346   if (isThumb)
 347     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 348                             TII.get(ARM::t2LDRpci))
 349                     .addReg(DestReg).addConstantPoolIndex(Idx));
 350   else
 351     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 352                             TII.get(ARM::LDRcp))
 353                             .addReg(DestReg).addConstantPoolIndex(Idx)
 354                     .addReg(0).addImm(0));
 355
 356   // If we have a floating point constant we expect it in a floating point
 357   // register.
 358   // TODO: Make this use ARMBaseInstrInfo::copyPhysReg.
 359   if (C->getType()->isFloatTy()) {
 360     unsigned MoveReg = createResultReg(TLI.getRegClassFor(VT));
 361     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 362                             TII.get(ARM::VMOVRS), MoveReg)
 363                     .addReg(DestReg));
 364     return MoveReg;
 365   }
 366
 367   return DestReg;
 368 }
 369
 370 bool ARMFastISel::isTypeLegal(const Type *Ty, EVT &VT) {
 371   VT = TLI.getValueType(Ty, true);
 372
 373   // Only handle simple types.
 374   if (VT == MVT::Other || !VT.isSimple()) return false;
 375
 376   // Handle all legal types, i.e. a register that will directly hold this
 377   // value.
 378   return TLI.isTypeLegal(VT);
 379 }
 380
 381 bool ARMFastISel::isLoadTypeLegal(const Type *Ty, EVT &VT) {
 382   if (isTypeLegal(Ty, VT)) return true;
 383
 384   // If this is a type than can be sign or zero-extended to a basic operation
 385   // go ahead and accept it now.
 386   if (VT == MVT::i8 || VT == MVT::i16)
 387     return true;
 388
 389   return false;
 390 }
 391
 392 // Computes the Reg+Offset to get to an object.
 393 bool ARMFastISel::ARMComputeRegOffset(const Value *Obj, unsigned &Reg,
 394                                       int &Offset) {
 395   // Some boilerplate from the X86 FastISel.
 396   const User *U = NULL;
 397   unsigned Opcode = Instruction::UserOp1;
 398   if (const Instruction *I = dyn_cast<Instruction>(Obj)) {
 399     // Don't walk into other basic blocks; it's possible we haven't
 400     // visited them yet, so the instructions may not yet be assigned
 401     // virtual registers.
 402     if (FuncInfo.MBBMap[I->getParent()] != FuncInfo.MBB)
 403       return false;
 404
 405     Opcode = I->getOpcode();
 406     U = I;
 407   } else if (const ConstantExpr *C = dyn_cast<ConstantExpr>(Obj)) {
 408     Opcode = C->getOpcode();
 409     U = C;
 410   }
 411
 412   if (const PointerType *Ty = dyn_cast<PointerType>(Obj->getType()))
 413     if (Ty->getAddressSpace() > 255)
 414       // Fast instruction selection doesn't support the special
 415       // address spaces.
 416       return false;
 417
 418   switch (Opcode) {
 419     default:
 420     //errs() << "Failing Opcode is: " << *Op1 << "\n";
 421     break;
 422     case Instruction::Alloca: {
 423       assert(false && "Alloca should have been handled earlier!");
 424       return false;
 425     }
 426   }
 427
 428   if (const GlobalValue *GV = dyn_cast<GlobalValue>(Obj)) {
 429     //errs() << "Failing GV is: " << GV << "\n";
 430     (void)GV;
 431     return false;
 432   }
 433
 434   // Try to get this in a register if nothing else has worked.
 435   Reg = getRegForValue(Obj);
 436   if (Reg == 0) return false;
 437
 438   // Since the offset may be too large for the load instruction
 439   // get the reg+offset into a register.
 440   // TODO: Verify the additions work, otherwise we'll need to add the
 441   // offset instead of 0 to the instructions and do all sorts of operand
 442   // munging.
 443   // TODO: Optimize this somewhat.
 444   if (Offset != 0) {
 445     ARMCC::CondCodes Pred = ARMCC::AL;
 446     unsigned PredReg = 0;
 447
 448     if (!isThumb)
 449       emitARMRegPlusImmediate(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 450                               Reg, Reg, Offset, Pred, PredReg,
 451                               static_cast<const ARMBaseInstrInfo&>(TII));
 452     else {
 453       assert(AFI->isThumb2Function());
 454       emitT2RegPlusImmediate(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 455                              Reg, Reg, Offset, Pred, PredReg,
 456                              static_cast<const ARMBaseInstrInfo&>(TII));
 457     }
 458   }
 459
 460   return true;
 461 }
 462
 463 bool ARMFastISel::ARMLoadAlloca(const Instruction *I, EVT VT) {
 464   Value *Op0 = I->getOperand(0);
 465
 466   // Verify it's an alloca.
 467   if (const AllocaInst *AI = dyn_cast<AllocaInst>(Op0)) {
 468     DenseMap<const AllocaInst*, int>::iterator SI =
 469       FuncInfo.StaticAllocaMap.find(AI);
 470
 471     if (SI != FuncInfo.StaticAllocaMap.end()) {
 472       TargetRegisterClass* RC = TLI.getRegClassFor(VT);
 473       unsigned ResultReg = createResultReg(RC);
 474       TII.loadRegFromStackSlot(*FuncInfo.MBB, *FuncInfo.InsertPt,
 475                                ResultReg, SI->second, RC,
 476                                TM.getRegisterInfo());
 477       UpdateValueMap(I, ResultReg);
 478       return true;
 479     }
 480   }
 481   return false;
 482 }
 483
 484 bool ARMFastISel::ARMEmitLoad(EVT VT, unsigned &ResultReg,
 485                               unsigned Reg, int Offset) {
 486
 487   assert(VT.isSimple() && "Non-simple types are invalid here!");
 488   unsigned Opc;
 489
 490   switch (VT.getSimpleVT().SimpleTy) {
 491     default:
 492       assert(false && "Trying to emit for an unhandled type!");
 493       return false;
 494     case MVT::i16:
 495       Opc = isThumb ? ARM::tLDRH : ARM::LDRH;
 496       VT = MVT::i32;
 497       break;
 498     case MVT::i8:
 499       Opc = isThumb ? ARM::tLDRB : ARM::LDRB;
 500       VT = MVT::i32;
 501       break;
 502     case MVT::i32:
 503       Opc = isThumb ? ARM::tLDR : ARM::LDR;
 504       break;
 505   }
 506
 507   ResultReg = createResultReg(TLI.getRegClassFor(VT));
 508
 509   // TODO: Fix the Addressing modes so that these can share some code.
 510   // Since this is a Thumb1 load this will work in Thumb1 or 2 mode.
 511   if (isThumb)
 512     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 513                             TII.get(Opc), ResultReg)
 514                     .addReg(Reg).addImm(Offset).addReg(0));
 515   else
 516     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 517                             TII.get(Opc), ResultReg)
 518                     .addReg(Reg).addReg(0).addImm(Offset));
 519
 520   return true;
 521 }
 522
 523 bool ARMFastISel::ARMStoreAlloca(const Instruction *I, unsigned SrcReg, EVT VT){
 524   Value *Op1 = I->getOperand(1);
 525
 526   // Verify it's an alloca.
 527   if (const AllocaInst *AI = dyn_cast<AllocaInst>(Op1)) {
 528     DenseMap<const AllocaInst*, int>::iterator SI =
 529       FuncInfo.StaticAllocaMap.find(AI);
 530
 531     if (SI != FuncInfo.StaticAllocaMap.end()) {
 532       TargetRegisterClass* RC = TLI.getRegClassFor(VT);
 533       assert(SrcReg != 0 && "Nothing to store!");
 534       TII.storeRegToStackSlot(*FuncInfo.MBB, *FuncInfo.InsertPt,
 535                               SrcReg, true /*isKill*/, SI->second, RC,
 536                               TM.getRegisterInfo());
 537       return true;
 538     }
 539   }
 540   return false;
 541 }
 542
 543 bool ARMFastISel::ARMEmitStore(EVT VT, unsigned SrcReg,
 544                                unsigned DstReg, int Offset) {
 545   unsigned StrOpc;
 546   switch (VT.getSimpleVT().SimpleTy) {
 547     default: return false;
 548     case MVT::i1:
 549     case MVT::i8: StrOpc = isThumb ? ARM::tSTRB : ARM::STRB; break;
 550     case MVT::i16: StrOpc = isThumb ? ARM::tSTRH : ARM::STRH; break;
 551     case MVT::i32: StrOpc = isThumb ? ARM::tSTR : ARM::STR; break;
 552     case MVT::f32:
 553       if (!Subtarget->hasVFP2()) return false;
 554       StrOpc = ARM::VSTRS;
 555       break;
 556     case MVT::f64:
 557       if (!Subtarget->hasVFP2()) return false;
 558       StrOpc = ARM::VSTRD;
 559       break;
 560   }
 561
 562   if (isThumb)
 563     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 564                             TII.get(StrOpc), SrcReg)
 565                     .addReg(DstReg).addImm(Offset).addReg(0));
 566   else
 567     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL,
 568                             TII.get(StrOpc), SrcReg)
 569                     .addReg(DstReg).addReg(0).addImm(Offset));
 570
 571   return true;
 572 }
 573
 574 bool ARMFastISel::ARMSelectStore(const Instruction *I) {
 575   Value *Op0 = I->getOperand(0);
 576   unsigned SrcReg = 0;
 577
 578   // Yay type legalization
 579   EVT VT;
 580   if (!isLoadTypeLegal(I->getOperand(0)->getType(), VT))
 581     return false;
 582
 583   // Get the value to be stored into a register.
 584   SrcReg = getRegForValue(Op0);
 585   if (SrcReg == 0)
 586     return false;
 587
 588   // If we're an alloca we know we have a frame index and can emit the store
 589   // quickly.
 590   if (ARMStoreAlloca(I, SrcReg, VT))
 591     return true;
 592
 593   // Our register and offset with innocuous defaults.
 594   unsigned Reg = 0;
 595   int Offset = 0;
 596
 597   // See if we can handle this as Reg + Offset
 598   if (!ARMComputeRegOffset(I->getOperand(1), Reg, Offset))
 599     return false;
 600
 601   if (!ARMEmitStore(VT, SrcReg, Reg, Offset /* 0 */)) return false;
 602
 603   return false;
 604
 605 }
 606
 607 bool ARMFastISel::ARMSelectLoad(const Instruction *I) {
 608   // Verify we have a legal type before going any further.
 609   EVT VT;
 610   if (!isLoadTypeLegal(I->getType(), VT))
 611     return false;
 612
 613   // If we're an alloca we know we have a frame index and can emit the load
 614   // directly in short order.
 615   if (ARMLoadAlloca(I, VT))
 616     return true;
 617
 618   // Our register and offset with innocuous defaults.
 619   unsigned Reg = 0;
 620   int Offset = 0;
 621
 622   // See if we can handle this as Reg + Offset
 623   if (!ARMComputeRegOffset(I->getOperand(0), Reg, Offset))
 624     return false;
 625
 626   unsigned ResultReg;
 627   if (!ARMEmitLoad(VT, ResultReg, Reg, Offset /* 0 */)) return false;
 628
 629   UpdateValueMap(I, ResultReg);
 630   return true;
 631 }
 632
 633 bool ARMFastISel::ARMSelectBranch(const Instruction *I) {
 634   const BranchInst *BI = cast<BranchInst>(I);
 635   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
 636   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
 637
 638   // Simple branch support.
 639   unsigned CondReg = getRegForValue(BI->getCondition());
 640   if (CondReg == 0) return false;
 641
 642   unsigned CmpOpc = isThumb ? ARM::t2CMPrr : ARM::CMPrr;
 643   unsigned BrOpc = isThumb ? ARM::t2Bcc : ARM::Bcc;
 644   AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(CmpOpc))
 645                   .addReg(CondReg).addReg(CondReg));
 646   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(BrOpc))
 647                   .addMBB(TBB).addImm(ARMCC::NE).addReg(ARM::CPSR);
 648   FastEmitBranch(FBB, DL);
 649   FuncInfo.MBB->addSuccessor(TBB);
 650   return true;
 651 }
 652
 653 // TODO: SoftFP support.
 654 bool ARMFastISel::TargetSelectInstruction(const Instruction *I) {
 655   // No Thumb-1 for now.
 656   if (isThumb && !AFI->isThumb2Function()) return false;
 657
 658   switch (I->getOpcode()) {
 659     case Instruction::Load:
 660       return ARMSelectLoad(I);
 661     case Instruction::Store:
 662       return ARMSelectStore(I);
 663     case Instruction::Br:
 664       return ARMSelectBranch(I);
 665     default: break;
 666   }
 667   return false;
 668 }
 669
 670 namespace llvm {
 671   llvm::FastISel *ARM::createFastISel(FunctionLoweringInfo &funcInfo) {
 672     if (EnableARMFastISel) return new ARMFastISel(funcInfo);
 673     return 0;
 674   }
 675 }