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