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