lib/Target/CellSPU/SPUISelLowering.cpp

   1 //===-- SPUISelLowering.cpp - Cell SPU DAG Lowering Implementation --------===//
   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 implements the SPUTargetLowering class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "SPURegisterNames.h"
  15 #include "SPUISelLowering.h"
  16 #include "SPUTargetMachine.h"
  17 #include "SPUFrameInfo.h"
  18 #include "llvm/ADT/VectorExtras.h"
  19 #include "llvm/CodeGen/CallingConvLower.h"
  20 #include "llvm/CodeGen/MachineFrameInfo.h"
  21 #include "llvm/CodeGen/MachineFunction.h"
  22 #include "llvm/CodeGen/MachineInstrBuilder.h"
  23 #include "llvm/CodeGen/MachineRegisterInfo.h"
  24 #include "llvm/CodeGen/SelectionDAG.h"
  25 #include "llvm/Constants.h"
  26 #include "llvm/Function.h"
  27 #include "llvm/Intrinsics.h"
  28 #include "llvm/Support/Debug.h"
  29 #include "llvm/Support/MathExtras.h"
  30 #include "llvm/Target/TargetOptions.h"
  31
  32 #include <map>
  33
  34 using namespace llvm;
  35
  36 // Used in getTargetNodeName() below
  37 namespace {
  38   std::map<unsigned, const char *> node_names;
  39
  40   //! MVT mapping to useful data for Cell SPU
  41   struct valtype_map_s {
  42     const MVT   valtype;
  43     const int   prefslot_byte;
  44   };
  45
  46   const valtype_map_s valtype_map[] = {
  47     { MVT::i1,   3 },
  48     { MVT::i8,   3 },
  49     { MVT::i16,  2 },
  50     { MVT::i32,  0 },
  51     { MVT::f32,  0 },
  52     { MVT::i64,  0 },
  53     { MVT::f64,  0 },
  54     { MVT::i128, 0 }
  55   };
  56
  57   const size_t n_valtype_map = sizeof(valtype_map) / sizeof(valtype_map[0]);
  58
  59   const valtype_map_s *getValueTypeMapEntry(MVT VT) {
  60     const valtype_map_s *retval = 0;
  61
  62     for (size_t i = 0; i < n_valtype_map; ++i) {
  63       if (valtype_map[i].valtype == VT) {
  64         retval = valtype_map + i;
  65         break;
  66       }
  67     }
  68
  69 #ifndef NDEBUG
  70     if (retval == 0) {
  71       cerr << "getValueTypeMapEntry returns NULL for "
  72            << VT.getMVTString()
  73            << "\n";
  74       abort();
  75     }
  76 #endif
  77
  78     return retval;
  79   }
  80
  81   //! Predicate that returns true if operand is a memory target
  82   /*!
  83     \arg Op Operand to test
  84     \return true if the operand is a memory target (i.e., global
  85     address, external symbol, constant pool) or an A-form
  86     address.
  87    */
  88   bool isMemoryOperand(const SDValue &Op)
  89   {
  90     const unsigned Opc = Op.getOpcode();
  91     return (Opc == ISD::GlobalAddress
  92             || Opc == ISD::GlobalTLSAddress
  93             || Opc == ISD::JumpTable
  94             || Opc == ISD::ConstantPool
  95             || Opc == ISD::ExternalSymbol
  96             || Opc == ISD::TargetGlobalAddress
  97             || Opc == ISD::TargetGlobalTLSAddress
  98             || Opc == ISD::TargetJumpTable
  99             || Opc == ISD::TargetConstantPool
 100             || Opc == ISD::TargetExternalSymbol
 101             || Opc == SPUISD::AFormAddr);
 102   }
 103
 104   //! Predicate that returns true if the operand is an indirect target
 105   bool isIndirectOperand(const SDValue &Op)
 106   {
 107     const unsigned Opc = Op.getOpcode();
 108     return (Opc == ISD::Register
 109             || Opc == SPUISD::LDRESULT);
 110   }
 111 }
 112
 113 SPUTargetLowering::SPUTargetLowering(SPUTargetMachine &TM)
 114   : TargetLowering(TM),
 115     SPUTM(TM)
 116 {
 117   // Fold away setcc operations if possible.
 118   setPow2DivIsCheap();
 119
 120   // Use _setjmp/_longjmp instead of setjmp/longjmp.
 121   setUseUnderscoreSetJmp(true);
 122   setUseUnderscoreLongJmp(true);
 123
 124   // Set up the SPU's register classes:
 125   addRegisterClass(MVT::i8,   SPU::R8CRegisterClass);
 126   addRegisterClass(MVT::i16,  SPU::R16CRegisterClass);
 127   addRegisterClass(MVT::i32,  SPU::R32CRegisterClass);
 128   addRegisterClass(MVT::i64,  SPU::R64CRegisterClass);
 129   addRegisterClass(MVT::f32,  SPU::R32FPRegisterClass);
 130   addRegisterClass(MVT::f64,  SPU::R64FPRegisterClass);
 131   addRegisterClass(MVT::i128, SPU::GPRCRegisterClass);
 132
 133   // Initialize libcalls:
 134   setLibcallName(RTLIB::MUL_I64, "__muldi3");
 135
 136   // SPU has no sign or zero extended loads for i1, i8, i16:
 137   setLoadExtAction(ISD::EXTLOAD,  MVT::i1, Promote);
 138   setLoadExtAction(ISD::SEXTLOAD, MVT::i1, Promote);
 139   setLoadExtAction(ISD::ZEXTLOAD, MVT::i1, Promote);
 140
 141   setLoadExtAction(ISD::EXTLOAD,  MVT::i8, Custom);
 142   setLoadExtAction(ISD::SEXTLOAD, MVT::i8, Custom);
 143   setLoadExtAction(ISD::ZEXTLOAD, MVT::i8, Custom);
 144   setTruncStoreAction(MVT::i8,    MVT::i8, Custom);
 145   setTruncStoreAction(MVT::i16,   MVT::i8, Custom);
 146   setTruncStoreAction(MVT::i32,   MVT::i8, Custom);
 147   setTruncStoreAction(MVT::i64,   MVT::i8, Custom);
 148   setTruncStoreAction(MVT::i128,  MVT::i8, Custom);
 149
 150   setLoadExtAction(ISD::EXTLOAD,  MVT::i16, Custom);
 151   setLoadExtAction(ISD::SEXTLOAD, MVT::i16, Custom);
 152   setLoadExtAction(ISD::ZEXTLOAD, MVT::i16, Custom);
 153
 154   // SPU constant load actions are custom lowered:
 155   setOperationAction(ISD::Constant,   MVT::i64, Custom);
 156   setOperationAction(ISD::ConstantFP, MVT::f32, Legal);
 157   setOperationAction(ISD::ConstantFP, MVT::f64, Custom);
 158
 159   // SPU's loads and stores have to be custom lowered:
 160   for (unsigned sctype = (unsigned) MVT::i8; sctype < (unsigned) MVT::f128;
 161        ++sctype) {
 162     MVT VT = (MVT::SimpleValueType)sctype;
 163
 164     setOperationAction(ISD::LOAD, VT, Custom);
 165     setOperationAction(ISD::STORE, VT, Custom);
 166   }
 167
 168   // Custom lower BRCOND for i8 to "promote" the result to i16
 169   setOperationAction(ISD::BRCOND, MVT::Other, Custom);
 170
 171   // Expand the jumptable branches
 172   setOperationAction(ISD::BR_JT,        MVT::Other, Expand);
 173   setOperationAction(ISD::BR_CC,        MVT::Other, Expand);
 174
 175   // Custom lower SELECT_CC for most cases, but expand by default
 176   setOperationAction(ISD::SELECT_CC,    MVT::Other, Expand);
 177   setOperationAction(ISD::SELECT_CC,    MVT::i8,    Custom);
 178   setOperationAction(ISD::SELECT_CC,    MVT::i16,   Custom);
 179   setOperationAction(ISD::SELECT_CC,    MVT::i32,   Custom);
 180 #if 0
 181   setOperationAction(ISD::SELECT_CC,    MVT::i64,   Custom);
 182 #endif
 183
 184   // SPU has no intrinsics for these particular operations:
 185   setOperationAction(ISD::MEMBARRIER, MVT::Other, Expand);
 186
 187   // PowerPC has no SREM/UREM instructions
 188   setOperationAction(ISD::SREM, MVT::i32, Expand);
 189   setOperationAction(ISD::UREM, MVT::i32, Expand);
 190   setOperationAction(ISD::SREM, MVT::i64, Expand);
 191   setOperationAction(ISD::UREM, MVT::i64, Expand);
 192
 193   // We don't support sin/cos/sqrt/fmod
 194   setOperationAction(ISD::FSIN , MVT::f64, Expand);
 195   setOperationAction(ISD::FCOS , MVT::f64, Expand);
 196   setOperationAction(ISD::FREM , MVT::f64, Expand);
 197   setOperationAction(ISD::FSIN , MVT::f32, Expand);
 198   setOperationAction(ISD::FCOS , MVT::f32, Expand);
 199   setOperationAction(ISD::FREM , MVT::f32, Expand);
 200
 201   // If we're enabling GP optimizations, use hardware square root
 202   setOperationAction(ISD::FSQRT, MVT::f64, Expand);
 203   setOperationAction(ISD::FSQRT, MVT::f32, Expand);
 204
 205   setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 206   setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
 207
 208   // SPU can do rotate right and left, so legalize it... but customize for i8
 209   // because instructions don't exist.
 210
 211   // FIXME: Change from "expand" to appropriate type once ROTR is supported in
 212   //        .td files.
 213   setOperationAction(ISD::ROTR, MVT::i32,    Expand /*Legal*/);
 214   setOperationAction(ISD::ROTR, MVT::i16,    Expand /*Legal*/);
 215   setOperationAction(ISD::ROTR, MVT::i8,     Expand /*Custom*/);
 216
 217   setOperationAction(ISD::ROTL, MVT::i32,    Legal);
 218   setOperationAction(ISD::ROTL, MVT::i16,    Legal);
 219   setOperationAction(ISD::ROTL, MVT::i8,     Custom);
 220
 221   // SPU has no native version of shift left/right for i8
 222   setOperationAction(ISD::SHL,  MVT::i8,     Custom);
 223   setOperationAction(ISD::SRL,  MVT::i8,     Custom);
 224   setOperationAction(ISD::SRA,  MVT::i8,     Custom);
 225
 226   // SPU needs custom lowering for shift left/right for i64
 227   setOperationAction(ISD::SHL,  MVT::i64,    Custom);
 228   setOperationAction(ISD::SRL,  MVT::i64,    Custom);
 229   setOperationAction(ISD::SRA,  MVT::i64,    Custom);
 230
 231   // Custom lower i8, i32 and i64 multiplications
 232   setOperationAction(ISD::MUL,  MVT::i8,     Custom);
 233   setOperationAction(ISD::MUL,  MVT::i32,    Custom);
 234   setOperationAction(ISD::MUL,  MVT::i64,    Expand);   // libcall
 235
 236   // SMUL_LOHI, UMUL_LOHI
 237   setOperationAction(ISD::SMUL_LOHI, MVT::i32, Custom);
 238   setOperationAction(ISD::UMUL_LOHI, MVT::i32, Custom);
 239   setOperationAction(ISD::SMUL_LOHI, MVT::i64, Custom);
 240   setOperationAction(ISD::UMUL_LOHI, MVT::i64, Custom);
 241
 242   // Need to custom handle (some) common i8, i64 math ops
 243   setOperationAction(ISD::ADD,  MVT::i64,    Custom);
 244   setOperationAction(ISD::SUB,  MVT::i8,     Custom);
 245   setOperationAction(ISD::SUB,  MVT::i64,    Custom);
 246
 247   // SPU does not have BSWAP. It does have i32 support CTLZ.
 248   // CTPOP has to be custom lowered.
 249   setOperationAction(ISD::BSWAP, MVT::i32,   Expand);
 250   setOperationAction(ISD::BSWAP, MVT::i64,   Expand);
 251
 252   setOperationAction(ISD::CTPOP, MVT::i8,    Custom);
 253   setOperationAction(ISD::CTPOP, MVT::i16,   Custom);
 254   setOperationAction(ISD::CTPOP, MVT::i32,   Custom);
 255   setOperationAction(ISD::CTPOP, MVT::i64,   Custom);
 256
 257   setOperationAction(ISD::CTTZ , MVT::i32,   Expand);
 258   setOperationAction(ISD::CTTZ , MVT::i64,   Expand);
 259
 260   setOperationAction(ISD::CTLZ , MVT::i32,   Legal);
 261
 262   // SPU has a version of select that implements (a&~c)|(b&c), just like
 263   // select ought to work:
 264   setOperationAction(ISD::SELECT, MVT::i8,   Legal);
 265   setOperationAction(ISD::SELECT, MVT::i16,  Legal);
 266   setOperationAction(ISD::SELECT, MVT::i32,  Legal);
 267   setOperationAction(ISD::SELECT, MVT::i64,  Expand);
 268
 269   setOperationAction(ISD::SETCC, MVT::i8,    Legal);
 270   setOperationAction(ISD::SETCC, MVT::i16,   Legal);
 271   setOperationAction(ISD::SETCC, MVT::i32,   Legal);
 272   setOperationAction(ISD::SETCC, MVT::i64,   Expand);
 273
 274   // Zero extension and sign extension for i64 have to be
 275   // custom legalized
 276   setOperationAction(ISD::ZERO_EXTEND, MVT::i64, Custom);
 277   setOperationAction(ISD::SIGN_EXTEND, MVT::i64, Custom);
 278   setOperationAction(ISD::ANY_EXTEND,  MVT::i64, Custom);
 279
 280   // SPU has a legal FP -> signed INT instruction
 281   setOperationAction(ISD::FP_TO_SINT, MVT::i32, Legal);
 282   setOperationAction(ISD::FP_TO_SINT, MVT::i64, Custom);
 283   setOperationAction(ISD::FP_TO_UINT, MVT::i32, Legal);
 284   setOperationAction(ISD::FP_TO_UINT, MVT::i64, Custom);
 285
 286   // FDIV on SPU requires custom lowering
 287   setOperationAction(ISD::FDIV, MVT::f32, Custom);
 288   //setOperationAction(ISD::FDIV, MVT::f64, Custom);
 289
 290   // SPU has [U|S]INT_TO_FP
 291   setOperationAction(ISD::SINT_TO_FP, MVT::i32, Legal);
 292   setOperationAction(ISD::SINT_TO_FP, MVT::i16, Promote);
 293   setOperationAction(ISD::SINT_TO_FP, MVT::i8, Promote);
 294   setOperationAction(ISD::UINT_TO_FP, MVT::i32, Legal);
 295   setOperationAction(ISD::UINT_TO_FP, MVT::i16, Promote);
 296   setOperationAction(ISD::UINT_TO_FP, MVT::i8, Promote);
 297   setOperationAction(ISD::SINT_TO_FP, MVT::i64, Custom);
 298   setOperationAction(ISD::UINT_TO_FP, MVT::i64, Custom);
 299
 300   setOperationAction(ISD::BIT_CONVERT, MVT::i32, Legal);
 301   setOperationAction(ISD::BIT_CONVERT, MVT::f32, Legal);
 302   setOperationAction(ISD::BIT_CONVERT, MVT::i64, Legal);
 303   setOperationAction(ISD::BIT_CONVERT, MVT::f64, Legal);
 304
 305   // We cannot sextinreg(i1).  Expand to shifts.
 306   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
 307
 308   // Support label based line numbers.
 309   setOperationAction(ISD::DBG_STOPPOINT, MVT::Other, Expand);
 310   setOperationAction(ISD::DEBUG_LOC, MVT::Other, Expand);
 311
 312   // We want to legalize GlobalAddress and ConstantPool nodes into the
 313   // appropriate instructions to materialize the address.
 314   for (unsigned sctype = (unsigned) MVT::i8; sctype < (unsigned) MVT::f128;
 315        ++sctype) {
 316     MVT VT = (MVT::SimpleValueType)sctype;
 317
 318     setOperationAction(ISD::GlobalAddress, VT, Custom);
 319     setOperationAction(ISD::ConstantPool,  VT, Custom);
 320     setOperationAction(ISD::JumpTable,     VT, Custom);
 321   }
 322
 323   // RET must be custom lowered, to meet ABI requirements
 324   setOperationAction(ISD::RET,           MVT::Other, Custom);
 325
 326   // VASTART needs to be custom lowered to use the VarArgsFrameIndex
 327   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
 328
 329   // Use the default implementation.
 330   setOperationAction(ISD::VAARG             , MVT::Other, Expand);
 331   setOperationAction(ISD::VACOPY            , MVT::Other, Expand);
 332   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
 333   setOperationAction(ISD::STACKSAVE         , MVT::Other, Expand);
 334   setOperationAction(ISD::STACKRESTORE      , MVT::Other, Expand);
 335   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32  , Expand);
 336   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i64  , Expand);
 337
 338   // Cell SPU has instructions for converting between i64 and fp.
 339   setOperationAction(ISD::FP_TO_SINT, MVT::i64, Custom);
 340   setOperationAction(ISD::SINT_TO_FP, MVT::i64, Custom);
 341
 342   // To take advantage of the above i64 FP_TO_SINT, promote i32 FP_TO_UINT
 343   setOperationAction(ISD::FP_TO_UINT, MVT::i32, Promote);
 344
 345   // BUILD_PAIR can't be handled natively, and should be expanded to shl/or
 346   setOperationAction(ISD::BUILD_PAIR, MVT::i64, Expand);
 347
 348   // First set operation action for all vector types to expand. Then we
 349   // will selectively turn on ones that can be effectively codegen'd.
 350   addRegisterClass(MVT::v16i8, SPU::VECREGRegisterClass);
 351   addRegisterClass(MVT::v8i16, SPU::VECREGRegisterClass);
 352   addRegisterClass(MVT::v4i32, SPU::VECREGRegisterClass);
 353   addRegisterClass(MVT::v2i64, SPU::VECREGRegisterClass);
 354   addRegisterClass(MVT::v4f32, SPU::VECREGRegisterClass);
 355   addRegisterClass(MVT::v2f64, SPU::VECREGRegisterClass);
 356
 357   for (unsigned i = (unsigned)MVT::FIRST_VECTOR_VALUETYPE;
 358        i <= (unsigned)MVT::LAST_VECTOR_VALUETYPE; ++i) {
 359     MVT VT = (MVT::SimpleValueType)i;
 360
 361     // add/sub are legal for all supported vector VT's.
 362     setOperationAction(ISD::ADD , VT, Legal);
 363     setOperationAction(ISD::SUB , VT, Legal);
 364     // mul has to be custom lowered.
 365     setOperationAction(ISD::MUL , VT, Custom);
 366
 367     setOperationAction(ISD::AND   , VT, Legal);
 368     setOperationAction(ISD::OR    , VT, Legal);
 369     setOperationAction(ISD::XOR   , VT, Legal);
 370     setOperationAction(ISD::LOAD  , VT, Legal);
 371     setOperationAction(ISD::SELECT, VT, Legal);
 372     setOperationAction(ISD::STORE,  VT, Legal);
 373
 374     // These operations need to be expanded:
 375     setOperationAction(ISD::SDIV, VT, Expand);
 376     setOperationAction(ISD::SREM, VT, Expand);
 377     setOperationAction(ISD::UDIV, VT, Expand);
 378     setOperationAction(ISD::UREM, VT, Expand);
 379     setOperationAction(ISD::FDIV, VT, Custom);
 380
 381     // Custom lower build_vector, constant pool spills, insert and
 382     // extract vector elements:
 383     setOperationAction(ISD::BUILD_VECTOR, VT, Custom);
 384     setOperationAction(ISD::ConstantPool, VT, Custom);
 385     setOperationAction(ISD::SCALAR_TO_VECTOR, VT, Custom);
 386     setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Custom);
 387     setOperationAction(ISD::INSERT_VECTOR_ELT, VT, Custom);
 388     setOperationAction(ISD::VECTOR_SHUFFLE, VT, Custom);
 389   }
 390
 391   setOperationAction(ISD::MUL, MVT::v16i8, Custom);
 392   setOperationAction(ISD::AND, MVT::v16i8, Custom);
 393   setOperationAction(ISD::OR,  MVT::v16i8, Custom);
 394   setOperationAction(ISD::XOR, MVT::v16i8, Custom);
 395   setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4f32, Custom);
 396
 397   setShiftAmountType(MVT::i32);
 398   setBooleanContents(ZeroOrOneBooleanContent);
 399
 400   setStackPointerRegisterToSaveRestore(SPU::R1);
 401
 402   // We have target-specific dag combine patterns for the following nodes:
 403   setTargetDAGCombine(ISD::ADD);
 404   setTargetDAGCombine(ISD::ZERO_EXTEND);
 405   setTargetDAGCombine(ISD::SIGN_EXTEND);
 406   setTargetDAGCombine(ISD::ANY_EXTEND);
 407
 408   computeRegisterProperties();
 409
 410   // Set other properties:
 411   setSchedulingPreference(SchedulingForLatency);
 412 }
 413
 414 const char *
 415 SPUTargetLowering::getTargetNodeName(unsigned Opcode) const
 416 {
 417   if (node_names.empty()) {
 418     node_names[(unsigned) SPUISD::RET_FLAG] = "SPUISD::RET_FLAG";
 419     node_names[(unsigned) SPUISD::Hi] = "SPUISD::Hi";
 420     node_names[(unsigned) SPUISD::Lo] = "SPUISD::Lo";
 421     node_names[(unsigned) SPUISD::PCRelAddr] = "SPUISD::PCRelAddr";
 422     node_names[(unsigned) SPUISD::AFormAddr] = "SPUISD::AFormAddr";
 423     node_names[(unsigned) SPUISD::IndirectAddr] = "SPUISD::IndirectAddr";
 424     node_names[(unsigned) SPUISD::LDRESULT] = "SPUISD::LDRESULT";
 425     node_names[(unsigned) SPUISD::CALL] = "SPUISD::CALL";
 426     node_names[(unsigned) SPUISD::SHUFB] = "SPUISD::SHUFB";
 427     node_names[(unsigned) SPUISD::SHUFFLE_MASK] = "SPUISD::SHUFFLE_MASK";
 428     node_names[(unsigned) SPUISD::CNTB] = "SPUISD::CNTB";
 429     node_names[(unsigned) SPUISD::PROMOTE_SCALAR] = "SPUISD::PROMOTE_SCALAR";
 430     node_names[(unsigned) SPUISD::VEC2PREFSLOT] = "SPUISD::VEC2PREFSLOT";
 431     node_names[(unsigned) SPUISD::VEC2PREFSLOT_CHAINED]
 432                                               = "SPUISD::VEC2PREFSLOT_CHAINED";
 433     node_names[(unsigned) SPUISD::EXTRACT_I1_ZEXT] = "SPUISD::EXTRACT_I1_ZEXT";
 434     node_names[(unsigned) SPUISD::EXTRACT_I1_SEXT] = "SPUISD::EXTRACT_I1_SEXT";
 435     node_names[(unsigned) SPUISD::EXTRACT_I8_ZEXT] = "SPUISD::EXTRACT_I8_ZEXT";
 436     node_names[(unsigned) SPUISD::EXTRACT_I8_SEXT] = "SPUISD::EXTRACT_I8_SEXT";
 437     node_names[(unsigned) SPUISD::MPY] = "SPUISD::MPY";
 438     node_names[(unsigned) SPUISD::MPYU] = "SPUISD::MPYU";
 439     node_names[(unsigned) SPUISD::MPYH] = "SPUISD::MPYH";
 440     node_names[(unsigned) SPUISD::MPYHH] = "SPUISD::MPYHH";
 441     node_names[(unsigned) SPUISD::SHLQUAD_L_BITS] = "SPUISD::SHLQUAD_L_BITS";
 442     node_names[(unsigned) SPUISD::SHLQUAD_L_BYTES] = "SPUISD::SHLQUAD_L_BYTES";
 443     node_names[(unsigned) SPUISD::VEC_SHL] = "SPUISD::VEC_SHL";
 444     node_names[(unsigned) SPUISD::VEC_SRL] = "SPUISD::VEC_SRL";
 445     node_names[(unsigned) SPUISD::VEC_SRA] = "SPUISD::VEC_SRA";
 446     node_names[(unsigned) SPUISD::VEC_ROTL] = "SPUISD::VEC_ROTL";
 447     node_names[(unsigned) SPUISD::VEC_ROTR] = "SPUISD::VEC_ROTR";
 448     node_names[(unsigned) SPUISD::ROTQUAD_RZ_BYTES] =
 449       "SPUISD::ROTQUAD_RZ_BYTES";
 450     node_names[(unsigned) SPUISD::ROTQUAD_RZ_BITS] =
 451       "SPUISD::ROTQUAD_RZ_BITS";
 452     node_names[(unsigned) SPUISD::ROTBYTES_LEFT] = "SPUISD::ROTBYTES_LEFT";
 453     node_names[(unsigned) SPUISD::ROTBYTES_LEFT_CHAINED] =
 454       "SPUISD::ROTBYTES_LEFT_CHAINED";
 455     node_names[(unsigned) SPUISD::ROTBYTES_LEFT_BITS] =
 456       "SPUISD::ROTBYTES_LEFT_BITS";
 457     node_names[(unsigned) SPUISD::SELECT_MASK] = "SPUISD::SELECT_MASK";
 458     node_names[(unsigned) SPUISD::SELB] = "SPUISD::SELB";
 459     node_names[(unsigned) SPUISD::ADD_EXTENDED] = "SPUISD::ADD_EXTENDED";
 460     node_names[(unsigned) SPUISD::CARRY_GENERATE] = "SPUISD::CARRY_GENERATE";
 461     node_names[(unsigned) SPUISD::SUB_EXTENDED] = "SPUISD::SUB_EXTENDED";
 462     node_names[(unsigned) SPUISD::BORROW_GENERATE] = "SPUISD::BORROW_GENERATE";
 463     node_names[(unsigned) SPUISD::FPInterp] = "SPUISD::FPInterp";
 464     node_names[(unsigned) SPUISD::FPRecipEst] = "SPUISD::FPRecipEst";
 465     node_names[(unsigned) SPUISD::SEXT32TO64] = "SPUISD::SEXT32TO64";
 466   }
 467
 468   std::map<unsigned, const char *>::iterator i = node_names.find(Opcode);
 469
 470   return ((i != node_names.end()) ? i->second : 0);
 471 }
 472
 473 MVT SPUTargetLowering::getSetCCResultType(const SDValue &Op) const {
 474   MVT VT = Op.getValueType();
 475   return (VT.isInteger() ? VT : MVT(MVT::i32));
 476 }
 477
 478 //===----------------------------------------------------------------------===//
 479 // Calling convention code:
 480 //===----------------------------------------------------------------------===//
 481
 482 #include "SPUGenCallingConv.inc"
 483
 484 //===----------------------------------------------------------------------===//
 485 //  LowerOperation implementation
 486 //===----------------------------------------------------------------------===//
 487
 488 /// Aligned load common code for CellSPU
 489 /*!
 490   \param[in] Op The SelectionDAG load or store operand
 491   \param[in] DAG The selection DAG
 492   \param[in] ST CellSPU subtarget information structure
 493   \param[in,out] alignment Caller initializes this to the load or store node's
 494   value from getAlignment(), may be updated while generating the aligned load
 495   \param[in,out] alignOffs Aligned offset; set by AlignedLoad to the aligned
 496   offset (divisible by 16, modulo 16 == 0)
 497   \param[in,out] prefSlotOffs Preferred slot offset; set by AlignedLoad to the
 498   offset of the preferred slot (modulo 16 != 0)
 499   \param[in,out] VT Caller initializes this value type to the the load or store
 500   node's loaded or stored value type; may be updated if an i1-extended load or
 501   store.
 502   \param[out] was16aligned true if the base pointer had 16-byte alignment,
 503   otherwise false. Can help to determine if the chunk needs to be rotated.
 504
 505  Both load and store lowering load a block of data aligned on a 16-byte
 506  boundary. This is the common aligned load code shared between both.
 507  */
 508 static SDValue
 509 AlignedLoad(SDValue Op, SelectionDAG &DAG, const SPUSubtarget *ST,
 510             LSBaseSDNode *LSN,
 511             unsigned &alignment, int &alignOffs, int &prefSlotOffs,
 512             MVT &VT, bool &was16aligned)
 513 {
 514   MVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
 515   const valtype_map_s *vtm = getValueTypeMapEntry(VT);
 516   SDValue basePtr = LSN->getBasePtr();
 517   SDValue chain = LSN->getChain();
 518
 519   if (basePtr.getOpcode() == ISD::ADD) {
 520     SDValue Op1 = basePtr.getNode()->getOperand(1);
 521
 522     if (Op1.getOpcode() == ISD::Constant
 523         || Op1.getOpcode() == ISD::TargetConstant) {
 524       const ConstantSDNode *CN = cast<ConstantSDNode>(basePtr.getOperand(1));
 525
 526       alignOffs = (int) CN->getZExtValue();
 527       prefSlotOffs = (int) (alignOffs & 0xf);
 528
 529       // Adjust the rotation amount to ensure that the final result ends up in
 530       // the preferred slot:
 531       prefSlotOffs -= vtm->prefslot_byte;
 532       basePtr = basePtr.getOperand(0);
 533
 534       // Loading from memory, can we adjust alignment?
 535       if (basePtr.getOpcode() == SPUISD::AFormAddr) {
 536         SDValue APtr = basePtr.getOperand(0);
 537         if (APtr.getOpcode() == ISD::TargetGlobalAddress) {
 538           GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(APtr);
 539           alignment = GSDN->getGlobal()->getAlignment();
 540         }
 541       }
 542     } else {
 543       alignOffs = 0;
 544       prefSlotOffs = -vtm->prefslot_byte;
 545     }
 546   } else if (basePtr.getOpcode() == ISD::FrameIndex) {
 547     FrameIndexSDNode *FIN = cast<FrameIndexSDNode>(basePtr);
 548     alignOffs = int(FIN->getIndex() * SPUFrameInfo::stackSlotSize());
 549     prefSlotOffs = (int) (alignOffs & 0xf);
 550     prefSlotOffs -= vtm->prefslot_byte;
 551     basePtr = DAG.getRegister(SPU::R1, VT);
 552   } else {
 553     alignOffs = 0;
 554     prefSlotOffs = -vtm->prefslot_byte;
 555   }
 556
 557   if (alignment == 16) {
 558     // Realign the base pointer as a D-Form address:
 559     if (!isMemoryOperand(basePtr) || (alignOffs & ~0xf) != 0) {
 560       basePtr = DAG.getNode(ISD::ADD, PtrVT,
 561                             basePtr,
 562                             DAG.getConstant((alignOffs & ~0xf), PtrVT));
 563     }
 564
 565     // Emit the vector load:
 566     was16aligned = true;
 567     return DAG.getLoad(MVT::v16i8, chain, basePtr,
 568                        LSN->getSrcValue(), LSN->getSrcValueOffset(),
 569                        LSN->isVolatile(), 16);
 570   }
 571
 572   // Unaligned load or we're using the "large memory" model, which means that
 573   // we have to be very pessimistic:
 574   if (isMemoryOperand(basePtr) || isIndirectOperand(basePtr)) {
 575     basePtr = DAG.getNode(SPUISD::IndirectAddr, PtrVT, basePtr,
 576                           DAG.getConstant(0, PtrVT));
 577   }
 578
 579   // Add the offset
 580   basePtr = DAG.getNode(ISD::ADD, PtrVT, basePtr,
 581                         DAG.getConstant((alignOffs & ~0xf), PtrVT));
 582   was16aligned = false;
 583   return DAG.getLoad(MVT::v16i8, chain, basePtr,
 584                      LSN->getSrcValue(), LSN->getSrcValueOffset(),
 585                      LSN->isVolatile(), 16);
 586 }
 587
 588 /// Custom lower loads for CellSPU
 589 /*!
 590  All CellSPU loads and stores are aligned to 16-byte boundaries, so for elements
 591  within a 16-byte block, we have to rotate to extract the requested element.
 592  */
 593 static SDValue
 594 LowerLOAD(SDValue Op, SelectionDAG &DAG, const SPUSubtarget *ST) {
 595   LoadSDNode *LN = cast<LoadSDNode>(Op);
 596   SDValue the_chain = LN->getChain();
 597   MVT VT = LN->getMemoryVT();
 598   MVT OpVT = Op.getNode()->getValueType(0);
 599   ISD::LoadExtType ExtType = LN->getExtensionType();
 600   unsigned alignment = LN->getAlignment();
 601   SDValue Ops[8];
 602
 603   switch (LN->getAddressingMode()) {
 604   case ISD::UNINDEXED: {
 605     int offset, rotamt;
 606     bool was16aligned;
 607     SDValue result =
 608       AlignedLoad(Op, DAG, ST, LN,alignment, offset, rotamt, VT, was16aligned);
 609
 610     if (result.getNode() == 0)
 611       return result;
 612
 613     the_chain = result.getValue(1);
 614     // Rotate the chunk if necessary
 615     if (rotamt < 0)
 616       rotamt += 16;
 617     if (rotamt != 0 || !was16aligned) {
 618       SDVTList vecvts = DAG.getVTList(MVT::v16i8, MVT::Other);
 619
 620       Ops[0] = the_chain;
 621       Ops[1] = result;
 622       if (was16aligned) {
 623         Ops[2] = DAG.getConstant(rotamt, MVT::i16);
 624       } else {
 625         MVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
 626         LoadSDNode *LN1 = cast<LoadSDNode>(result);
 627         Ops[2] = DAG.getNode(ISD::ADD, PtrVT, LN1->getBasePtr(),
 628                              DAG.getConstant(rotamt, PtrVT));
 629       }
 630
 631       result = DAG.getNode(SPUISD::ROTBYTES_LEFT_CHAINED, vecvts, Ops, 3);
 632       the_chain = result.getValue(1);
 633     }
 634
 635     if (VT == OpVT || ExtType == ISD::EXTLOAD) {
 636       SDVTList scalarvts;
 637       MVT vecVT = MVT::v16i8;
 638
 639       // Convert the loaded v16i8 vector to the appropriate vector type
 640       // specified by the operand:
 641       if (OpVT == VT) {
 642         if (VT != MVT::i1)
 643           vecVT = MVT::getVectorVT(VT, (128 / VT.getSizeInBits()));
 644       } else
 645         vecVT = MVT::getVectorVT(OpVT, (128 / OpVT.getSizeInBits()));
 646
 647       Ops[0] = the_chain;
 648       Ops[1] = DAG.getNode(ISD::BIT_CONVERT, vecVT, result);
 649       scalarvts = DAG.getVTList((OpVT == VT ? VT : OpVT), MVT::Other);
 650       result = DAG.getNode(SPUISD::VEC2PREFSLOT_CHAINED, scalarvts, Ops, 2);
 651       the_chain = result.getValue(1);
 652     } else {
 653       // Handle the sign and zero-extending loads for i1 and i8:
 654       unsigned NewOpC;
 655
 656       if (ExtType == ISD::SEXTLOAD) {
 657         NewOpC = (OpVT == MVT::i1
 658                   ? SPUISD::EXTRACT_I1_SEXT
 659                   : SPUISD::EXTRACT_I8_SEXT);
 660       } else {
 661         assert(ExtType == ISD::ZEXTLOAD);
 662         NewOpC = (OpVT == MVT::i1
 663                   ? SPUISD::EXTRACT_I1_ZEXT
 664                   : SPUISD::EXTRACT_I8_ZEXT);
 665       }
 666
 667       result = DAG.getNode(NewOpC, OpVT, result);
 668     }
 669
 670     SDVTList retvts = DAG.getVTList(OpVT, MVT::Other);
 671     SDValue retops[2] = {
 672       result,
 673       the_chain
 674     };
 675
 676     result = DAG.getNode(SPUISD::LDRESULT, retvts,
 677                          retops, sizeof(retops) / sizeof(retops[0]));
 678     return result;
 679   }
 680   case ISD::PRE_INC:
 681   case ISD::PRE_DEC:
 682   case ISD::POST_INC:
 683   case ISD::POST_DEC:
 684   case ISD::LAST_INDEXED_MODE:
 685     cerr << "LowerLOAD: Got a LoadSDNode with an addr mode other than "
 686             "UNINDEXED\n";
 687     cerr << (unsigned) LN->getAddressingMode() << "\n";
 688     abort();
 689     /*NOTREACHED*/
 690   }
 691
 692   return SDValue();
 693 }
 694
 695 /// Custom lower stores for CellSPU
 696 /*!
 697  All CellSPU stores are aligned to 16-byte boundaries, so for elements
 698  within a 16-byte block, we have to generate a shuffle to insert the
 699  requested element into its place, then store the resulting block.
 700  */
 701 static SDValue
 702 LowerSTORE(SDValue Op, SelectionDAG &DAG, const SPUSubtarget *ST) {
 703   StoreSDNode *SN = cast<StoreSDNode>(Op);
 704   SDValue Value = SN->getValue();
 705   MVT VT = Value.getValueType();
 706   MVT StVT = (!SN->isTruncatingStore() ? VT : SN->getMemoryVT());
 707   MVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
 708   unsigned alignment = SN->getAlignment();
 709
 710   switch (SN->getAddressingMode()) {
 711   case ISD::UNINDEXED: {
 712     int chunk_offset, slot_offset;
 713     bool was16aligned;
 714
 715     // The vector type we really want to load from the 16-byte chunk.
 716     MVT vecVT = MVT::getVectorVT(VT, (128 / VT.getSizeInBits())),
 717         stVecVT = MVT::getVectorVT(StVT, (128 / StVT.getSizeInBits()));
 718
 719     SDValue alignLoadVec =
 720       AlignedLoad(Op, DAG, ST, SN, alignment,
 721                   chunk_offset, slot_offset, VT, was16aligned);
 722
 723     if (alignLoadVec.getNode() == 0)
 724       return alignLoadVec;
 725
 726     LoadSDNode *LN = cast<LoadSDNode>(alignLoadVec);
 727     SDValue basePtr = LN->getBasePtr();
 728     SDValue the_chain = alignLoadVec.getValue(1);
 729     SDValue theValue = SN->getValue();
 730     SDValue result;
 731
 732     if (StVT != VT
 733         && (theValue.getOpcode() == ISD::AssertZext
 734             || theValue.getOpcode() == ISD::AssertSext)) {
 735       // Drill down and get the value for zero- and sign-extended
 736       // quantities
 737       theValue = theValue.getOperand(0);
 738     }
 739
 740     chunk_offset &= 0xf;
 741
 742     SDValue insertEltOffs = DAG.getConstant(chunk_offset, PtrVT);
 743     SDValue insertEltPtr;
 744
 745     // If the base pointer is already a D-form address, then just create
 746     // a new D-form address with a slot offset and the orignal base pointer.
 747     // Otherwise generate a D-form address with the slot offset relative
 748     // to the stack pointer, which is always aligned.
 749     DEBUG(cerr << "CellSPU LowerSTORE: basePtr = ");
 750     DEBUG(basePtr.getNode()->dump(&DAG));
 751     DEBUG(cerr << "\n");
 752
 753     if (basePtr.getOpcode() == SPUISD::IndirectAddr ||
 754         (basePtr.getOpcode() == ISD::ADD
 755          && basePtr.getOperand(0).getOpcode() == SPUISD::IndirectAddr)) {
 756       insertEltPtr = basePtr;
 757     } else {
 758       insertEltPtr = DAG.getNode(ISD::ADD, PtrVT, basePtr, insertEltOffs);
 759     }
 760
 761     SDValue insertEltOp =
 762             DAG.getNode(SPUISD::SHUFFLE_MASK, vecVT, insertEltPtr);
 763     SDValue vectorizeOp =
 764             DAG.getNode(ISD::SCALAR_TO_VECTOR, vecVT, theValue);
 765
 766     result = DAG.getNode(SPUISD::SHUFB, vecVT,
 767                          vectorizeOp, alignLoadVec,
 768                          DAG.getNode(ISD::BIT_CONVERT, MVT::v4i32, insertEltOp));
 769
 770     result = DAG.getStore(the_chain, result, basePtr,
 771                           LN->getSrcValue(), LN->getSrcValueOffset(),
 772                           LN->isVolatile(), LN->getAlignment());
 773
 774 #if 0 && defined(NDEBUG)
 775     if (DebugFlag && isCurrentDebugType(DEBUG_TYPE)) {
 776       const SDValue &currentRoot = DAG.getRoot();
 777
 778       DAG.setRoot(result);
 779       cerr << "------- CellSPU:LowerStore result:\n";
 780       DAG.dump();
 781       cerr << "-------\n";
 782       DAG.setRoot(currentRoot);
 783     }
 784 #endif
 785
 786     return result;
 787     /*UNREACHED*/
 788   }
 789   case ISD::PRE_INC:
 790   case ISD::PRE_DEC:
 791   case ISD::POST_INC:
 792   case ISD::POST_DEC:
 793   case ISD::LAST_INDEXED_MODE:
 794     cerr << "LowerLOAD: Got a LoadSDNode with an addr mode other than "
 795             "UNINDEXED\n";
 796     cerr << (unsigned) SN->getAddressingMode() << "\n";
 797     abort();
 798     /*NOTREACHED*/
 799   }
 800
 801   return SDValue();
 802 }
 803
 804 /// Generate the address of a constant pool entry.
 805 static SDValue
 806 LowerConstantPool(SDValue Op, SelectionDAG &DAG, const SPUSubtarget *ST) {
 807   MVT PtrVT = Op.getValueType();
 808   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
 809   Constant *C = CP->getConstVal();
 810   SDValue CPI = DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment());
 811   SDValue Zero = DAG.getConstant(0, PtrVT);
 812   const TargetMachine &TM = DAG.getTarget();
 813
 814   if (TM.getRelocationModel() == Reloc::Static) {
 815     if (!ST->usingLargeMem()) {
 816       // Just return the SDValue with the constant pool address in it.
 817       return DAG.getNode(SPUISD::AFormAddr, PtrVT, CPI, Zero);
 818     } else {
 819       SDValue Hi = DAG.getNode(SPUISD::Hi, PtrVT, CPI, Zero);
 820       SDValue Lo = DAG.getNode(SPUISD::Lo, PtrVT, CPI, Zero);
 821       return DAG.getNode(SPUISD::IndirectAddr, PtrVT, Hi, Lo);
 822     }
 823   }
 824
 825   assert(0 &&
 826          "LowerConstantPool: Relocation model other than static"
 827          " not supported.");
 828   return SDValue();
 829 }
 830
 831 static SDValue
 832 LowerJumpTable(SDValue Op, SelectionDAG &DAG, const SPUSubtarget *ST) {
 833   MVT PtrVT = Op.getValueType();
 834   JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
 835   SDValue JTI = DAG.getTargetJumpTable(JT->getIndex(), PtrVT);
 836   SDValue Zero = DAG.getConstant(0, PtrVT);
 837   const TargetMachine &TM = DAG.getTarget();
 838
 839   if (TM.getRelocationModel() == Reloc::Static) {
 840     if (!ST->usingLargeMem()) {
 841       return DAG.getNode(SPUISD::AFormAddr, PtrVT, JTI, Zero);
 842     } else {
 843       SDValue Hi = DAG.getNode(SPUISD::Hi, PtrVT, JTI, Zero);
 844       SDValue Lo = DAG.getNode(SPUISD::Lo, PtrVT, JTI, Zero);
 845       return DAG.getNode(SPUISD::IndirectAddr, PtrVT, Hi, Lo);
 846     }
 847   }
 848
 849   assert(0 &&
 850          "LowerJumpTable: Relocation model other than static not supported.");
 851   return SDValue();
 852 }
 853
 854 static SDValue
 855 LowerGlobalAddress(SDValue Op, SelectionDAG &DAG, const SPUSubtarget *ST) {
 856   MVT PtrVT = Op.getValueType();
 857   GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op);
 858   GlobalValue *GV = GSDN->getGlobal();
 859   SDValue GA = DAG.getTargetGlobalAddress(GV, PtrVT, GSDN->getOffset());
 860   const TargetMachine &TM = DAG.getTarget();
 861   SDValue Zero = DAG.getConstant(0, PtrVT);
 862
 863   if (TM.getRelocationModel() == Reloc::Static) {
 864     if (!ST->usingLargeMem()) {
 865       return DAG.getNode(SPUISD::AFormAddr, PtrVT, GA, Zero);
 866     } else {
 867       SDValue Hi = DAG.getNode(SPUISD::Hi, PtrVT, GA, Zero);
 868       SDValue Lo = DAG.getNode(SPUISD::Lo, PtrVT, GA, Zero);
 869       return DAG.getNode(SPUISD::IndirectAddr, PtrVT, Hi, Lo);
 870     }
 871   } else {
 872     cerr << "LowerGlobalAddress: Relocation model other than static not "
 873          << "supported.\n";
 874     abort();
 875     /*NOTREACHED*/
 876   }
 877
 878   return SDValue();
 879 }
 880
 881 //! Custom lower i64 integer constants
 882 /*!
 883  This code inserts all of the necessary juggling that needs to occur to load
 884  a 64-bit constant into a register.
 885  */
 886 static SDValue
 887 LowerConstant(SDValue Op, SelectionDAG &DAG) {
 888   MVT VT = Op.getValueType();
 889
 890   if (VT == MVT::i64) {
 891     ConstantSDNode *CN = cast<ConstantSDNode>(Op.getNode());
 892     SDValue T = DAG.getConstant(CN->getZExtValue(), VT);
 893     return DAG.getNode(SPUISD::VEC2PREFSLOT, VT,
 894                        DAG.getNode(ISD::BUILD_VECTOR, MVT::v2i64, T, T));
 895   } else {
 896     cerr << "LowerConstant: unhandled constant type "
 897          << VT.getMVTString()
 898          << "\n";
 899     abort();
 900     /*NOTREACHED*/
 901   }
 902
 903   return SDValue();
 904 }
 905
 906 //! Custom lower double precision floating point constants
 907 static SDValue
 908 LowerConstantFP(SDValue Op, SelectionDAG &DAG) {
 909   MVT VT = Op.getValueType();
 910
 911   if (VT == MVT::f64) {
 912     ConstantFPSDNode *FP = cast<ConstantFPSDNode>(Op.getNode());
 913
 914     assert((FP != 0) &&
 915            "LowerConstantFP: Node is not ConstantFPSDNode");
 916
 917     uint64_t dbits = DoubleToBits(FP->getValueAPF().convertToDouble());
 918     SDValue T = DAG.getConstant(dbits, MVT::i64);
 919     SDValue Tvec = DAG.getNode(ISD::BUILD_VECTOR, MVT::v2i64, T, T);
 920     return DAG.getNode(SPUISD::VEC2PREFSLOT, VT,
 921                        DAG.getNode(ISD::BIT_CONVERT, MVT::v2f64, Tvec));
 922   }
 923
 924   return SDValue();
 925 }
 926
 927 //! Lower MVT::i8 brcond to a promoted type (MVT::i32, MVT::i16)
 928 static SDValue
 929 LowerBRCOND(SDValue Op, SelectionDAG &DAG)
 930 {
 931   SDValue Cond = Op.getOperand(1);
 932   MVT CondVT = Cond.getValueType();
 933   MVT CondNVT;
 934
 935   if (CondVT == MVT::i8) {
 936     CondNVT = MVT::i16;
 937     return DAG.getNode(ISD::BRCOND, Op.getValueType(),
 938                       Op.getOperand(0),
 939                       DAG.getNode(ISD::ZERO_EXTEND, CondNVT, Op.getOperand(1)),
 940                       Op.getOperand(2));
 941   } else
 942     return SDValue();                // Unchanged
 943 }
 944
 945 static SDValue
 946 LowerFORMAL_ARGUMENTS(SDValue Op, SelectionDAG &DAG, int &VarArgsFrameIndex)
 947 {
 948   MachineFunction &MF = DAG.getMachineFunction();
 949   MachineFrameInfo *MFI = MF.getFrameInfo();
 950   MachineRegisterInfo &RegInfo = MF.getRegInfo();
 951   SmallVector<SDValue, 48> ArgValues;
 952   SDValue Root = Op.getOperand(0);
 953   bool isVarArg = cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue() != 0;
 954
 955   const unsigned *ArgRegs = SPURegisterInfo::getArgRegs();
 956   const unsigned NumArgRegs = SPURegisterInfo::getNumArgRegs();
 957
 958   unsigned ArgOffset = SPUFrameInfo::minStackSize();
 959   unsigned ArgRegIdx = 0;
 960   unsigned StackSlotSize = SPUFrameInfo::stackSlotSize();
 961
 962   MVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
 963
 964   // Add DAG nodes to load the arguments or copy them out of registers.
 965   for (unsigned ArgNo = 0, e = Op.getNode()->getNumValues() - 1;
 966        ArgNo != e; ++ArgNo) {
 967     MVT ObjectVT = Op.getValue(ArgNo).getValueType();
 968     unsigned ObjSize = ObjectVT.getSizeInBits()/8;
 969     SDValue ArgVal;
 970
 971     if (ArgRegIdx < NumArgRegs) {
 972       const TargetRegisterClass *ArgRegClass;
 973
 974       switch (ObjectVT.getSimpleVT()) {
 975       default: {
 976         cerr << "LowerFORMAL_ARGUMENTS Unhandled argument type: "
 977              << ObjectVT.getMVTString()
 978              << "\n";
 979         abort();
 980       }
 981       case MVT::i8:
 982         ArgRegClass = &SPU::R8CRegClass;
 983         break;
 984       case MVT::i16:
 985         ArgRegClass = &SPU::R16CRegClass;
 986         break;
 987       case MVT::i32:
 988         ArgRegClass = &SPU::R32CRegClass;
 989         break;
 990       case MVT::i64:
 991         ArgRegClass = &SPU::R64CRegClass;
 992         break;
 993       case MVT::f32:
 994         ArgRegClass = &SPU::R32FPRegClass;
 995         break;
 996       case MVT::f64:
 997         ArgRegClass = &SPU::R64FPRegClass;
 998         break;
 999       case MVT::v2f64:
1000       case MVT::v4f32:
1001       case MVT::v2i64:
1002       case MVT::v4i32:
1003       case MVT::v8i16:
1004       case MVT::v16i8:
1005         ArgRegClass = &SPU::VECREGRegClass;
1006         break;
1007       }
1008
1009       unsigned VReg = RegInfo.createVirtualRegister(ArgRegClass);
1010       RegInfo.addLiveIn(ArgRegs[ArgRegIdx], VReg);
1011       ArgVal = DAG.getCopyFromReg(Root, VReg, ObjectVT);
1012       ++ArgRegIdx;
1013     } else {
1014       // We need to load the argument to a virtual register if we determined
1015       // above that we ran out of physical registers of the appropriate type
1016       // or we're forced to do vararg
1017       int FI = MFI->CreateFixedObject(ObjSize, ArgOffset);
1018       SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
1019       ArgVal = DAG.getLoad(ObjectVT, Root, FIN, NULL, 0);
1020       ArgOffset += StackSlotSize;
1021     }
1022
1023     ArgValues.push_back(ArgVal);
1024     // Update the chain
1025     Root = ArgVal.getOperand(0);
1026   }
1027
1028   // vararg handling:
1029   if (isVarArg) {
1030     // unsigned int ptr_size = PtrVT.getSizeInBits() / 8;
1031     // We will spill (79-3)+1 registers to the stack
1032     SmallVector<SDValue, 79-3+1> MemOps;
1033
1034     // Create the frame slot
1035
1036     for (; ArgRegIdx != NumArgRegs; ++ArgRegIdx) {
1037       VarArgsFrameIndex = MFI->CreateFixedObject(StackSlotSize, ArgOffset);
1038       SDValue FIN = DAG.getFrameIndex(VarArgsFrameIndex, PtrVT);
1039       SDValue ArgVal = DAG.getRegister(ArgRegs[ArgRegIdx], MVT::v16i8);
1040       SDValue Store = DAG.getStore(Root, ArgVal, FIN, NULL, 0);
1041       Root = Store.getOperand(0);
1042       MemOps.push_back(Store);
1043
1044       // Increment address by stack slot size for the next stored argument
1045       ArgOffset += StackSlotSize;
1046     }
1047     if (!MemOps.empty())
1048       Root = DAG.getNode(ISD::TokenFactor,MVT::Other,&MemOps[0],MemOps.size());
1049   }
1050
1051   ArgValues.push_back(Root);
1052
1053   // Return the new list of results.
1054   return DAG.getNode(ISD::MERGE_VALUES, Op.getNode()->getVTList(),
1055                      &ArgValues[0], ArgValues.size());
1056 }
1057
1058 /// isLSAAddress - Return the immediate to use if the specified
1059 /// value is representable as a LSA address.
1060 static SDNode *isLSAAddress(SDValue Op, SelectionDAG &DAG) {
1061   ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op);
1062   if (!C) return 0;
1063
1064   int Addr = C->getZExtValue();
1065   if ((Addr & 3) != 0 ||  // Low 2 bits are implicitly zero.
1066       (Addr << 14 >> 14) != Addr)
1067     return 0;  // Top 14 bits have to be sext of immediate.
1068
1069   return DAG.getConstant((int)C->getZExtValue() >> 2, MVT::i32).getNode();
1070 }
1071
1072 static
1073 SDValue
1074 LowerCALL(SDValue Op, SelectionDAG &DAG, const SPUSubtarget *ST) {
1075   CallSDNode *TheCall = cast<CallSDNode>(Op.getNode());
1076   SDValue Chain = TheCall->getChain();
1077   SDValue Callee    = TheCall->getCallee();
1078   unsigned NumOps     = TheCall->getNumArgs();
1079   unsigned StackSlotSize = SPUFrameInfo::stackSlotSize();
1080   const unsigned *ArgRegs = SPURegisterInfo::getArgRegs();
1081   const unsigned NumArgRegs = SPURegisterInfo::getNumArgRegs();
1082
1083   // Handy pointer type
1084   MVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1085
1086   // Accumulate how many bytes are to be pushed on the stack, including the
1087   // linkage area, and parameter passing area.  According to the SPU ABI,
1088   // we minimally need space for [LR] and [SP]
1089   unsigned NumStackBytes = SPUFrameInfo::minStackSize();
1090
1091   // Set up a copy of the stack pointer for use loading and storing any
1092   // arguments that may not fit in the registers available for argument
1093   // passing.
1094   SDValue StackPtr = DAG.getRegister(SPU::R1, MVT::i32);
1095
1096   // Figure out which arguments are going to go in registers, and which in
1097   // memory.
1098   unsigned ArgOffset = SPUFrameInfo::minStackSize(); // Just below [LR]
1099   unsigned ArgRegIdx = 0;
1100
1101   // Keep track of registers passing arguments
1102   std::vector<std::pair<unsigned, SDValue> > RegsToPass;
1103   // And the arguments passed on the stack
1104   SmallVector<SDValue, 8> MemOpChains;
1105
1106   for (unsigned i = 0; i != NumOps; ++i) {
1107     SDValue Arg = TheCall->getArg(i);
1108
1109     // PtrOff will be used to store the current argument to the stack if a
1110     // register cannot be found for it.
1111     SDValue PtrOff = DAG.getConstant(ArgOffset, StackPtr.getValueType());
1112     PtrOff = DAG.getNode(ISD::ADD, PtrVT, StackPtr, PtrOff);
1113
1114     switch (Arg.getValueType().getSimpleVT()) {
1115     default: assert(0 && "Unexpected ValueType for argument!");
1116     case MVT::i32:
1117     case MVT::i64:
1118     case MVT::i128:
1119       if (ArgRegIdx != NumArgRegs) {
1120         RegsToPass.push_back(std::make_pair(ArgRegs[ArgRegIdx++], Arg));
1121       } else {
1122         MemOpChains.push_back(DAG.getStore(Chain, Arg, PtrOff, NULL, 0));
1123         ArgOffset += StackSlotSize;
1124       }
1125       break;
1126     case MVT::f32:
1127     case MVT::f64:
1128       if (ArgRegIdx != NumArgRegs) {
1129         RegsToPass.push_back(std::make_pair(ArgRegs[ArgRegIdx++], Arg));
1130       } else {
1131         MemOpChains.push_back(DAG.getStore(Chain, Arg, PtrOff, NULL, 0));
1132         ArgOffset += StackSlotSize;
1133       }
1134       break;
1135     case MVT::v4f32:
1136     case MVT::v4i32:
1137     case MVT::v8i16:
1138     case MVT::v16i8:
1139       if (ArgRegIdx != NumArgRegs) {
1140         RegsToPass.push_back(std::make_pair(ArgRegs[ArgRegIdx++], Arg));
1141       } else {
1142         MemOpChains.push_back(DAG.getStore(Chain, Arg, PtrOff, NULL, 0));
1143         ArgOffset += StackSlotSize;
1144       }
1145       break;
1146     }
1147   }
1148
1149   // Update number of stack bytes actually used, insert a call sequence start
1150   NumStackBytes = (ArgOffset - SPUFrameInfo::minStackSize());
1151   Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumStackBytes,
1152                                                             true));
1153
1154   if (!MemOpChains.empty()) {
1155     // Adjust the stack pointer for the stack arguments.
1156     Chain = DAG.getNode(ISD::TokenFactor, MVT::Other,
1157                         &MemOpChains[0], MemOpChains.size());
1158   }
1159
1160   // Build a sequence of copy-to-reg nodes chained together with token chain
1161   // and flag operands which copy the outgoing args into the appropriate regs.
1162   SDValue InFlag;
1163   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
1164     Chain = DAG.getCopyToReg(Chain, RegsToPass[i].first, RegsToPass[i].second,
1165                              InFlag);
1166     InFlag = Chain.getValue(1);
1167   }
1168
1169   SmallVector<SDValue, 8> Ops;
1170   unsigned CallOpc = SPUISD::CALL;
1171
1172   // If the callee is a GlobalAddress/ExternalSymbol node (quite common, every
1173   // direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol
1174   // node so that legalize doesn't hack it.
1175   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1176     GlobalValue *GV = G->getGlobal();
1177     MVT CalleeVT = Callee.getValueType();
1178     SDValue Zero = DAG.getConstant(0, PtrVT);
1179     SDValue GA = DAG.getTargetGlobalAddress(GV, CalleeVT);
1180
1181     if (!ST->usingLargeMem()) {
1182       // Turn calls to targets that are defined (i.e., have bodies) into BRSL
1183       // style calls, otherwise, external symbols are BRASL calls. This assumes
1184       // that declared/defined symbols are in the same compilation unit and can
1185       // be reached through PC-relative jumps.
1186       //
1187       // NOTE:
1188       // This may be an unsafe assumption for JIT and really large compilation
1189       // units.
1190       if (GV->isDeclaration()) {
1191         Callee = DAG.getNode(SPUISD::AFormAddr, CalleeVT, GA, Zero);
1192       } else {
1193         Callee = DAG.getNode(SPUISD::PCRelAddr, CalleeVT, GA, Zero);
1194       }
1195     } else {
1196       // "Large memory" mode: Turn all calls into indirect calls with a X-form
1197       // address pairs:
1198       Callee = DAG.getNode(SPUISD::IndirectAddr, PtrVT, GA, Zero);
1199     }
1200   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
1201     Callee = DAG.getExternalSymbol(S->getSymbol(), Callee.getValueType());
1202   else if (SDNode *Dest = isLSAAddress(Callee, DAG)) {
1203     // If this is an absolute destination address that appears to be a legal
1204     // local store address, use the munged value.
1205     Callee = SDValue(Dest, 0);
1206   }
1207
1208   Ops.push_back(Chain);
1209   Ops.push_back(Callee);
1210
1211   // Add argument registers to the end of the list so that they are known live
1212   // into the call.
1213   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
1214     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
1215                                   RegsToPass[i].second.getValueType()));
1216
1217   if (InFlag.getNode())
1218     Ops.push_back(InFlag);
1219   // Returns a chain and a flag for retval copy to use.
1220   Chain = DAG.getNode(CallOpc, DAG.getVTList(MVT::Other, MVT::Flag),
1221                       &Ops[0], Ops.size());
1222   InFlag = Chain.getValue(1);
1223
1224   Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumStackBytes, true),
1225                              DAG.getIntPtrConstant(0, true), InFlag);
1226   if (TheCall->getValueType(0) != MVT::Other)
1227     InFlag = Chain.getValue(1);
1228
1229   SDValue ResultVals[3];
1230   unsigned NumResults = 0;
1231
1232   // If the call has results, copy the values out of the ret val registers.
1233   switch (TheCall->getValueType(0).getSimpleVT()) {
1234   default: assert(0 && "Unexpected ret value!");
1235   case MVT::Other: break;
1236   case MVT::i32:
1237     if (TheCall->getValueType(1) == MVT::i32) {
1238       Chain = DAG.getCopyFromReg(Chain, SPU::R4, MVT::i32, InFlag).getValue(1);
1239       ResultVals[0] = Chain.getValue(0);
1240       Chain = DAG.getCopyFromReg(Chain, SPU::R3, MVT::i32,
1241                                  Chain.getValue(2)).getValue(1);
1242       ResultVals[1] = Chain.getValue(0);
1243       NumResults = 2;
1244     } else {
1245       Chain = DAG.getCopyFromReg(Chain, SPU::R3, MVT::i32, InFlag).getValue(1);
1246       ResultVals[0] = Chain.getValue(0);
1247       NumResults = 1;
1248     }
1249     break;
1250   case MVT::i64:
1251     Chain = DAG.getCopyFromReg(Chain, SPU::R3, MVT::i64, InFlag).getValue(1);
1252     ResultVals[0] = Chain.getValue(0);
1253     NumResults = 1;
1254     break;
1255   case MVT::f32:
1256   case MVT::f64:
1257     Chain = DAG.getCopyFromReg(Chain, SPU::R3, TheCall->getValueType(0),
1258                                InFlag).getValue(1);
1259     ResultVals[0] = Chain.getValue(0);
1260     NumResults = 1;
1261     break;
1262   case MVT::v2f64:
1263   case MVT::v4f32:
1264   case MVT::v4i32:
1265   case MVT::v8i16:
1266   case MVT::v16i8:
1267     Chain = DAG.getCopyFromReg(Chain, SPU::R3, TheCall->getValueType(0),
1268                                    InFlag).getValue(1);
1269     ResultVals[0] = Chain.getValue(0);
1270     NumResults = 1;
1271     break;
1272   }
1273
1274   // If the function returns void, just return the chain.
1275   if (NumResults == 0)
1276     return Chain;
1277
1278   // Otherwise, merge everything together with a MERGE_VALUES node.
1279   ResultVals[NumResults++] = Chain;
1280   SDValue Res = DAG.getMergeValues(ResultVals, NumResults);
1281   return Res.getValue(Op.getResNo());
1282 }
1283
1284 static SDValue
1285 LowerRET(SDValue Op, SelectionDAG &DAG, TargetMachine &TM) {
1286   SmallVector<CCValAssign, 16> RVLocs;
1287   unsigned CC = DAG.getMachineFunction().getFunction()->getCallingConv();
1288   bool isVarArg = DAG.getMachineFunction().getFunction()->isVarArg();
1289   CCState CCInfo(CC, isVarArg, TM, RVLocs);
1290   CCInfo.AnalyzeReturn(Op.getNode(), RetCC_SPU);
1291
1292   // If this is the first return lowered for this function, add the regs to the
1293   // liveout set for the function.
1294   if (DAG.getMachineFunction().getRegInfo().liveout_empty()) {
1295     for (unsigned i = 0; i != RVLocs.size(); ++i)
1296       DAG.getMachineFunction().getRegInfo().addLiveOut(RVLocs[i].getLocReg());
1297   }
1298
1299   SDValue Chain = Op.getOperand(0);
1300   SDValue Flag;
1301
1302   // Copy the result values into the output registers.
1303   for (unsigned i = 0; i != RVLocs.size(); ++i) {
1304     CCValAssign &VA = RVLocs[i];
1305     assert(VA.isRegLoc() && "Can only return in registers!");
1306     Chain = DAG.getCopyToReg(Chain, VA.getLocReg(), Op.getOperand(i*2+1), Flag);
1307     Flag = Chain.getValue(1);
1308   }
1309
1310   if (Flag.getNode())
1311     return DAG.getNode(SPUISD::RET_FLAG, MVT::Other, Chain, Flag);
1312   else
1313     return DAG.getNode(SPUISD::RET_FLAG, MVT::Other, Chain);
1314 }
1315
1316
1317 //===----------------------------------------------------------------------===//
1318 // Vector related lowering:
1319 //===----------------------------------------------------------------------===//
1320
1321 static ConstantSDNode *
1322 getVecImm(SDNode *N) {
1323   SDValue OpVal(0, 0);
1324
1325   // Check to see if this buildvec has a single non-undef value in its elements.
1326   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
1327     if (N->getOperand(i).getOpcode() == ISD::UNDEF) continue;
1328     if (OpVal.getNode() == 0)
1329       OpVal = N->getOperand(i);
1330     else if (OpVal != N->getOperand(i))
1331       return 0;
1332   }
1333
1334   if (OpVal.getNode() != 0) {
1335     if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(OpVal)) {
1336       return CN;
1337     }
1338   }
1339
1340   return 0; // All UNDEF: use implicit def.; not Constant node
1341 }
1342
1343 /// get_vec_i18imm - Test if this vector is a vector filled with the same value
1344 /// and the value fits into an unsigned 18-bit constant, and if so, return the
1345 /// constant
1346 SDValue SPU::get_vec_u18imm(SDNode *N, SelectionDAG &DAG,
1347                               MVT ValueType) {
1348   if (ConstantSDNode *CN = getVecImm(N)) {
1349     uint64_t Value = CN->getZExtValue();
1350     if (ValueType == MVT::i64) {
1351       uint64_t UValue = CN->getZExtValue();
1352       uint32_t upper = uint32_t(UValue >> 32);
1353       uint32_t lower = uint32_t(UValue);
1354       if (upper != lower)
1355         return SDValue();
1356       Value = Value >> 32;
1357     }
1358     if (Value <= 0x3ffff)
1359       return DAG.getTargetConstant(Value, ValueType);
1360   }
1361
1362   return SDValue();
1363 }
1364
1365 /// get_vec_i16imm - Test if this vector is a vector filled with the same value
1366 /// and the value fits into a signed 16-bit constant, and if so, return the
1367 /// constant
1368 SDValue SPU::get_vec_i16imm(SDNode *N, SelectionDAG &DAG,
1369                               MVT ValueType) {
1370   if (ConstantSDNode *CN = getVecImm(N)) {
1371     int64_t Value = CN->getSExtValue();
1372     if (ValueType == MVT::i64) {
1373       uint64_t UValue = CN->getZExtValue();
1374       uint32_t upper = uint32_t(UValue >> 32);
1375       uint32_t lower = uint32_t(UValue);
1376       if (upper != lower)
1377         return SDValue();
1378       Value = Value >> 32;
1379     }
1380     if (Value >= -(1 << 15) && Value <= ((1 << 15) - 1)) {
1381       return DAG.getTargetConstant(Value, ValueType);
1382     }
1383   }
1384
1385   return SDValue();
1386 }
1387
1388 /// get_vec_i10imm - Test if this vector is a vector filled with the same value
1389 /// and the value fits into a signed 10-bit constant, and if so, return the
1390 /// constant
1391 SDValue SPU::get_vec_i10imm(SDNode *N, SelectionDAG &DAG,
1392                               MVT ValueType) {
1393   if (ConstantSDNode *CN = getVecImm(N)) {
1394     int64_t Value = CN->getSExtValue();
1395     if (ValueType == MVT::i64) {
1396       uint64_t UValue = CN->getZExtValue();
1397       uint32_t upper = uint32_t(UValue >> 32);
1398       uint32_t lower = uint32_t(UValue);
1399       if (upper != lower)
1400         return SDValue();
1401       Value = Value >> 32;
1402     }
1403     if (isS10Constant(Value))
1404       return DAG.getTargetConstant(Value, ValueType);
1405   }
1406
1407   return SDValue();
1408 }
1409
1410 /// get_vec_i8imm - Test if this vector is a vector filled with the same value
1411 /// and the value fits into a signed 8-bit constant, and if so, return the
1412 /// constant.
1413 ///
1414 /// @note: The incoming vector is v16i8 because that's the only way we can load
1415 /// constant vectors. Thus, we test to see if the upper and lower bytes are the
1416 /// same value.
1417 SDValue SPU::get_vec_i8imm(SDNode *N, SelectionDAG &DAG,
1418                              MVT ValueType) {
1419   if (ConstantSDNode *CN = getVecImm(N)) {
1420     int Value = (int) CN->getZExtValue();
1421     if (ValueType == MVT::i16
1422         && Value <= 0xffff                 /* truncated from uint64_t */
1423         && ((short) Value >> 8) == ((short) Value & 0xff))
1424       return DAG.getTargetConstant(Value & 0xff, ValueType);
1425     else if (ValueType == MVT::i8
1426              && (Value & 0xff) == Value)
1427       return DAG.getTargetConstant(Value, ValueType);
1428   }
1429
1430   return SDValue();
1431 }
1432
1433 /// get_ILHUvec_imm - Test if this vector is a vector filled with the same value
1434 /// and the value fits into a signed 16-bit constant, and if so, return the
1435 /// constant
1436 SDValue SPU::get_ILHUvec_imm(SDNode *N, SelectionDAG &DAG,
1437                                MVT ValueType) {
1438   if (ConstantSDNode *CN = getVecImm(N)) {
1439     uint64_t Value = CN->getZExtValue();
1440     if ((ValueType == MVT::i32
1441           && ((unsigned) Value & 0xffff0000) == (unsigned) Value)
1442         || (ValueType == MVT::i64 && (Value & 0xffff0000) == Value))
1443       return DAG.getTargetConstant(Value >> 16, ValueType);
1444   }
1445
1446   return SDValue();
1447 }
1448
1449 /// get_v4i32_imm - Catch-all for general 32-bit constant vectors
1450 SDValue SPU::get_v4i32_imm(SDNode *N, SelectionDAG &DAG) {
1451   if (ConstantSDNode *CN = getVecImm(N)) {
1452     return DAG.getTargetConstant((unsigned) CN->getZExtValue(), MVT::i32);
1453   }
1454
1455   return SDValue();
1456 }
1457
1458 /// get_v4i32_imm - Catch-all for general 64-bit constant vectors
1459 SDValue SPU::get_v2i64_imm(SDNode *N, SelectionDAG &DAG) {
1460   if (ConstantSDNode *CN = getVecImm(N)) {
1461     return DAG.getTargetConstant((unsigned) CN->getZExtValue(), MVT::i64);
1462   }
1463
1464   return SDValue();
1465 }
1466
1467 // If this is a vector of constants or undefs, get the bits.  A bit in
1468 // UndefBits is set if the corresponding element of the vector is an
1469 // ISD::UNDEF value.  For undefs, the corresponding VectorBits values are
1470 // zero.   Return true if this is not an array of constants, false if it is.
1471 //
1472 static bool GetConstantBuildVectorBits(SDNode *BV, uint64_t VectorBits[2],
1473                                        uint64_t UndefBits[2]) {
1474   // Start with zero'd results.
1475   VectorBits[0] = VectorBits[1] = UndefBits[0] = UndefBits[1] = 0;
1476
1477   unsigned EltBitSize = BV->getOperand(0).getValueType().getSizeInBits();
1478   for (unsigned i = 0, e = BV->getNumOperands(); i != e; ++i) {
1479     SDValue OpVal = BV->getOperand(i);
1480
1481     unsigned PartNo = i >= e/2;     // In the upper 128 bits?
1482     unsigned SlotNo = e/2 - (i & (e/2-1))-1;  // Which subpiece of the uint64_t.
1483
1484     uint64_t EltBits = 0;
1485     if (OpVal.getOpcode() == ISD::UNDEF) {
1486       uint64_t EltUndefBits = ~0ULL >> (64-EltBitSize);
1487       UndefBits[PartNo] |= EltUndefBits << (SlotNo*EltBitSize);
1488       continue;
1489     } else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(OpVal)) {
1490       EltBits = CN->getZExtValue() & (~0ULL >> (64-EltBitSize));
1491     } else if (ConstantFPSDNode *CN = dyn_cast<ConstantFPSDNode>(OpVal)) {
1492       const APFloat &apf = CN->getValueAPF();
1493       EltBits = (CN->getValueType(0) == MVT::f32
1494                  ? FloatToBits(apf.convertToFloat())
1495                  : DoubleToBits(apf.convertToDouble()));
1496     } else {
1497       // Nonconstant element.
1498       return true;
1499     }
1500
1501     VectorBits[PartNo] |= EltBits << (SlotNo*EltBitSize);
1502   }
1503
1504   //printf("%llx %llx  %llx %llx\n",
1505   //       VectorBits[0], VectorBits[1], UndefBits[0], UndefBits[1]);
1506   return false;
1507 }
1508
1509 /// If this is a splat (repetition) of a value across the whole vector, return
1510 /// the smallest size that splats it.  For example, "0x01010101010101..." is a
1511 /// splat of 0x01, 0x0101, and 0x01010101.  We return SplatBits = 0x01 and
1512 /// SplatSize = 1 byte.
1513 static bool isConstantSplat(const uint64_t Bits128[2],
1514                             const uint64_t Undef128[2],
1515                             int MinSplatBits,
1516                             uint64_t &SplatBits, uint64_t &SplatUndef,
1517                             int &SplatSize) {
1518   // Don't let undefs prevent splats from matching.  See if the top 64-bits are
1519   // the same as the lower 64-bits, ignoring undefs.
1520   uint64_t Bits64  = Bits128[0] | Bits128[1];
1521   uint64_t Undef64 = Undef128[0] & Undef128[1];
1522   uint32_t Bits32  = uint32_t(Bits64) | uint32_t(Bits64 >> 32);
1523   uint32_t Undef32 = uint32_t(Undef64) & uint32_t(Undef64 >> 32);
1524   uint16_t Bits16  = uint16_t(Bits32)  | uint16_t(Bits32 >> 16);
1525   uint16_t Undef16 = uint16_t(Undef32) & uint16_t(Undef32 >> 16);
1526
1527   if ((Bits128[0] & ~Undef128[1]) == (Bits128[1] & ~Undef128[0])) {
1528     if (MinSplatBits < 64) {
1529
1530       // Check that the top 32-bits are the same as the lower 32-bits, ignoring
1531       // undefs.
1532       if ((Bits64 & (~Undef64 >> 32)) == ((Bits64 >> 32) & ~Undef64)) {
1533         if (MinSplatBits < 32) {
1534
1535           // If the top 16-bits are different than the lower 16-bits, ignoring
1536           // undefs, we have an i32 splat.
1537           if ((Bits32 & (~Undef32 >> 16)) == ((Bits32 >> 16) & ~Undef32)) {
1538             if (MinSplatBits < 16) {
1539               // If the top 8-bits are different than the lower 8-bits, ignoring
1540               // undefs, we have an i16 splat.
1541               if ((Bits16 & (uint16_t(~Undef16) >> 8))
1542                   == ((Bits16 >> 8) & ~Undef16)) {
1543                 // Otherwise, we have an 8-bit splat.
1544                 SplatBits  = uint8_t(Bits16)  | uint8_t(Bits16 >> 8);
1545                 SplatUndef = uint8_t(Undef16) & uint8_t(Undef16 >> 8);
1546                 SplatSize = 1;
1547                 return true;
1548               }
1549             } else {
1550               SplatBits = Bits16;
1551               SplatUndef = Undef16;
1552               SplatSize = 2;
1553               return true;
1554             }
1555           }
1556         } else {
1557           SplatBits = Bits32;
1558           SplatUndef = Undef32;
1559           SplatSize = 4;
1560           return true;
1561         }
1562       }
1563     } else {
1564       SplatBits = Bits128[0];
1565       SplatUndef = Undef128[0];
1566       SplatSize = 8;
1567       return true;
1568     }
1569   }
1570
1571   return false;  // Can't be a splat if two pieces don't match.
1572 }
1573
1574 // If this is a case we can't handle, return null and let the default
1575 // expansion code take care of it.  If we CAN select this case, and if it
1576 // selects to a single instruction, return Op.  Otherwise, if we can codegen
1577 // this case more efficiently than a constant pool load, lower it to the
1578 // sequence of ops that should be used.
1579 static SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) {
1580   MVT VT = Op.getValueType();
1581   // If this is a vector of constants or undefs, get the bits.  A bit in
1582   // UndefBits is set if the corresponding element of the vector is an
1583   // ISD::UNDEF value.  For undefs, the corresponding VectorBits values are
1584   // zero.
1585   uint64_t VectorBits[2];
1586   uint64_t UndefBits[2];
1587   uint64_t SplatBits, SplatUndef;
1588   int SplatSize;
1589   if (GetConstantBuildVectorBits(Op.getNode(), VectorBits, UndefBits)
1590       || !isConstantSplat(VectorBits, UndefBits,
1591                           VT.getVectorElementType().getSizeInBits(),
1592                           SplatBits, SplatUndef, SplatSize))
1593     return SDValue();   // Not a constant vector, not a splat.
1594
1595   switch (VT.getSimpleVT()) {
1596   default:
1597   case MVT::v4f32: {
1598     uint32_t Value32 = SplatBits;
1599     assert(SplatSize == 4
1600            && "LowerBUILD_VECTOR: Unexpected floating point vector element.");
1601     // NOTE: pretend the constant is an integer. LLVM won't load FP constants
1602     SDValue T = DAG.getConstant(Value32, MVT::i32);
1603     return DAG.getNode(ISD::BIT_CONVERT, MVT::v4f32,
1604                        DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32, T, T, T, T));
1605     break;
1606   }
1607   case MVT::v2f64: {
1608     uint64_t f64val = SplatBits;
1609     assert(SplatSize == 8
1610            && "LowerBUILD_VECTOR: 64-bit float vector size > 8 bytes.");
1611     // NOTE: pretend the constant is an integer. LLVM won't load FP constants
1612     SDValue T = DAG.getConstant(f64val, MVT::i64);
1613     return DAG.getNode(ISD::BIT_CONVERT, MVT::v2f64,
1614                        DAG.getNode(ISD::BUILD_VECTOR, MVT::v2i64, T, T));
1615     break;
1616   }
1617   case MVT::v16i8: {
1618    // 8-bit constants have to be expanded to 16-bits
1619    unsigned short Value16 = SplatBits | (SplatBits << 8);
1620    SDValue Ops[8];
1621    for (int i = 0; i < 8; ++i)
1622      Ops[i] = DAG.getConstant(Value16, MVT::i16);
1623    return DAG.getNode(ISD::BIT_CONVERT, VT,
1624                       DAG.getNode(ISD::BUILD_VECTOR, MVT::v8i16, Ops, 8));
1625   }
1626   case MVT::v8i16: {
1627     unsigned short Value16;
1628     if (SplatSize == 2)
1629       Value16 = (unsigned short) (SplatBits & 0xffff);
1630     else
1631       Value16 = (unsigned short) (SplatBits | (SplatBits << 8));
1632     SDValue T = DAG.getConstant(Value16, VT.getVectorElementType());
1633     SDValue Ops[8];
1634     for (int i = 0; i < 8; ++i) Ops[i] = T;
1635     return DAG.getNode(ISD::BUILD_VECTOR, VT, Ops, 8);
1636   }
1637   case MVT::v4i32: {
1638     unsigned int Value = SplatBits;
1639     SDValue T = DAG.getConstant(Value, VT.getVectorElementType());
1640     return DAG.getNode(ISD::BUILD_VECTOR, VT, T, T, T, T);
1641   }
1642   case MVT::v2i64: {
1643     uint64_t val = SplatBits;
1644     uint32_t upper = uint32_t(val >> 32);
1645     uint32_t lower = uint32_t(val);
1646
1647     if (upper == lower) {
1648       // Magic constant that can be matched by IL, ILA, et. al.
1649       SDValue Val = DAG.getTargetConstant(val, MVT::i64);
1650       return DAG.getNode(ISD::BUILD_VECTOR, VT, Val, Val);
1651     } else {
1652       SDValue LO32;
1653       SDValue HI32;
1654       SmallVector<SDValue, 16> ShufBytes;
1655       SDValue Result;
1656       bool upper_special, lower_special;
1657
1658       // NOTE: This code creates common-case shuffle masks that can be easily
1659       // detected as common expressions. It is not attempting to create highly
1660       // specialized masks to replace any and all 0's, 0xff's and 0x80's.
1661
1662       // Detect if the upper or lower half is a special shuffle mask pattern:
1663       upper_special = (upper == 0||upper == 0xffffffff||upper == 0x80000000);
1664       lower_special = (lower == 0||lower == 0xffffffff||lower == 0x80000000);
1665
1666       // Create lower vector if not a special pattern
1667       if (!lower_special) {
1668         SDValue LO32C = DAG.getConstant(lower, MVT::i32);
1669         LO32 = DAG.getNode(ISD::BIT_CONVERT, VT,
1670                            DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32,
1671                                        LO32C, LO32C, LO32C, LO32C));
1672       }
1673
1674       // Create upper vector if not a special pattern
1675       if (!upper_special) {
1676         SDValue HI32C = DAG.getConstant(upper, MVT::i32);
1677         HI32 = DAG.getNode(ISD::BIT_CONVERT, VT,
1678                            DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32,
1679                                        HI32C, HI32C, HI32C, HI32C));
1680       }
1681
1682       // If either upper or lower are special, then the two input operands are
1683       // the same (basically, one of them is a "don't care")
1684       if (lower_special)
1685         LO32 = HI32;
1686       if (upper_special)
1687         HI32 = LO32;
1688       if (lower_special && upper_special) {
1689         // Unhappy situation... both upper and lower are special, so punt with
1690         // a target constant:
1691         SDValue Zero = DAG.getConstant(0, MVT::i32);
1692         HI32 = LO32 = DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32, Zero, Zero,
1693                                   Zero, Zero);
1694       }
1695
1696       for (int i = 0; i < 4; ++i) {
1697         uint64_t val = 0;
1698         for (int j = 0; j < 4; ++j) {
1699           SDValue V;
1700           bool process_upper, process_lower;
1701           val <<= 8;
1702           process_upper = (upper_special && (i & 1) == 0);
1703           process_lower = (lower_special && (i & 1) == 1);
1704
1705           if (process_upper || process_lower) {
1706             if ((process_upper && upper == 0)
1707                 || (process_lower && lower == 0))
1708               val |= 0x80;
1709             else if ((process_upper && upper == 0xffffffff)
1710                      || (process_lower && lower == 0xffffffff))
1711               val |= 0xc0;
1712             else if ((process_upper && upper == 0x80000000)
1713                      || (process_lower && lower == 0x80000000))
1714               val |= (j == 0 ? 0xe0 : 0x80);
1715           } else
1716             val |= i * 4 + j + ((i & 1) * 16);
1717         }
1718
1719         ShufBytes.push_back(DAG.getConstant(val, MVT::i32));
1720       }
1721
1722       return DAG.getNode(SPUISD::SHUFB, VT, HI32, LO32,
1723                          DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32,
1724                                      &ShufBytes[0], ShufBytes.size()));
1725     }
1726   }
1727   }
1728
1729   return SDValue();
1730 }
1731
1732 /// LowerVECTOR_SHUFFLE - Lower a vector shuffle (V1, V2, V3) to something on
1733 /// which the Cell can operate. The code inspects V3 to ascertain whether the
1734 /// permutation vector, V3, is monotonically increasing with one "exception"
1735 /// element, e.g., (0, 1, _, 3). If this is the case, then generate a
1736 /// SHUFFLE_MASK synthetic instruction. Otherwise, spill V3 to the constant pool.
1737 /// In either case, the net result is going to eventually invoke SHUFB to
1738 /// permute/shuffle the bytes from V1 and V2.
1739 /// \note
1740 /// SHUFFLE_MASK is eventually selected as one of the C*D instructions, generate
1741 /// control word for byte/halfword/word insertion. This takes care of a single
1742 /// element move from V2 into V1.
1743 /// \note
1744 /// SPUISD::SHUFB is eventually selected as Cell's <i>shufb</i> instructions.
1745 static SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) {
1746   SDValue V1 = Op.getOperand(0);
1747   SDValue V2 = Op.getOperand(1);
1748   SDValue PermMask = Op.getOperand(2);
1749
1750   if (V2.getOpcode() == ISD::UNDEF) V2 = V1;
1751
1752   // If we have a single element being moved from V1 to V2, this can be handled
1753   // using the C*[DX] compute mask instructions, but the vector elements have
1754   // to be monotonically increasing with one exception element.
1755   MVT EltVT = V1.getValueType().getVectorElementType();
1756   unsigned EltsFromV2 = 0;
1757   unsigned V2Elt = 0;
1758   unsigned V2EltIdx0 = 0;
1759   unsigned CurrElt = 0;
1760   bool monotonic = true;
1761   if (EltVT == MVT::i8)
1762     V2EltIdx0 = 16;
1763   else if (EltVT == MVT::i16)
1764     V2EltIdx0 = 8;
1765   else if (EltVT == MVT::i32)
1766     V2EltIdx0 = 4;
1767   else
1768     assert(0 && "Unhandled vector type in LowerVECTOR_SHUFFLE");
1769
1770   for (unsigned i = 0, e = PermMask.getNumOperands();
1771        EltsFromV2 <= 1 && monotonic && i != e;
1772        ++i) {
1773     unsigned SrcElt;
1774     if (PermMask.getOperand(i).getOpcode() == ISD::UNDEF)
1775       SrcElt = 0;
1776     else
1777       SrcElt = cast<ConstantSDNode>(PermMask.getOperand(i))->getZExtValue();
1778
1779     if (SrcElt >= V2EltIdx0) {
1780       ++EltsFromV2;
1781       V2Elt = (V2EltIdx0 - SrcElt) << 2;
1782     } else if (CurrElt != SrcElt) {
1783       monotonic = false;
1784     }
1785
1786     ++CurrElt;
1787   }
1788
1789   if (EltsFromV2 == 1 && monotonic) {
1790     // Compute mask and shuffle
1791     MachineFunction &MF = DAG.getMachineFunction();
1792     MachineRegisterInfo &RegInfo = MF.getRegInfo();
1793     unsigned VReg = RegInfo.createVirtualRegister(&SPU::R32CRegClass);
1794     MVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1795     // Initialize temporary register to 0
1796     SDValue InitTempReg =
1797       DAG.getCopyToReg(DAG.getEntryNode(), VReg, DAG.getConstant(0, PtrVT));
1798     // Copy register's contents as index in SHUFFLE_MASK:
1799     SDValue ShufMaskOp =
1800       DAG.getNode(SPUISD::SHUFFLE_MASK, MVT::v4i32,
1801                   DAG.getTargetConstant(V2Elt, MVT::i32),
1802                   DAG.getCopyFromReg(InitTempReg, VReg, PtrVT));
1803     // Use shuffle mask in SHUFB synthetic instruction:
1804     return DAG.getNode(SPUISD::SHUFB, V1.getValueType(), V2, V1, ShufMaskOp);
1805   } else {
1806    // Convert the SHUFFLE_VECTOR mask's input element units to the
1807    // actual bytes.
1808     unsigned BytesPerElement = EltVT.getSizeInBits()/8;
1809
1810     SmallVector<SDValue, 16> ResultMask;
1811     for (unsigned i = 0, e = PermMask.getNumOperands(); i != e; ++i) {
1812       unsigned SrcElt;
1813       if (PermMask.getOperand(i).getOpcode() == ISD::UNDEF)
1814         SrcElt = 0;
1815       else
1816         SrcElt = cast<ConstantSDNode>(PermMask.getOperand(i))->getZExtValue();
1817
1818       for (unsigned j = 0; j < BytesPerElement; ++j) {
1819         ResultMask.push_back(DAG.getConstant(SrcElt*BytesPerElement+j,
1820                                              MVT::i8));
1821       }
1822     }
1823
1824     SDValue VPermMask = DAG.getNode(ISD::BUILD_VECTOR, MVT::v16i8,
1825                                     &ResultMask[0], ResultMask.size());
1826     return DAG.getNode(SPUISD::SHUFB, V1.getValueType(), V1, V2, VPermMask);
1827   }
1828 }
1829
1830 static SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) {
1831   SDValue Op0 = Op.getOperand(0);                     // Op0 = the scalar
1832
1833   if (Op0.getNode()->getOpcode() == ISD::Constant) {
1834     // For a constant, build the appropriate constant vector, which will
1835     // eventually simplify to a vector register load.
1836
1837     ConstantSDNode *CN = cast<ConstantSDNode>(Op0.getNode());
1838     SmallVector<SDValue, 16> ConstVecValues;
1839     MVT VT;
1840     size_t n_copies;
1841
1842     // Create a constant vector:
1843     switch (Op.getValueType().getSimpleVT()) {
1844     default: assert(0 && "Unexpected constant value type in "
1845                          "LowerSCALAR_TO_VECTOR");
1846     case MVT::v16i8: n_copies = 16; VT = MVT::i8; break;
1847     case MVT::v8i16: n_copies = 8; VT = MVT::i16; break;
1848     case MVT::v4i32: n_copies = 4; VT = MVT::i32; break;
1849     case MVT::v4f32: n_copies = 4; VT = MVT::f32; break;
1850     case MVT::v2i64: n_copies = 2; VT = MVT::i64; break;
1851     case MVT::v2f64: n_copies = 2; VT = MVT::f64; break;
1852     }
1853
1854     SDValue CValue = DAG.getConstant(CN->getZExtValue(), VT);
1855     for (size_t j = 0; j < n_copies; ++j)
1856       ConstVecValues.push_back(CValue);
1857
1858     return DAG.getNode(ISD::BUILD_VECTOR, Op.getValueType(),
1859                        &ConstVecValues[0], ConstVecValues.size());
1860   } else {
1861     // Otherwise, copy the value from one register to another:
1862     switch (Op0.getValueType().getSimpleVT()) {
1863     default: assert(0 && "Unexpected value type in LowerSCALAR_TO_VECTOR");
1864     case MVT::i8:
1865     case MVT::i16:
1866     case MVT::i32:
1867     case MVT::i64:
1868     case MVT::f32:
1869     case MVT::f64:
1870       return DAG.getNode(SPUISD::PROMOTE_SCALAR, Op.getValueType(), Op0, Op0);
1871     }
1872   }
1873
1874   return SDValue();
1875 }
1876
1877 static SDValue LowerVectorMUL(SDValue Op, SelectionDAG &DAG) {
1878   switch (Op.getValueType().getSimpleVT()) {
1879   default:
1880     cerr << "CellSPU: Unknown vector multiplication, got "
1881          << Op.getValueType().getMVTString()
1882          << "\n";
1883     abort();
1884     /*NOTREACHED*/
1885
1886   case MVT::v4i32: {
1887     SDValue rA = Op.getOperand(0);
1888     SDValue rB = Op.getOperand(1);
1889     SDValue HiProd1 = DAG.getNode(SPUISD::MPYH, MVT::v4i32, rA, rB);
1890     SDValue HiProd2 = DAG.getNode(SPUISD::MPYH, MVT::v4i32, rB, rA);
1891     SDValue LoProd = DAG.getNode(SPUISD::MPYU, MVT::v4i32, rA, rB);
1892     SDValue Residual1 = DAG.getNode(ISD::ADD, MVT::v4i32, LoProd, HiProd1);
1893
1894     return DAG.getNode(ISD::ADD, MVT::v4i32, Residual1, HiProd2);
1895     break;
1896   }
1897
1898   // Multiply two v8i16 vectors (pipeline friendly version):
1899   // a) multiply lower halves, mask off upper 16-bit of 32-bit product
1900   // b) multiply upper halves, rotate left by 16 bits (inserts 16 lower zeroes)
1901   // c) Use SELB to select upper and lower halves from the intermediate results
1902   //
1903   // NOTE: We really want to move the SELECT_MASK to earlier to actually get the
1904   // dual-issue. This code does manage to do this, even if it's a little on
1905   // the wacky side
1906   case MVT::v8i16: {
1907     MachineFunction &MF = DAG.getMachineFunction();
1908     MachineRegisterInfo &RegInfo = MF.getRegInfo();
1909     SDValue Chain = Op.getOperand(0);
1910     SDValue rA = Op.getOperand(0);
1911     SDValue rB = Op.getOperand(1);
1912     unsigned FSMBIreg = RegInfo.createVirtualRegister(&SPU::VECREGRegClass);
1913     unsigned HiProdReg = RegInfo.createVirtualRegister(&SPU::VECREGRegClass);
1914
1915     SDValue FSMBOp =
1916       DAG.getCopyToReg(Chain, FSMBIreg,
1917                        DAG.getNode(SPUISD::SELECT_MASK, MVT::v8i16,
1918                                    DAG.getConstant(0xcccc, MVT::i16)));
1919
1920     SDValue HHProd =
1921       DAG.getCopyToReg(FSMBOp, HiProdReg,
1922                        DAG.getNode(SPUISD::MPYHH, MVT::v8i16, rA, rB));
1923
1924     SDValue HHProd_v4i32 =
1925       DAG.getNode(ISD::BIT_CONVERT, MVT::v4i32,
1926                   DAG.getCopyFromReg(HHProd, HiProdReg, MVT::v4i32));
1927
1928     return DAG.getNode(SPUISD::SELB, MVT::v8i16,
1929                        DAG.getNode(SPUISD::MPY, MVT::v8i16, rA, rB),
1930                        DAG.getNode(ISD::BIT_CONVERT, Op.getValueType(),
1931                                    DAG.getNode(SPUISD::VEC_SHL, MVT::v4i32,
1932                                                HHProd_v4i32,
1933                                                DAG.getConstant(16, MVT::i16))),
1934                        DAG.getCopyFromReg(FSMBOp, FSMBIreg, MVT::v4i32));
1935   }
1936
1937   // This M00sE is N@stI! (apologies to Monty Python)
1938   //
1939   // SPU doesn't know how to do any 8-bit multiplication, so the solution
1940   // is to break it all apart, sign extend, and reassemble the various
1941   // intermediate products.
1942   case MVT::v16i8: {
1943     SDValue rA = Op.getOperand(0);
1944     SDValue rB = Op.getOperand(1);
1945     SDValue c8 = DAG.getConstant(8, MVT::i32);
1946     SDValue c16 = DAG.getConstant(16, MVT::i32);
1947
1948     SDValue LLProd =
1949       DAG.getNode(SPUISD::MPY, MVT::v8i16,
1950                   DAG.getNode(ISD::BIT_CONVERT, MVT::v8i16, rA),
1951                   DAG.getNode(ISD::BIT_CONVERT, MVT::v8i16, rB));
1952
1953     SDValue rALH = DAG.getNode(SPUISD::VEC_SRA, MVT::v8i16, rA, c8);
1954
1955     SDValue rBLH = DAG.getNode(SPUISD::VEC_SRA, MVT::v8i16, rB, c8);
1956
1957     SDValue LHProd =
1958       DAG.getNode(SPUISD::VEC_SHL, MVT::v8i16,
1959                   DAG.getNode(SPUISD::MPY, MVT::v8i16, rALH, rBLH), c8);
1960
1961     SDValue FSMBmask = DAG.getNode(SPUISD::SELECT_MASK, MVT::v8i16,
1962                                      DAG.getConstant(0x2222, MVT::i16));
1963
1964     SDValue LoProdParts =
1965       DAG.getNode(ISD::BIT_CONVERT, MVT::v4i32,
1966                   DAG.getNode(SPUISD::SELB, MVT::v8i16,
1967                               LLProd, LHProd, FSMBmask));
1968
1969     SDValue LoProdMask = DAG.getConstant(0xffff, MVT::i32);
1970
1971     SDValue LoProd =
1972       DAG.getNode(ISD::AND, MVT::v4i32,
1973                   LoProdParts,
1974                   DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32,
1975                               LoProdMask, LoProdMask,
1976                               LoProdMask, LoProdMask));
1977
1978     SDValue rAH =
1979       DAG.getNode(SPUISD::VEC_SRA, MVT::v4i32,
1980                   DAG.getNode(ISD::BIT_CONVERT, MVT::v4i32, rA), c16);
1981
1982     SDValue rBH =
1983       DAG.getNode(SPUISD::VEC_SRA, MVT::v4i32,
1984                   DAG.getNode(ISD::BIT_CONVERT, MVT::v4i32, rB), c16);
1985
1986     SDValue HLProd =
1987       DAG.getNode(SPUISD::MPY, MVT::v8i16,
1988                   DAG.getNode(ISD::BIT_CONVERT, MVT::v8i16, rAH),
1989                   DAG.getNode(ISD::BIT_CONVERT, MVT::v8i16, rBH));
1990
1991     SDValue HHProd_1 =
1992       DAG.getNode(SPUISD::MPY, MVT::v8i16,
1993                   DAG.getNode(ISD::BIT_CONVERT, MVT::v8i16,
1994                               DAG.getNode(SPUISD::VEC_SRA,
1995                                           MVT::v4i32, rAH, c8)),
1996                   DAG.getNode(ISD::BIT_CONVERT, MVT::v8i16,
1997                               DAG.getNode(SPUISD::VEC_SRA,
1998                                           MVT::v4i32, rBH, c8)));
1999
2000     SDValue HHProd =
2001       DAG.getNode(SPUISD::SELB, MVT::v8i16,
2002                   HLProd,
2003                   DAG.getNode(SPUISD::VEC_SHL, MVT::v8i16, HHProd_1, c8),
2004                   FSMBmask);
2005
2006     SDValue HiProd =
2007       DAG.getNode(SPUISD::VEC_SHL, MVT::v4i32, HHProd, c16);
2008
2009     return DAG.getNode(ISD::BIT_CONVERT, MVT::v16i8,
2010                        DAG.getNode(ISD::OR, MVT::v4i32,
2011                                    LoProd, HiProd));
2012   }
2013   }
2014
2015   return SDValue();
2016 }
2017
2018 static SDValue LowerFDIVf32(SDValue Op, SelectionDAG &DAG) {
2019   MachineFunction &MF = DAG.getMachineFunction();
2020   MachineRegisterInfo &RegInfo = MF.getRegInfo();
2021
2022   SDValue A = Op.getOperand(0);
2023   SDValue B = Op.getOperand(1);
2024   MVT VT = Op.getValueType();
2025
2026   unsigned VRegBR, VRegC;
2027
2028   if (VT == MVT::f32) {
2029     VRegBR = RegInfo.createVirtualRegister(&SPU::R32FPRegClass);
2030     VRegC = RegInfo.createVirtualRegister(&SPU::R32FPRegClass);
2031   } else {
2032     VRegBR = RegInfo.createVirtualRegister(&SPU::VECREGRegClass);
2033     VRegC = RegInfo.createVirtualRegister(&SPU::VECREGRegClass);
2034   }
2035   // TODO: make sure we're feeding FPInterp the right arguments
2036   // Right now: fi B, frest(B)
2037
2038   // Computes BRcpl =
2039   // (Floating Interpolate (FP Reciprocal Estimate B))
2040   SDValue BRcpl =
2041       DAG.getCopyToReg(DAG.getEntryNode(), VRegBR,
2042                        DAG.getNode(SPUISD::FPInterp, VT, B,
2043                                 DAG.getNode(SPUISD::FPRecipEst, VT, B)));
2044
2045   // Computes A * BRcpl and stores in a temporary register
2046   SDValue AxBRcpl =
2047       DAG.getCopyToReg(BRcpl, VRegC,
2048                  DAG.getNode(ISD::FMUL, VT, A,
2049                         DAG.getCopyFromReg(BRcpl, VRegBR, VT)));
2050   // What's the Chain variable do? It's magic!
2051   // TODO: set Chain = Op(0).getEntryNode()
2052
2053   return DAG.getNode(ISD::FADD, VT,
2054                 DAG.getCopyFromReg(AxBRcpl, VRegC, VT),
2055                 DAG.getNode(ISD::FMUL, VT,
2056                         DAG.getCopyFromReg(AxBRcpl, VRegBR, VT),
2057                         DAG.getNode(ISD::FSUB, VT, A,
2058                             DAG.getNode(ISD::FMUL, VT, B,
2059                             DAG.getCopyFromReg(AxBRcpl, VRegC, VT)))));
2060 }
2061
2062 static SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) {
2063   MVT VT = Op.getValueType();
2064   SDValue N = Op.getOperand(0);
2065   SDValue Elt = Op.getOperand(1);
2066   SDValue retval;
2067
2068   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Elt)) {
2069     // Constant argument:
2070     int EltNo = (int) C->getZExtValue();
2071
2072     // sanity checks:
2073     if (VT == MVT::i8 && EltNo >= 16)
2074       assert(0 && "SPU LowerEXTRACT_VECTOR_ELT: i8 extraction slot > 15");
2075     else if (VT == MVT::i16 && EltNo >= 8)
2076       assert(0 && "SPU LowerEXTRACT_VECTOR_ELT: i16 extraction slot > 7");
2077     else if (VT == MVT::i32 && EltNo >= 4)
2078       assert(0 && "SPU LowerEXTRACT_VECTOR_ELT: i32 extraction slot > 4");
2079     else if (VT == MVT::i64 && EltNo >= 2)
2080       assert(0 && "SPU LowerEXTRACT_VECTOR_ELT: i64 extraction slot > 2");
2081
2082     if (EltNo == 0 && (VT == MVT::i32 || VT == MVT::i64)) {
2083       // i32 and i64: Element 0 is the preferred slot
2084       return DAG.getNode(SPUISD::VEC2PREFSLOT, VT, N);
2085     }
2086
2087     // Need to generate shuffle mask and extract:
2088     int prefslot_begin = -1, prefslot_end = -1;
2089     int elt_byte = EltNo * VT.getSizeInBits() / 8;
2090
2091     switch (VT.getSimpleVT()) {
2092     default:
2093       assert(false && "Invalid value type!");
2094     case MVT::i8: {
2095       prefslot_begin = prefslot_end = 3;
2096       break;
2097     }
2098     case MVT::i16: {
2099       prefslot_begin = 2; prefslot_end = 3;
2100       break;
2101     }
2102     case MVT::i32:
2103     case MVT::f32: {
2104       prefslot_begin = 0; prefslot_end = 3;
2105       break;
2106     }
2107     case MVT::i64:
2108     case MVT::f64: {
2109       prefslot_begin = 0; prefslot_end = 7;
2110       break;
2111     }
2112     }
2113
2114     assert(prefslot_begin != -1 && prefslot_end != -1 &&
2115            "LowerEXTRACT_VECTOR_ELT: preferred slots uninitialized");
2116
2117     unsigned int ShufBytes[16];
2118     for (int i = 0; i < 16; ++i) {
2119       // zero fill uppper part of preferred slot, don't care about the
2120       // other slots:
2121       unsigned int mask_val;
2122       if (i <= prefslot_end) {
2123         mask_val =
2124           ((i < prefslot_begin)
2125            ? 0x80
2126            : elt_byte + (i - prefslot_begin));
2127
2128         ShufBytes[i] = mask_val;
2129       } else
2130         ShufBytes[i] = ShufBytes[i % (prefslot_end + 1)];
2131     }
2132
2133     SDValue ShufMask[4];
2134     for (unsigned i = 0; i < sizeof(ShufMask)/sizeof(ShufMask[0]); ++i) {
2135       unsigned bidx = i / 4;
2136       unsigned int bits = ((ShufBytes[bidx] << 24) |
2137                            (ShufBytes[bidx+1] << 16) |
2138                            (ShufBytes[bidx+2] << 8) |
2139                            ShufBytes[bidx+3]);
2140       ShufMask[i] = DAG.getConstant(bits, MVT::i32);
2141     }
2142
2143     SDValue ShufMaskVec = DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32,
2144                                       &ShufMask[0],
2145                                       sizeof(ShufMask) / sizeof(ShufMask[0]));
2146
2147     retval = DAG.getNode(SPUISD::VEC2PREFSLOT, VT,
2148                          DAG.getNode(SPUISD::SHUFB, N.getValueType(),
2149                                      N, N, ShufMaskVec));
2150   } else {
2151     // Variable index: Rotate the requested element into slot 0, then replicate
2152     // slot 0 across the vector
2153     MVT VecVT = N.getValueType();
2154     if (!VecVT.isSimple() || !VecVT.isVector() || !VecVT.is128BitVector()) {
2155       cerr << "LowerEXTRACT_VECTOR_ELT: Must have a simple, 128-bit vector type!\n";
2156       abort();
2157     }
2158
2159     // Make life easier by making sure the index is zero-extended to i32
2160     if (Elt.getValueType() != MVT::i32)
2161       Elt = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Elt);
2162
2163     // Scale the index to a bit/byte shift quantity
2164     APInt scaleFactor =
2165             APInt(32, uint64_t(16 / N.getValueType().getVectorNumElements()), false);
2166     unsigned scaleShift = scaleFactor.logBase2();
2167     SDValue vecShift;
2168
2169     if (scaleShift > 0) {
2170       // Scale the shift factor:
2171       Elt = DAG.getNode(ISD::SHL, MVT::i32, Elt,
2172                         DAG.getConstant(scaleShift, MVT::i32));
2173     }
2174
2175     vecShift = DAG.getNode(SPUISD::SHLQUAD_L_BYTES, VecVT, N, Elt);
2176
2177     // Replicate the bytes starting at byte 0 across the entire vector (for
2178     // consistency with the notion of a unified register set)
2179     SDValue replicate;
2180
2181     switch (VT.getSimpleVT()) {
2182     default:
2183       cerr << "LowerEXTRACT_VECTOR_ELT(varable): Unhandled vector type\n";
2184       abort();
2185       /*NOTREACHED*/
2186     case MVT::i8: {
2187       SDValue factor = DAG.getConstant(0x00000000, MVT::i32);
2188       replicate = DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32, factor, factor,
2189                               factor, factor);
2190       break;
2191     }
2192     case MVT::i16: {
2193       SDValue factor = DAG.getConstant(0x00010001, MVT::i32);
2194       replicate = DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32, factor, factor,
2195                               factor, factor);
2196       break;
2197     }
2198     case MVT::i32:
2199     case MVT::f32: {
2200       SDValue factor = DAG.getConstant(0x00010203, MVT::i32);
2201       replicate = DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32, factor, factor,
2202                               factor, factor);
2203       break;
2204     }
2205     case MVT::i64:
2206     case MVT::f64: {
2207       SDValue loFactor = DAG.getConstant(0x00010203, MVT::i32);
2208       SDValue hiFactor = DAG.getConstant(0x04050607, MVT::i32);
2209       replicate = DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32, loFactor, hiFactor,
2210                               loFactor, hiFactor);
2211       break;
2212     }
2213     }
2214
2215     retval = DAG.getNode(SPUISD::VEC2PREFSLOT, VT,
2216                          DAG.getNode(SPUISD::SHUFB, VecVT,
2217                                      vecShift, vecShift, replicate));
2218   }
2219
2220   return retval;
2221 }
2222
2223 static SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) {
2224   SDValue VecOp = Op.getOperand(0);
2225   SDValue ValOp = Op.getOperand(1);
2226   SDValue IdxOp = Op.getOperand(2);
2227   MVT VT = Op.getValueType();
2228
2229   ConstantSDNode *CN = cast<ConstantSDNode>(IdxOp);
2230   assert(CN != 0 && "LowerINSERT_VECTOR_ELT: Index is not constant!");
2231
2232   MVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
2233   // Use $sp ($1) because it's always 16-byte aligned and it's available:
2234   SDValue Pointer = DAG.getNode(SPUISD::IndirectAddr, PtrVT,
2235                                 DAG.getRegister(SPU::R1, PtrVT),
2236                                 DAG.getConstant(CN->getSExtValue(), PtrVT));
2237   SDValue ShufMask = DAG.getNode(SPUISD::SHUFFLE_MASK, VT, Pointer);
2238
2239   SDValue result =
2240     DAG.getNode(SPUISD::SHUFB, VT,
2241                 DAG.getNode(ISD::SCALAR_TO_VECTOR, VT, ValOp),
2242                 VecOp,
2243                 DAG.getNode(ISD::BIT_CONVERT, MVT::v4i32, ShufMask));
2244
2245   return result;
2246 }
2247
2248 static SDValue LowerI8Math(SDValue Op, SelectionDAG &DAG, unsigned Opc)
2249 {
2250   SDValue N0 = Op.getOperand(0);      // Everything has at least one operand
2251
2252   assert(Op.getValueType() == MVT::i8);
2253   switch (Opc) {
2254   default:
2255     assert(0 && "Unhandled i8 math operator");
2256     /*NOTREACHED*/
2257     break;
2258   case ISD::SUB: {
2259     // 8-bit subtraction: Promote the arguments up to 16-bits and truncate
2260     // the result:
2261     SDValue N1 = Op.getOperand(1);
2262     N0 = (N0.getOpcode() != ISD::Constant
2263           ? DAG.getNode(ISD::SIGN_EXTEND, MVT::i16, N0)
2264           : DAG.getConstant(cast<ConstantSDNode>(N0)->getZExtValue(),
2265                             MVT::i16));
2266     N1 = (N1.getOpcode() != ISD::Constant
2267           ? DAG.getNode(ISD::SIGN_EXTEND, MVT::i16, N1)
2268           : DAG.getConstant(cast<ConstantSDNode>(N1)->getZExtValue(),
2269                             MVT::i16));
2270     return DAG.getNode(ISD::TRUNCATE, MVT::i8,
2271                        DAG.getNode(Opc, MVT::i16, N0, N1));
2272   }
2273   case ISD::ROTR:
2274   case ISD::ROTL: {
2275     SDValue N1 = Op.getOperand(1);
2276     unsigned N1Opc;
2277     N0 = (N0.getOpcode() != ISD::Constant
2278           ? DAG.getNode(ISD::ZERO_EXTEND, MVT::i16, N0)
2279           : DAG.getConstant(cast<ConstantSDNode>(N0)->getZExtValue(),
2280                             MVT::i16));
2281     N1Opc = N1.getValueType().bitsLT(MVT::i32)
2282             ? ISD::ZERO_EXTEND
2283             : ISD::TRUNCATE;
2284     N1 = (N1.getOpcode() != ISD::Constant
2285           ? DAG.getNode(N1Opc, MVT::i32, N1)
2286           : DAG.getConstant(cast<ConstantSDNode>(N1)->getZExtValue(),
2287                             MVT::i32));
2288     SDValue ExpandArg =
2289       DAG.getNode(ISD::OR, MVT::i16, N0,
2290                   DAG.getNode(ISD::SHL, MVT::i16,
2291                               N0, DAG.getConstant(8, MVT::i32)));
2292     return DAG.getNode(ISD::TRUNCATE, MVT::i8,
2293                        DAG.getNode(Opc, MVT::i16, ExpandArg, N1));
2294   }
2295   case ISD::SRL:
2296   case ISD::SHL: {
2297     SDValue N1 = Op.getOperand(1);
2298     unsigned N1Opc;
2299     N0 = (N0.getOpcode() != ISD::Constant
2300           ? DAG.getNode(ISD::ZERO_EXTEND, MVT::i16, N0)
2301           : DAG.getConstant(cast<ConstantSDNode>(N0)->getZExtValue(),
2302                             MVT::i16));
2303     N1Opc = N1.getValueType().bitsLT(MVT::i16)
2304             ? ISD::ZERO_EXTEND
2305             : ISD::TRUNCATE;
2306     N1 = (N1.getOpcode() != ISD::Constant
2307           ? DAG.getNode(N1Opc, MVT::i16, N1)
2308           : DAG.getConstant(cast<ConstantSDNode>(N1)->getZExtValue(),
2309                             MVT::i16));
2310     return DAG.getNode(ISD::TRUNCATE, MVT::i8,
2311                        DAG.getNode(Opc, MVT::i16, N0, N1));
2312   }
2313   case ISD::SRA: {
2314     SDValue N1 = Op.getOperand(1);
2315     unsigned N1Opc;
2316     N0 = (N0.getOpcode() != ISD::Constant
2317           ? DAG.getNode(ISD::SIGN_EXTEND, MVT::i16, N0)
2318           : DAG.getConstant(cast<ConstantSDNode>(N0)->getZExtValue(),
2319                             MVT::i16));
2320     N1Opc = N1.getValueType().bitsLT(MVT::i16)
2321             ? ISD::SIGN_EXTEND
2322             : ISD::TRUNCATE;
2323     N1 = (N1.getOpcode() != ISD::Constant
2324           ? DAG.getNode(N1Opc, MVT::i16, N1)
2325           : DAG.getConstant(cast<ConstantSDNode>(N1)->getZExtValue(),
2326                             MVT::i16));
2327     return DAG.getNode(ISD::TRUNCATE, MVT::i8,
2328                        DAG.getNode(Opc, MVT::i16, N0, N1));
2329   }
2330   case ISD::MUL: {
2331     SDValue N1 = Op.getOperand(1);
2332     unsigned N1Opc;
2333     N0 = (N0.getOpcode() != ISD::Constant
2334           ? DAG.getNode(ISD::SIGN_EXTEND, MVT::i16, N0)
2335           : DAG.getConstant(cast<ConstantSDNode>(N0)->getZExtValue(),
2336                             MVT::i16));
2337     N1Opc = N1.getValueType().bitsLT(MVT::i16) ? ISD::SIGN_EXTEND : ISD::TRUNCATE;
2338     N1 = (N1.getOpcode() != ISD::Constant
2339           ? DAG.getNode(N1Opc, MVT::i16, N1)
2340           : DAG.getConstant(cast<ConstantSDNode>(N1)->getZExtValue(),
2341                             MVT::i16));
2342     return DAG.getNode(ISD::TRUNCATE, MVT::i8,
2343                        DAG.getNode(Opc, MVT::i16, N0, N1));
2344     break;
2345   }
2346   }
2347
2348   return SDValue();
2349 }
2350
2351 static SDValue LowerI64Math(SDValue Op, SelectionDAG &DAG, unsigned Opc)
2352 {
2353   MVT VT = Op.getValueType();
2354   MVT VecVT = MVT::getVectorVT(VT, (128 / VT.getSizeInBits()));
2355
2356   SDValue Op0 = Op.getOperand(0);
2357
2358   switch (Opc) {
2359   case ISD::ZERO_EXTEND:
2360   case ISD::SIGN_EXTEND:
2361   case ISD::ANY_EXTEND: {
2362     MVT Op0VT = Op0.getValueType();
2363     MVT Op0VecVT = MVT::getVectorVT(Op0VT, (128 / Op0VT.getSizeInBits()));
2364
2365     assert(Op0VT == MVT::i32
2366            && "CellSPU: Zero/sign extending something other than i32");
2367
2368     DEBUG(cerr << "CellSPU.LowerI64Math: lowering zero/sign/any extend\n");
2369
2370     SDValue PromoteScalar =
2371             DAG.getNode(SPUISD::PROMOTE_SCALAR, Op0VecVT, Op0);
2372
2373     if (Opc != ISD::SIGN_EXTEND) {
2374       // Use a shuffle to zero extend the i32 to i64 directly:
2375       SDValue shufMask =
2376               DAG.getNode(ISD::BUILD_VECTOR, Op0VecVT,
2377                           DAG.getConstant(0x80808080, MVT::i32),
2378                           DAG.getConstant(0x00010203, MVT::i32),
2379                           DAG.getConstant(0x80808080, MVT::i32),
2380                           DAG.getConstant(0x08090a0b, MVT::i32));
2381       SDValue zextShuffle =
2382               DAG.getNode(SPUISD::SHUFB, Op0VecVT,
2383                           PromoteScalar, PromoteScalar, shufMask);
2384
2385       return DAG.getNode(SPUISD::VEC2PREFSLOT, VT,
2386                          DAG.getNode(ISD::BIT_CONVERT, VecVT, zextShuffle));
2387     } else {
2388       // SPU has no "rotate quadword and replicate bit 0" (i.e. rotate/shift
2389       // right and propagate the sign bit) instruction.
2390       SDValue RotQuad =
2391               DAG.getNode(SPUISD::ROTQUAD_RZ_BYTES, Op0VecVT,
2392                           PromoteScalar, DAG.getConstant(4, MVT::i32));
2393       SDValue SignQuad =
2394               DAG.getNode(SPUISD::VEC_SRA, Op0VecVT,
2395                           PromoteScalar, DAG.getConstant(32, MVT::i32));
2396       SDValue SelMask =
2397               DAG.getNode(SPUISD::SELECT_MASK, Op0VecVT,
2398                           DAG.getConstant(0xf0f0, MVT::i16));
2399       SDValue CombineQuad =
2400               DAG.getNode(SPUISD::SELB, Op0VecVT,
2401                           SignQuad, RotQuad, SelMask);
2402
2403       return DAG.getNode(SPUISD::VEC2PREFSLOT, VT,
2404                          DAG.getNode(ISD::BIT_CONVERT, VecVT, CombineQuad));
2405     }
2406   }
2407
2408   case ISD::ADD: {
2409     // Turn operands into vectors to satisfy type checking (shufb works on
2410     // vectors)
2411     SDValue Op0 =
2412       DAG.getNode(SPUISD::PROMOTE_SCALAR, MVT::v2i64, Op.getOperand(0));
2413     SDValue Op1 =
2414       DAG.getNode(SPUISD::PROMOTE_SCALAR, MVT::v2i64, Op.getOperand(1));
2415     SmallVector<SDValue, 16> ShufBytes;
2416
2417     // Create the shuffle mask for "rotating" the borrow up one register slot
2418     // once the borrow is generated.
2419     ShufBytes.push_back(DAG.getConstant(0x04050607, MVT::i32));
2420     ShufBytes.push_back(DAG.getConstant(0x80808080, MVT::i32));
2421     ShufBytes.push_back(DAG.getConstant(0x0c0d0e0f, MVT::i32));
2422     ShufBytes.push_back(DAG.getConstant(0x80808080, MVT::i32));
2423
2424     SDValue CarryGen =
2425       DAG.getNode(SPUISD::CARRY_GENERATE, MVT::v2i64, Op0, Op1);
2426     SDValue ShiftedCarry =
2427       DAG.getNode(SPUISD::SHUFB, MVT::v2i64,
2428                   CarryGen, CarryGen,
2429                   DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32,
2430                               &ShufBytes[0], ShufBytes.size()));
2431
2432     return DAG.getNode(SPUISD::VEC2PREFSLOT, MVT::i64,
2433                        DAG.getNode(SPUISD::ADD_EXTENDED, MVT::v2i64,
2434                                    Op0, Op1, ShiftedCarry));
2435   }
2436
2437   case ISD::SUB: {
2438     // Turn operands into vectors to satisfy type checking (shufb works on
2439     // vectors)
2440     SDValue Op0 =
2441       DAG.getNode(SPUISD::PROMOTE_SCALAR, MVT::v2i64, Op.getOperand(0));
2442     SDValue Op1 =
2443       DAG.getNode(SPUISD::PROMOTE_SCALAR, MVT::v2i64, Op.getOperand(1));
2444     SmallVector<SDValue, 16> ShufBytes;
2445
2446     // Create the shuffle mask for "rotating" the borrow up one register slot
2447     // once the borrow is generated.
2448     ShufBytes.push_back(DAG.getConstant(0x04050607, MVT::i32));
2449     ShufBytes.push_back(DAG.getConstant(0xc0c0c0c0, MVT::i32));
2450     ShufBytes.push_back(DAG.getConstant(0x0c0d0e0f, MVT::i32));
2451     ShufBytes.push_back(DAG.getConstant(0xc0c0c0c0, MVT::i32));
2452
2453     SDValue BorrowGen =
2454       DAG.getNode(SPUISD::BORROW_GENERATE, MVT::v2i64, Op0, Op1);
2455     SDValue ShiftedBorrow =
2456       DAG.getNode(SPUISD::SHUFB, MVT::v2i64,
2457                   BorrowGen, BorrowGen,
2458                   DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32,
2459                               &ShufBytes[0], ShufBytes.size()));
2460
2461     return DAG.getNode(SPUISD::VEC2PREFSLOT, MVT::i64,
2462                        DAG.getNode(SPUISD::SUB_EXTENDED, MVT::v2i64,
2463                                    Op0, Op1, ShiftedBorrow));
2464   }
2465
2466   case ISD::SHL: {
2467     SDValue ShiftAmt = Op.getOperand(1);
2468     MVT ShiftAmtVT = ShiftAmt.getValueType();
2469     SDValue Op0Vec = DAG.getNode(SPUISD::PROMOTE_SCALAR, VecVT, Op0);
2470     SDValue MaskLower =
2471       DAG.getNode(SPUISD::SELB, VecVT,
2472                   Op0Vec,
2473                   DAG.getConstant(0, VecVT),
2474                   DAG.getNode(SPUISD::SELECT_MASK, VecVT,
2475                               DAG.getConstant(0xff00ULL, MVT::i16)));
2476     SDValue ShiftAmtBytes =
2477       DAG.getNode(ISD::SRL, ShiftAmtVT,
2478                   ShiftAmt,
2479                   DAG.getConstant(3, ShiftAmtVT));
2480     SDValue ShiftAmtBits =
2481       DAG.getNode(ISD::AND, ShiftAmtVT,
2482                   ShiftAmt,
2483                   DAG.getConstant(7, ShiftAmtVT));
2484
2485     return DAG.getNode(SPUISD::VEC2PREFSLOT, VT,
2486                        DAG.getNode(SPUISD::SHLQUAD_L_BITS, VecVT,
2487                                    DAG.getNode(SPUISD::SHLQUAD_L_BYTES, VecVT,
2488                                                MaskLower, ShiftAmtBytes),
2489                                    ShiftAmtBits));
2490   }
2491
2492   case ISD::SRL: {
2493     MVT VT = Op.getValueType();
2494     SDValue ShiftAmt = Op.getOperand(1);
2495     MVT ShiftAmtVT = ShiftAmt.getValueType();
2496     SDValue ShiftAmtBytes =
2497       DAG.getNode(ISD::SRL, ShiftAmtVT,
2498                   ShiftAmt,
2499                   DAG.getConstant(3, ShiftAmtVT));
2500     SDValue ShiftAmtBits =
2501       DAG.getNode(ISD::AND, ShiftAmtVT,
2502                   ShiftAmt,
2503                   DAG.getConstant(7, ShiftAmtVT));
2504
2505     return DAG.getNode(SPUISD::ROTQUAD_RZ_BITS, VT,
2506                        DAG.getNode(SPUISD::ROTQUAD_RZ_BYTES, VT,
2507                                    Op0, ShiftAmtBytes),
2508                        ShiftAmtBits);
2509   }
2510
2511   case ISD::SRA: {
2512     // Promote Op0 to vector
2513     SDValue Op0 =
2514       DAG.getNode(SPUISD::PROMOTE_SCALAR, MVT::v2i64, Op.getOperand(0));
2515     SDValue ShiftAmt = Op.getOperand(1);
2516     MVT ShiftVT = ShiftAmt.getValueType();
2517
2518     // Negate variable shift amounts
2519     if (!isa<ConstantSDNode>(ShiftAmt)) {
2520       ShiftAmt = DAG.getNode(ISD::SUB, ShiftVT,
2521                              DAG.getConstant(0, ShiftVT), ShiftAmt);
2522     }
2523
2524     SDValue UpperHalfSign =
2525       DAG.getNode(SPUISD::VEC2PREFSLOT, MVT::i32,
2526                   DAG.getNode(ISD::BIT_CONVERT, MVT::v4i32,
2527                               DAG.getNode(SPUISD::VEC_SRA, MVT::v2i64,
2528                                           Op0, DAG.getConstant(31, MVT::i32))));
2529     SDValue UpperHalfSignMask =
2530       DAG.getNode(SPUISD::SELECT_MASK, MVT::v2i64, UpperHalfSign);
2531     SDValue UpperLowerMask =
2532       DAG.getNode(SPUISD::SELECT_MASK, MVT::v2i64,
2533                   DAG.getConstant(0xff00, MVT::i16));
2534     SDValue UpperLowerSelect =
2535       DAG.getNode(SPUISD::SELB, MVT::v2i64,
2536                   UpperHalfSignMask, Op0, UpperLowerMask);
2537     SDValue RotateLeftBytes =
2538       DAG.getNode(SPUISD::ROTBYTES_LEFT_BITS, MVT::v2i64,
2539                   UpperLowerSelect, ShiftAmt);
2540     SDValue RotateLeftBits =
2541       DAG.getNode(SPUISD::ROTBYTES_LEFT, MVT::v2i64,
2542                   RotateLeftBytes, ShiftAmt);
2543
2544     return DAG.getNode(SPUISD::VEC2PREFSLOT, MVT::i64,
2545                        RotateLeftBits);
2546   }
2547   }
2548
2549   return SDValue();
2550 }
2551
2552 //! Lower byte immediate operations for v16i8 vectors:
2553 static SDValue
2554 LowerByteImmed(SDValue Op, SelectionDAG &DAG) {
2555   SDValue ConstVec;
2556   SDValue Arg;
2557   MVT VT = Op.getValueType();
2558
2559   ConstVec = Op.getOperand(0);
2560   Arg = Op.getOperand(1);
2561   if (ConstVec.getNode()->getOpcode() != ISD::BUILD_VECTOR) {
2562     if (ConstVec.getNode()->getOpcode() == ISD::BIT_CONVERT) {
2563       ConstVec = ConstVec.getOperand(0);
2564     } else {
2565       ConstVec = Op.getOperand(1);
2566       Arg = Op.getOperand(0);
2567       if (ConstVec.getNode()->getOpcode() == ISD::BIT_CONVERT) {
2568         ConstVec = ConstVec.getOperand(0);
2569       }
2570     }
2571   }
2572
2573   if (ConstVec.getNode()->getOpcode() == ISD::BUILD_VECTOR) {
2574     uint64_t VectorBits[2];
2575     uint64_t UndefBits[2];
2576     uint64_t SplatBits, SplatUndef;
2577     int SplatSize;
2578
2579     if (!GetConstantBuildVectorBits(ConstVec.getNode(), VectorBits, UndefBits)
2580         && isConstantSplat(VectorBits, UndefBits,
2581                            VT.getVectorElementType().getSizeInBits(),
2582                            SplatBits, SplatUndef, SplatSize)) {
2583       SDValue tcVec[16];
2584       SDValue tc = DAG.getTargetConstant(SplatBits & 0xff, MVT::i8);
2585       const size_t tcVecSize = sizeof(tcVec) / sizeof(tcVec[0]);
2586
2587       // Turn the BUILD_VECTOR into a set of target constants:
2588       for (size_t i = 0; i < tcVecSize; ++i)
2589         tcVec[i] = tc;
2590
2591       return DAG.getNode(Op.getNode()->getOpcode(), VT, Arg,
2592                          DAG.getNode(ISD::BUILD_VECTOR, VT, tcVec, tcVecSize));
2593     }
2594   }
2595   // These operations (AND, OR, XOR) are legal, they just couldn't be custom
2596   // lowered.  Return the operation, rather than a null SDValue.
2597   return Op;
2598 }
2599
2600 //! Lower i32 multiplication
2601 static SDValue LowerMUL(SDValue Op, SelectionDAG &DAG, MVT VT,
2602                           unsigned Opc) {
2603   switch (VT.getSimpleVT()) {
2604   default:
2605     cerr << "CellSPU: Unknown LowerMUL value type, got "
2606          << Op.getValueType().getMVTString()
2607          << "\n";
2608     abort();
2609     /*NOTREACHED*/
2610
2611   case MVT::i32: {
2612     SDValue rA = Op.getOperand(0);
2613     SDValue rB = Op.getOperand(1);
2614
2615     return DAG.getNode(ISD::ADD, MVT::i32,
2616                        DAG.getNode(ISD::ADD, MVT::i32,
2617                                    DAG.getNode(SPUISD::MPYH, MVT::i32, rA, rB),
2618                                    DAG.getNode(SPUISD::MPYH, MVT::i32, rB, rA)),
2619                        DAG.getNode(SPUISD::MPYU, MVT::i32, rA, rB));
2620   }
2621   }
2622
2623   return SDValue();
2624 }
2625
2626 //! Custom lowering for CTPOP (count population)
2627 /*!
2628   Custom lowering code that counts the number ones in the input
2629   operand. SPU has such an instruction, but it counts the number of
2630   ones per byte, which then have to be accumulated.
2631 */
2632 static SDValue LowerCTPOP(SDValue Op, SelectionDAG &DAG) {
2633   MVT VT = Op.getValueType();
2634   MVT vecVT = MVT::getVectorVT(VT, (128 / VT.getSizeInBits()));
2635
2636   switch (VT.getSimpleVT()) {
2637   default:
2638     assert(false && "Invalid value type!");
2639   case MVT::i8: {
2640     SDValue N = Op.getOperand(0);
2641     SDValue Elt0 = DAG.getConstant(0, MVT::i32);
2642
2643     SDValue Promote = DAG.getNode(SPUISD::PROMOTE_SCALAR, vecVT, N, N);
2644     SDValue CNTB = DAG.getNode(SPUISD::CNTB, vecVT, Promote);
2645
2646     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, MVT::i8, CNTB, Elt0);
2647   }
2648
2649   case MVT::i16: {
2650     MachineFunction &MF = DAG.getMachineFunction();
2651     MachineRegisterInfo &RegInfo = MF.getRegInfo();
2652
2653     unsigned CNTB_reg = RegInfo.createVirtualRegister(&SPU::R16CRegClass);
2654
2655     SDValue N = Op.getOperand(0);
2656     SDValue Elt0 = DAG.getConstant(0, MVT::i16);
2657     SDValue Mask0 = DAG.getConstant(0x0f, MVT::i16);
2658     SDValue Shift1 = DAG.getConstant(8, MVT::i32);
2659
2660     SDValue Promote = DAG.getNode(SPUISD::PROMOTE_SCALAR, vecVT, N, N);
2661     SDValue CNTB = DAG.getNode(SPUISD::CNTB, vecVT, Promote);
2662
2663     // CNTB_result becomes the chain to which all of the virtual registers
2664     // CNTB_reg, SUM1_reg become associated:
2665     SDValue CNTB_result =
2666       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, MVT::i16, CNTB, Elt0);
2667
2668     SDValue CNTB_rescopy =
2669       DAG.getCopyToReg(CNTB_result, CNTB_reg, CNTB_result);
2670
2671     SDValue Tmp1 = DAG.getCopyFromReg(CNTB_rescopy, CNTB_reg, MVT::i16);
2672
2673     return DAG.getNode(ISD::AND, MVT::i16,
2674                        DAG.getNode(ISD::ADD, MVT::i16,
2675                                    DAG.getNode(ISD::SRL, MVT::i16,
2676                                                Tmp1, Shift1),
2677                                    Tmp1),
2678                        Mask0);
2679   }
2680
2681   case MVT::i32: {
2682     MachineFunction &MF = DAG.getMachineFunction();
2683     MachineRegisterInfo &RegInfo = MF.getRegInfo();
2684
2685     unsigned CNTB_reg = RegInfo.createVirtualRegister(&SPU::R32CRegClass);
2686     unsigned SUM1_reg = RegInfo.createVirtualRegister(&SPU::R32CRegClass);
2687
2688     SDValue N = Op.getOperand(0);
2689     SDValue Elt0 = DAG.getConstant(0, MVT::i32);
2690     SDValue Mask0 = DAG.getConstant(0xff, MVT::i32);
2691     SDValue Shift1 = DAG.getConstant(16, MVT::i32);
2692     SDValue Shift2 = DAG.getConstant(8, MVT::i32);
2693
2694     SDValue Promote = DAG.getNode(SPUISD::PROMOTE_SCALAR, vecVT, N, N);
2695     SDValue CNTB = DAG.getNode(SPUISD::CNTB, vecVT, Promote);
2696
2697     // CNTB_result becomes the chain to which all of the virtual registers
2698     // CNTB_reg, SUM1_reg become associated:
2699     SDValue CNTB_result =
2700       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, MVT::i32, CNTB, Elt0);
2701
2702     SDValue CNTB_rescopy =
2703       DAG.getCopyToReg(CNTB_result, CNTB_reg, CNTB_result);
2704
2705     SDValue Comp1 =
2706       DAG.getNode(ISD::SRL, MVT::i32,
2707                   DAG.getCopyFromReg(CNTB_rescopy, CNTB_reg, MVT::i32), Shift1);
2708
2709     SDValue Sum1 =
2710       DAG.getNode(ISD::ADD, MVT::i32,
2711                   Comp1, DAG.getCopyFromReg(CNTB_rescopy, CNTB_reg, MVT::i32));
2712
2713     SDValue Sum1_rescopy =
2714       DAG.getCopyToReg(CNTB_result, SUM1_reg, Sum1);
2715
2716     SDValue Comp2 =
2717       DAG.getNode(ISD::SRL, MVT::i32,
2718                   DAG.getCopyFromReg(Sum1_rescopy, SUM1_reg, MVT::i32),
2719                   Shift2);
2720     SDValue Sum2 =
2721       DAG.getNode(ISD::ADD, MVT::i32, Comp2,
2722                   DAG.getCopyFromReg(Sum1_rescopy, SUM1_reg, MVT::i32));
2723
2724     return DAG.getNode(ISD::AND, MVT::i32, Sum2, Mask0);
2725   }
2726
2727   case MVT::i64:
2728     break;
2729   }
2730
2731   return SDValue();
2732 }
2733
2734 //! Lower ISD::SELECT_CC
2735 /*!
2736   ISD::SELECT_CC can (generally) be implemented directly on the SPU using the
2737   SELB instruction.
2738
2739   \note Need to revisit this in the future: if the code path through the true
2740   and false value computations is longer than the latency of a branch (6
2741   cycles), then it would be more advantageous to branch and insert a new basic
2742   block and branch on the condition. However, this code does not make that
2743   assumption, given the simplisitc uses so far.
2744  */
2745
2746 static SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) {
2747   MVT VT = Op.getValueType();
2748   SDValue lhs = Op.getOperand(0);
2749   SDValue rhs = Op.getOperand(1);
2750   SDValue trueval = Op.getOperand(2);
2751   SDValue falseval = Op.getOperand(3);
2752   SDValue condition = Op.getOperand(4);
2753
2754   // Note: Really should be ISD::SELECT instead of SPUISD::SELB, but LLVM's
2755   // legalizer insists on combining SETCC/SELECT into SELECT_CC, so we end up
2756   // with another "cannot select select_cc" assert:
2757
2758   SDValue compare = DAG.getNode(ISD::SETCC, VT, lhs, rhs, condition);
2759   return DAG.getNode(SPUISD::SELB, VT, trueval, falseval, compare);
2760 }
2761
2762 //! Custom (target-specific) lowering entry point
2763 /*!
2764   This is where LLVM's DAG selection process calls to do target-specific
2765   lowering of nodes.
2766  */
2767 SDValue
2768 SPUTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG)
2769 {
2770   unsigned Opc = (unsigned) Op.getOpcode();
2771   MVT VT = Op.getValueType();
2772
2773   switch (Opc) {
2774   default: {
2775     cerr << "SPUTargetLowering::LowerOperation(): need to lower this!\n";
2776     cerr << "Op.getOpcode() = " << Opc << "\n";
2777     cerr << "*Op.getNode():\n";
2778     Op.getNode()->dump();
2779     abort();
2780   }
2781   case ISD::LOAD:
2782   case ISD::SEXTLOAD:
2783   case ISD::ZEXTLOAD:
2784     return LowerLOAD(Op, DAG, SPUTM.getSubtargetImpl());
2785   case ISD::STORE:
2786     return LowerSTORE(Op, DAG, SPUTM.getSubtargetImpl());
2787   case ISD::ConstantPool:
2788     return LowerConstantPool(Op, DAG, SPUTM.getSubtargetImpl());
2789   case ISD::GlobalAddress:
2790     return LowerGlobalAddress(Op, DAG, SPUTM.getSubtargetImpl());
2791   case ISD::JumpTable:
2792     return LowerJumpTable(Op, DAG, SPUTM.getSubtargetImpl());
2793   case ISD::Constant:
2794     return LowerConstant(Op, DAG);
2795   case ISD::ConstantFP:
2796     return LowerConstantFP(Op, DAG);
2797   case ISD::BRCOND:
2798     return LowerBRCOND(Op, DAG);
2799   case ISD::FORMAL_ARGUMENTS:
2800     return LowerFORMAL_ARGUMENTS(Op, DAG, VarArgsFrameIndex);
2801   case ISD::CALL:
2802     return LowerCALL(Op, DAG, SPUTM.getSubtargetImpl());
2803   case ISD::RET:
2804     return LowerRET(Op, DAG, getTargetMachine());
2805
2806
2807   // i8, i64 math ops:
2808   case ISD::ZERO_EXTEND:
2809   case ISD::SIGN_EXTEND:
2810   case ISD::ANY_EXTEND:
2811   case ISD::ADD:
2812   case ISD::SUB:
2813   case ISD::ROTR:
2814   case ISD::ROTL:
2815   case ISD::SRL:
2816   case ISD::SHL:
2817   case ISD::SRA: {
2818     if (VT == MVT::i8)
2819       return LowerI8Math(Op, DAG, Opc);
2820     else if (VT == MVT::i64)
2821       return LowerI64Math(Op, DAG, Opc);
2822     break;
2823   }
2824
2825   // Vector-related lowering.
2826   case ISD::BUILD_VECTOR:
2827     return LowerBUILD_VECTOR(Op, DAG);
2828   case ISD::SCALAR_TO_VECTOR:
2829     return LowerSCALAR_TO_VECTOR(Op, DAG);
2830   case ISD::VECTOR_SHUFFLE:
2831     return LowerVECTOR_SHUFFLE(Op, DAG);
2832   case ISD::EXTRACT_VECTOR_ELT:
2833     return LowerEXTRACT_VECTOR_ELT(Op, DAG);
2834   case ISD::INSERT_VECTOR_ELT:
2835     return LowerINSERT_VECTOR_ELT(Op, DAG);
2836
2837   // Look for ANDBI, ORBI and XORBI opportunities and lower appropriately:
2838   case ISD::AND:
2839   case ISD::OR:
2840   case ISD::XOR:
2841     return LowerByteImmed(Op, DAG);
2842
2843   // Vector and i8 multiply:
2844   case ISD::MUL:
2845     if (VT.isVector())
2846       return LowerVectorMUL(Op, DAG);
2847     else if (VT == MVT::i8)
2848       return LowerI8Math(Op, DAG, Opc);
2849     else
2850       return LowerMUL(Op, DAG, VT, Opc);
2851
2852   case ISD::FDIV:
2853     if (VT == MVT::f32 || VT == MVT::v4f32)
2854       return LowerFDIVf32(Op, DAG);
2855 #if 0
2856     // This is probably a libcall
2857     else if (Op.getValueType() == MVT::f64)
2858       return LowerFDIVf64(Op, DAG);
2859 #endif
2860     else
2861       assert(0 && "Calling FDIV on unsupported MVT");
2862
2863   case ISD::CTPOP:
2864     return LowerCTPOP(Op, DAG);
2865
2866   case ISD::SELECT_CC:
2867     return LowerSELECT_CC(Op, DAG);
2868   }
2869
2870   return SDValue();
2871 }
2872
2873 void SPUTargetLowering::ReplaceNodeResults(SDNode *N,
2874                                            SmallVectorImpl<SDValue>&Results,
2875                                            SelectionDAG &DAG)
2876 {
2877 #if 0
2878   unsigned Opc = (unsigned) N->getOpcode();
2879   MVT OpVT = N->getValueType(0);
2880
2881   switch (Opc) {
2882   default: {
2883     cerr << "SPUTargetLowering::ReplaceNodeResults(): need to fix this!\n";
2884     cerr << "Op.getOpcode() = " << Opc << "\n";
2885     cerr << "*Op.getNode():\n";
2886     N->dump();
2887     abort();
2888     /*NOTREACHED*/
2889   }
2890   }
2891 #endif
2892
2893   /* Otherwise, return unchanged */
2894 }
2895
2896 //===----------------------------------------------------------------------===//
2897 // Target Optimization Hooks
2898 //===----------------------------------------------------------------------===//
2899
2900 SDValue
2901 SPUTargetLowering::PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const
2902 {
2903 #if 0
2904   TargetMachine &TM = getTargetMachine();
2905 #endif
2906   const SPUSubtarget *ST = SPUTM.getSubtargetImpl();
2907   SelectionDAG &DAG = DCI.DAG;
2908   SDValue Op0 = N->getOperand(0);       // everything has at least one operand
2909   MVT NodeVT = N->getValueType(0);      // The node's value type
2910   MVT Op0VT = Op0.getValueType();      // The first operand's result
2911   SDValue Result;                       // Initially, empty result
2912
2913   switch (N->getOpcode()) {
2914   default: break;
2915   case ISD::ADD: {
2916     SDValue Op1 = N->getOperand(1);
2917
2918     if (isa<ConstantSDNode>(Op1) && Op0.getOpcode() == SPUISD::IndirectAddr) {
2919       SDValue Op01 = Op0.getOperand(1);
2920       if (Op01.getOpcode() == ISD::Constant
2921           || Op01.getOpcode() == ISD::TargetConstant) {
2922         // (add <const>, (SPUindirect <arg>, <const>)) ->
2923         // (SPUindirect <arg>, <const + const>)
2924         ConstantSDNode *CN0 = cast<ConstantSDNode>(Op1);
2925         ConstantSDNode *CN1 = cast<ConstantSDNode>(Op01);
2926         SDValue combinedConst =
2927           DAG.getConstant(CN0->getZExtValue() + CN1->getZExtValue(), Op0VT);
2928
2929         DEBUG(cerr << "Replace: (add " << CN0->getZExtValue() << ", "
2930                    << "(SPUindirect <arg>, " << CN1->getZExtValue() << "))\n");
2931         DEBUG(cerr << "With:    (SPUindirect <arg>, "
2932                    << CN0->getZExtValue() + CN1->getZExtValue() << ")\n");
2933         return DAG.getNode(SPUISD::IndirectAddr, Op0VT,
2934                            Op0.getOperand(0), combinedConst);
2935       }
2936     } else if (isa<ConstantSDNode>(Op0)
2937                && Op1.getOpcode() == SPUISD::IndirectAddr) {
2938       SDValue Op11 = Op1.getOperand(1);
2939       if (Op11.getOpcode() == ISD::Constant
2940           || Op11.getOpcode() == ISD::TargetConstant) {
2941         // (add (SPUindirect <arg>, <const>), <const>) ->
2942         // (SPUindirect <arg>, <const + const>)
2943         ConstantSDNode *CN0 = cast<ConstantSDNode>(Op0);
2944         ConstantSDNode *CN1 = cast<ConstantSDNode>(Op11);
2945         SDValue combinedConst =
2946           DAG.getConstant(CN0->getZExtValue() + CN1->getZExtValue(), Op0VT);
2947
2948         DEBUG(cerr << "Replace: (add " << CN0->getZExtValue() << ", "
2949                    << "(SPUindirect <arg>, " << CN1->getZExtValue() << "))\n");
2950         DEBUG(cerr << "With:    (SPUindirect <arg>, "
2951                    << CN0->getZExtValue() + CN1->getZExtValue() << ")\n");
2952
2953         return DAG.getNode(SPUISD::IndirectAddr, Op1.getValueType(),
2954                            Op1.getOperand(0), combinedConst);
2955       }
2956     }
2957     break;
2958   }
2959   case ISD::SIGN_EXTEND:
2960   case ISD::ZERO_EXTEND:
2961   case ISD::ANY_EXTEND: {
2962     if (Op0.getOpcode() == SPUISD::VEC2PREFSLOT && NodeVT == Op0VT) {
2963       // (any_extend (SPUextract_elt0 <arg>)) ->
2964       // (SPUextract_elt0 <arg>)
2965       // Types must match, however...
2966       DEBUG(cerr << "Replace: ");
2967       DEBUG(N->dump(&DAG));
2968       DEBUG(cerr << "\nWith:    ");
2969       DEBUG(Op0.getNode()->dump(&DAG));
2970       DEBUG(cerr << "\n");
2971
2972       return Op0;
2973     }
2974     break;
2975   }
2976   case SPUISD::IndirectAddr: {
2977     if (!ST->usingLargeMem() && Op0.getOpcode() == SPUISD::AFormAddr) {
2978       ConstantSDNode *CN = cast<ConstantSDNode>(N->getOperand(1));
2979       if (CN->getZExtValue() == 0) {
2980         // (SPUindirect (SPUaform <addr>, 0), 0) ->
2981         // (SPUaform <addr>, 0)
2982
2983         DEBUG(cerr << "Replace: ");
2984         DEBUG(N->dump(&DAG));
2985         DEBUG(cerr << "\nWith:    ");
2986         DEBUG(Op0.getNode()->dump(&DAG));
2987         DEBUG(cerr << "\n");
2988
2989         return Op0;
2990       }
2991     }
2992     break;
2993   }
2994   case SPUISD::SHLQUAD_L_BITS:
2995   case SPUISD::SHLQUAD_L_BYTES:
2996   case SPUISD::VEC_SHL:
2997   case SPUISD::VEC_SRL:
2998   case SPUISD::VEC_SRA:
2999   case SPUISD::ROTQUAD_RZ_BYTES:
3000   case SPUISD::ROTQUAD_RZ_BITS: {
3001     SDValue Op1 = N->getOperand(1);
3002
3003     if (isa<ConstantSDNode>(Op1)) {
3004       // Kill degenerate vector shifts:
3005       ConstantSDNode *CN = cast<ConstantSDNode>(Op1);
3006       if (CN->getZExtValue() == 0) {
3007         Result = Op0;
3008       }
3009     }
3010     break;
3011   }
3012   case SPUISD::PROMOTE_SCALAR: {
3013     switch (Op0.getOpcode()) {
3014     default:
3015       break;
3016     case ISD::ANY_EXTEND:
3017     case ISD::ZERO_EXTEND:
3018     case ISD::SIGN_EXTEND: {
3019       // (SPUpromote_scalar (any|zero|sign_extend (SPUvec2prefslot <arg>))) ->
3020       // <arg>
3021       // but only if the SPUpromote_scalar and <arg> types match.
3022       SDValue Op00 = Op0.getOperand(0);
3023       if (Op00.getOpcode() == SPUISD::VEC2PREFSLOT) {
3024         SDValue Op000 = Op00.getOperand(0);
3025         if (Op000.getValueType() == NodeVT) {
3026           Result = Op000;
3027         }
3028       }
3029       break;
3030     }
3031     case SPUISD::VEC2PREFSLOT: {
3032       // (SPUpromote_scalar (SPUvec2prefslot <arg>)) ->
3033       // <arg>
3034       Result = Op0.getOperand(0);
3035       break;
3036     }
3037     }
3038     break;
3039   }
3040   }
3041   // Otherwise, return unchanged.
3042 #ifndef NDEBUG
3043   if (Result.getNode()) {
3044     DEBUG(cerr << "\nReplace.SPU: ");
3045     DEBUG(N->dump(&DAG));
3046     DEBUG(cerr << "\nWith:        ");
3047     DEBUG(Result.getNode()->dump(&DAG));
3048     DEBUG(cerr << "\n");
3049   }
3050 #endif
3051
3052   return Result;
3053 }
3054
3055 //===----------------------------------------------------------------------===//
3056 // Inline Assembly Support
3057 //===----------------------------------------------------------------------===//
3058
3059 /// getConstraintType - Given a constraint letter, return the type of
3060 /// constraint it is for this target.
3061 SPUTargetLowering::ConstraintType
3062 SPUTargetLowering::getConstraintType(const std::string &ConstraintLetter) const {
3063   if (ConstraintLetter.size() == 1) {
3064     switch (ConstraintLetter[0]) {
3065     default: break;
3066     case 'b':
3067     case 'r':
3068     case 'f':
3069     case 'v':
3070     case 'y':
3071       return C_RegisterClass;
3072     }
3073   }
3074   return TargetLowering::getConstraintType(ConstraintLetter);
3075 }
3076
3077 std::pair<unsigned, const TargetRegisterClass*>
3078 SPUTargetLowering::getRegForInlineAsmConstraint(const std::string &Constraint,
3079                                                 MVT VT) const
3080 {
3081   if (Constraint.size() == 1) {
3082     // GCC RS6000 Constraint Letters
3083     switch (Constraint[0]) {
3084     case 'b':   // R1-R31
3085     case 'r':   // R0-R31
3086       if (VT == MVT::i64)
3087         return std::make_pair(0U, SPU::R64CRegisterClass);
3088       return std::make_pair(0U, SPU::R32CRegisterClass);
3089     case 'f':
3090       if (VT == MVT::f32)
3091         return std::make_pair(0U, SPU::R32FPRegisterClass);
3092       else if (VT == MVT::f64)
3093         return std::make_pair(0U, SPU::R64FPRegisterClass);
3094       break;
3095     case 'v':
3096       return std::make_pair(0U, SPU::GPRCRegisterClass);
3097     }
3098   }
3099
3100   return TargetLowering::getRegForInlineAsmConstraint(Constraint, VT);
3101 }
3102
3103 //! Compute used/known bits for a SPU operand
3104 void
3105 SPUTargetLowering::computeMaskedBitsForTargetNode(const SDValue Op,
3106                                                   const APInt &Mask,
3107                                                   APInt &KnownZero,
3108                                                   APInt &KnownOne,
3109                                                   const SelectionDAG &DAG,
3110                                                   unsigned Depth ) const {
3111 #if 0
3112   const uint64_t uint64_sizebits = sizeof(uint64_t) * 8;
3113 #endif
3114
3115   switch (Op.getOpcode()) {
3116   default:
3117     // KnownZero = KnownOne = APInt(Mask.getBitWidth(), 0);
3118     break;
3119
3120 #if 0
3121   case CALL:
3122   case SHUFB:
3123   case SHUFFLE_MASK:
3124   case CNTB:
3125 #endif
3126
3127   case SPUISD::PROMOTE_SCALAR: {
3128     SDValue Op0 = Op.getOperand(0);
3129     MVT Op0VT = Op0.getValueType();
3130     unsigned Op0VTBits = Op0VT.getSizeInBits();
3131     uint64_t InMask = Op0VT.getIntegerVTBitMask();
3132     KnownZero |= APInt(Op0VTBits, ~InMask, false);
3133     KnownOne |= APInt(Op0VTBits, InMask, false);
3134     break;
3135   }
3136
3137   case SPUISD::LDRESULT:
3138   case SPUISD::VEC2PREFSLOT:
3139   case SPUISD::VEC2PREFSLOT_CHAINED: {
3140     MVT OpVT = Op.getValueType();
3141     unsigned OpVTBits = OpVT.getSizeInBits();
3142     uint64_t InMask = OpVT.getIntegerVTBitMask();
3143     KnownZero |= APInt(OpVTBits, ~InMask, false);
3144     KnownOne |= APInt(OpVTBits, InMask, false);
3145     break;
3146   }
3147
3148 #if 0
3149   case EXTRACT_I1_ZEXT:
3150   case EXTRACT_I1_SEXT:
3151   case EXTRACT_I8_ZEXT:
3152   case EXTRACT_I8_SEXT:
3153   case MPY:
3154   case MPYU:
3155   case MPYH:
3156   case MPYHH:
3157   case SPUISD::SHLQUAD_L_BITS:
3158   case SPUISD::SHLQUAD_L_BYTES:
3159   case SPUISD::VEC_SHL:
3160   case SPUISD::VEC_SRL:
3161   case SPUISD::VEC_SRA:
3162   case SPUISD::VEC_ROTL:
3163   case SPUISD::VEC_ROTR:
3164   case SPUISD::ROTQUAD_RZ_BYTES:
3165   case SPUISD::ROTQUAD_RZ_BITS:
3166   case SPUISD::ROTBYTES_LEFT:
3167   case SPUISD::ROTBYTES_LEFT_CHAINED:
3168   case SPUISD::SELECT_MASK:
3169   case SPUISD::SELB:
3170   case SPUISD::FPInterp:
3171   case SPUISD::FPRecipEst:
3172   case SPUISD::SEXT32TO64:
3173 #endif
3174   }
3175 }
3176
3177 // LowerAsmOperandForConstraint
3178 void
3179 SPUTargetLowering::LowerAsmOperandForConstraint(SDValue Op,
3180                                                 char ConstraintLetter,
3181                                                 bool hasMemory,
3182                                                 std::vector<SDValue> &Ops,
3183                                                 SelectionDAG &DAG) const {
3184   // Default, for the time being, to the base class handler
3185   TargetLowering::LowerAsmOperandForConstraint(Op, ConstraintLetter, hasMemory,
3186                                                Ops, DAG);
3187 }
3188
3189 /// isLegalAddressImmediate - Return true if the integer value can be used
3190 /// as the offset of the target addressing mode.
3191 bool SPUTargetLowering::isLegalAddressImmediate(int64_t V,
3192                                                 const Type *Ty) const {
3193   // SPU's addresses are 256K:
3194   return (V > -(1 << 18) && V < (1 << 18) - 1);
3195 }
3196
3197 bool SPUTargetLowering::isLegalAddressImmediate(llvm::GlobalValue* GV) const {
3198   return false;
3199 }
3200
3201 bool
3202 SPUTargetLowering::isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const {
3203   // The SPU target isn't yet aware of offsets.
3204   return false;
3205 }