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