lib/Target/CellSPU/SPUISelLowering.cpp

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