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