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