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