lib/Target/CellSPU/SPUISelDAGToDAG.cpp

   1 //===-- SPUISelDAGToDAG.cpp - CellSPU pattern matching inst selector ------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines a pattern matching instruction selector for the Cell SPU,
  11 // converting from a legalized dag to a SPU-target dag.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "SPU.h"
  16 #include "SPUTargetMachine.h"
  17 #include "SPUISelLowering.h"
  18 #include "SPUHazardRecognizers.h"
  19 #include "SPUFrameInfo.h"
  20 #include "SPURegisterNames.h"
  21 #include "SPUTargetMachine.h"
  22 #include "llvm/CodeGen/MachineConstantPool.h"
  23 #include "llvm/CodeGen/MachineInstrBuilder.h"
  24 #include "llvm/CodeGen/MachineFunction.h"
  25 #include "llvm/CodeGen/SelectionDAG.h"
  26 #include "llvm/CodeGen/SelectionDAGISel.h"
  27 #include "llvm/CodeGen/PseudoSourceValue.h"
  28 #include "llvm/Target/TargetOptions.h"
  29 #include "llvm/ADT/Statistic.h"
  30 #include "llvm/Constants.h"
  31 #include "llvm/GlobalValue.h"
  32 #include "llvm/Intrinsics.h"
  33 #include "llvm/LLVMContext.h"
  34 #include "llvm/Support/Debug.h"
  35 #include "llvm/Support/ErrorHandling.h"
  36 #include "llvm/Support/MathExtras.h"
  37 #include "llvm/Support/Compiler.h"
  38 #include "llvm/Support/raw_ostream.h"
  39
  40 using namespace llvm;
  41
  42 namespace {
  43   //! ConstantSDNode predicate for i32 sign-extended, 10-bit immediates
  44   bool
  45   isI64IntS10Immediate(ConstantSDNode *CN)
  46   {
  47     return isS10Constant(CN->getSExtValue());
  48   }
  49
  50   //! ConstantSDNode predicate for i32 sign-extended, 10-bit immediates
  51   bool
  52   isI32IntS10Immediate(ConstantSDNode *CN)
  53   {
  54     return isS10Constant(CN->getSExtValue());
  55   }
  56
  57   //! ConstantSDNode predicate for i32 unsigned 10-bit immediate values
  58   bool
  59   isI32IntU10Immediate(ConstantSDNode *CN)
  60   {
  61     return isU10Constant(CN->getSExtValue());
  62   }
  63
  64   //! ConstantSDNode predicate for i16 sign-extended, 10-bit immediate values
  65   bool
  66   isI16IntS10Immediate(ConstantSDNode *CN)
  67   {
  68     return isS10Constant(CN->getSExtValue());
  69   }
  70
  71   //! SDNode predicate for i16 sign-extended, 10-bit immediate values
  72   bool
  73   isI16IntS10Immediate(SDNode *N)
  74   {
  75     ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N);
  76     return (CN != 0 && isI16IntS10Immediate(CN));
  77   }
  78
  79   //! ConstantSDNode predicate for i16 unsigned 10-bit immediate values
  80   bool
  81   isI16IntU10Immediate(ConstantSDNode *CN)
  82   {
  83     return isU10Constant((short) CN->getZExtValue());
  84   }
  85
  86   //! SDNode predicate for i16 sign-extended, 10-bit immediate values
  87   bool
  88   isI16IntU10Immediate(SDNode *N)
  89   {
  90     return (N->getOpcode() == ISD::Constant
  91             && isI16IntU10Immediate(cast<ConstantSDNode>(N)));
  92   }
  93
  94   //! ConstantSDNode predicate for signed 16-bit values
  95   /*!
  96     \arg CN The constant SelectionDAG node holding the value
  97     \arg Imm The returned 16-bit value, if returning true
  98
  99     This predicate tests the value in \a CN to see whether it can be
 100     represented as a 16-bit, sign-extended quantity. Returns true if
 101     this is the case.
 102    */
 103   bool
 104   isIntS16Immediate(ConstantSDNode *CN, short &Imm)
 105   {
 106     EVT vt = CN->getValueType(0);
 107     Imm = (short) CN->getZExtValue();
 108     if (vt.getSimpleVT() >= MVT::i1 && vt.getSimpleVT() <= MVT::i16) {
 109       return true;
 110     } else if (vt == MVT::i32) {
 111       int32_t i_val = (int32_t) CN->getZExtValue();
 112       short s_val = (short) i_val;
 113       return i_val == s_val;
 114     } else {
 115       int64_t i_val = (int64_t) CN->getZExtValue();
 116       short s_val = (short) i_val;
 117       return i_val == s_val;
 118     }
 119
 120     return false;
 121   }
 122
 123   //! SDNode predicate for signed 16-bit values.
 124   bool
 125   isIntS16Immediate(SDNode *N, short &Imm)
 126   {
 127     return (N->getOpcode() == ISD::Constant
 128             && isIntS16Immediate(cast<ConstantSDNode>(N), Imm));
 129   }
 130
 131   //! ConstantFPSDNode predicate for representing floats as 16-bit sign ext.
 132   static bool
 133   isFPS16Immediate(ConstantFPSDNode *FPN, short &Imm)
 134   {
 135     EVT vt = FPN->getValueType(0);
 136     if (vt == MVT::f32) {
 137       int val = FloatToBits(FPN->getValueAPF().convertToFloat());
 138       int sval = (int) ((val << 16) >> 16);
 139       Imm = (short) val;
 140       return val == sval;
 141     }
 142
 143     return false;
 144   }
 145
 146   bool
 147   isHighLow(const SDValue &Op)
 148   {
 149     return (Op.getOpcode() == SPUISD::IndirectAddr
 150             && ((Op.getOperand(0).getOpcode() == SPUISD::Hi
 151                  && Op.getOperand(1).getOpcode() == SPUISD::Lo)
 152                 || (Op.getOperand(0).getOpcode() == SPUISD::Lo
 153                     && Op.getOperand(1).getOpcode() == SPUISD::Hi)));
 154   }
 155
 156   //===------------------------------------------------------------------===//
 157   //! EVT to "useful stuff" mapping structure:
 158
 159   struct valtype_map_s {
 160     EVT VT;
 161     unsigned ldresult_ins;      /// LDRESULT instruction (0 = undefined)
 162     bool ldresult_imm;          /// LDRESULT instruction requires immediate?
 163     unsigned lrinst;            /// LR instruction
 164   };
 165
 166   const valtype_map_s valtype_map[] = {
 167     { MVT::i8,    SPU::ORBIr8,  true,  SPU::LRr8 },
 168     { MVT::i16,   SPU::ORHIr16, true,  SPU::LRr16 },
 169     { MVT::i32,   SPU::ORIr32,  true,  SPU::LRr32 },
 170     { MVT::i64,   SPU::ORr64,   false, SPU::LRr64 },
 171     { MVT::f32,   SPU::ORf32,   false, SPU::LRf32 },
 172     { MVT::f64,   SPU::ORf64,   false, SPU::LRf64 },
 173     // vector types... (sigh!)
 174     { MVT::v16i8, 0,            false, SPU::LRv16i8 },
 175     { MVT::v8i16, 0,            false, SPU::LRv8i16 },
 176     { MVT::v4i32, 0,            false, SPU::LRv4i32 },
 177     { MVT::v2i64, 0,            false, SPU::LRv2i64 },
 178     { MVT::v4f32, 0,            false, SPU::LRv4f32 },
 179     { MVT::v2f64, 0,            false, SPU::LRv2f64 }
 180   };
 181
 182   const size_t n_valtype_map = sizeof(valtype_map) / sizeof(valtype_map[0]);
 183
 184   const valtype_map_s *getValueTypeMapEntry(EVT VT)
 185   {
 186     const valtype_map_s *retval = 0;
 187     for (size_t i = 0; i < n_valtype_map; ++i) {
 188       if (valtype_map[i].VT == VT) {
 189         retval = valtype_map + i;
 190         break;
 191       }
 192     }
 193
 194
 195 #ifndef NDEBUG
 196     if (retval == 0) {
 197       std::string msg;
 198       raw_string_ostream Msg(msg);
 199       Msg << "SPUISelDAGToDAG.cpp: getValueTypeMapEntry returns NULL for "
 200            << VT.getEVTString();
 201       llvm_report_error(Msg.str());
 202     }
 203 #endif
 204
 205     return retval;
 206   }
 207
 208   //! Generate the carry-generate shuffle mask.
 209   SDValue getCarryGenerateShufMask(SelectionDAG &DAG, DebugLoc dl) {
 210     SmallVector<SDValue, 16 > ShufBytes;
 211
 212     // Create the shuffle mask for "rotating" the borrow up one register slot
 213     // once the borrow is generated.
 214     ShufBytes.push_back(DAG.getConstant(0x04050607, MVT::i32));
 215     ShufBytes.push_back(DAG.getConstant(0x80808080, MVT::i32));
 216     ShufBytes.push_back(DAG.getConstant(0x0c0d0e0f, MVT::i32));
 217     ShufBytes.push_back(DAG.getConstant(0x80808080, MVT::i32));
 218
 219     return DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
 220                        &ShufBytes[0], ShufBytes.size());
 221   }
 222
 223   //! Generate the borrow-generate shuffle mask
 224   SDValue getBorrowGenerateShufMask(SelectionDAG &DAG, DebugLoc dl) {
 225     SmallVector<SDValue, 16 > ShufBytes;
 226
 227     // Create the shuffle mask for "rotating" the borrow up one register slot
 228     // once the borrow is generated.
 229     ShufBytes.push_back(DAG.getConstant(0x04050607, MVT::i32));
 230     ShufBytes.push_back(DAG.getConstant(0xc0c0c0c0, MVT::i32));
 231     ShufBytes.push_back(DAG.getConstant(0x0c0d0e0f, MVT::i32));
 232     ShufBytes.push_back(DAG.getConstant(0xc0c0c0c0, MVT::i32));
 233
 234     return DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
 235                        &ShufBytes[0], ShufBytes.size());
 236   }
 237
 238   //===------------------------------------------------------------------===//
 239   /// SPUDAGToDAGISel - Cell SPU-specific code to select SPU machine
 240   /// instructions for SelectionDAG operations.
 241   ///
 242   class SPUDAGToDAGISel :
 243     public SelectionDAGISel
 244   {
 245     SPUTargetMachine &TM;
 246     SPUTargetLowering &SPUtli;
 247     unsigned GlobalBaseReg;
 248
 249   public:
 250     explicit SPUDAGToDAGISel(SPUTargetMachine &tm) :
 251       SelectionDAGISel(tm),
 252       TM(tm),
 253       SPUtli(*tm.getTargetLowering())
 254     { }
 255
 256     virtual bool runOnMachineFunction(MachineFunction &MF) {
 257       // Make sure we re-emit a set of the global base reg if necessary
 258       GlobalBaseReg = 0;
 259       SelectionDAGISel::runOnMachineFunction(MF);
 260       return true;
 261     }
 262
 263     /// getI32Imm - Return a target constant with the specified value, of type
 264     /// i32.
 265     inline SDValue getI32Imm(uint32_t Imm) {
 266       return CurDAG->getTargetConstant(Imm, MVT::i32);
 267     }
 268
 269     /// getI64Imm - Return a target constant with the specified value, of type
 270     /// i64.
 271     inline SDValue getI64Imm(uint64_t Imm) {
 272       return CurDAG->getTargetConstant(Imm, MVT::i64);
 273     }
 274
 275     /// getSmallIPtrImm - Return a target constant of pointer type.
 276     inline SDValue getSmallIPtrImm(unsigned Imm) {
 277       return CurDAG->getTargetConstant(Imm, SPUtli.getPointerTy());
 278       }
 279
 280     SDNode *emitBuildVector(SDNode *bvNode) {
 281       EVT vecVT = bvNode->getValueType(0);
 282       EVT eltVT = vecVT.getVectorElementType();
 283       DebugLoc dl = bvNode->getDebugLoc();
 284
 285       // Check to see if this vector can be represented as a CellSPU immediate
 286       // constant by invoking all of the instruction selection predicates:
 287       if (((vecVT == MVT::v8i16) &&
 288            (SPU::get_vec_i16imm(bvNode, *CurDAG, MVT::i16).getNode() != 0)) ||
 289           ((vecVT == MVT::v4i32) &&
 290            ((SPU::get_vec_i16imm(bvNode, *CurDAG, MVT::i32).getNode() != 0) ||
 291             (SPU::get_ILHUvec_imm(bvNode, *CurDAG, MVT::i32).getNode() != 0) ||
 292             (SPU::get_vec_u18imm(bvNode, *CurDAG, MVT::i32).getNode() != 0) ||
 293             (SPU::get_v4i32_imm(bvNode, *CurDAG).getNode() != 0))) ||
 294           ((vecVT == MVT::v2i64) &&
 295            ((SPU::get_vec_i16imm(bvNode, *CurDAG, MVT::i64).getNode() != 0) ||
 296             (SPU::get_ILHUvec_imm(bvNode, *CurDAG, MVT::i64).getNode() != 0) ||
 297             (SPU::get_vec_u18imm(bvNode, *CurDAG, MVT::i64).getNode() != 0)))) {
 298         HandleSDNode Dummy(SDValue(bvNode, 0));
 299         Select(bvNode);
 300         return Dummy.getValue().getNode();
 301       }
 302
 303       // No, need to emit a constant pool spill:
 304       std::vector<Constant*> CV;
 305
 306       for (size_t i = 0; i < bvNode->getNumOperands(); ++i) {
 307         ConstantSDNode *V = dyn_cast<ConstantSDNode > (bvNode->getOperand(i));
 308         CV.push_back(const_cast<ConstantInt *>(V->getConstantIntValue()));
 309       }
 310
 311       Constant *CP = ConstantVector::get(CV);
 312       SDValue CPIdx = CurDAG->getConstantPool(CP, SPUtli.getPointerTy());
 313       unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment();
 314       SDValue CGPoolOffset =
 315               SPU::LowerConstantPool(CPIdx, *CurDAG,
 316                                      SPUtli.getSPUTargetMachine());
 317
 318       HandleSDNode Dummy(CurDAG->getLoad(vecVT, dl,
 319                                          CurDAG->getEntryNode(), CGPoolOffset,
 320                                          PseudoSourceValue::getConstantPool(),0,
 321                                          false, false, Alignment));
 322       CurDAG->ReplaceAllUsesWith(SDValue(bvNode, 0), Dummy.getValue());
 323       SelectCode(Dummy.getValue().getNode());
 324       return Dummy.getValue().getNode();
 325     }
 326
 327     /// Select - Convert the specified operand from a target-independent to a
 328     /// target-specific node if it hasn't already been changed.
 329     SDNode *Select(SDNode *N);
 330
 331     //! Emit the instruction sequence for i64 shl
 332     SDNode *SelectSHLi64(SDNode *N, EVT OpVT);
 333
 334     //! Emit the instruction sequence for i64 srl
 335     SDNode *SelectSRLi64(SDNode *N, EVT OpVT);
 336
 337     //! Emit the instruction sequence for i64 sra
 338     SDNode *SelectSRAi64(SDNode *N, EVT OpVT);
 339
 340     //! Emit the necessary sequence for loading i64 constants:
 341     SDNode *SelectI64Constant(SDNode *N, EVT OpVT, DebugLoc dl);
 342
 343     //! Alternate instruction emit sequence for loading i64 constants
 344     SDNode *SelectI64Constant(uint64_t i64const, EVT OpVT, DebugLoc dl);
 345
 346     //! Returns true if the address N is an A-form (local store) address
 347     bool SelectAFormAddr(SDNode *Op, SDValue N, SDValue &Base,
 348                          SDValue &Index);
 349
 350     //! D-form address predicate
 351     bool SelectDFormAddr(SDNode *Op, SDValue N, SDValue &Base,
 352                          SDValue &Index);
 353
 354     /// Alternate D-form address using i7 offset predicate
 355     bool SelectDForm2Addr(SDNode *Op, SDValue N, SDValue &Disp,
 356                           SDValue &Base);
 357
 358     /// D-form address selection workhorse
 359     bool DFormAddressPredicate(SDNode *Op, SDValue N, SDValue &Disp,
 360                                SDValue &Base, int minOffset, int maxOffset);
 361
 362     //! Address predicate if N can be expressed as an indexed [r+r] operation.
 363     bool SelectXFormAddr(SDNode *Op, SDValue N, SDValue &Base,
 364                          SDValue &Index);
 365
 366     /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for
 367     /// inline asm expressions.
 368     virtual bool SelectInlineAsmMemoryOperand(const SDValue &Op,
 369                                               char ConstraintCode,
 370                                               std::vector<SDValue> &OutOps) {
 371       SDValue Op0, Op1;
 372       switch (ConstraintCode) {
 373       default: return true;
 374       case 'm':   // memory
 375         if (!SelectDFormAddr(Op.getNode(), Op, Op0, Op1)
 376             && !SelectAFormAddr(Op.getNode(), Op, Op0, Op1))
 377           SelectXFormAddr(Op.getNode(), Op, Op0, Op1);
 378         break;
 379       case 'o':   // offsetable
 380         if (!SelectDFormAddr(Op.getNode(), Op, Op0, Op1)
 381             && !SelectAFormAddr(Op.getNode(), Op, Op0, Op1)) {
 382           Op0 = Op;
 383           Op1 = getSmallIPtrImm(0);
 384         }
 385         break;
 386       case 'v':   // not offsetable
 387 #if 1
 388         llvm_unreachable("InlineAsmMemoryOperand 'v' constraint not handled.");
 389 #else
 390         SelectAddrIdxOnly(Op, Op, Op0, Op1);
 391 #endif
 392         break;
 393       }
 394
 395       OutOps.push_back(Op0);
 396       OutOps.push_back(Op1);
 397       return false;
 398     }
 399
 400     /// InstructionSelect - This callback is invoked by
 401     /// SelectionDAGISel when it has created a SelectionDAG for us to codegen.
 402     virtual void InstructionSelect();
 403
 404     virtual const char *getPassName() const {
 405       return "Cell SPU DAG->DAG Pattern Instruction Selection";
 406     }
 407
 408     /// CreateTargetHazardRecognizer - Return the hazard recognizer to use for
 409     /// this target when scheduling the DAG.
 410     virtual ScheduleHazardRecognizer *CreateTargetHazardRecognizer() {
 411       const TargetInstrInfo *II = TM.getInstrInfo();
 412       assert(II && "No InstrInfo?");
 413       return new SPUHazardRecognizer(*II);
 414     }
 415
 416     // Include the pieces autogenerated from the target description.
 417 #include "SPUGenDAGISel.inc"
 418   };
 419 }
 420
 421 /// InstructionSelect - This callback is invoked by
 422 /// SelectionDAGISel when it has created a SelectionDAG for us to codegen.
 423 void
 424 SPUDAGToDAGISel::InstructionSelect()
 425 {
 426   // Select target instructions for the DAG.
 427   SelectRoot(*CurDAG);
 428   CurDAG->RemoveDeadNodes();
 429 }
 430
 431 /*!
 432  \arg Op The ISD instruction operand
 433  \arg N The address to be tested
 434  \arg Base The base address
 435  \arg Index The base address index
 436  */
 437 bool
 438 SPUDAGToDAGISel::SelectAFormAddr(SDNode *Op, SDValue N, SDValue &Base,
 439                     SDValue &Index) {
 440   // These match the addr256k operand type:
 441   EVT OffsVT = MVT::i16;
 442   SDValue Zero = CurDAG->getTargetConstant(0, OffsVT);
 443
 444   switch (N.getOpcode()) {
 445   case ISD::Constant:
 446   case ISD::ConstantPool:
 447   case ISD::GlobalAddress:
 448     llvm_report_error("SPU SelectAFormAddr: Constant/Pool/Global not lowered.");
 449     /*NOTREACHED*/
 450
 451   case ISD::TargetConstant:
 452   case ISD::TargetGlobalAddress:
 453   case ISD::TargetJumpTable:
 454     llvm_report_error("SPUSelectAFormAddr: Target Constant/Pool/Global "
 455                       "not wrapped as A-form address.");
 456     /*NOTREACHED*/
 457
 458   case SPUISD::AFormAddr:
 459     // Just load from memory if there's only a single use of the location,
 460     // otherwise, this will get handled below with D-form offset addresses
 461     if (N.hasOneUse()) {
 462       SDValue Op0 = N.getOperand(0);
 463       switch (Op0.getOpcode()) {
 464       case ISD::TargetConstantPool:
 465       case ISD::TargetJumpTable:
 466         Base = Op0;
 467         Index = Zero;
 468         return true;
 469
 470       case ISD::TargetGlobalAddress: {
 471         GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op0);
 472         GlobalValue *GV = GSDN->getGlobal();
 473         if (GV->getAlignment() == 16) {
 474           Base = Op0;
 475           Index = Zero;
 476           return true;
 477         }
 478         break;
 479       }
 480       }
 481     }
 482     break;
 483   }
 484   return false;
 485 }
 486
 487 bool
 488 SPUDAGToDAGISel::SelectDForm2Addr(SDNode *Op, SDValue N, SDValue &Disp,
 489                                   SDValue &Base) {
 490   const int minDForm2Offset = -(1 << 7);
 491   const int maxDForm2Offset = (1 << 7) - 1;
 492   return DFormAddressPredicate(Op, N, Disp, Base, minDForm2Offset,
 493                                maxDForm2Offset);
 494 }
 495
 496 /*!
 497   \arg Op The ISD instruction (ignored)
 498   \arg N The address to be tested
 499   \arg Base Base address register/pointer
 500   \arg Index Base address index
 501
 502   Examine the input address by a base register plus a signed 10-bit
 503   displacement, [r+I10] (D-form address).
 504
 505   \return true if \a N is a D-form address with \a Base and \a Index set
 506   to non-empty SDValue instances.
 507 */
 508 bool
 509 SPUDAGToDAGISel::SelectDFormAddr(SDNode *Op, SDValue N, SDValue &Base,
 510                                  SDValue &Index) {
 511   return DFormAddressPredicate(Op, N, Base, Index,
 512                                SPUFrameInfo::minFrameOffset(),
 513                                SPUFrameInfo::maxFrameOffset());
 514 }
 515
 516 bool
 517 SPUDAGToDAGISel::DFormAddressPredicate(SDNode *Op, SDValue N, SDValue &Base,
 518                                       SDValue &Index, int minOffset,
 519                                       int maxOffset) {
 520   unsigned Opc = N.getOpcode();
 521   EVT PtrTy = SPUtli.getPointerTy();
 522
 523   if (Opc == ISD::FrameIndex) {
 524     // Stack frame index must be less than 512 (divided by 16):
 525     FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(N);
 526     int FI = int(FIN->getIndex());
 527     DEBUG(errs() << "SelectDFormAddr: ISD::FrameIndex = "
 528                << FI << "\n");
 529     if (SPUFrameInfo::FItoStackOffset(FI) < maxOffset) {
 530       Base = CurDAG->getTargetConstant(0, PtrTy);
 531       Index = CurDAG->getTargetFrameIndex(FI, PtrTy);
 532       return true;
 533     }
 534   } else if (Opc == ISD::ADD) {
 535     // Generated by getelementptr
 536     const SDValue Op0 = N.getOperand(0);
 537     const SDValue Op1 = N.getOperand(1);
 538
 539     if ((Op0.getOpcode() == SPUISD::Hi && Op1.getOpcode() == SPUISD::Lo)
 540         || (Op1.getOpcode() == SPUISD::Hi && Op0.getOpcode() == SPUISD::Lo)) {
 541       Base = CurDAG->getTargetConstant(0, PtrTy);
 542       Index = N;
 543       return true;
 544     } else if (Op1.getOpcode() == ISD::Constant
 545                || Op1.getOpcode() == ISD::TargetConstant) {
 546       ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Op1);
 547       int32_t offset = int32_t(CN->getSExtValue());
 548
 549       if (Op0.getOpcode() == ISD::FrameIndex) {
 550         FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Op0);
 551         int FI = int(FIN->getIndex());
 552         DEBUG(errs() << "SelectDFormAddr: ISD::ADD offset = " << offset
 553                    << " frame index = " << FI << "\n");
 554
 555         if (SPUFrameInfo::FItoStackOffset(FI) < maxOffset) {
 556           Base = CurDAG->getTargetConstant(offset, PtrTy);
 557           Index = CurDAG->getTargetFrameIndex(FI, PtrTy);
 558           return true;
 559         }
 560       } else if (offset > minOffset && offset < maxOffset) {
 561         Base = CurDAG->getTargetConstant(offset, PtrTy);
 562         Index = Op0;
 563         return true;
 564       }
 565     } else if (Op0.getOpcode() == ISD::Constant
 566                || Op0.getOpcode() == ISD::TargetConstant) {
 567       ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Op0);
 568       int32_t offset = int32_t(CN->getSExtValue());
 569
 570       if (Op1.getOpcode() == ISD::FrameIndex) {
 571         FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Op1);
 572         int FI = int(FIN->getIndex());
 573         DEBUG(errs() << "SelectDFormAddr: ISD::ADD offset = " << offset
 574                    << " frame index = " << FI << "\n");
 575
 576         if (SPUFrameInfo::FItoStackOffset(FI) < maxOffset) {
 577           Base = CurDAG->getTargetConstant(offset, PtrTy);
 578           Index = CurDAG->getTargetFrameIndex(FI, PtrTy);
 579           return true;
 580         }
 581       } else if (offset > minOffset && offset < maxOffset) {
 582         Base = CurDAG->getTargetConstant(offset, PtrTy);
 583         Index = Op1;
 584         return true;
 585       }
 586     }
 587   } else if (Opc == SPUISD::IndirectAddr) {
 588     // Indirect with constant offset -> D-Form address
 589     const SDValue Op0 = N.getOperand(0);
 590     const SDValue Op1 = N.getOperand(1);
 591
 592     if (Op0.getOpcode() == SPUISD::Hi
 593         && Op1.getOpcode() == SPUISD::Lo) {
 594       // (SPUindirect (SPUhi <arg>, 0), (SPUlo <arg>, 0))
 595       Base = CurDAG->getTargetConstant(0, PtrTy);
 596       Index = N;
 597       return true;
 598     } else if (isa<ConstantSDNode>(Op0) || isa<ConstantSDNode>(Op1)) {
 599       int32_t offset = 0;
 600       SDValue idxOp;
 601
 602       if (isa<ConstantSDNode>(Op1)) {
 603         ConstantSDNode *CN = cast<ConstantSDNode>(Op1);
 604         offset = int32_t(CN->getSExtValue());
 605         idxOp = Op0;
 606       } else if (isa<ConstantSDNode>(Op0)) {
 607         ConstantSDNode *CN = cast<ConstantSDNode>(Op0);
 608         offset = int32_t(CN->getSExtValue());
 609         idxOp = Op1;
 610       }
 611
 612       if (offset >= minOffset && offset <= maxOffset) {
 613         Base = CurDAG->getTargetConstant(offset, PtrTy);
 614         Index = idxOp;
 615         return true;
 616       }
 617     }
 618   } else if (Opc == SPUISD::AFormAddr) {
 619     Base = CurDAG->getTargetConstant(0, N.getValueType());
 620     Index = N;
 621     return true;
 622   } else if (Opc == SPUISD::LDRESULT) {
 623     Base = CurDAG->getTargetConstant(0, N.getValueType());
 624     Index = N;
 625     return true;
 626   } else if (Opc == ISD::Register || Opc == ISD::CopyFromReg) {
 627     unsigned OpOpc = Op->getOpcode();
 628
 629     if (OpOpc == ISD::STORE || OpOpc == ISD::LOAD) {
 630       // Direct load/store without getelementptr
 631       SDValue Addr, Offs;
 632
 633       // Get the register from CopyFromReg
 634       if (Opc == ISD::CopyFromReg)
 635         Addr = N.getOperand(1);
 636       else
 637         Addr = N;                       // Register
 638
 639       Offs = ((OpOpc == ISD::STORE) ? Op->getOperand(3) : Op->getOperand(2));
 640
 641       if (Offs.getOpcode() == ISD::Constant || Offs.getOpcode() == ISD::UNDEF) {
 642         if (Offs.getOpcode() == ISD::UNDEF)
 643           Offs = CurDAG->getTargetConstant(0, Offs.getValueType());
 644
 645         Base = Offs;
 646         Index = Addr;
 647         return true;
 648       }
 649     } else {
 650       /* If otherwise unadorned, default to D-form address with 0 offset: */
 651       if (Opc == ISD::CopyFromReg) {
 652         Index = N.getOperand(1);
 653       } else {
 654         Index = N;
 655       }
 656
 657       Base = CurDAG->getTargetConstant(0, Index.getValueType());
 658       return true;
 659     }
 660   }
 661
 662   return false;
 663 }
 664
 665 /*!
 666   \arg Op The ISD instruction operand
 667   \arg N The address operand
 668   \arg Base The base pointer operand
 669   \arg Index The offset/index operand
 670
 671   If the address \a N can be expressed as an A-form or D-form address, returns
 672   false.  Otherwise, creates two operands, Base and Index that will become the
 673   (r)(r) X-form address.
 674 */
 675 bool
 676 SPUDAGToDAGISel::SelectXFormAddr(SDNode *Op, SDValue N, SDValue &Base,
 677                                  SDValue &Index) {
 678   if (!SelectAFormAddr(Op, N, Base, Index)
 679       && !SelectDFormAddr(Op, N, Base, Index)) {
 680     // If the address is neither A-form or D-form, punt and use an X-form
 681     // address:
 682     Base = N.getOperand(1);
 683     Index = N.getOperand(0);
 684     return true;
 685   }
 686
 687   return false;
 688 }
 689
 690 //! Convert the operand from a target-independent to a target-specific node
 691 /*!
 692  */
 693 SDNode *
 694 SPUDAGToDAGISel::Select(SDNode *N) {
 695   unsigned Opc = N->getOpcode();
 696   int n_ops = -1;
 697   unsigned NewOpc;
 698   EVT OpVT = N->getValueType(0);
 699   SDValue Ops[8];
 700   DebugLoc dl = N->getDebugLoc();
 701
 702   if (N->isMachineOpcode())
 703     return NULL;   // Already selected.
 704
 705   if (Opc == ISD::FrameIndex) {
 706     int FI = cast<FrameIndexSDNode>(N)->getIndex();
 707     SDValue TFI = CurDAG->getTargetFrameIndex(FI, N->getValueType(0));
 708     SDValue Imm0 = CurDAG->getTargetConstant(0, N->getValueType(0));
 709
 710     if (FI < 128) {
 711       NewOpc = SPU::AIr32;
 712       Ops[0] = TFI;
 713       Ops[1] = Imm0;
 714       n_ops = 2;
 715     } else {
 716       NewOpc = SPU::Ar32;
 717       Ops[0] = CurDAG->getRegister(SPU::R1, N->getValueType(0));
 718       Ops[1] = SDValue(CurDAG->getMachineNode(SPU::ILAr32, dl,
 719                                               N->getValueType(0), TFI, Imm0),
 720                        0);
 721       n_ops = 2;
 722     }
 723   } else if (Opc == ISD::Constant && OpVT == MVT::i64) {
 724     // Catch the i64 constants that end up here. Note: The backend doesn't
 725     // attempt to legalize the constant (it's useless because DAGCombiner
 726     // will insert 64-bit constants and we can't stop it).
 727     return SelectI64Constant(N, OpVT, N->getDebugLoc());
 728   } else if ((Opc == ISD::ZERO_EXTEND || Opc == ISD::ANY_EXTEND)
 729              && OpVT == MVT::i64) {
 730     SDValue Op0 = N->getOperand(0);
 731     EVT Op0VT = Op0.getValueType();
 732     EVT Op0VecVT = EVT::getVectorVT(*CurDAG->getContext(),
 733                                     Op0VT, (128 / Op0VT.getSizeInBits()));
 734     EVT OpVecVT = EVT::getVectorVT(*CurDAG->getContext(),
 735                                    OpVT, (128 / OpVT.getSizeInBits()));
 736     SDValue shufMask;
 737
 738     switch (Op0VT.getSimpleVT().SimpleTy) {
 739     default:
 740       llvm_report_error("CellSPU Select: Unhandled zero/any extend EVT");
 741       /*NOTREACHED*/
 742     case MVT::i32:
 743       shufMask = CurDAG->getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
 744                                  CurDAG->getConstant(0x80808080, MVT::i32),
 745                                  CurDAG->getConstant(0x00010203, MVT::i32),
 746                                  CurDAG->getConstant(0x80808080, MVT::i32),
 747                                  CurDAG->getConstant(0x08090a0b, MVT::i32));
 748       break;
 749
 750     case MVT::i16:
 751       shufMask = CurDAG->getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
 752                                  CurDAG->getConstant(0x80808080, MVT::i32),
 753                                  CurDAG->getConstant(0x80800203, MVT::i32),
 754                                  CurDAG->getConstant(0x80808080, MVT::i32),
 755                                  CurDAG->getConstant(0x80800a0b, MVT::i32));
 756       break;
 757
 758     case MVT::i8:
 759       shufMask = CurDAG->getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
 760                                  CurDAG->getConstant(0x80808080, MVT::i32),
 761                                  CurDAG->getConstant(0x80808003, MVT::i32),
 762                                  CurDAG->getConstant(0x80808080, MVT::i32),
 763                                  CurDAG->getConstant(0x8080800b, MVT::i32));
 764       break;
 765     }
 766
 767     SDNode *shufMaskLoad = emitBuildVector(shufMask.getNode());
 768     SDNode *PromoteScalar =
 769             SelectCode(CurDAG->getNode(SPUISD::PREFSLOT2VEC, dl,
 770                                        Op0VecVT, Op0).getNode());
 771
 772     SDValue zextShuffle =
 773             CurDAG->getNode(SPUISD::SHUFB, dl, OpVecVT,
 774                             SDValue(PromoteScalar, 0),
 775                             SDValue(PromoteScalar, 0),
 776                             SDValue(shufMaskLoad, 0));
 777
 778     // N.B.: BIT_CONVERT replaces and updates the zextShuffle node, so we
 779     // re-use it in the VEC2PREFSLOT selection without needing to explicitly
 780     // call SelectCode (it's already done for us.)
 781     SelectCode(CurDAG->getNode(ISD::BIT_CONVERT, dl, OpVecVT, zextShuffle).getNode());
 782     HandleSDNode Dummy(CurDAG->getNode(SPUISD::VEC2PREFSLOT, dl, OpVT,
 783                                       zextShuffle));
 784
 785     CurDAG->ReplaceAllUsesWith(N, Dummy.getValue().getNode());
 786     SelectCode(Dummy.getValue().getNode());
 787     return Dummy.getValue().getNode();
 788   } else if (Opc == ISD::ADD && (OpVT == MVT::i64 || OpVT == MVT::v2i64)) {
 789     SDNode *CGLoad =
 790             emitBuildVector(getCarryGenerateShufMask(*CurDAG, dl).getNode());
 791
 792     HandleSDNode Dummy(CurDAG->getNode(SPUISD::ADD64_MARKER, dl, OpVT,
 793                                        N->getOperand(0), N->getOperand(1),
 794                                        SDValue(CGLoad, 0)));
 795
 796     CurDAG->ReplaceAllUsesWith(N, Dummy.getValue().getNode());
 797     SelectCode(Dummy.getValue().getNode());
 798     return Dummy.getValue().getNode();
 799   } else if (Opc == ISD::SUB && (OpVT == MVT::i64 || OpVT == MVT::v2i64)) {
 800     SDNode *CGLoad =
 801             emitBuildVector(getBorrowGenerateShufMask(*CurDAG, dl).getNode());
 802
 803     HandleSDNode Dummy(CurDAG->getNode(SPUISD::SUB64_MARKER, dl, OpVT,
 804                                        N->getOperand(0), N->getOperand(1),
 805                                        SDValue(CGLoad, 0)));
 806
 807     CurDAG->ReplaceAllUsesWith(N, Dummy.getValue().getNode());
 808     SelectCode(Dummy.getValue().getNode());
 809     return Dummy.getValue().getNode();
 810   } else if (Opc == ISD::MUL && (OpVT == MVT::i64 || OpVT == MVT::v2i64)) {
 811     SDNode *CGLoad =
 812             emitBuildVector(getCarryGenerateShufMask(*CurDAG, dl).getNode());
 813
 814     HandleSDNode Dummy(CurDAG->getNode(SPUISD::MUL64_MARKER, dl, OpVT,
 815                                        N->getOperand(0), N->getOperand(1),
 816                                        SDValue(CGLoad, 0)));
 817     CurDAG->ReplaceAllUsesWith(N, Dummy.getValue().getNode());
 818     SelectCode(Dummy.getValue().getNode());
 819     return Dummy.getValue().getNode();
 820   } else if (Opc == ISD::TRUNCATE) {
 821     SDValue Op0 = N->getOperand(0);
 822     if ((Op0.getOpcode() == ISD::SRA || Op0.getOpcode() == ISD::SRL)
 823         && OpVT == MVT::i32
 824         && Op0.getValueType() == MVT::i64) {
 825       // Catch (truncate:i32 ([sra|srl]:i64 arg, c), where c >= 32
 826       //
 827       // Take advantage of the fact that the upper 32 bits are in the
 828       // i32 preferred slot and avoid shuffle gymnastics:
 829       ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Op0.getOperand(1));
 830       if (CN != 0) {
 831         unsigned shift_amt = unsigned(CN->getZExtValue());
 832
 833         if (shift_amt >= 32) {
 834           SDNode *hi32 =
 835                   CurDAG->getMachineNode(SPU::ORr32_r64, dl, OpVT,
 836                                          Op0.getOperand(0));
 837
 838           shift_amt -= 32;
 839           if (shift_amt > 0) {
 840             // Take care of the additional shift, if present:
 841             SDValue shift = CurDAG->getTargetConstant(shift_amt, MVT::i32);
 842             unsigned Opc = SPU::ROTMAIr32_i32;
 843
 844             if (Op0.getOpcode() == ISD::SRL)
 845               Opc = SPU::ROTMr32;
 846
 847             hi32 = CurDAG->getMachineNode(Opc, dl, OpVT, SDValue(hi32, 0),
 848                                           shift);
 849           }
 850
 851           return hi32;
 852         }
 853       }
 854     }
 855   } else if (Opc == ISD::SHL) {
 856     if (OpVT == MVT::i64)
 857       return SelectSHLi64(N, OpVT);
 858   } else if (Opc == ISD::SRL) {
 859     if (OpVT == MVT::i64)
 860       return SelectSRLi64(N, OpVT);
 861   } else if (Opc == ISD::SRA) {
 862     if (OpVT == MVT::i64)
 863       return SelectSRAi64(N, OpVT);
 864   } else if (Opc == ISD::FNEG
 865              && (OpVT == MVT::f64 || OpVT == MVT::v2f64)) {
 866     DebugLoc dl = N->getDebugLoc();
 867     // Check if the pattern is a special form of DFNMS:
 868     // (fneg (fsub (fmul R64FP:$rA, R64FP:$rB), R64FP:$rC))
 869     SDValue Op0 = N->getOperand(0);
 870     if (Op0.getOpcode() == ISD::FSUB) {
 871       SDValue Op00 = Op0.getOperand(0);
 872       if (Op00.getOpcode() == ISD::FMUL) {
 873         unsigned Opc = SPU::DFNMSf64;
 874         if (OpVT == MVT::v2f64)
 875           Opc = SPU::DFNMSv2f64;
 876
 877         return CurDAG->getMachineNode(Opc, dl, OpVT,
 878                                       Op00.getOperand(0),
 879                                       Op00.getOperand(1),
 880                                       Op0.getOperand(1));
 881       }
 882     }
 883
 884     SDValue negConst = CurDAG->getConstant(0x8000000000000000ULL, MVT::i64);
 885     SDNode *signMask = 0;
 886     unsigned Opc = SPU::XORfneg64;
 887
 888     if (OpVT == MVT::f64) {
 889       signMask = SelectI64Constant(negConst.getNode(), MVT::i64, dl);
 890     } else if (OpVT == MVT::v2f64) {
 891       Opc = SPU::XORfnegvec;
 892       signMask = emitBuildVector(CurDAG->getNode(ISD::BUILD_VECTOR, dl,
 893                                                  MVT::v2i64,
 894                                                  negConst, negConst).getNode());
 895     }
 896
 897     return CurDAG->getMachineNode(Opc, dl, OpVT,
 898                                   N->getOperand(0), SDValue(signMask, 0));
 899   } else if (Opc == ISD::FABS) {
 900     if (OpVT == MVT::f64) {
 901       SDNode *signMask = SelectI64Constant(0x7fffffffffffffffULL, MVT::i64, dl);
 902       return CurDAG->getMachineNode(SPU::ANDfabs64, dl, OpVT,
 903                                     N->getOperand(0), SDValue(signMask, 0));
 904     } else if (OpVT == MVT::v2f64) {
 905       SDValue absConst = CurDAG->getConstant(0x7fffffffffffffffULL, MVT::i64);
 906       SDValue absVec = CurDAG->getNode(ISD::BUILD_VECTOR, dl, MVT::v2i64,
 907                                        absConst, absConst);
 908       SDNode *signMask = emitBuildVector(absVec.getNode());
 909       return CurDAG->getMachineNode(SPU::ANDfabsvec, dl, OpVT,
 910                                     N->getOperand(0), SDValue(signMask, 0));
 911     }
 912   } else if (Opc == SPUISD::LDRESULT) {
 913     // Custom select instructions for LDRESULT
 914     EVT VT = N->getValueType(0);
 915     SDValue Arg = N->getOperand(0);
 916     SDValue Chain = N->getOperand(1);
 917     SDNode *Result;
 918     const valtype_map_s *vtm = getValueTypeMapEntry(VT);
 919
 920     if (vtm->ldresult_ins == 0) {
 921       std::string msg;
 922       raw_string_ostream Msg(msg);
 923       Msg << "LDRESULT for unsupported type: "
 924            << VT.getEVTString();
 925       llvm_report_error(Msg.str());
 926     }
 927
 928     Opc = vtm->ldresult_ins;
 929     if (vtm->ldresult_imm) {
 930       SDValue Zero = CurDAG->getTargetConstant(0, VT);
 931
 932       Result = CurDAG->getMachineNode(Opc, dl, VT, MVT::Other, Arg, Zero, Chain);
 933     } else {
 934       Result = CurDAG->getMachineNode(Opc, dl, VT, MVT::Other, Arg, Arg, Chain);
 935     }
 936
 937     return Result;
 938   } else if (Opc == SPUISD::IndirectAddr) {
 939     // Look at the operands: SelectCode() will catch the cases that aren't
 940     // specifically handled here.
 941     //
 942     // SPUInstrInfo catches the following patterns:
 943     // (SPUindirect (SPUhi ...), (SPUlo ...))
 944     // (SPUindirect $sp, imm)
 945     EVT VT = N->getValueType(0);
 946     SDValue Op0 = N->getOperand(0);
 947     SDValue Op1 = N->getOperand(1);
 948     RegisterSDNode *RN;
 949
 950     if ((Op0.getOpcode() != SPUISD::Hi && Op1.getOpcode() != SPUISD::Lo)
 951         || (Op0.getOpcode() == ISD::Register
 952             && ((RN = dyn_cast<RegisterSDNode>(Op0.getNode())) != 0
 953                 && RN->getReg() != SPU::R1))) {
 954       NewOpc = SPU::Ar32;
 955       if (Op1.getOpcode() == ISD::Constant) {
 956         ConstantSDNode *CN = cast<ConstantSDNode>(Op1);
 957         Op1 = CurDAG->getTargetConstant(CN->getSExtValue(), VT);
 958         NewOpc = (isI32IntS10Immediate(CN) ? SPU::AIr32 : SPU::Ar32);
 959       }
 960       Ops[0] = Op0;
 961       Ops[1] = Op1;
 962       n_ops = 2;
 963     }
 964   }
 965
 966   if (n_ops > 0) {
 967     if (N->hasOneUse())
 968       return CurDAG->SelectNodeTo(N, NewOpc, OpVT, Ops, n_ops);
 969     else
 970       return CurDAG->getMachineNode(NewOpc, dl, OpVT, Ops, n_ops);
 971   } else
 972     return SelectCode(N);
 973 }
 974
 975 /*!
 976  * Emit the instruction sequence for i64 left shifts. The basic algorithm
 977  * is to fill the bottom two word slots with zeros so that zeros are shifted
 978  * in as the entire quadword is shifted left.
 979  *
 980  * \note This code could also be used to implement v2i64 shl.
 981  *
 982  * @param Op The shl operand
 983  * @param OpVT Op's machine value value type (doesn't need to be passed, but
 984  * makes life easier.)
 985  * @return The SDNode with the entire instruction sequence
 986  */
 987 SDNode *
 988 SPUDAGToDAGISel::SelectSHLi64(SDNode *N, EVT OpVT) {
 989   SDValue Op0 = N->getOperand(0);
 990   EVT VecVT = EVT::getVectorVT(*CurDAG->getContext(),
 991                                OpVT, (128 / OpVT.getSizeInBits()));
 992   SDValue ShiftAmt = N->getOperand(1);
 993   EVT ShiftAmtVT = ShiftAmt.getValueType();
 994   SDNode *VecOp0, *SelMask, *ZeroFill, *Shift = 0;
 995   SDValue SelMaskVal;
 996   DebugLoc dl = N->getDebugLoc();
 997
 998   VecOp0 = CurDAG->getMachineNode(SPU::ORv2i64_i64, dl, VecVT, Op0);
 999   SelMaskVal = CurDAG->getTargetConstant(0xff00ULL, MVT::i16);
1000   SelMask = CurDAG->getMachineNode(SPU::FSMBIv2i64, dl, VecVT, SelMaskVal);
1001   ZeroFill = CurDAG->getMachineNode(SPU::ILv2i64, dl, VecVT,
1002                                     CurDAG->getTargetConstant(0, OpVT));
1003   VecOp0 = CurDAG->getMachineNode(SPU::SELBv2i64, dl, VecVT,
1004                                   SDValue(ZeroFill, 0),
1005                                   SDValue(VecOp0, 0),
1006                                   SDValue(SelMask, 0));
1007
1008   if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(ShiftAmt)) {
1009     unsigned bytes = unsigned(CN->getZExtValue()) >> 3;
1010     unsigned bits = unsigned(CN->getZExtValue()) & 7;
1011
1012     if (bytes > 0) {
1013       Shift =
1014         CurDAG->getMachineNode(SPU::SHLQBYIv2i64, dl, VecVT,
1015                                SDValue(VecOp0, 0),
1016                                CurDAG->getTargetConstant(bytes, ShiftAmtVT));
1017     }
1018
1019     if (bits > 0) {
1020       Shift =
1021         CurDAG->getMachineNode(SPU::SHLQBIIv2i64, dl, VecVT,
1022                                SDValue((Shift != 0 ? Shift : VecOp0), 0),
1023                                CurDAG->getTargetConstant(bits, ShiftAmtVT));
1024     }
1025   } else {
1026     SDNode *Bytes =
1027       CurDAG->getMachineNode(SPU::ROTMIr32, dl, ShiftAmtVT,
1028                              ShiftAmt,
1029                              CurDAG->getTargetConstant(3, ShiftAmtVT));
1030     SDNode *Bits =
1031       CurDAG->getMachineNode(SPU::ANDIr32, dl, ShiftAmtVT,
1032                              ShiftAmt,
1033                              CurDAG->getTargetConstant(7, ShiftAmtVT));
1034     Shift =
1035       CurDAG->getMachineNode(SPU::SHLQBYv2i64, dl, VecVT,
1036                              SDValue(VecOp0, 0), SDValue(Bytes, 0));
1037     Shift =
1038       CurDAG->getMachineNode(SPU::SHLQBIv2i64, dl, VecVT,
1039                              SDValue(Shift, 0), SDValue(Bits, 0));
1040   }
1041
1042   return CurDAG->getMachineNode(SPU::ORi64_v2i64, dl, OpVT, SDValue(Shift, 0));
1043 }
1044
1045 /*!
1046  * Emit the instruction sequence for i64 logical right shifts.
1047  *
1048  * @param Op The shl operand
1049  * @param OpVT Op's machine value value type (doesn't need to be passed, but
1050  * makes life easier.)
1051  * @return The SDNode with the entire instruction sequence
1052  */
1053 SDNode *
1054 SPUDAGToDAGISel::SelectSRLi64(SDNode *N, EVT OpVT) {
1055   SDValue Op0 = N->getOperand(0);
1056   EVT VecVT = EVT::getVectorVT(*CurDAG->getContext(),
1057                                OpVT, (128 / OpVT.getSizeInBits()));
1058   SDValue ShiftAmt = N->getOperand(1);
1059   EVT ShiftAmtVT = ShiftAmt.getValueType();
1060   SDNode *VecOp0, *Shift = 0;
1061   DebugLoc dl = N->getDebugLoc();
1062
1063   VecOp0 = CurDAG->getMachineNode(SPU::ORv2i64_i64, dl, VecVT, Op0);
1064
1065   if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(ShiftAmt)) {
1066     unsigned bytes = unsigned(CN->getZExtValue()) >> 3;
1067     unsigned bits = unsigned(CN->getZExtValue()) & 7;
1068
1069     if (bytes > 0) {
1070       Shift =
1071         CurDAG->getMachineNode(SPU::ROTQMBYIv2i64, dl, VecVT,
1072                                SDValue(VecOp0, 0),
1073                                CurDAG->getTargetConstant(bytes, ShiftAmtVT));
1074     }
1075
1076     if (bits > 0) {
1077       Shift =
1078         CurDAG->getMachineNode(SPU::ROTQMBIIv2i64, dl, VecVT,
1079                                SDValue((Shift != 0 ? Shift : VecOp0), 0),
1080                                CurDAG->getTargetConstant(bits, ShiftAmtVT));
1081     }
1082   } else {
1083     SDNode *Bytes =
1084       CurDAG->getMachineNode(SPU::ROTMIr32, dl, ShiftAmtVT,
1085                              ShiftAmt,
1086                              CurDAG->getTargetConstant(3, ShiftAmtVT));
1087     SDNode *Bits =
1088       CurDAG->getMachineNode(SPU::ANDIr32, dl, ShiftAmtVT,
1089                              ShiftAmt,
1090                              CurDAG->getTargetConstant(7, ShiftAmtVT));
1091
1092     // Ensure that the shift amounts are negated!
1093     Bytes = CurDAG->getMachineNode(SPU::SFIr32, dl, ShiftAmtVT,
1094                                    SDValue(Bytes, 0),
1095                                    CurDAG->getTargetConstant(0, ShiftAmtVT));
1096
1097     Bits = CurDAG->getMachineNode(SPU::SFIr32, dl, ShiftAmtVT,
1098                                   SDValue(Bits, 0),
1099                                   CurDAG->getTargetConstant(0, ShiftAmtVT));
1100
1101     Shift =
1102       CurDAG->getMachineNode(SPU::ROTQMBYv2i64, dl, VecVT,
1103                              SDValue(VecOp0, 0), SDValue(Bytes, 0));
1104     Shift =
1105       CurDAG->getMachineNode(SPU::ROTQMBIv2i64, dl, VecVT,
1106                              SDValue(Shift, 0), SDValue(Bits, 0));
1107   }
1108
1109   return CurDAG->getMachineNode(SPU::ORi64_v2i64, dl, OpVT, SDValue(Shift, 0));
1110 }
1111
1112 /*!
1113  * Emit the instruction sequence for i64 arithmetic right shifts.
1114  *
1115  * @param Op The shl operand
1116  * @param OpVT Op's machine value value type (doesn't need to be passed, but
1117  * makes life easier.)
1118  * @return The SDNode with the entire instruction sequence
1119  */
1120 SDNode *
1121 SPUDAGToDAGISel::SelectSRAi64(SDNode *N, EVT OpVT) {
1122   // Promote Op0 to vector
1123   EVT VecVT = EVT::getVectorVT(*CurDAG->getContext(),
1124                                OpVT, (128 / OpVT.getSizeInBits()));
1125   SDValue ShiftAmt = N->getOperand(1);
1126   EVT ShiftAmtVT = ShiftAmt.getValueType();
1127   DebugLoc dl = N->getDebugLoc();
1128
1129   SDNode *VecOp0 =
1130     CurDAG->getMachineNode(SPU::ORv2i64_i64, dl, VecVT, N->getOperand(0));
1131
1132   SDValue SignRotAmt = CurDAG->getTargetConstant(31, ShiftAmtVT);
1133   SDNode *SignRot =
1134     CurDAG->getMachineNode(SPU::ROTMAIv2i64_i32, dl, MVT::v2i64,
1135                            SDValue(VecOp0, 0), SignRotAmt);
1136   SDNode *UpperHalfSign =
1137     CurDAG->getMachineNode(SPU::ORi32_v4i32, dl, MVT::i32, SDValue(SignRot, 0));
1138
1139   SDNode *UpperHalfSignMask =
1140     CurDAG->getMachineNode(SPU::FSM64r32, dl, VecVT, SDValue(UpperHalfSign, 0));
1141   SDNode *UpperLowerMask =
1142     CurDAG->getMachineNode(SPU::FSMBIv2i64, dl, VecVT,
1143                            CurDAG->getTargetConstant(0xff00ULL, MVT::i16));
1144   SDNode *UpperLowerSelect =
1145     CurDAG->getMachineNode(SPU::SELBv2i64, dl, VecVT,
1146                            SDValue(UpperHalfSignMask, 0),
1147                            SDValue(VecOp0, 0),
1148                            SDValue(UpperLowerMask, 0));
1149
1150   SDNode *Shift = 0;
1151
1152   if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(ShiftAmt)) {
1153     unsigned bytes = unsigned(CN->getZExtValue()) >> 3;
1154     unsigned bits = unsigned(CN->getZExtValue()) & 7;
1155
1156     if (bytes > 0) {
1157       bytes = 31 - bytes;
1158       Shift =
1159         CurDAG->getMachineNode(SPU::ROTQBYIv2i64, dl, VecVT,
1160                                SDValue(UpperLowerSelect, 0),
1161                                CurDAG->getTargetConstant(bytes, ShiftAmtVT));
1162     }
1163
1164     if (bits > 0) {
1165       bits = 8 - bits;
1166       Shift =
1167         CurDAG->getMachineNode(SPU::ROTQBIIv2i64, dl, VecVT,
1168                                SDValue((Shift != 0 ? Shift : UpperLowerSelect), 0),
1169                                CurDAG->getTargetConstant(bits, ShiftAmtVT));
1170     }
1171   } else {
1172     SDNode *NegShift =
1173       CurDAG->getMachineNode(SPU::SFIr32, dl, ShiftAmtVT,
1174                              ShiftAmt, CurDAG->getTargetConstant(0, ShiftAmtVT));
1175
1176     Shift =
1177       CurDAG->getMachineNode(SPU::ROTQBYBIv2i64_r32, dl, VecVT,
1178                              SDValue(UpperLowerSelect, 0), SDValue(NegShift, 0));
1179     Shift =
1180       CurDAG->getMachineNode(SPU::ROTQBIv2i64, dl, VecVT,
1181                              SDValue(Shift, 0), SDValue(NegShift, 0));
1182   }
1183
1184   return CurDAG->getMachineNode(SPU::ORi64_v2i64, dl, OpVT, SDValue(Shift, 0));
1185 }
1186
1187 /*!
1188  Do the necessary magic necessary to load a i64 constant
1189  */
1190 SDNode *SPUDAGToDAGISel::SelectI64Constant(SDNode *N, EVT OpVT,
1191                                            DebugLoc dl) {
1192   ConstantSDNode *CN = cast<ConstantSDNode>(N);
1193   return SelectI64Constant(CN->getZExtValue(), OpVT, dl);
1194 }
1195
1196 SDNode *SPUDAGToDAGISel::SelectI64Constant(uint64_t Value64, EVT OpVT,
1197                                            DebugLoc dl) {
1198   EVT OpVecVT = EVT::getVectorVT(*CurDAG->getContext(), OpVT, 2);
1199   SDValue i64vec =
1200           SPU::LowerV2I64Splat(OpVecVT, *CurDAG, Value64, dl);
1201
1202   // Here's where it gets interesting, because we have to parse out the
1203   // subtree handed back in i64vec:
1204
1205   if (i64vec.getOpcode() == ISD::BIT_CONVERT) {
1206     // The degenerate case where the upper and lower bits in the splat are
1207     // identical:
1208     SDValue Op0 = i64vec.getOperand(0);
1209
1210     ReplaceUses(i64vec, Op0);
1211     return CurDAG->getMachineNode(SPU::ORi64_v2i64, dl, OpVT,
1212                                   SDValue(emitBuildVector(Op0.getNode()), 0));
1213   } else if (i64vec.getOpcode() == SPUISD::SHUFB) {
1214     SDValue lhs = i64vec.getOperand(0);
1215     SDValue rhs = i64vec.getOperand(1);
1216     SDValue shufmask = i64vec.getOperand(2);
1217
1218     if (lhs.getOpcode() == ISD::BIT_CONVERT) {
1219       ReplaceUses(lhs, lhs.getOperand(0));
1220       lhs = lhs.getOperand(0);
1221     }
1222
1223     SDNode *lhsNode = (lhs.getNode()->isMachineOpcode()
1224                        ? lhs.getNode()
1225                        : emitBuildVector(lhs.getNode()));
1226
1227     if (rhs.getOpcode() == ISD::BIT_CONVERT) {
1228       ReplaceUses(rhs, rhs.getOperand(0));
1229       rhs = rhs.getOperand(0);
1230     }
1231
1232     SDNode *rhsNode = (rhs.getNode()->isMachineOpcode()
1233                        ? rhs.getNode()
1234                        : emitBuildVector(rhs.getNode()));
1235
1236     if (shufmask.getOpcode() == ISD::BIT_CONVERT) {
1237       ReplaceUses(shufmask, shufmask.getOperand(0));
1238       shufmask = shufmask.getOperand(0);
1239     }
1240
1241     SDNode *shufMaskNode = (shufmask.getNode()->isMachineOpcode()
1242                             ? shufmask.getNode()
1243                             : emitBuildVector(shufmask.getNode()));
1244
1245     SDNode *shufNode =
1246             Select(CurDAG->getNode(SPUISD::SHUFB, dl, OpVecVT,
1247                                    SDValue(lhsNode, 0), SDValue(rhsNode, 0),
1248                                    SDValue(shufMaskNode, 0)).getNode());
1249
1250     return CurDAG->getMachineNode(SPU::ORi64_v2i64, dl, OpVT,
1251                                   SDValue(shufNode, 0));
1252   } else if (i64vec.getOpcode() == ISD::BUILD_VECTOR) {
1253     return CurDAG->getMachineNode(SPU::ORi64_v2i64, dl, OpVT,
1254                                   SDValue(emitBuildVector(i64vec.getNode()), 0));
1255   } else {
1256     llvm_report_error("SPUDAGToDAGISel::SelectI64Constant: Unhandled i64vec"
1257                       "condition");
1258   }
1259 }
1260
1261 /// createSPUISelDag - This pass converts a legalized DAG into a
1262 /// SPU-specific DAG, ready for instruction scheduling.
1263 ///
1264 FunctionPass *llvm::createSPUISelDag(SPUTargetMachine &TM) {
1265   return new SPUDAGToDAGISel(TM);
1266 }