lib/Target/ARM/ARMISelDAGToDAG.cpp

   1 //===-- ARMISelDAGToDAG.cpp - A dag to dag inst selector for ARM ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Chris Lattner and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines an instruction selector for the ARM target.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ARM.h"
  15 #include "ARMTargetMachine.h"
  16 #include "llvm/CallingConv.h"
  17 #include "llvm/DerivedTypes.h"
  18 #include "llvm/Function.h"
  19 #include "llvm/Constants.h"
  20 #include "llvm/Intrinsics.h"
  21 #include "llvm/ADT/VectorExtras.h"
  22 #include "llvm/CodeGen/MachineFrameInfo.h"
  23 #include "llvm/CodeGen/MachineFunction.h"
  24 #include "llvm/CodeGen/MachineInstrBuilder.h"
  25 #include "llvm/CodeGen/SelectionDAG.h"
  26 #include "llvm/CodeGen/SelectionDAGISel.h"
  27 #include "llvm/CodeGen/SSARegMap.h"
  28 #include "llvm/Target/TargetLowering.h"
  29 #include "llvm/Support/Debug.h"
  30 #include <vector>
  31 using namespace llvm;
  32
  33 namespace {
  34   class ARMTargetLowering : public TargetLowering {
  35     int VarArgsFrameIndex;            // FrameIndex for start of varargs area.
  36   public:
  37     ARMTargetLowering(TargetMachine &TM);
  38     virtual SDOperand LowerOperation(SDOperand Op, SelectionDAG &DAG);
  39     virtual const char *getTargetNodeName(unsigned Opcode) const;
  40     std::vector<unsigned>
  41     getRegClassForInlineAsmConstraint(const std::string &Constraint,
  42                                       MVT::ValueType VT) const;
  43   };
  44
  45 }
  46
  47 ARMTargetLowering::ARMTargetLowering(TargetMachine &TM)
  48   : TargetLowering(TM) {
  49   addRegisterClass(MVT::i32, ARM::IntRegsRegisterClass);
  50   addRegisterClass(MVT::f32, ARM::FPRegsRegisterClass);
  51   addRegisterClass(MVT::f64, ARM::DFPRegsRegisterClass);
  52
  53   setLoadXAction(ISD::EXTLOAD, MVT::f32, Expand);
  54
  55   setOperationAction(ISD::FP_TO_SINT, MVT::i32, Custom);
  56   setOperationAction(ISD::SINT_TO_FP, MVT::i32, Custom);
  57
  58   setOperationAction(ISD::FP_TO_UINT, MVT::i32, Custom);
  59   setOperationAction(ISD::UINT_TO_FP, MVT::i32, Custom);
  60
  61   setOperationAction(ISD::RET,           MVT::Other, Custom);
  62   setOperationAction(ISD::GlobalAddress, MVT::i32,   Custom);
  63   setOperationAction(ISD::ConstantPool,  MVT::i32,   Custom);
  64
  65   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16, Expand);
  66   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8 , Expand);
  67   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1 , Expand);
  68
  69   setOperationAction(ISD::SELECT, MVT::i32, Expand);
  70   setOperationAction(ISD::SELECT, MVT::f32, Expand);
  71   setOperationAction(ISD::SELECT, MVT::f64, Expand);
  72
  73   setOperationAction(ISD::SETCC, MVT::i32, Expand);
  74   setOperationAction(ISD::SETCC, MVT::f32, Expand);
  75   setOperationAction(ISD::SETCC, MVT::f64, Expand);
  76
  77   setOperationAction(ISD::SELECT_CC, MVT::i32, Custom);
  78   setOperationAction(ISD::SELECT_CC, MVT::f32, Custom);
  79   setOperationAction(ISD::SELECT_CC, MVT::f64, Custom);
  80
  81   setOperationAction(ISD::MEMMOVE, MVT::Other, Expand);
  82   setOperationAction(ISD::MEMSET, MVT::Other, Expand);
  83   setOperationAction(ISD::MEMCPY, MVT::Other, Expand);
  84
  85   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
  86   setOperationAction(ISD::BRIND, MVT::Other, Expand);
  87   setOperationAction(ISD::BR_CC, MVT::i32, Custom);
  88   setOperationAction(ISD::BR_CC, MVT::f32, Custom);
  89   setOperationAction(ISD::BR_CC, MVT::f64, Custom);
  90
  91   setOperationAction(ISD::BRCOND,        MVT::Other, Expand);
  92
  93   setOperationAction(ISD::SHL_PARTS, MVT::i32, Expand);
  94   setOperationAction(ISD::SRA_PARTS, MVT::i32, Expand);
  95   setOperationAction(ISD::SRL_PARTS, MVT::i32, Expand);
  96   setOperationAction(ISD::SDIV,      MVT::i32, Expand);
  97   setOperationAction(ISD::UDIV,      MVT::i32, Expand);
  98   setOperationAction(ISD::SREM,      MVT::i32, Expand);
  99   setOperationAction(ISD::UREM,      MVT::i32, Expand);
 100
 101   setOperationAction(ISD::VASTART,       MVT::Other, Custom);
 102   setOperationAction(ISD::VACOPY,            MVT::Other, Expand);
 103   setOperationAction(ISD::VAEND,         MVT::Other, Expand);
 104   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32, Expand);
 105
 106   setOperationAction(ISD::ConstantFP, MVT::f64, Expand);
 107   setOperationAction(ISD::ConstantFP, MVT::f32, Expand);
 108
 109   setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 110   setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
 111
 112   setStackPointerRegisterToSaveRestore(ARM::R13);
 113
 114   setSchedulingPreference(SchedulingForRegPressure);
 115   computeRegisterProperties();
 116 }
 117
 118 namespace llvm {
 119   namespace ARMISD {
 120     enum NodeType {
 121       // Start the numbering where the builting ops and target ops leave off.
 122       FIRST_NUMBER = ISD::BUILTIN_OP_END+ARM::INSTRUCTION_LIST_END,
 123       /// CALL - A direct function call.
 124       CALL,
 125
 126       /// Return with a flag operand.
 127       RET_FLAG,
 128
 129       CMP,
 130
 131       SELECT,
 132
 133       BR,
 134
 135       FSITOS,
 136       FTOSIS,
 137
 138       FSITOD,
 139       FTOSID,
 140
 141       FUITOS,
 142       FTOUIS,
 143
 144       FUITOD,
 145       FTOUID,
 146
 147       FMRRD,
 148
 149       FMDRR,
 150
 151       FMSTAT
 152     };
 153   }
 154 }
 155
 156 /// DAGFPCCToARMCC - Convert a DAG fp condition code to an ARM CC
 157 // Unordered = !N & !Z & C & V = V
 158 // Ordered   =  N | Z | !C | !V = N | Z | !V
 159 static std::vector<unsigned> DAGFPCCToARMCC(ISD::CondCode CC) {
 160   switch (CC) {
 161   default:
 162     assert(0 && "Unknown fp condition code!");
 163 // SETOEQ = (N | Z | !V) & Z = Z                               = EQ
 164   case ISD::SETEQ:
 165   case ISD::SETOEQ: return make_vector<unsigned>(ARMCC::EQ, 0);
 166 // SETOGT = (N | Z | !V) & !N & !Z = !V &!N &!Z = (N = V) & !Z = GT
 167   case ISD::SETGT:
 168   case ISD::SETOGT: return make_vector<unsigned>(ARMCC::GT, 0);
 169 // SETOGE = (N | Z | !V) & !N = (Z | !V) & !N = !V & !N        = GE
 170   case ISD::SETGE:
 171   case ISD::SETOGE: return make_vector<unsigned>(ARMCC::GE, 0);
 172 // SETOLT = (N | Z | !V) & N = N                               = MI
 173   case ISD::SETLT:
 174   case ISD::SETOLT: return make_vector<unsigned>(ARMCC::MI, 0);
 175 // SETOLE = (N | Z | !V) & (N | Z) = N | Z = !C | Z            = LS
 176   case ISD::SETLE:
 177   case ISD::SETOLE: return make_vector<unsigned>(ARMCC::LS, 0);
 178 // SETONE = OGT | OLT
 179   case ISD::SETONE: return make_vector<unsigned>(ARMCC::GT, ARMCC::MI, 0);
 180 // SETO   = N | Z | !V = Z | !V = !V                           = VC
 181   case ISD::SETO:   return make_vector<unsigned>(ARMCC::VC, 0);
 182 // SETUO  = V                                                  = VS
 183   case ISD::SETUO:  return make_vector<unsigned>(ARMCC::VS, 0);
 184 // SETUEQ = V | Z  (need two instructions)                     = EQ/VS
 185   case ISD::SETUEQ: return make_vector<unsigned>(ARMCC::EQ, ARMCC::VS, 0);
 186 // SETUGT = V | (!Z & !N) = !Z & !N = !Z & C                   = HI
 187   case ISD::SETUGT: return make_vector<unsigned>(ARMCC::HI, 0);
 188 // SETUGE = V | !N = !N                                        = PL
 189   case ISD::SETUGE: return make_vector<unsigned>(ARMCC::PL, 0);
 190 // SETULT = V | N                                              = LT
 191   case ISD::SETULT: return make_vector<unsigned>(ARMCC::LT, 0);
 192 // SETULE = V | Z | N                                          = LE
 193   case ISD::SETULE: return make_vector<unsigned>(ARMCC::LE, 0);
 194 // SETUNE = V | !Z = !Z                                        = NE
 195   case ISD::SETNE:
 196   case ISD::SETUNE: return make_vector<unsigned>(ARMCC::NE, 0);
 197   }
 198 }
 199
 200 /// DAGIntCCToARMCC - Convert a DAG integer condition code to an ARM CC
 201 static std::vector<unsigned> DAGIntCCToARMCC(ISD::CondCode CC) {
 202   switch (CC) {
 203   default:
 204     assert(0 && "Unknown integer condition code!");
 205   case ISD::SETEQ:  return make_vector<unsigned>(ARMCC::EQ, 0);
 206   case ISD::SETNE:  return make_vector<unsigned>(ARMCC::NE, 0);
 207   case ISD::SETLT:  return make_vector<unsigned>(ARMCC::LT, 0);
 208   case ISD::SETLE:  return make_vector<unsigned>(ARMCC::LE, 0);
 209   case ISD::SETGT:  return make_vector<unsigned>(ARMCC::GT, 0);
 210   case ISD::SETGE:  return make_vector<unsigned>(ARMCC::GE, 0);
 211   case ISD::SETULT: return make_vector<unsigned>(ARMCC::CC, 0);
 212   case ISD::SETULE: return make_vector<unsigned>(ARMCC::LS, 0);
 213   case ISD::SETUGT: return make_vector<unsigned>(ARMCC::HI, 0);
 214   case ISD::SETUGE: return make_vector<unsigned>(ARMCC::CS, 0);
 215   }
 216 }
 217
 218 std::vector<unsigned> ARMTargetLowering::
 219 getRegClassForInlineAsmConstraint(const std::string &Constraint,
 220                                   MVT::ValueType VT) const {
 221   if (Constraint.size() == 1) {
 222     // FIXME: handling only r regs
 223     switch (Constraint[0]) {
 224     default: break;  // Unknown constraint letter
 225
 226     case 'r':   // GENERAL_REGS
 227     case 'R':   // LEGACY_REGS
 228       if (VT == MVT::i32)
 229         return make_vector<unsigned>(ARM::R0,  ARM::R1,  ARM::R2,  ARM::R3,
 230                                      ARM::R4,  ARM::R5,  ARM::R6,  ARM::R7,
 231                                      ARM::R8,  ARM::R9,  ARM::R10, ARM::R11,
 232                                      ARM::R12, ARM::R13, ARM::R14, 0);
 233       break;
 234
 235     }
 236   }
 237
 238   return std::vector<unsigned>();
 239 }
 240
 241 const char *ARMTargetLowering::getTargetNodeName(unsigned Opcode) const {
 242   switch (Opcode) {
 243   default: return 0;
 244   case ARMISD::CALL:          return "ARMISD::CALL";
 245   case ARMISD::RET_FLAG:      return "ARMISD::RET_FLAG";
 246   case ARMISD::SELECT:        return "ARMISD::SELECT";
 247   case ARMISD::CMP:           return "ARMISD::CMP";
 248   case ARMISD::BR:            return "ARMISD::BR";
 249   case ARMISD::FSITOS:        return "ARMISD::FSITOS";
 250   case ARMISD::FTOSIS:        return "ARMISD::FTOSIS";
 251   case ARMISD::FSITOD:        return "ARMISD::FSITOD";
 252   case ARMISD::FTOSID:        return "ARMISD::FTOSID";
 253   case ARMISD::FUITOS:        return "ARMISD::FUITOS";
 254   case ARMISD::FTOUIS:        return "ARMISD::FTOUIS";
 255   case ARMISD::FUITOD:        return "ARMISD::FUITOD";
 256   case ARMISD::FTOUID:        return "ARMISD::FTOUID";
 257   case ARMISD::FMRRD:         return "ARMISD::FMRRD";
 258   case ARMISD::FMDRR:         return "ARMISD::FMDRR";
 259   case ARMISD::FMSTAT:        return "ARMISD::FMSTAT";
 260   }
 261 }
 262
 263 class ArgumentLayout {
 264   std::vector<bool>           is_reg;
 265   std::vector<unsigned>       pos;
 266   std::vector<MVT::ValueType> types;
 267 public:
 268   ArgumentLayout(const std::vector<MVT::ValueType> &Types) {
 269     types = Types;
 270
 271     unsigned      RegNum = 0;
 272     unsigned StackOffset = 0;
 273     for(std::vector<MVT::ValueType>::const_iterator I = Types.begin();
 274         I != Types.end();
 275         ++I) {
 276       MVT::ValueType VT = *I;
 277       assert(VT == MVT::i32 || VT == MVT::f32 || VT == MVT::f64);
 278       unsigned     size = MVT::getSizeInBits(VT)/32;
 279
 280       RegNum = ((RegNum + size - 1) / size) * size;
 281       if (RegNum < 4) {
 282         pos.push_back(RegNum);
 283         is_reg.push_back(true);
 284         RegNum += size;
 285       } else {
 286         unsigned bytes = size * 32/8;
 287         StackOffset = ((StackOffset + bytes - 1) / bytes) * bytes;
 288         pos.push_back(StackOffset);
 289         is_reg.push_back(false);
 290         StackOffset += bytes;
 291       }
 292     }
 293   }
 294   unsigned getRegisterNum(unsigned argNum) {
 295     assert(isRegister(argNum));
 296     return pos[argNum];
 297   }
 298   unsigned getOffset(unsigned argNum) {
 299     assert(isOffset(argNum));
 300     return pos[argNum];
 301   }
 302   unsigned isRegister(unsigned argNum) {
 303     assert(argNum < is_reg.size());
 304     return is_reg[argNum];
 305   }
 306   unsigned isOffset(unsigned argNum) {
 307     return !isRegister(argNum);
 308   }
 309   MVT::ValueType getType(unsigned argNum) {
 310     assert(argNum < types.size());
 311     return types[argNum];
 312   }
 313   unsigned getStackSize(void) {
 314     int last = is_reg.size() - 1;
 315     if (last < 0)
 316       return 0;
 317     if (isRegister(last))
 318       return 0;
 319     return getOffset(last) + MVT::getSizeInBits(getType(last))/8;
 320   }
 321   int lastRegArg(void) {
 322     int size = is_reg.size();
 323     int last = 0;
 324     while(last < size && isRegister(last))
 325       last++;
 326     last--;
 327     return last;
 328   }
 329   int lastRegNum(void) {
 330     int            l = lastRegArg();
 331     if (l < 0)
 332       return -1;
 333     unsigned       r = getRegisterNum(l);
 334     MVT::ValueType t = getType(l);
 335     assert(t == MVT::i32 || t == MVT::f32 || t == MVT::f64);
 336     if (t == MVT::f64)
 337       return r + 1;
 338     return r;
 339   }
 340 };
 341
 342 // This transforms a ISD::CALL node into a
 343 // callseq_star <- ARMISD:CALL <- callseq_end
 344 // chain
 345 static SDOperand LowerCALL(SDOperand Op, SelectionDAG &DAG) {
 346   SDOperand Chain    = Op.getOperand(0);
 347   unsigned CallConv  = cast<ConstantSDNode>(Op.getOperand(1))->getValue();
 348   assert((CallConv == CallingConv::C ||
 349           CallConv == CallingConv::Fast)
 350          && "unknown calling convention");
 351   SDOperand Callee   = Op.getOperand(4);
 352   unsigned NumOps    = (Op.getNumOperands() - 5) / 2;
 353   SDOperand StackPtr = DAG.getRegister(ARM::R13, MVT::i32);
 354   static const unsigned regs[] = {
 355     ARM::R0, ARM::R1, ARM::R2, ARM::R3
 356   };
 357
 358   std::vector<MVT::ValueType> Types;
 359   for (unsigned i = 0; i < NumOps; ++i) {
 360     MVT::ValueType VT = Op.getOperand(5+2*i).getValueType();
 361     Types.push_back(VT);
 362   }
 363   ArgumentLayout Layout(Types);
 364
 365   unsigned NumBytes = Layout.getStackSize();
 366
 367   Chain = DAG.getCALLSEQ_START(Chain,
 368                                DAG.getConstant(NumBytes, MVT::i32));
 369
 370   //Build a sequence of stores
 371   std::vector<SDOperand> MemOpChains;
 372   for (unsigned i = Layout.lastRegArg() + 1; i < NumOps; ++i) {
 373     SDOperand      Arg = Op.getOperand(5+2*i);
 374     unsigned ArgOffset = Layout.getOffset(i);
 375     SDOperand   PtrOff = DAG.getConstant(ArgOffset, StackPtr.getValueType());
 376     PtrOff             = DAG.getNode(ISD::ADD, MVT::i32, StackPtr, PtrOff);
 377     MemOpChains.push_back(DAG.getStore(Chain, Arg, PtrOff, NULL, 0));
 378   }
 379   if (!MemOpChains.empty())
 380     Chain = DAG.getNode(ISD::TokenFactor, MVT::Other,
 381                         &MemOpChains[0], MemOpChains.size());
 382
 383   // If the callee is a GlobalAddress node (quite common, every direct call is)
 384   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
 385   // Likewise ExternalSymbol -> TargetExternalSymbol.
 386   assert(Callee.getValueType() == MVT::i32);
 387   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
 388     Callee = DAG.getTargetGlobalAddress(G->getGlobal(), MVT::i32);
 389   else if (ExternalSymbolSDNode *E = dyn_cast<ExternalSymbolSDNode>(Callee))
 390     Callee = DAG.getTargetExternalSymbol(E->getSymbol(), MVT::i32);
 391
 392   // If this is a direct call, pass the chain and the callee.
 393   assert (Callee.Val);
 394   std::vector<SDOperand> Ops;
 395   Ops.push_back(Chain);
 396   Ops.push_back(Callee);
 397
 398   // Build a sequence of copy-to-reg nodes chained together with token chain
 399   // and flag operands which copy the outgoing args into the appropriate regs.
 400   SDOperand InFlag;
 401   for (int i = 0, e = Layout.lastRegArg(); i <= e; ++i) {
 402     SDOperand     Arg = Op.getOperand(5+2*i);
 403     unsigned   RegNum = Layout.getRegisterNum(i);
 404     unsigned     Reg1 = regs[RegNum];
 405     MVT::ValueType VT = Layout.getType(i);
 406     assert(VT == Arg.getValueType());
 407     assert(VT == MVT::i32 || VT == MVT::f32 || VT == MVT::f64);
 408
 409     // Add argument register to the end of the list so that it is known live
 410     // into the call.
 411     Ops.push_back(DAG.getRegister(Reg1, MVT::i32));
 412     if (VT == MVT::f64) {
 413       unsigned    Reg2 = regs[RegNum + 1];
 414       SDOperand SDReg1 = DAG.getRegister(Reg1, MVT::i32);
 415       SDOperand SDReg2 = DAG.getRegister(Reg2, MVT::i32);
 416
 417       Ops.push_back(DAG.getRegister(Reg2, MVT::i32));
 418       SDVTList    VTs = DAG.getVTList(MVT::Other, MVT::Flag);
 419       SDOperand Ops[] = {Chain, SDReg1, SDReg2, Arg, InFlag};
 420       Chain = DAG.getNode(ARMISD::FMRRD, VTs, Ops, InFlag.Val ? 5 : 4);
 421     } else {
 422       if (VT == MVT::f32)
 423         Arg = DAG.getNode(ISD::BIT_CONVERT, MVT::i32, Arg);
 424       Chain = DAG.getCopyToReg(Chain, Reg1, Arg, InFlag);
 425     }
 426     InFlag = Chain.getValue(1);
 427   }
 428
 429   std::vector<MVT::ValueType> NodeTys;
 430   NodeTys.push_back(MVT::Other);   // Returns a chain
 431   NodeTys.push_back(MVT::Flag);    // Returns a flag for retval copy to use.
 432
 433   unsigned CallOpc = ARMISD::CALL;
 434   if (InFlag.Val)
 435     Ops.push_back(InFlag);
 436   Chain = DAG.getNode(CallOpc, NodeTys, &Ops[0], Ops.size());
 437   InFlag = Chain.getValue(1);
 438
 439   std::vector<SDOperand> ResultVals;
 440   NodeTys.clear();
 441
 442   // If the call has results, copy the values out of the ret val registers.
 443   MVT::ValueType VT = Op.Val->getValueType(0);
 444   if (VT != MVT::Other) {
 445     assert(VT == MVT::i32 || VT == MVT::f32 || VT == MVT::f64);
 446
 447     SDOperand Value1 = DAG.getCopyFromReg(Chain, ARM::R0, MVT::i32, InFlag);
 448     Chain            = Value1.getValue(1);
 449     InFlag           = Value1.getValue(2);
 450     NodeTys.push_back(VT);
 451     if (VT == MVT::i32) {
 452       ResultVals.push_back(Value1);
 453       if (Op.Val->getValueType(1) == MVT::i32) {
 454         SDOperand Value2 = DAG.getCopyFromReg(Chain, ARM::R1, MVT::i32, InFlag);
 455         Chain            = Value2.getValue(1);
 456         ResultVals.push_back(Value2);
 457         NodeTys.push_back(VT);
 458       }
 459     }
 460     if (VT == MVT::f32) {
 461       SDOperand Value = DAG.getNode(ISD::BIT_CONVERT, MVT::f32, Value1);
 462       ResultVals.push_back(Value);
 463     }
 464     if (VT == MVT::f64) {
 465       SDOperand Value2 = DAG.getCopyFromReg(Chain, ARM::R1, MVT::i32, InFlag);
 466       Chain            = Value2.getValue(1);
 467       SDOperand Value  = DAG.getNode(ARMISD::FMDRR, MVT::f64, Value1, Value2);
 468       ResultVals.push_back(Value);
 469     }
 470   }
 471
 472   Chain = DAG.getNode(ISD::CALLSEQ_END, MVT::Other, Chain,
 473                       DAG.getConstant(NumBytes, MVT::i32));
 474   NodeTys.push_back(MVT::Other);
 475
 476   if (ResultVals.empty())
 477     return Chain;
 478
 479   ResultVals.push_back(Chain);
 480   SDOperand Res = DAG.getNode(ISD::MERGE_VALUES, NodeTys, &ResultVals[0],
 481                               ResultVals.size());
 482   return Res.getValue(Op.ResNo);
 483 }
 484
 485 static SDOperand LowerRET(SDOperand Op, SelectionDAG &DAG) {
 486   SDOperand Copy;
 487   SDOperand Chain = Op.getOperand(0);
 488   SDOperand    R0 = DAG.getRegister(ARM::R0, MVT::i32);
 489   SDOperand    R1 = DAG.getRegister(ARM::R1, MVT::i32);
 490
 491   switch(Op.getNumOperands()) {
 492   default:
 493     assert(0 && "Do not know how to return this many arguments!");
 494     abort();
 495   case 1: {
 496     SDOperand LR = DAG.getRegister(ARM::R14, MVT::i32);
 497     return DAG.getNode(ARMISD::RET_FLAG, MVT::Other, Chain);
 498   }
 499   case 3: {
 500     SDOperand Val = Op.getOperand(1);
 501     assert(Val.getValueType() == MVT::i32 ||
 502            Val.getValueType() == MVT::f32 ||
 503            Val.getValueType() == MVT::f64);
 504
 505     if (Val.getValueType() == MVT::f64) {
 506       SDVTList    VTs = DAG.getVTList(MVT::Other, MVT::Flag);
 507       SDOperand Ops[] = {Chain, R0, R1, Val};
 508       Copy  = DAG.getNode(ARMISD::FMRRD, VTs, Ops, 4);
 509     } else {
 510       if (Val.getValueType() == MVT::f32)
 511         Val = DAG.getNode(ISD::BIT_CONVERT, MVT::i32, Val);
 512       Copy = DAG.getCopyToReg(Chain, R0, Val, SDOperand());
 513     }
 514
 515     if (DAG.getMachineFunction().liveout_empty()) {
 516       DAG.getMachineFunction().addLiveOut(ARM::R0);
 517       if (Val.getValueType() == MVT::f64)
 518         DAG.getMachineFunction().addLiveOut(ARM::R1);
 519     }
 520     break;
 521   }
 522   case 5:
 523     Copy = DAG.getCopyToReg(Chain, ARM::R1, Op.getOperand(3), SDOperand());
 524     Copy = DAG.getCopyToReg(Copy, ARM::R0, Op.getOperand(1), Copy.getValue(1));
 525     // If we haven't noted the R0+R1 are live out, do so now.
 526     if (DAG.getMachineFunction().liveout_empty()) {
 527       DAG.getMachineFunction().addLiveOut(ARM::R0);
 528       DAG.getMachineFunction().addLiveOut(ARM::R1);
 529     }
 530     break;
 531   }
 532
 533   //We must use RET_FLAG instead of BRIND because BRIND doesn't have a flag
 534   return DAG.getNode(ARMISD::RET_FLAG, MVT::Other, Copy, Copy.getValue(1));
 535 }
 536
 537 static SDOperand LowerConstantPool(SDOperand Op, SelectionDAG &DAG) {
 538   MVT::ValueType PtrVT = Op.getValueType();
 539   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
 540   Constant *C = CP->getConstVal();
 541   SDOperand CPI = DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment());
 542
 543   return CPI;
 544 }
 545
 546 static SDOperand LowerGlobalAddress(SDOperand Op,
 547                                     SelectionDAG &DAG) {
 548   GlobalValue  *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
 549   int alignment = 2;
 550   SDOperand CPAddr = DAG.getConstantPool(GV, MVT::i32, alignment);
 551   return DAG.getLoad(MVT::i32, DAG.getEntryNode(), CPAddr, NULL, 0);
 552 }
 553
 554 static SDOperand LowerVASTART(SDOperand Op, SelectionDAG &DAG,
 555                               unsigned VarArgsFrameIndex) {
 556   // vastart just stores the address of the VarArgsFrameIndex slot into the
 557   // memory location argument.
 558   MVT::ValueType PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
 559   SDOperand FR = DAG.getFrameIndex(VarArgsFrameIndex, PtrVT);
 560   SrcValueSDNode *SV = cast<SrcValueSDNode>(Op.getOperand(2));
 561   return DAG.getStore(Op.getOperand(0), FR, Op.getOperand(1), SV->getValue(),
 562                       SV->getOffset());
 563 }
 564
 565 static SDOperand LowerFORMAL_ARGUMENTS(SDOperand Op, SelectionDAG &DAG,
 566                                        int &VarArgsFrameIndex) {
 567   MachineFunction   &MF = DAG.getMachineFunction();
 568   MachineFrameInfo *MFI = MF.getFrameInfo();
 569   SSARegMap     *RegMap = MF.getSSARegMap();
 570   unsigned      NumArgs = Op.Val->getNumValues()-1;
 571   SDOperand        Root = Op.getOperand(0);
 572   bool         isVarArg = cast<ConstantSDNode>(Op.getOperand(2))->getValue() != 0;
 573   static const unsigned REGS[] = {
 574     ARM::R0, ARM::R1, ARM::R2, ARM::R3
 575   };
 576
 577   std::vector<MVT::ValueType> Types(Op.Val->value_begin(), Op.Val->value_end() - 1);
 578   ArgumentLayout Layout(Types);
 579
 580   std::vector<SDOperand> ArgValues;
 581   for (unsigned ArgNo = 0; ArgNo < NumArgs; ++ArgNo) {
 582     MVT::ValueType VT = Types[ArgNo];
 583
 584     SDOperand Value;
 585     if (Layout.isRegister(ArgNo)) {
 586       assert(VT == MVT::i32 || VT == MVT::f32 || VT == MVT::f64);
 587       unsigned  RegNum = Layout.getRegisterNum(ArgNo);
 588       unsigned    Reg1 = REGS[RegNum];
 589       unsigned   VReg1 = RegMap->createVirtualRegister(&ARM::IntRegsRegClass);
 590       SDOperand Value1 = DAG.getCopyFromReg(Root, VReg1, MVT::i32);
 591       MF.addLiveIn(Reg1, VReg1);
 592       if (VT == MVT::f64) {
 593         unsigned    Reg2 = REGS[RegNum + 1];
 594         unsigned   VReg2 = RegMap->createVirtualRegister(&ARM::IntRegsRegClass);
 595         SDOperand Value2 = DAG.getCopyFromReg(Root, VReg2, MVT::i32);
 596         MF.addLiveIn(Reg2, VReg2);
 597         Value            = DAG.getNode(ARMISD::FMDRR, MVT::f64, Value1, Value2);
 598       } else {
 599         Value = Value1;
 600         if (VT == MVT::f32)
 601           Value = DAG.getNode(ISD::BIT_CONVERT, VT, Value);
 602       }
 603     } else {
 604       // If the argument is actually used, emit a load from the right stack
 605       // slot.
 606       if (!Op.Val->hasNUsesOfValue(0, ArgNo)) {
 607         unsigned Offset = Layout.getOffset(ArgNo);
 608         unsigned   Size = MVT::getSizeInBits(VT)/8;
 609         int          FI = MFI->CreateFixedObject(Size, Offset);
 610         SDOperand   FIN = DAG.getFrameIndex(FI, VT);
 611         Value = DAG.getLoad(VT, Root, FIN, NULL, 0);
 612       } else {
 613         Value = DAG.getNode(ISD::UNDEF, VT);
 614       }
 615     }
 616     ArgValues.push_back(Value);
 617   }
 618
 619   unsigned NextRegNum = Layout.lastRegNum() + 1;
 620
 621   if (isVarArg) {
 622     //If this function is vararg we must store the remaing
 623     //registers so that they can be acessed with va_start
 624     VarArgsFrameIndex = MFI->CreateFixedObject(MVT::getSizeInBits(MVT::i32)/8,
 625                                                -16 + NextRegNum * 4);
 626
 627     SmallVector<SDOperand, 4> MemOps;
 628     for (unsigned RegNo = NextRegNum; RegNo < 4; ++RegNo) {
 629       int RegOffset = - (4 - RegNo) * 4;
 630       int FI = MFI->CreateFixedObject(MVT::getSizeInBits(MVT::i32)/8,
 631                                       RegOffset);
 632       SDOperand FIN = DAG.getFrameIndex(FI, MVT::i32);
 633
 634       unsigned VReg = RegMap->createVirtualRegister(&ARM::IntRegsRegClass);
 635       MF.addLiveIn(REGS[RegNo], VReg);
 636
 637       SDOperand Val = DAG.getCopyFromReg(Root, VReg, MVT::i32);
 638       SDOperand Store = DAG.getStore(Val.getValue(1), Val, FIN, NULL, 0);
 639       MemOps.push_back(Store);
 640     }
 641     Root = DAG.getNode(ISD::TokenFactor, MVT::Other,&MemOps[0],MemOps.size());
 642   }
 643
 644   ArgValues.push_back(Root);
 645
 646   // Return the new list of results.
 647   std::vector<MVT::ValueType> RetVT(Op.Val->value_begin(),
 648                                     Op.Val->value_end());
 649   return DAG.getNode(ISD::MERGE_VALUES, RetVT, &ArgValues[0], ArgValues.size());
 650 }
 651
 652 static SDOperand GetCMP(ISD::CondCode CC, SDOperand LHS, SDOperand RHS,
 653                         SelectionDAG &DAG) {
 654   MVT::ValueType vt = LHS.getValueType();
 655   assert(vt == MVT::i32 || vt == MVT::f32 || vt == MVT::f64);
 656
 657   SDOperand Cmp = DAG.getNode(ARMISD::CMP,  MVT::Flag, LHS, RHS);
 658
 659   if (vt != MVT::i32)
 660     Cmp = DAG.getNode(ARMISD::FMSTAT, MVT::Flag, Cmp);
 661   return Cmp;
 662 }
 663
 664 static std::vector<SDOperand> GetARMCC(ISD::CondCode CC, MVT::ValueType vt,
 665                           SelectionDAG &DAG) {
 666   assert(vt == MVT::i32 || vt == MVT::f32 || vt == MVT::f64);
 667   std::vector<unsigned> vcc;
 668   if (vt == MVT::i32)
 669     vcc = DAGIntCCToARMCC(CC);
 670   else
 671     vcc = DAGFPCCToARMCC(CC);
 672
 673   std::vector<unsigned>::iterator it;
 674   std::vector<SDOperand> result;
 675   for( it = vcc.begin(); it != vcc.end(); it++ )
 676     result.push_back(DAG.getConstant(*it,MVT::i32));
 677   return result;
 678 }
 679
 680 static bool isUInt8Immediate(uint32_t x) {
 681   return x < (1 << 8);
 682 }
 683
 684 static uint32_t rotateL(uint32_t x) {
 685   uint32_t bit31 = (x & (1 << 31)) >> 31;
 686   uint32_t     t = x << 1;
 687   return t | bit31;
 688 }
 689
 690 static bool isRotInt8Immediate(uint32_t x) {
 691   int r;
 692   for (r = 0; r < 16; r++) {
 693     if (isUInt8Immediate(x))
 694       return true;
 695     x = rotateL(rotateL(x));
 696   }
 697   return false;
 698 }
 699
 700 static void LowerCMP(SDOperand &Cmp, std::vector<SDOperand> &ARMCC,
 701                      SDOperand LHS, SDOperand RHS, ISD::CondCode CC,
 702                      SelectionDAG &DAG) {
 703   MVT::ValueType vt = LHS.getValueType();
 704   if (vt == MVT::i32) {
 705     assert(!isa<ConstantSDNode>(LHS));
 706     if (ConstantSDNode *SD_C = dyn_cast<ConstantSDNode>(RHS.Val)) {
 707       uint32_t C = SD_C->getValue();
 708
 709       uint32_t NC;
 710       switch(CC) {
 711       default:
 712         NC = C; break;
 713       case ISD::SETLT:
 714       case ISD::SETULT:
 715       case ISD::SETGE:
 716       case ISD::SETUGE:
 717         NC = C - 1; break;
 718       case ISD::SETLE:
 719       case ISD::SETULE:
 720       case ISD::SETGT:
 721       case ISD::SETUGT:
 722         NC = C + 1; break;
 723       }
 724
 725       ISD::CondCode NCC;
 726       switch(CC) {
 727       default:
 728         NCC = CC; break;
 729       case ISD::SETLT:
 730         NCC = ISD::SETLE; break;
 731       case ISD::SETULT:
 732         NCC = ISD::SETULE; break;
 733       case ISD::SETGE:
 734         NCC = ISD::SETGT; break;
 735       case ISD::SETUGE:
 736         NCC = ISD::SETUGT; break;
 737       case ISD::SETLE:
 738         NCC = ISD::SETLT; break;
 739       case ISD::SETULE:
 740         NCC = ISD::SETULT; break;
 741       case ISD::SETGT:
 742         NCC = ISD::SETGE; break;
 743       case ISD::SETUGT:
 744         NCC = ISD::SETUGE; break;
 745       }
 746
 747       if (!isRotInt8Immediate(C) && isRotInt8Immediate(NC)) {
 748         RHS = DAG.getConstant(NC, MVT::i32);
 749         CC  = NCC;
 750       }
 751     }
 752   }
 753   Cmp   = GetCMP(CC, LHS, RHS, DAG);
 754   ARMCC = GetARMCC(CC, vt, DAG);
 755 }
 756
 757 static SDOperand LowerSELECT_CC(SDOperand Op, SelectionDAG &DAG) {
 758   SDOperand LHS = Op.getOperand(0);
 759   SDOperand RHS = Op.getOperand(1);
 760   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
 761   SDOperand TrueVal = Op.getOperand(2);
 762   SDOperand FalseVal = Op.getOperand(3);
 763   SDOperand Cmp;
 764   std::vector<SDOperand> ARMCC;
 765   LowerCMP(Cmp, ARMCC, LHS, RHS, CC, DAG);
 766
 767   SDOperand Aux = FalseVal;
 768   SDVTList  VTs = DAG.getVTList(Op.getValueType(), MVT::Flag);
 769   std::vector<SDOperand>::iterator it;
 770   for (it = ARMCC.begin(); it != ARMCC.end(); ++it){
 771     SDOperand  Flag = it == ARMCC.begin() ? Cmp : Aux.getValue(1);
 772     SDOperand Ops[] = {TrueVal, Aux, *it, Flag};
 773     Aux  = DAG.getNode(ARMISD::SELECT, VTs, Ops, 4);
 774   }
 775   return Aux;
 776 }
 777
 778 static SDOperand LowerBR_CC(SDOperand Op, SelectionDAG &DAG) {
 779   SDOperand  Chain = Op.getOperand(0);
 780   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
 781   SDOperand    LHS = Op.getOperand(2);
 782   SDOperand    RHS = Op.getOperand(3);
 783   SDOperand   Dest = Op.getOperand(4);
 784   SDOperand Cmp;
 785   std::vector<SDOperand> ARMCC;
 786   LowerCMP(Cmp, ARMCC, LHS, RHS, CC, DAG);
 787
 788   SDOperand Aux = Chain;
 789   SDVTList  VTs = DAG.getVTList(MVT::Other, MVT::Flag);
 790   std::vector<SDOperand>::iterator it;
 791   for (it = ARMCC.begin(); it != ARMCC.end(); it++){
 792     SDOperand  Flag = it == ARMCC.begin() ? Cmp : Aux.getValue(1);
 793     SDOperand Ops[] = {Aux, Dest, *it, Flag};
 794     Aux = DAG.getNode(ARMISD::BR, VTs, Ops, 4);
 795   }
 796   return Aux;
 797 }
 798
 799 static SDOperand LowerSINT_TO_FP(SDOperand Op, SelectionDAG &DAG) {
 800   SDOperand IntVal  = Op.getOperand(0);
 801   assert(IntVal.getValueType() == MVT::i32);
 802   MVT::ValueType vt = Op.getValueType();
 803   assert(vt == MVT::f32 ||
 804          vt == MVT::f64);
 805
 806   SDOperand Tmp = DAG.getNode(ISD::BIT_CONVERT, MVT::f32, IntVal);
 807   ARMISD::NodeType op = vt == MVT::f32 ? ARMISD::FSITOS : ARMISD::FSITOD;
 808   return DAG.getNode(op, vt, Tmp);
 809 }
 810
 811 static SDOperand LowerFP_TO_SINT(SDOperand Op, SelectionDAG &DAG) {
 812   assert(Op.getValueType() == MVT::i32);
 813   SDOperand FloatVal = Op.getOperand(0);
 814   MVT::ValueType  vt = FloatVal.getValueType();
 815   assert(vt == MVT::f32 || vt == MVT::f64);
 816
 817   ARMISD::NodeType op = vt == MVT::f32 ? ARMISD::FTOSIS : ARMISD::FTOSID;
 818   SDOperand Tmp = DAG.getNode(op, MVT::f32, FloatVal);
 819   return DAG.getNode(ISD::BIT_CONVERT, MVT::i32, Tmp);
 820 }
 821
 822 static SDOperand LowerUINT_TO_FP(SDOperand Op, SelectionDAG &DAG) {
 823   SDOperand IntVal  = Op.getOperand(0);
 824   assert(IntVal.getValueType() == MVT::i32);
 825   MVT::ValueType vt = Op.getValueType();
 826   assert(vt == MVT::f32 ||
 827          vt == MVT::f64);
 828
 829   SDOperand Tmp = DAG.getNode(ISD::BIT_CONVERT, MVT::f32, IntVal);
 830   ARMISD::NodeType op = vt == MVT::f32 ? ARMISD::FUITOS : ARMISD::FUITOD;
 831   return DAG.getNode(op, vt, Tmp);
 832 }
 833
 834 static SDOperand LowerFP_TO_UINT(SDOperand Op, SelectionDAG &DAG) {
 835   assert(Op.getValueType() == MVT::i32);
 836   SDOperand FloatVal = Op.getOperand(0);
 837   MVT::ValueType  vt = FloatVal.getValueType();
 838   assert(vt == MVT::f32 || vt == MVT::f64);
 839
 840   ARMISD::NodeType op = vt == MVT::f32 ? ARMISD::FTOUIS : ARMISD::FTOUID;
 841   SDOperand Tmp = DAG.getNode(op, MVT::f32, FloatVal);
 842   return DAG.getNode(ISD::BIT_CONVERT, MVT::i32, Tmp);
 843 }
 844
 845 SDOperand ARMTargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) {
 846   switch (Op.getOpcode()) {
 847   default:
 848     assert(0 && "Should not custom lower this!");
 849     abort();
 850   case ISD::ConstantPool:
 851     return LowerConstantPool(Op, DAG);
 852   case ISD::GlobalAddress:
 853     return LowerGlobalAddress(Op, DAG);
 854   case ISD::FP_TO_SINT:
 855     return LowerFP_TO_SINT(Op, DAG);
 856   case ISD::SINT_TO_FP:
 857     return LowerSINT_TO_FP(Op, DAG);
 858   case ISD::FP_TO_UINT:
 859     return LowerFP_TO_UINT(Op, DAG);
 860   case ISD::UINT_TO_FP:
 861     return LowerUINT_TO_FP(Op, DAG);
 862   case ISD::FORMAL_ARGUMENTS:
 863     return LowerFORMAL_ARGUMENTS(Op, DAG, VarArgsFrameIndex);
 864   case ISD::CALL:
 865     return LowerCALL(Op, DAG);
 866   case ISD::RET:
 867     return LowerRET(Op, DAG);
 868   case ISD::SELECT_CC:
 869     return LowerSELECT_CC(Op, DAG);
 870   case ISD::BR_CC:
 871     return LowerBR_CC(Op, DAG);
 872   case ISD::VASTART:
 873     return LowerVASTART(Op, DAG, VarArgsFrameIndex);
 874   }
 875 }
 876
 877 //===----------------------------------------------------------------------===//
 878 // Instruction Selector Implementation
 879 //===----------------------------------------------------------------------===//
 880
 881 //===--------------------------------------------------------------------===//
 882 /// ARMDAGToDAGISel - ARM specific code to select ARM machine
 883 /// instructions for SelectionDAG operations.
 884 ///
 885 namespace {
 886 class ARMDAGToDAGISel : public SelectionDAGISel {
 887   ARMTargetLowering Lowering;
 888
 889 public:
 890   ARMDAGToDAGISel(TargetMachine &TM)
 891     : SelectionDAGISel(Lowering), Lowering(TM) {
 892   }
 893
 894   SDNode *Select(SDOperand Op);
 895   virtual void InstructionSelectBasicBlock(SelectionDAG &DAG);
 896   bool SelectAddrMode1(SDOperand Op, SDOperand N, SDOperand &Arg,
 897                        SDOperand &Shift, SDOperand &ShiftType);
 898   bool SelectAddrMode1a(SDOperand Op, SDOperand N, SDOperand &Arg,
 899                         SDOperand &Shift, SDOperand &ShiftType);
 900   bool SelectAddrMode2(SDOperand Op, SDOperand N, SDOperand &Arg,
 901                        SDOperand &Offset);
 902   bool SelectAddrMode5(SDOperand Op, SDOperand N, SDOperand &Arg,
 903                        SDOperand &Offset);
 904
 905   // Include the pieces autogenerated from the target description.
 906 #include "ARMGenDAGISel.inc"
 907 };
 908
 909 void ARMDAGToDAGISel::InstructionSelectBasicBlock(SelectionDAG &DAG) {
 910   DEBUG(BB->dump());
 911
 912   DAG.setRoot(SelectRoot(DAG.getRoot()));
 913   DAG.RemoveDeadNodes();
 914
 915   ScheduleAndEmitDAG(DAG);
 916 }
 917
 918 static bool isInt12Immediate(SDNode *N, short &Imm) {
 919   if (N->getOpcode() != ISD::Constant)
 920     return false;
 921
 922   int32_t t = cast<ConstantSDNode>(N)->getValue();
 923   int max = 1<<12;
 924   int min = -max;
 925   if (t > min && t < max) {
 926     Imm = t;
 927     return true;
 928   }
 929   else
 930     return false;
 931 }
 932
 933 static bool isInt12Immediate(SDOperand Op, short &Imm) {
 934   return isInt12Immediate(Op.Val, Imm);
 935 }
 936
 937 bool ARMDAGToDAGISel::SelectAddrMode1(SDOperand Op,
 938                                       SDOperand N,
 939                                       SDOperand &Arg,
 940                                       SDOperand &Shift,
 941                                       SDOperand &ShiftType) {
 942   switch(N.getOpcode()) {
 943   case ISD::Constant: {
 944     uint32_t val = cast<ConstantSDNode>(N)->getValue();
 945     if(!isRotInt8Immediate(val)) {
 946       SDOperand Z = CurDAG->getTargetConstant(0,     MVT::i32);
 947       SDNode *n;
 948       if (isRotInt8Immediate(~val)) {
 949         SDOperand C = CurDAG->getTargetConstant(~val,  MVT::i32);
 950         n           = CurDAG->getTargetNode(ARM::MVN,  MVT::i32, C, Z, Z);
 951      } else {
 952         Constant    *C = ConstantInt::get(Type::Int32Ty, val);
 953         int  alignment = 2;
 954         SDOperand Addr = CurDAG->getTargetConstantPool(C, MVT::i32, alignment);
 955         n              = CurDAG->getTargetNode(ARM::LDR,  MVT::i32, Addr, Z);
 956       }
 957       Arg            = SDOperand(n, 0);
 958     } else
 959       Arg            = CurDAG->getTargetConstant(val,    MVT::i32);
 960
 961     Shift     = CurDAG->getTargetConstant(0,             MVT::i32);
 962     ShiftType = CurDAG->getTargetConstant(ARMShift::LSL, MVT::i32);
 963     return true;
 964   }
 965   case ISD::SRA:
 966     Arg       = N.getOperand(0);
 967     Shift     = N.getOperand(1);
 968     ShiftType = CurDAG->getTargetConstant(ARMShift::ASR, MVT::i32);
 969     return true;
 970   case ISD::SRL:
 971     Arg       = N.getOperand(0);
 972     Shift     = N.getOperand(1);
 973     ShiftType = CurDAG->getTargetConstant(ARMShift::LSR, MVT::i32);
 974     return true;
 975   case ISD::SHL:
 976     Arg       = N.getOperand(0);
 977     Shift     = N.getOperand(1);
 978     ShiftType = CurDAG->getTargetConstant(ARMShift::LSL, MVT::i32);
 979     return true;
 980   }
 981
 982   Arg       = N;
 983   Shift     = CurDAG->getTargetConstant(0, MVT::i32);
 984   ShiftType = CurDAG->getTargetConstant(ARMShift::LSL, MVT::i32);
 985   return true;
 986 }
 987
 988 bool ARMDAGToDAGISel::SelectAddrMode2(SDOperand Op, SDOperand N,
 989                                       SDOperand &Arg, SDOperand &Offset) {
 990   //TODO: complete and cleanup!
 991   SDOperand Zero = CurDAG->getTargetConstant(0, MVT::i32);
 992   if (FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(N)) {
 993     Arg    = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i32);
 994     Offset = Zero;
 995     return true;
 996   }
 997   if (N.getOpcode() == ISD::ADD) {
 998     short imm = 0;
 999     if (isInt12Immediate(N.getOperand(1), imm)) {
1000       Offset = CurDAG->getTargetConstant(imm, MVT::i32);
1001       if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) {
1002         Arg = CurDAG->getTargetFrameIndex(FI->getIndex(), N.getValueType());
1003       } else {
1004         Arg = N.getOperand(0);
1005       }
1006       return true; // [r+i]
1007     }
1008   }
1009   Offset = Zero;
1010   if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N))
1011     Arg = CurDAG->getTargetFrameIndex(FI->getIndex(), N.getValueType());
1012   else
1013     Arg = N;
1014   return true;
1015 }
1016
1017 bool ARMDAGToDAGISel::SelectAddrMode5(SDOperand Op,
1018                                       SDOperand N, SDOperand &Arg,
1019                                       SDOperand &Offset) {
1020   //TODO: detect offset
1021   Offset = CurDAG->getTargetConstant(0, MVT::i32);
1022   Arg    = N;
1023   return true;
1024 }
1025
1026 SDNode *ARMDAGToDAGISel::Select(SDOperand Op) {
1027   SDNode *N = Op.Val;
1028
1029   switch (N->getOpcode()) {
1030   default:
1031     return SelectCode(Op);
1032     break;
1033   case ISD::FrameIndex: {
1034     int FI = cast<FrameIndexSDNode>(N)->getIndex();
1035     SDOperand Ops[] = {CurDAG->getTargetFrameIndex(FI, MVT::i32),
1036                        CurDAG->getTargetConstant(0, MVT::i32),
1037                        CurDAG->getTargetConstant(0, MVT::i32),
1038                        CurDAG->getTargetConstant(ARMShift::LSL, MVT::i32)};
1039
1040     return CurDAG->SelectNodeTo(N, ARM::ADD, MVT::i32, Ops,
1041                                 sizeof(Ops)/sizeof(SDOperand));
1042     break;
1043   }
1044   }
1045 }
1046
1047 }  // end anonymous namespace
1048
1049 /// createARMISelDag - This pass converts a legalized DAG into a
1050 /// ARM-specific DAG, ready for instruction scheduling.
1051 ///
1052 FunctionPass *llvm::createARMISelDag(TargetMachine &TM) {
1053   return new ARMDAGToDAGISel(TM);
1054 }