lib/Target/NVPTX/NVPTXISelDAGToDAG.cpp

   1 //===-- NVPTXISelDAGToDAG.cpp - A dag to dag inst selector for NVPTX ------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines an instruction selector for the NVPTX target.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "nvptx-isel"
  15 #include "NVPTXISelDAGToDAG.h"
  16 #include "llvm/IR/GlobalValue.h"
  17 #include "llvm/IR/Instructions.h"
  18 #include "llvm/Support/CommandLine.h"
  19 #include "llvm/Support/Debug.h"
  20 #include "llvm/Support/ErrorHandling.h"
  21 #include "llvm/Support/raw_ostream.h"
  22 #include "llvm/Target/TargetIntrinsicInfo.h"
  23
  24 using namespace llvm;
  25
  26 static cl::opt<int>
  27 FMAContractLevel("nvptx-fma-level", cl::ZeroOrMore, cl::Hidden,
  28                  cl::desc("NVPTX Specific: FMA contraction (0: don't do it"
  29                           " 1: do it  2: do it aggressively"),
  30                  cl::init(2));
  31
  32 static cl::opt<int> UsePrecDivF32(
  33     "nvptx-prec-divf32", cl::ZeroOrMore, cl::Hidden,
  34     cl::desc("NVPTX Specifies: 0 use div.approx, 1 use div.full, 2 use"
  35              " IEEE Compliant F32 div.rnd if avaiable."),
  36     cl::init(2));
  37
  38 static cl::opt<bool>
  39 UsePrecSqrtF32("nvptx-prec-sqrtf32", cl::Hidden,
  40           cl::desc("NVPTX Specific: 0 use sqrt.approx, 1 use sqrt.rn."),
  41           cl::init(true));
  42
  43 static cl::opt<bool>
  44 FtzEnabled("nvptx-f32ftz", cl::ZeroOrMore, cl::Hidden,
  45            cl::desc("NVPTX Specific: Flush f32 subnormals to sign-preserving zero."),
  46            cl::init(false));
  47
  48
  49 /// createNVPTXISelDag - This pass converts a legalized DAG into a
  50 /// NVPTX-specific DAG, ready for instruction scheduling.
  51 FunctionPass *llvm::createNVPTXISelDag(NVPTXTargetMachine &TM,
  52                                        llvm::CodeGenOpt::Level OptLevel) {
  53   return new NVPTXDAGToDAGISel(TM, OptLevel);
  54 }
  55
  56 NVPTXDAGToDAGISel::NVPTXDAGToDAGISel(NVPTXTargetMachine &tm,
  57                                      CodeGenOpt::Level OptLevel)
  58     : SelectionDAGISel(tm, OptLevel),
  59       Subtarget(tm.getSubtarget<NVPTXSubtarget>()) {
  60
  61   doFMAF32 = (OptLevel > 0) && Subtarget.hasFMAF32() && (FMAContractLevel >= 1);
  62   doFMAF64 = (OptLevel > 0) && Subtarget.hasFMAF64() && (FMAContractLevel >= 1);
  63   doFMAF32AGG =
  64       (OptLevel > 0) && Subtarget.hasFMAF32() && (FMAContractLevel == 2);
  65   doFMAF64AGG =
  66       (OptLevel > 0) && Subtarget.hasFMAF64() && (FMAContractLevel == 2);
  67
  68   allowFMA = (FMAContractLevel >= 1);
  69
  70   doMulWide = (OptLevel > 0);
  71 }
  72
  73 int NVPTXDAGToDAGISel::getDivF32Level() const {
  74   if (UsePrecDivF32.getNumOccurrences() > 0) {
  75     // If nvptx-prec-div32=N is used on the command-line, always honor it
  76     return UsePrecDivF32;
  77   } else {
  78     // Otherwise, use div.approx if fast math is enabled
  79     if (TM.Options.UnsafeFPMath)
  80       return 0;
  81     else
  82       return 2;
  83   }
  84 }
  85
  86 bool NVPTXDAGToDAGISel::usePrecSqrtF32() const {
  87   if (UsePrecSqrtF32.getNumOccurrences() > 0) {
  88     // If nvptx-prec-sqrtf32 is used on the command-line, always honor it
  89     return UsePrecSqrtF32;
  90   } else {
  91     // Otherwise, use sqrt.approx if fast math is enabled
  92     if (TM.Options.UnsafeFPMath)
  93       return false;
  94     else
  95       return true;
  96   }
  97 }
  98
  99 bool NVPTXDAGToDAGISel::useF32FTZ() const {
 100   if (FtzEnabled.getNumOccurrences() > 0) {
 101     // If nvptx-f32ftz is used on the command-line, always honor it
 102     return FtzEnabled;
 103   } else {
 104     const Function *F = MF->getFunction();
 105     // Otherwise, check for an nvptx-f32ftz attribute on the function
 106     if (F->hasFnAttribute("nvptx-f32ftz"))
 107       return (F->getAttributes().getAttribute(AttributeSet::FunctionIndex,
 108                                               "nvptx-f32ftz")
 109                                               .getValueAsString() == "true");
 110     else
 111       return false;
 112   }
 113 }
 114
 115 /// Select - Select instructions not customized! Used for
 116 /// expanded, promoted and normal instructions.
 117 SDNode *NVPTXDAGToDAGISel::Select(SDNode *N) {
 118
 119   if (N->isMachineOpcode()) {
 120     N->setNodeId(-1);
 121     return NULL; // Already selected.
 122   }
 123
 124   SDNode *ResNode = NULL;
 125   switch (N->getOpcode()) {
 126   case ISD::LOAD:
 127     ResNode = SelectLoad(N);
 128     break;
 129   case ISD::STORE:
 130     ResNode = SelectStore(N);
 131     break;
 132   case NVPTXISD::LoadV2:
 133   case NVPTXISD::LoadV4:
 134     ResNode = SelectLoadVector(N);
 135     break;
 136   case NVPTXISD::LDGV2:
 137   case NVPTXISD::LDGV4:
 138   case NVPTXISD::LDUV2:
 139   case NVPTXISD::LDUV4:
 140     ResNode = SelectLDGLDUVector(N);
 141     break;
 142   case NVPTXISD::StoreV2:
 143   case NVPTXISD::StoreV4:
 144     ResNode = SelectStoreVector(N);
 145     break;
 146   case NVPTXISD::LoadParam:
 147   case NVPTXISD::LoadParamV2:
 148   case NVPTXISD::LoadParamV4:
 149     ResNode = SelectLoadParam(N);
 150     break;
 151   case NVPTXISD::StoreRetval:
 152   case NVPTXISD::StoreRetvalV2:
 153   case NVPTXISD::StoreRetvalV4:
 154     ResNode = SelectStoreRetval(N);
 155     break;
 156   case NVPTXISD::StoreParam:
 157   case NVPTXISD::StoreParamV2:
 158   case NVPTXISD::StoreParamV4:
 159   case NVPTXISD::StoreParamS32:
 160   case NVPTXISD::StoreParamU32:
 161     ResNode = SelectStoreParam(N);
 162     break;
 163   case ISD::INTRINSIC_WO_CHAIN:
 164     ResNode = SelectIntrinsicNoChain(N);
 165     break;
 166   case NVPTXISD::Tex1DFloatI32:
 167   case NVPTXISD::Tex1DFloatFloat:
 168   case NVPTXISD::Tex1DFloatFloatLevel:
 169   case NVPTXISD::Tex1DFloatFloatGrad:
 170   case NVPTXISD::Tex1DI32I32:
 171   case NVPTXISD::Tex1DI32Float:
 172   case NVPTXISD::Tex1DI32FloatLevel:
 173   case NVPTXISD::Tex1DI32FloatGrad:
 174   case NVPTXISD::Tex1DArrayFloatI32:
 175   case NVPTXISD::Tex1DArrayFloatFloat:
 176   case NVPTXISD::Tex1DArrayFloatFloatLevel:
 177   case NVPTXISD::Tex1DArrayFloatFloatGrad:
 178   case NVPTXISD::Tex1DArrayI32I32:
 179   case NVPTXISD::Tex1DArrayI32Float:
 180   case NVPTXISD::Tex1DArrayI32FloatLevel:
 181   case NVPTXISD::Tex1DArrayI32FloatGrad:
 182   case NVPTXISD::Tex2DFloatI32:
 183   case NVPTXISD::Tex2DFloatFloat:
 184   case NVPTXISD::Tex2DFloatFloatLevel:
 185   case NVPTXISD::Tex2DFloatFloatGrad:
 186   case NVPTXISD::Tex2DI32I32:
 187   case NVPTXISD::Tex2DI32Float:
 188   case NVPTXISD::Tex2DI32FloatLevel:
 189   case NVPTXISD::Tex2DI32FloatGrad:
 190   case NVPTXISD::Tex2DArrayFloatI32:
 191   case NVPTXISD::Tex2DArrayFloatFloat:
 192   case NVPTXISD::Tex2DArrayFloatFloatLevel:
 193   case NVPTXISD::Tex2DArrayFloatFloatGrad:
 194   case NVPTXISD::Tex2DArrayI32I32:
 195   case NVPTXISD::Tex2DArrayI32Float:
 196   case NVPTXISD::Tex2DArrayI32FloatLevel:
 197   case NVPTXISD::Tex2DArrayI32FloatGrad:
 198   case NVPTXISD::Tex3DFloatI32:
 199   case NVPTXISD::Tex3DFloatFloat:
 200   case NVPTXISD::Tex3DFloatFloatLevel:
 201   case NVPTXISD::Tex3DFloatFloatGrad:
 202   case NVPTXISD::Tex3DI32I32:
 203   case NVPTXISD::Tex3DI32Float:
 204   case NVPTXISD::Tex3DI32FloatLevel:
 205   case NVPTXISD::Tex3DI32FloatGrad:
 206     ResNode = SelectTextureIntrinsic(N);
 207     break;
 208   case NVPTXISD::Suld1DI8Trap:
 209   case NVPTXISD::Suld1DI16Trap:
 210   case NVPTXISD::Suld1DI32Trap:
 211   case NVPTXISD::Suld1DV2I8Trap:
 212   case NVPTXISD::Suld1DV2I16Trap:
 213   case NVPTXISD::Suld1DV2I32Trap:
 214   case NVPTXISD::Suld1DV4I8Trap:
 215   case NVPTXISD::Suld1DV4I16Trap:
 216   case NVPTXISD::Suld1DV4I32Trap:
 217   case NVPTXISD::Suld1DArrayI8Trap:
 218   case NVPTXISD::Suld1DArrayI16Trap:
 219   case NVPTXISD::Suld1DArrayI32Trap:
 220   case NVPTXISD::Suld1DArrayV2I8Trap:
 221   case NVPTXISD::Suld1DArrayV2I16Trap:
 222   case NVPTXISD::Suld1DArrayV2I32Trap:
 223   case NVPTXISD::Suld1DArrayV4I8Trap:
 224   case NVPTXISD::Suld1DArrayV4I16Trap:
 225   case NVPTXISD::Suld1DArrayV4I32Trap:
 226   case NVPTXISD::Suld2DI8Trap:
 227   case NVPTXISD::Suld2DI16Trap:
 228   case NVPTXISD::Suld2DI32Trap:
 229   case NVPTXISD::Suld2DV2I8Trap:
 230   case NVPTXISD::Suld2DV2I16Trap:
 231   case NVPTXISD::Suld2DV2I32Trap:
 232   case NVPTXISD::Suld2DV4I8Trap:
 233   case NVPTXISD::Suld2DV4I16Trap:
 234   case NVPTXISD::Suld2DV4I32Trap:
 235   case NVPTXISD::Suld2DArrayI8Trap:
 236   case NVPTXISD::Suld2DArrayI16Trap:
 237   case NVPTXISD::Suld2DArrayI32Trap:
 238   case NVPTXISD::Suld2DArrayV2I8Trap:
 239   case NVPTXISD::Suld2DArrayV2I16Trap:
 240   case NVPTXISD::Suld2DArrayV2I32Trap:
 241   case NVPTXISD::Suld2DArrayV4I8Trap:
 242   case NVPTXISD::Suld2DArrayV4I16Trap:
 243   case NVPTXISD::Suld2DArrayV4I32Trap:
 244   case NVPTXISD::Suld3DI8Trap:
 245   case NVPTXISD::Suld3DI16Trap:
 246   case NVPTXISD::Suld3DI32Trap:
 247   case NVPTXISD::Suld3DV2I8Trap:
 248   case NVPTXISD::Suld3DV2I16Trap:
 249   case NVPTXISD::Suld3DV2I32Trap:
 250   case NVPTXISD::Suld3DV4I8Trap:
 251   case NVPTXISD::Suld3DV4I16Trap:
 252   case NVPTXISD::Suld3DV4I32Trap:
 253     ResNode = SelectSurfaceIntrinsic(N);
 254     break;
 255   case ISD::ADDRSPACECAST:
 256     ResNode = SelectAddrSpaceCast(N);
 257     break;
 258   default:
 259     break;
 260   }
 261   if (ResNode)
 262     return ResNode;
 263   return SelectCode(N);
 264 }
 265
 266 static unsigned int getCodeAddrSpace(MemSDNode *N,
 267                                      const NVPTXSubtarget &Subtarget) {
 268   const Value *Src = N->getMemOperand()->getValue();
 269
 270   if (!Src)
 271     return NVPTX::PTXLdStInstCode::GENERIC;
 272
 273   if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) {
 274     switch (PT->getAddressSpace()) {
 275     case llvm::ADDRESS_SPACE_LOCAL: return NVPTX::PTXLdStInstCode::LOCAL;
 276     case llvm::ADDRESS_SPACE_GLOBAL: return NVPTX::PTXLdStInstCode::GLOBAL;
 277     case llvm::ADDRESS_SPACE_SHARED: return NVPTX::PTXLdStInstCode::SHARED;
 278     case llvm::ADDRESS_SPACE_GENERIC: return NVPTX::PTXLdStInstCode::GENERIC;
 279     case llvm::ADDRESS_SPACE_PARAM: return NVPTX::PTXLdStInstCode::PARAM;
 280     case llvm::ADDRESS_SPACE_CONST: return NVPTX::PTXLdStInstCode::CONSTANT;
 281     default: break;
 282     }
 283   }
 284   return NVPTX::PTXLdStInstCode::GENERIC;
 285 }
 286
 287 SDNode *NVPTXDAGToDAGISel::SelectIntrinsicNoChain(SDNode *N) {
 288   unsigned IID = cast<ConstantSDNode>(N->getOperand(0))->getZExtValue();
 289   switch (IID) {
 290   default:
 291     return NULL;
 292   case Intrinsic::nvvm_texsurf_handle_internal:
 293     return SelectTexSurfHandle(N);
 294   }
 295 }
 296
 297 SDNode *NVPTXDAGToDAGISel::SelectTexSurfHandle(SDNode *N) {
 298   // Op 0 is the intrinsic ID
 299   SDValue Wrapper = N->getOperand(1);
 300   SDValue GlobalVal = Wrapper.getOperand(0);
 301   return CurDAG->getMachineNode(NVPTX::texsurf_handles, SDLoc(N), MVT::i64,
 302                                 GlobalVal);
 303 }
 304
 305 SDNode *NVPTXDAGToDAGISel::SelectAddrSpaceCast(SDNode *N) {
 306   SDValue Src = N->getOperand(0);
 307   AddrSpaceCastSDNode *CastN = cast<AddrSpaceCastSDNode>(N);
 308   unsigned SrcAddrSpace = CastN->getSrcAddressSpace();
 309   unsigned DstAddrSpace = CastN->getDestAddressSpace();
 310
 311   assert(SrcAddrSpace != DstAddrSpace &&
 312          "addrspacecast must be between different address spaces");
 313
 314   if (DstAddrSpace == ADDRESS_SPACE_GENERIC) {
 315     // Specific to generic
 316     unsigned Opc;
 317     switch (SrcAddrSpace) {
 318     default: report_fatal_error("Bad address space in addrspacecast");
 319     case ADDRESS_SPACE_GLOBAL:
 320       Opc = Subtarget.is64Bit() ? NVPTX::cvta_global_yes_64
 321                                 : NVPTX::cvta_global_yes;
 322       break;
 323     case ADDRESS_SPACE_SHARED:
 324       Opc = Subtarget.is64Bit() ? NVPTX::cvta_shared_yes_64
 325                                 : NVPTX::cvta_shared_yes;
 326       break;
 327     case ADDRESS_SPACE_CONST:
 328       Opc = Subtarget.is64Bit() ? NVPTX::cvta_const_yes_64
 329                                 : NVPTX::cvta_const_yes;
 330       break;
 331     case ADDRESS_SPACE_LOCAL:
 332       Opc = Subtarget.is64Bit() ? NVPTX::cvta_local_yes_64
 333                                 : NVPTX::cvta_local_yes;
 334       break;
 335     }
 336     return CurDAG->getMachineNode(Opc, SDLoc(N), N->getValueType(0), Src);
 337   } else {
 338     // Generic to specific
 339     if (SrcAddrSpace != 0)
 340       report_fatal_error("Cannot cast between two non-generic address spaces");
 341     unsigned Opc;
 342     switch (DstAddrSpace) {
 343     default: report_fatal_error("Bad address space in addrspacecast");
 344     case ADDRESS_SPACE_GLOBAL:
 345       Opc = Subtarget.is64Bit() ? NVPTX::cvta_to_global_yes_64
 346                                 : NVPTX::cvta_to_global_yes;
 347       break;
 348     case ADDRESS_SPACE_SHARED:
 349       Opc = Subtarget.is64Bit() ? NVPTX::cvta_to_shared_yes_64
 350                                 : NVPTX::cvta_to_shared_yes;
 351       break;
 352     case ADDRESS_SPACE_CONST:
 353       Opc = Subtarget.is64Bit() ? NVPTX::cvta_to_const_yes_64
 354                                 : NVPTX::cvta_to_const_yes;
 355       break;
 356     case ADDRESS_SPACE_LOCAL:
 357       Opc = Subtarget.is64Bit() ? NVPTX::cvta_to_local_yes_64
 358                                 : NVPTX::cvta_to_local_yes;
 359       break;
 360     }
 361     return CurDAG->getMachineNode(Opc, SDLoc(N), N->getValueType(0), Src);
 362   }
 363 }
 364
 365 SDNode *NVPTXDAGToDAGISel::SelectLoad(SDNode *N) {
 366   SDLoc dl(N);
 367   LoadSDNode *LD = cast<LoadSDNode>(N);
 368   EVT LoadedVT = LD->getMemoryVT();
 369   SDNode *NVPTXLD = NULL;
 370
 371   // do not support pre/post inc/dec
 372   if (LD->isIndexed())
 373     return NULL;
 374
 375   if (!LoadedVT.isSimple())
 376     return NULL;
 377
 378   // Address Space Setting
 379   unsigned int codeAddrSpace = getCodeAddrSpace(LD, Subtarget);
 380
 381   // Volatile Setting
 382   // - .volatile is only availalble for .global and .shared
 383   bool isVolatile = LD->isVolatile();
 384   if (codeAddrSpace != NVPTX::PTXLdStInstCode::GLOBAL &&
 385       codeAddrSpace != NVPTX::PTXLdStInstCode::SHARED &&
 386       codeAddrSpace != NVPTX::PTXLdStInstCode::GENERIC)
 387     isVolatile = false;
 388
 389   // Vector Setting
 390   MVT SimpleVT = LoadedVT.getSimpleVT();
 391   unsigned vecType = NVPTX::PTXLdStInstCode::Scalar;
 392   if (SimpleVT.isVector()) {
 393     unsigned num = SimpleVT.getVectorNumElements();
 394     if (num == 2)
 395       vecType = NVPTX::PTXLdStInstCode::V2;
 396     else if (num == 4)
 397       vecType = NVPTX::PTXLdStInstCode::V4;
 398     else
 399       return NULL;
 400   }
 401
 402   // Type Setting: fromType + fromTypeWidth
 403   //
 404   // Sign   : ISD::SEXTLOAD
 405   // Unsign : ISD::ZEXTLOAD, ISD::NON_EXTLOAD or ISD::EXTLOAD and the
 406   //          type is integer
 407   // Float  : ISD::NON_EXTLOAD or ISD::EXTLOAD and the type is float
 408   MVT ScalarVT = SimpleVT.getScalarType();
 409   // Read at least 8 bits (predicates are stored as 8-bit values)
 410   unsigned fromTypeWidth = std::max(8U, ScalarVT.getSizeInBits());
 411   unsigned int fromType;
 412   if ((LD->getExtensionType() == ISD::SEXTLOAD))
 413     fromType = NVPTX::PTXLdStInstCode::Signed;
 414   else if (ScalarVT.isFloatingPoint())
 415     fromType = NVPTX::PTXLdStInstCode::Float;
 416   else
 417     fromType = NVPTX::PTXLdStInstCode::Unsigned;
 418
 419   // Create the machine instruction DAG
 420   SDValue Chain = N->getOperand(0);
 421   SDValue N1 = N->getOperand(1);
 422   SDValue Addr;
 423   SDValue Offset, Base;
 424   unsigned Opcode;
 425   MVT::SimpleValueType TargetVT = LD->getSimpleValueType(0).SimpleTy;
 426
 427   if (SelectDirectAddr(N1, Addr)) {
 428     switch (TargetVT) {
 429     case MVT::i8:
 430       Opcode = NVPTX::LD_i8_avar;
 431       break;
 432     case MVT::i16:
 433       Opcode = NVPTX::LD_i16_avar;
 434       break;
 435     case MVT::i32:
 436       Opcode = NVPTX::LD_i32_avar;
 437       break;
 438     case MVT::i64:
 439       Opcode = NVPTX::LD_i64_avar;
 440       break;
 441     case MVT::f32:
 442       Opcode = NVPTX::LD_f32_avar;
 443       break;
 444     case MVT::f64:
 445       Opcode = NVPTX::LD_f64_avar;
 446       break;
 447     default:
 448       return NULL;
 449     }
 450     SDValue Ops[] = { getI32Imm(isVolatile), getI32Imm(codeAddrSpace),
 451                       getI32Imm(vecType), getI32Imm(fromType),
 452                       getI32Imm(fromTypeWidth), Addr, Chain };
 453     NVPTXLD = CurDAG->getMachineNode(Opcode, dl, TargetVT, MVT::Other, Ops);
 454   } else if (Subtarget.is64Bit()
 455                  ? SelectADDRsi64(N1.getNode(), N1, Base, Offset)
 456                  : SelectADDRsi(N1.getNode(), N1, Base, Offset)) {
 457     switch (TargetVT) {
 458     case MVT::i8:
 459       Opcode = NVPTX::LD_i8_asi;
 460       break;
 461     case MVT::i16:
 462       Opcode = NVPTX::LD_i16_asi;
 463       break;
 464     case MVT::i32:
 465       Opcode = NVPTX::LD_i32_asi;
 466       break;
 467     case MVT::i64:
 468       Opcode = NVPTX::LD_i64_asi;
 469       break;
 470     case MVT::f32:
 471       Opcode = NVPTX::LD_f32_asi;
 472       break;
 473     case MVT::f64:
 474       Opcode = NVPTX::LD_f64_asi;
 475       break;
 476     default:
 477       return NULL;
 478     }
 479     SDValue Ops[] = { getI32Imm(isVolatile), getI32Imm(codeAddrSpace),
 480                       getI32Imm(vecType), getI32Imm(fromType),
 481                       getI32Imm(fromTypeWidth), Base, Offset, Chain };
 482     NVPTXLD = CurDAG->getMachineNode(Opcode, dl, TargetVT, MVT::Other, Ops);
 483   } else if (Subtarget.is64Bit()
 484                  ? SelectADDRri64(N1.getNode(), N1, Base, Offset)
 485                  : SelectADDRri(N1.getNode(), N1, Base, Offset)) {
 486     if (Subtarget.is64Bit()) {
 487       switch (TargetVT) {
 488       case MVT::i8:
 489         Opcode = NVPTX::LD_i8_ari_64;
 490         break;
 491       case MVT::i16:
 492         Opcode = NVPTX::LD_i16_ari_64;
 493         break;
 494       case MVT::i32:
 495         Opcode = NVPTX::LD_i32_ari_64;
 496         break;
 497       case MVT::i64:
 498         Opcode = NVPTX::LD_i64_ari_64;
 499         break;
 500       case MVT::f32:
 501         Opcode = NVPTX::LD_f32_ari_64;
 502         break;
 503       case MVT::f64:
 504         Opcode = NVPTX::LD_f64_ari_64;
 505         break;
 506       default:
 507         return NULL;
 508       }
 509     } else {
 510       switch (TargetVT) {
 511       case MVT::i8:
 512         Opcode = NVPTX::LD_i8_ari;
 513         break;
 514       case MVT::i16:
 515         Opcode = NVPTX::LD_i16_ari;
 516         break;
 517       case MVT::i32:
 518         Opcode = NVPTX::LD_i32_ari;
 519         break;
 520       case MVT::i64:
 521         Opcode = NVPTX::LD_i64_ari;
 522         break;
 523       case MVT::f32:
 524         Opcode = NVPTX::LD_f32_ari;
 525         break;
 526       case MVT::f64:
 527         Opcode = NVPTX::LD_f64_ari;
 528         break;
 529       default:
 530         return NULL;
 531       }
 532     }
 533     SDValue Ops[] = { getI32Imm(isVolatile), getI32Imm(codeAddrSpace),
 534                       getI32Imm(vecType), getI32Imm(fromType),
 535                       getI32Imm(fromTypeWidth), Base, Offset, Chain };
 536     NVPTXLD = CurDAG->getMachineNode(Opcode, dl, TargetVT, MVT::Other, Ops);
 537   } else {
 538     if (Subtarget.is64Bit()) {
 539       switch (TargetVT) {
 540       case MVT::i8:
 541         Opcode = NVPTX::LD_i8_areg_64;
 542         break;
 543       case MVT::i16:
 544         Opcode = NVPTX::LD_i16_areg_64;
 545         break;
 546       case MVT::i32:
 547         Opcode = NVPTX::LD_i32_areg_64;
 548         break;
 549       case MVT::i64:
 550         Opcode = NVPTX::LD_i64_areg_64;
 551         break;
 552       case MVT::f32:
 553         Opcode = NVPTX::LD_f32_areg_64;
 554         break;
 555       case MVT::f64:
 556         Opcode = NVPTX::LD_f64_areg_64;
 557         break;
 558       default:
 559         return NULL;
 560       }
 561     } else {
 562       switch (TargetVT) {
 563       case MVT::i8:
 564         Opcode = NVPTX::LD_i8_areg;
 565         break;
 566       case MVT::i16:
 567         Opcode = NVPTX::LD_i16_areg;
 568         break;
 569       case MVT::i32:
 570         Opcode = NVPTX::LD_i32_areg;
 571         break;
 572       case MVT::i64:
 573         Opcode = NVPTX::LD_i64_areg;
 574         break;
 575       case MVT::f32:
 576         Opcode = NVPTX::LD_f32_areg;
 577         break;
 578       case MVT::f64:
 579         Opcode = NVPTX::LD_f64_areg;
 580         break;
 581       default:
 582         return NULL;
 583       }
 584     }
 585     SDValue Ops[] = { getI32Imm(isVolatile), getI32Imm(codeAddrSpace),
 586                       getI32Imm(vecType), getI32Imm(fromType),
 587                       getI32Imm(fromTypeWidth), N1, Chain };
 588     NVPTXLD = CurDAG->getMachineNode(Opcode, dl, TargetVT, MVT::Other, Ops);
 589   }
 590
 591   if (NVPTXLD != NULL) {
 592     MachineSDNode::mmo_iterator MemRefs0 = MF->allocateMemRefsArray(1);
 593     MemRefs0[0] = cast<MemSDNode>(N)->getMemOperand();
 594     cast<MachineSDNode>(NVPTXLD)->setMemRefs(MemRefs0, MemRefs0 + 1);
 595   }
 596
 597   return NVPTXLD;
 598 }
 599
 600 SDNode *NVPTXDAGToDAGISel::SelectLoadVector(SDNode *N) {
 601
 602   SDValue Chain = N->getOperand(0);
 603   SDValue Op1 = N->getOperand(1);
 604   SDValue Addr, Offset, Base;
 605   unsigned Opcode;
 606   SDLoc DL(N);
 607   SDNode *LD;
 608   MemSDNode *MemSD = cast<MemSDNode>(N);
 609   EVT LoadedVT = MemSD->getMemoryVT();
 610
 611   if (!LoadedVT.isSimple())
 612     return NULL;
 613
 614   // Address Space Setting
 615   unsigned int CodeAddrSpace = getCodeAddrSpace(MemSD, Subtarget);
 616
 617   // Volatile Setting
 618   // - .volatile is only availalble for .global and .shared
 619   bool IsVolatile = MemSD->isVolatile();
 620   if (CodeAddrSpace != NVPTX::PTXLdStInstCode::GLOBAL &&
 621       CodeAddrSpace != NVPTX::PTXLdStInstCode::SHARED &&
 622       CodeAddrSpace != NVPTX::PTXLdStInstCode::GENERIC)
 623     IsVolatile = false;
 624
 625   // Vector Setting
 626   MVT SimpleVT = LoadedVT.getSimpleVT();
 627
 628   // Type Setting: fromType + fromTypeWidth
 629   //
 630   // Sign   : ISD::SEXTLOAD
 631   // Unsign : ISD::ZEXTLOAD, ISD::NON_EXTLOAD or ISD::EXTLOAD and the
 632   //          type is integer
 633   // Float  : ISD::NON_EXTLOAD or ISD::EXTLOAD and the type is float
 634   MVT ScalarVT = SimpleVT.getScalarType();
 635   // Read at least 8 bits (predicates are stored as 8-bit values)
 636   unsigned FromTypeWidth = std::max(8U, ScalarVT.getSizeInBits());
 637   unsigned int FromType;
 638   // The last operand holds the original LoadSDNode::getExtensionType() value
 639   unsigned ExtensionType = cast<ConstantSDNode>(
 640       N->getOperand(N->getNumOperands() - 1))->getZExtValue();
 641   if (ExtensionType == ISD::SEXTLOAD)
 642     FromType = NVPTX::PTXLdStInstCode::Signed;
 643   else if (ScalarVT.isFloatingPoint())
 644     FromType = NVPTX::PTXLdStInstCode::Float;
 645   else
 646     FromType = NVPTX::PTXLdStInstCode::Unsigned;
 647
 648   unsigned VecType;
 649
 650   switch (N->getOpcode()) {
 651   case NVPTXISD::LoadV2:
 652     VecType = NVPTX::PTXLdStInstCode::V2;
 653     break;
 654   case NVPTXISD::LoadV4:
 655     VecType = NVPTX::PTXLdStInstCode::V4;
 656     break;
 657   default:
 658     return NULL;
 659   }
 660
 661   EVT EltVT = N->getValueType(0);
 662
 663   if (SelectDirectAddr(Op1, Addr)) {
 664     switch (N->getOpcode()) {
 665     default:
 666       return NULL;
 667     case NVPTXISD::LoadV2:
 668       switch (EltVT.getSimpleVT().SimpleTy) {
 669       default:
 670         return NULL;
 671       case MVT::i8:
 672         Opcode = NVPTX::LDV_i8_v2_avar;
 673         break;
 674       case MVT::i16:
 675         Opcode = NVPTX::LDV_i16_v2_avar;
 676         break;
 677       case MVT::i32:
 678         Opcode = NVPTX::LDV_i32_v2_avar;
 679         break;
 680       case MVT::i64:
 681         Opcode = NVPTX::LDV_i64_v2_avar;
 682         break;
 683       case MVT::f32:
 684         Opcode = NVPTX::LDV_f32_v2_avar;
 685         break;
 686       case MVT::f64:
 687         Opcode = NVPTX::LDV_f64_v2_avar;
 688         break;
 689       }
 690       break;
 691     case NVPTXISD::LoadV4:
 692       switch (EltVT.getSimpleVT().SimpleTy) {
 693       default:
 694         return NULL;
 695       case MVT::i8:
 696         Opcode = NVPTX::LDV_i8_v4_avar;
 697         break;
 698       case MVT::i16:
 699         Opcode = NVPTX::LDV_i16_v4_avar;
 700         break;
 701       case MVT::i32:
 702         Opcode = NVPTX::LDV_i32_v4_avar;
 703         break;
 704       case MVT::f32:
 705         Opcode = NVPTX::LDV_f32_v4_avar;
 706         break;
 707       }
 708       break;
 709     }
 710
 711     SDValue Ops[] = { getI32Imm(IsVolatile), getI32Imm(CodeAddrSpace),
 712                       getI32Imm(VecType), getI32Imm(FromType),
 713                       getI32Imm(FromTypeWidth), Addr, Chain };
 714     LD = CurDAG->getMachineNode(Opcode, DL, N->getVTList(), Ops);
 715   } else if (Subtarget.is64Bit()
 716                  ? SelectADDRsi64(Op1.getNode(), Op1, Base, Offset)
 717                  : SelectADDRsi(Op1.getNode(), Op1, Base, Offset)) {
 718     switch (N->getOpcode()) {
 719     default:
 720       return NULL;
 721     case NVPTXISD::LoadV2:
 722       switch (EltVT.getSimpleVT().SimpleTy) {
 723       default:
 724         return NULL;
 725       case MVT::i8:
 726         Opcode = NVPTX::LDV_i8_v2_asi;
 727         break;
 728       case MVT::i16:
 729         Opcode = NVPTX::LDV_i16_v2_asi;
 730         break;
 731       case MVT::i32:
 732         Opcode = NVPTX::LDV_i32_v2_asi;
 733         break;
 734       case MVT::i64:
 735         Opcode = NVPTX::LDV_i64_v2_asi;
 736         break;
 737       case MVT::f32:
 738         Opcode = NVPTX::LDV_f32_v2_asi;
 739         break;
 740       case MVT::f64:
 741         Opcode = NVPTX::LDV_f64_v2_asi;
 742         break;
 743       }
 744       break;
 745     case NVPTXISD::LoadV4:
 746       switch (EltVT.getSimpleVT().SimpleTy) {
 747       default:
 748         return NULL;
 749       case MVT::i8:
 750         Opcode = NVPTX::LDV_i8_v4_asi;
 751         break;
 752       case MVT::i16:
 753         Opcode = NVPTX::LDV_i16_v4_asi;
 754         break;
 755       case MVT::i32:
 756         Opcode = NVPTX::LDV_i32_v4_asi;
 757         break;
 758       case MVT::f32:
 759         Opcode = NVPTX::LDV_f32_v4_asi;
 760         break;
 761       }
 762       break;
 763     }
 764
 765     SDValue Ops[] = { getI32Imm(IsVolatile), getI32Imm(CodeAddrSpace),
 766                       getI32Imm(VecType), getI32Imm(FromType),
 767                       getI32Imm(FromTypeWidth), Base, Offset, Chain };
 768     LD = CurDAG->getMachineNode(Opcode, DL, N->getVTList(), Ops);
 769   } else if (Subtarget.is64Bit()
 770                  ? SelectADDRri64(Op1.getNode(), Op1, Base, Offset)
 771                  : SelectADDRri(Op1.getNode(), Op1, Base, Offset)) {
 772     if (Subtarget.is64Bit()) {
 773       switch (N->getOpcode()) {
 774       default:
 775         return NULL;
 776       case NVPTXISD::LoadV2:
 777         switch (EltVT.getSimpleVT().SimpleTy) {
 778         default:
 779           return NULL;
 780         case MVT::i8:
 781           Opcode = NVPTX::LDV_i8_v2_ari_64;
 782           break;
 783         case MVT::i16:
 784           Opcode = NVPTX::LDV_i16_v2_ari_64;
 785           break;
 786         case MVT::i32:
 787           Opcode = NVPTX::LDV_i32_v2_ari_64;
 788           break;
 789         case MVT::i64:
 790           Opcode = NVPTX::LDV_i64_v2_ari_64;
 791           break;
 792         case MVT::f32:
 793           Opcode = NVPTX::LDV_f32_v2_ari_64;
 794           break;
 795         case MVT::f64:
 796           Opcode = NVPTX::LDV_f64_v2_ari_64;
 797           break;
 798         }
 799         break;
 800       case NVPTXISD::LoadV4:
 801         switch (EltVT.getSimpleVT().SimpleTy) {
 802         default:
 803           return NULL;
 804         case MVT::i8:
 805           Opcode = NVPTX::LDV_i8_v4_ari_64;
 806           break;
 807         case MVT::i16:
 808           Opcode = NVPTX::LDV_i16_v4_ari_64;
 809           break;
 810         case MVT::i32:
 811           Opcode = NVPTX::LDV_i32_v4_ari_64;
 812           break;
 813         case MVT::f32:
 814           Opcode = NVPTX::LDV_f32_v4_ari_64;
 815           break;
 816         }
 817         break;
 818       }
 819     } else {
 820       switch (N->getOpcode()) {
 821       default:
 822         return NULL;
 823       case NVPTXISD::LoadV2:
 824         switch (EltVT.getSimpleVT().SimpleTy) {
 825         default:
 826           return NULL;
 827         case MVT::i8:
 828           Opcode = NVPTX::LDV_i8_v2_ari;
 829           break;
 830         case MVT::i16:
 831           Opcode = NVPTX::LDV_i16_v2_ari;
 832           break;
 833         case MVT::i32:
 834           Opcode = NVPTX::LDV_i32_v2_ari;
 835           break;
 836         case MVT::i64:
 837           Opcode = NVPTX::LDV_i64_v2_ari;
 838           break;
 839         case MVT::f32:
 840           Opcode = NVPTX::LDV_f32_v2_ari;
 841           break;
 842         case MVT::f64:
 843           Opcode = NVPTX::LDV_f64_v2_ari;
 844           break;
 845         }
 846         break;
 847       case NVPTXISD::LoadV4:
 848         switch (EltVT.getSimpleVT().SimpleTy) {
 849         default:
 850           return NULL;
 851         case MVT::i8:
 852           Opcode = NVPTX::LDV_i8_v4_ari;
 853           break;
 854         case MVT::i16:
 855           Opcode = NVPTX::LDV_i16_v4_ari;
 856           break;
 857         case MVT::i32:
 858           Opcode = NVPTX::LDV_i32_v4_ari;
 859           break;
 860         case MVT::f32:
 861           Opcode = NVPTX::LDV_f32_v4_ari;
 862           break;
 863         }
 864         break;
 865       }
 866     }
 867
 868     SDValue Ops[] = { getI32Imm(IsVolatile), getI32Imm(CodeAddrSpace),
 869                       getI32Imm(VecType), getI32Imm(FromType),
 870                       getI32Imm(FromTypeWidth), Base, Offset, Chain };
 871
 872     LD = CurDAG->getMachineNode(Opcode, DL, N->getVTList(), Ops);
 873   } else {
 874     if (Subtarget.is64Bit()) {
 875       switch (N->getOpcode()) {
 876       default:
 877         return NULL;
 878       case NVPTXISD::LoadV2:
 879         switch (EltVT.getSimpleVT().SimpleTy) {
 880         default:
 881           return NULL;
 882         case MVT::i8:
 883           Opcode = NVPTX::LDV_i8_v2_areg_64;
 884           break;
 885         case MVT::i16:
 886           Opcode = NVPTX::LDV_i16_v2_areg_64;
 887           break;
 888         case MVT::i32:
 889           Opcode = NVPTX::LDV_i32_v2_areg_64;
 890           break;
 891         case MVT::i64:
 892           Opcode = NVPTX::LDV_i64_v2_areg_64;
 893           break;
 894         case MVT::f32:
 895           Opcode = NVPTX::LDV_f32_v2_areg_64;
 896           break;
 897         case MVT::f64:
 898           Opcode = NVPTX::LDV_f64_v2_areg_64;
 899           break;
 900         }
 901         break;
 902       case NVPTXISD::LoadV4:
 903         switch (EltVT.getSimpleVT().SimpleTy) {
 904         default:
 905           return NULL;
 906         case MVT::i8:
 907           Opcode = NVPTX::LDV_i8_v4_areg_64;
 908           break;
 909         case MVT::i16:
 910           Opcode = NVPTX::LDV_i16_v4_areg_64;
 911           break;
 912         case MVT::i32:
 913           Opcode = NVPTX::LDV_i32_v4_areg_64;
 914           break;
 915         case MVT::f32:
 916           Opcode = NVPTX::LDV_f32_v4_areg_64;
 917           break;
 918         }
 919         break;
 920       }
 921     } else {
 922       switch (N->getOpcode()) {
 923       default:
 924         return NULL;
 925       case NVPTXISD::LoadV2:
 926         switch (EltVT.getSimpleVT().SimpleTy) {
 927         default:
 928           return NULL;
 929         case MVT::i8:
 930           Opcode = NVPTX::LDV_i8_v2_areg;
 931           break;
 932         case MVT::i16:
 933           Opcode = NVPTX::LDV_i16_v2_areg;
 934           break;
 935         case MVT::i32:
 936           Opcode = NVPTX::LDV_i32_v2_areg;
 937           break;
 938         case MVT::i64:
 939           Opcode = NVPTX::LDV_i64_v2_areg;
 940           break;
 941         case MVT::f32:
 942           Opcode = NVPTX::LDV_f32_v2_areg;
 943           break;
 944         case MVT::f64:
 945           Opcode = NVPTX::LDV_f64_v2_areg;
 946           break;
 947         }
 948         break;
 949       case NVPTXISD::LoadV4:
 950         switch (EltVT.getSimpleVT().SimpleTy) {
 951         default:
 952           return NULL;
 953         case MVT::i8:
 954           Opcode = NVPTX::LDV_i8_v4_areg;
 955           break;
 956         case MVT::i16:
 957           Opcode = NVPTX::LDV_i16_v4_areg;
 958           break;
 959         case MVT::i32:
 960           Opcode = NVPTX::LDV_i32_v4_areg;
 961           break;
 962         case MVT::f32:
 963           Opcode = NVPTX::LDV_f32_v4_areg;
 964           break;
 965         }
 966         break;
 967       }
 968     }
 969
 970     SDValue Ops[] = { getI32Imm(IsVolatile), getI32Imm(CodeAddrSpace),
 971                       getI32Imm(VecType), getI32Imm(FromType),
 972                       getI32Imm(FromTypeWidth), Op1, Chain };
 973     LD = CurDAG->getMachineNode(Opcode, DL, N->getVTList(), Ops);
 974   }
 975
 976   MachineSDNode::mmo_iterator MemRefs0 = MF->allocateMemRefsArray(1);
 977   MemRefs0[0] = cast<MemSDNode>(N)->getMemOperand();
 978   cast<MachineSDNode>(LD)->setMemRefs(MemRefs0, MemRefs0 + 1);
 979
 980   return LD;
 981 }
 982
 983 SDNode *NVPTXDAGToDAGISel::SelectLDGLDUVector(SDNode *N) {
 984
 985   SDValue Chain = N->getOperand(0);
 986   SDValue Op1 = N->getOperand(1);
 987   unsigned Opcode;
 988   SDLoc DL(N);
 989   SDNode *LD;
 990   MemSDNode *Mem = cast<MemSDNode>(N);
 991   SDValue Base, Offset, Addr;
 992
 993   EVT EltVT = Mem->getMemoryVT().getVectorElementType();
 994
 995   if (SelectDirectAddr(Op1, Addr)) {
 996     switch (N->getOpcode()) {
 997     default:
 998       return NULL;
 999     case NVPTXISD::LDGV2:
1000       switch (EltVT.getSimpleVT().SimpleTy) {
1001       default:
1002         return NULL;
1003       case MVT::i8:
1004         Opcode = NVPTX::INT_PTX_LDG_G_v2i8_ELE_avar;
1005         break;
1006       case MVT::i16:
1007         Opcode = NVPTX::INT_PTX_LDG_G_v2i16_ELE_avar;
1008         break;
1009       case MVT::i32:
1010         Opcode = NVPTX::INT_PTX_LDG_G_v2i32_ELE_avar;
1011         break;
1012       case MVT::i64:
1013         Opcode = NVPTX::INT_PTX_LDG_G_v2i64_ELE_avar;
1014         break;
1015       case MVT::f32:
1016         Opcode = NVPTX::INT_PTX_LDG_G_v2f32_ELE_avar;
1017         break;
1018       case MVT::f64:
1019         Opcode = NVPTX::INT_PTX_LDG_G_v2f64_ELE_avar;
1020         break;
1021       }
1022       break;
1023     case NVPTXISD::LDUV2:
1024       switch (EltVT.getSimpleVT().SimpleTy) {
1025       default:
1026         return NULL;
1027       case MVT::i8:
1028         Opcode = NVPTX::INT_PTX_LDU_G_v2i8_ELE_avar;
1029         break;
1030       case MVT::i16:
1031         Opcode = NVPTX::INT_PTX_LDU_G_v2i16_ELE_avar;
1032         break;
1033       case MVT::i32:
1034         Opcode = NVPTX::INT_PTX_LDU_G_v2i32_ELE_avar;
1035         break;
1036       case MVT::i64:
1037         Opcode = NVPTX::INT_PTX_LDU_G_v2i64_ELE_avar;
1038         break;
1039       case MVT::f32:
1040         Opcode = NVPTX::INT_PTX_LDU_G_v2f32_ELE_avar;
1041         break;
1042       case MVT::f64:
1043         Opcode = NVPTX::INT_PTX_LDU_G_v2f64_ELE_avar;
1044         break;
1045       }
1046       break;
1047     case NVPTXISD::LDGV4:
1048       switch (EltVT.getSimpleVT().SimpleTy) {
1049       default:
1050         return NULL;
1051       case MVT::i8:
1052         Opcode = NVPTX::INT_PTX_LDG_G_v4i8_ELE_avar;
1053         break;
1054       case MVT::i16:
1055         Opcode = NVPTX::INT_PTX_LDG_G_v4i16_ELE_avar;
1056         break;
1057       case MVT::i32:
1058         Opcode = NVPTX::INT_PTX_LDG_G_v4i32_ELE_avar;
1059         break;
1060       case MVT::f32:
1061         Opcode = NVPTX::INT_PTX_LDG_G_v4f32_ELE_avar;
1062         break;
1063       }
1064       break;
1065     case NVPTXISD::LDUV4:
1066       switch (EltVT.getSimpleVT().SimpleTy) {
1067       default:
1068         return NULL;
1069       case MVT::i8:
1070         Opcode = NVPTX::INT_PTX_LDU_G_v4i8_ELE_avar;
1071         break;
1072       case MVT::i16:
1073         Opcode = NVPTX::INT_PTX_LDU_G_v4i16_ELE_avar;
1074         break;
1075       case MVT::i32:
1076         Opcode = NVPTX::INT_PTX_LDU_G_v4i32_ELE_avar;
1077         break;
1078       case MVT::f32:
1079         Opcode = NVPTX::INT_PTX_LDU_G_v4f32_ELE_avar;
1080         break;
1081       }
1082       break;
1083     }
1084
1085     SDValue Ops[] = { Addr, Chain };
1086     LD = CurDAG->getMachineNode(Opcode, DL, N->getVTList(),
1087                                 ArrayRef<SDValue>(Ops, 2));
1088   } else if (Subtarget.is64Bit()
1089                  ? SelectADDRri64(Op1.getNode(), Op1, Base, Offset)
1090                  : SelectADDRri(Op1.getNode(), Op1, Base, Offset)) {
1091     if (Subtarget.is64Bit()) {
1092       switch (N->getOpcode()) {
1093       default:
1094         return NULL;
1095       case NVPTXISD::LDGV2:
1096         switch (EltVT.getSimpleVT().SimpleTy) {
1097         default:
1098           return NULL;
1099         case MVT::i8:
1100           Opcode = NVPTX::INT_PTX_LDG_G_v2i8_ELE_ari64;
1101           break;
1102         case MVT::i16:
1103           Opcode = NVPTX::INT_PTX_LDG_G_v2i16_ELE_ari64;
1104           break;
1105         case MVT::i32:
1106           Opcode = NVPTX::INT_PTX_LDG_G_v2i32_ELE_ari64;
1107           break;
1108         case MVT::i64:
1109           Opcode = NVPTX::INT_PTX_LDG_G_v2i64_ELE_ari64;
1110           break;
1111         case MVT::f32:
1112           Opcode = NVPTX::INT_PTX_LDG_G_v2f32_ELE_ari64;
1113           break;
1114         case MVT::f64:
1115           Opcode = NVPTX::INT_PTX_LDG_G_v2f64_ELE_ari64;
1116           break;
1117         }
1118         break;
1119       case NVPTXISD::LDUV2:
1120         switch (EltVT.getSimpleVT().SimpleTy) {
1121         default:
1122           return NULL;
1123         case MVT::i8:
1124           Opcode = NVPTX::INT_PTX_LDU_G_v2i8_ELE_ari64;
1125           break;
1126         case MVT::i16:
1127           Opcode = NVPTX::INT_PTX_LDU_G_v2i16_ELE_ari64;
1128           break;
1129         case MVT::i32:
1130           Opcode = NVPTX::INT_PTX_LDU_G_v2i32_ELE_ari64;
1131           break;
1132         case MVT::i64:
1133           Opcode = NVPTX::INT_PTX_LDU_G_v2i64_ELE_ari64;
1134           break;
1135         case MVT::f32:
1136           Opcode = NVPTX::INT_PTX_LDU_G_v2f32_ELE_ari64;
1137           break;
1138         case MVT::f64:
1139           Opcode = NVPTX::INT_PTX_LDU_G_v2f64_ELE_ari64;
1140           break;
1141         }
1142         break;
1143       case NVPTXISD::LDGV4:
1144         switch (EltVT.getSimpleVT().SimpleTy) {
1145         default:
1146           return NULL;
1147         case MVT::i8:
1148           Opcode = NVPTX::INT_PTX_LDG_G_v4i8_ELE_ari64;
1149           break;
1150         case MVT::i16:
1151           Opcode = NVPTX::INT_PTX_LDG_G_v4i16_ELE_ari64;
1152           break;
1153         case MVT::i32:
1154           Opcode = NVPTX::INT_PTX_LDG_G_v4i32_ELE_ari64;
1155           break;
1156         case MVT::f32:
1157           Opcode = NVPTX::INT_PTX_LDG_G_v4f32_ELE_ari64;
1158           break;
1159         }
1160         break;
1161       case NVPTXISD::LDUV4:
1162         switch (EltVT.getSimpleVT().SimpleTy) {
1163         default:
1164           return NULL;
1165         case MVT::i8:
1166           Opcode = NVPTX::INT_PTX_LDU_G_v4i8_ELE_ari64;
1167           break;
1168         case MVT::i16:
1169           Opcode = NVPTX::INT_PTX_LDU_G_v4i16_ELE_ari64;
1170           break;
1171         case MVT::i32:
1172           Opcode = NVPTX::INT_PTX_LDU_G_v4i32_ELE_ari64;
1173           break;
1174         case MVT::f32:
1175           Opcode = NVPTX::INT_PTX_LDU_G_v4f32_ELE_ari64;
1176           break;
1177         }
1178         break;
1179       }
1180     } else {
1181       switch (N->getOpcode()) {
1182       default:
1183         return NULL;
1184       case NVPTXISD::LDGV2:
1185         switch (EltVT.getSimpleVT().SimpleTy) {
1186         default:
1187           return NULL;
1188         case MVT::i8:
1189           Opcode = NVPTX::INT_PTX_LDG_G_v2i8_ELE_ari32;
1190           break;
1191         case MVT::i16:
1192           Opcode = NVPTX::INT_PTX_LDG_G_v2i16_ELE_ari32;
1193           break;
1194         case MVT::i32:
1195           Opcode = NVPTX::INT_PTX_LDG_G_v2i32_ELE_ari32;
1196           break;
1197         case MVT::i64:
1198           Opcode = NVPTX::INT_PTX_LDG_G_v2i64_ELE_ari32;
1199           break;
1200         case MVT::f32:
1201           Opcode = NVPTX::INT_PTX_LDG_G_v2f32_ELE_ari32;
1202           break;
1203         case MVT::f64:
1204           Opcode = NVPTX::INT_PTX_LDG_G_v2f64_ELE_ari32;
1205           break;
1206         }
1207         break;
1208       case NVPTXISD::LDUV2:
1209         switch (EltVT.getSimpleVT().SimpleTy) {
1210         default:
1211           return NULL;
1212         case MVT::i8:
1213           Opcode = NVPTX::INT_PTX_LDU_G_v2i8_ELE_ari32;
1214           break;
1215         case MVT::i16:
1216           Opcode = NVPTX::INT_PTX_LDU_G_v2i16_ELE_ari32;
1217           break;
1218         case MVT::i32:
1219           Opcode = NVPTX::INT_PTX_LDU_G_v2i32_ELE_ari32;
1220           break;
1221         case MVT::i64:
1222           Opcode = NVPTX::INT_PTX_LDU_G_v2i64_ELE_ari32;
1223           break;
1224         case MVT::f32:
1225           Opcode = NVPTX::INT_PTX_LDU_G_v2f32_ELE_ari32;
1226           break;
1227         case MVT::f64:
1228           Opcode = NVPTX::INT_PTX_LDU_G_v2f64_ELE_ari32;
1229           break;
1230         }
1231         break;
1232       case NVPTXISD::LDGV4:
1233         switch (EltVT.getSimpleVT().SimpleTy) {
1234         default:
1235           return NULL;
1236         case MVT::i8:
1237           Opcode = NVPTX::INT_PTX_LDG_G_v4i8_ELE_ari32;
1238           break;
1239         case MVT::i16:
1240           Opcode = NVPTX::INT_PTX_LDG_G_v4i16_ELE_ari32;
1241           break;
1242         case MVT::i32:
1243           Opcode = NVPTX::INT_PTX_LDG_G_v4i32_ELE_ari32;
1244           break;
1245         case MVT::f32:
1246           Opcode = NVPTX::INT_PTX_LDG_G_v4f32_ELE_ari32;
1247           break;
1248         }
1249         break;
1250       case NVPTXISD::LDUV4:
1251         switch (EltVT.getSimpleVT().SimpleTy) {
1252         default:
1253           return NULL;
1254         case MVT::i8:
1255           Opcode = NVPTX::INT_PTX_LDU_G_v4i8_ELE_ari32;
1256           break;
1257         case MVT::i16:
1258           Opcode = NVPTX::INT_PTX_LDU_G_v4i16_ELE_ari32;
1259           break;
1260         case MVT::i32:
1261           Opcode = NVPTX::INT_PTX_LDU_G_v4i32_ELE_ari32;
1262           break;
1263         case MVT::f32:
1264           Opcode = NVPTX::INT_PTX_LDU_G_v4f32_ELE_ari32;
1265           break;
1266         }
1267         break;
1268       }
1269     }
1270
1271     SDValue Ops[] = { Base, Offset, Chain };
1272
1273     LD = CurDAG->getMachineNode(Opcode, DL, N->getVTList(),
1274                                 ArrayRef<SDValue>(Ops, 3));
1275   } else {
1276     if (Subtarget.is64Bit()) {
1277       switch (N->getOpcode()) {
1278       default:
1279         return NULL;
1280       case NVPTXISD::LDGV2:
1281         switch (EltVT.getSimpleVT().SimpleTy) {
1282         default:
1283           return NULL;
1284         case MVT::i8:
1285           Opcode = NVPTX::INT_PTX_LDG_G_v2i8_ELE_areg64;
1286           break;
1287         case MVT::i16:
1288           Opcode = NVPTX::INT_PTX_LDG_G_v2i16_ELE_areg64;
1289           break;
1290         case MVT::i32:
1291           Opcode = NVPTX::INT_PTX_LDG_G_v2i32_ELE_areg64;
1292           break;
1293         case MVT::i64:
1294           Opcode = NVPTX::INT_PTX_LDG_G_v2i64_ELE_areg64;
1295           break;
1296         case MVT::f32:
1297           Opcode = NVPTX::INT_PTX_LDG_G_v2f32_ELE_areg64;
1298           break;
1299         case MVT::f64:
1300           Opcode = NVPTX::INT_PTX_LDG_G_v2f64_ELE_areg64;
1301           break;
1302         }
1303         break;
1304       case NVPTXISD::LDUV2:
1305         switch (EltVT.getSimpleVT().SimpleTy) {
1306         default:
1307           return NULL;
1308         case MVT::i8:
1309           Opcode = NVPTX::INT_PTX_LDU_G_v2i8_ELE_areg64;
1310           break;
1311         case MVT::i16:
1312           Opcode = NVPTX::INT_PTX_LDU_G_v2i16_ELE_areg64;
1313           break;
1314         case MVT::i32:
1315           Opcode = NVPTX::INT_PTX_LDU_G_v2i32_ELE_areg64;
1316           break;
1317         case MVT::i64:
1318           Opcode = NVPTX::INT_PTX_LDU_G_v2i64_ELE_areg64;
1319           break;
1320         case MVT::f32:
1321           Opcode = NVPTX::INT_PTX_LDU_G_v2f32_ELE_areg64;
1322           break;
1323         case MVT::f64:
1324           Opcode = NVPTX::INT_PTX_LDU_G_v2f64_ELE_areg64;
1325           break;
1326         }
1327         break;
1328       case NVPTXISD::LDGV4:
1329         switch (EltVT.getSimpleVT().SimpleTy) {
1330         default:
1331           return NULL;
1332         case MVT::i8:
1333           Opcode = NVPTX::INT_PTX_LDG_G_v4i8_ELE_areg64;
1334           break;
1335         case MVT::i16:
1336           Opcode = NVPTX::INT_PTX_LDG_G_v4i16_ELE_areg64;
1337           break;
1338         case MVT::i32:
1339           Opcode = NVPTX::INT_PTX_LDG_G_v4i32_ELE_areg64;
1340           break;
1341         case MVT::f32:
1342           Opcode = NVPTX::INT_PTX_LDG_G_v4f32_ELE_areg64;
1343           break;
1344         }
1345         break;
1346       case NVPTXISD::LDUV4:
1347         switch (EltVT.getSimpleVT().SimpleTy) {
1348         default:
1349           return NULL;
1350         case MVT::i8:
1351           Opcode = NVPTX::INT_PTX_LDU_G_v4i8_ELE_areg64;
1352           break;
1353         case MVT::i16:
1354           Opcode = NVPTX::INT_PTX_LDU_G_v4i16_ELE_areg64;
1355           break;
1356         case MVT::i32:
1357           Opcode = NVPTX::INT_PTX_LDU_G_v4i32_ELE_areg64;
1358           break;
1359         case MVT::f32:
1360           Opcode = NVPTX::INT_PTX_LDU_G_v4f32_ELE_areg64;
1361           break;
1362         }
1363         break;
1364       }
1365     } else {
1366       switch (N->getOpcode()) {
1367       default:
1368         return NULL;
1369       case NVPTXISD::LDGV2:
1370         switch (EltVT.getSimpleVT().SimpleTy) {
1371         default:
1372           return NULL;
1373         case MVT::i8:
1374           Opcode = NVPTX::INT_PTX_LDG_G_v2i8_ELE_areg32;
1375           break;
1376         case MVT::i16:
1377           Opcode = NVPTX::INT_PTX_LDG_G_v2i16_ELE_areg32;
1378           break;
1379         case MVT::i32:
1380           Opcode = NVPTX::INT_PTX_LDG_G_v2i32_ELE_areg32;
1381           break;
1382         case MVT::i64:
1383           Opcode = NVPTX::INT_PTX_LDG_G_v2i64_ELE_areg32;
1384           break;
1385         case MVT::f32:
1386           Opcode = NVPTX::INT_PTX_LDG_G_v2f32_ELE_areg32;
1387           break;
1388         case MVT::f64:
1389           Opcode = NVPTX::INT_PTX_LDG_G_v2f64_ELE_areg32;
1390           break;
1391         }
1392         break;
1393       case NVPTXISD::LDUV2:
1394         switch (EltVT.getSimpleVT().SimpleTy) {
1395         default:
1396           return NULL;
1397         case MVT::i8:
1398           Opcode = NVPTX::INT_PTX_LDU_G_v2i8_ELE_areg32;
1399           break;
1400         case MVT::i16:
1401           Opcode = NVPTX::INT_PTX_LDU_G_v2i16_ELE_areg32;
1402           break;
1403         case MVT::i32:
1404           Opcode = NVPTX::INT_PTX_LDU_G_v2i32_ELE_areg32;
1405           break;
1406         case MVT::i64:
1407           Opcode = NVPTX::INT_PTX_LDU_G_v2i64_ELE_areg32;
1408           break;
1409         case MVT::f32:
1410           Opcode = NVPTX::INT_PTX_LDU_G_v2f32_ELE_areg32;
1411           break;
1412         case MVT::f64:
1413           Opcode = NVPTX::INT_PTX_LDU_G_v2f64_ELE_areg32;
1414           break;
1415         }
1416         break;
1417       case NVPTXISD::LDGV4:
1418         switch (EltVT.getSimpleVT().SimpleTy) {
1419         default:
1420           return NULL;
1421         case MVT::i8:
1422           Opcode = NVPTX::INT_PTX_LDG_G_v4i8_ELE_areg32;
1423           break;
1424         case MVT::i16:
1425           Opcode = NVPTX::INT_PTX_LDG_G_v4i16_ELE_areg32;
1426           break;
1427         case MVT::i32:
1428           Opcode = NVPTX::INT_PTX_LDG_G_v4i32_ELE_areg32;
1429           break;
1430         case MVT::f32:
1431           Opcode = NVPTX::INT_PTX_LDG_G_v4f32_ELE_areg32;
1432           break;
1433         }
1434         break;
1435       case NVPTXISD::LDUV4:
1436         switch (EltVT.getSimpleVT().SimpleTy) {
1437         default:
1438           return NULL;
1439         case MVT::i8:
1440           Opcode = NVPTX::INT_PTX_LDU_G_v4i8_ELE_areg32;
1441           break;
1442         case MVT::i16:
1443           Opcode = NVPTX::INT_PTX_LDU_G_v4i16_ELE_areg32;
1444           break;
1445         case MVT::i32:
1446           Opcode = NVPTX::INT_PTX_LDU_G_v4i32_ELE_areg32;
1447           break;
1448         case MVT::f32:
1449           Opcode = NVPTX::INT_PTX_LDU_G_v4f32_ELE_areg32;
1450           break;
1451         }
1452         break;
1453       }
1454     }
1455
1456     SDValue Ops[] = { Op1, Chain };
1457     LD = CurDAG->getMachineNode(Opcode, DL, N->getVTList(),
1458                                 ArrayRef<SDValue>(Ops, 2));
1459   }
1460
1461   MachineSDNode::mmo_iterator MemRefs0 = MF->allocateMemRefsArray(1);
1462   MemRefs0[0] = cast<MemSDNode>(N)->getMemOperand();
1463   cast<MachineSDNode>(LD)->setMemRefs(MemRefs0, MemRefs0 + 1);
1464
1465   return LD;
1466 }
1467
1468 SDNode *NVPTXDAGToDAGISel::SelectStore(SDNode *N) {
1469   SDLoc dl(N);
1470   StoreSDNode *ST = cast<StoreSDNode>(N);
1471   EVT StoreVT = ST->getMemoryVT();
1472   SDNode *NVPTXST = NULL;
1473
1474   // do not support pre/post inc/dec
1475   if (ST->isIndexed())
1476     return NULL;
1477
1478   if (!StoreVT.isSimple())
1479     return NULL;
1480
1481   // Address Space Setting
1482   unsigned int codeAddrSpace = getCodeAddrSpace(ST, Subtarget);
1483
1484   // Volatile Setting
1485   // - .volatile is only availalble for .global and .shared
1486   bool isVolatile = ST->isVolatile();
1487   if (codeAddrSpace != NVPTX::PTXLdStInstCode::GLOBAL &&
1488       codeAddrSpace != NVPTX::PTXLdStInstCode::SHARED &&
1489       codeAddrSpace != NVPTX::PTXLdStInstCode::GENERIC)
1490     isVolatile = false;
1491
1492   // Vector Setting
1493   MVT SimpleVT = StoreVT.getSimpleVT();
1494   unsigned vecType = NVPTX::PTXLdStInstCode::Scalar;
1495   if (SimpleVT.isVector()) {
1496     unsigned num = SimpleVT.getVectorNumElements();
1497     if (num == 2)
1498       vecType = NVPTX::PTXLdStInstCode::V2;
1499     else if (num == 4)
1500       vecType = NVPTX::PTXLdStInstCode::V4;
1501     else
1502       return NULL;
1503   }
1504
1505   // Type Setting: toType + toTypeWidth
1506   // - for integer type, always use 'u'
1507   //
1508   MVT ScalarVT = SimpleVT.getScalarType();
1509   unsigned toTypeWidth = ScalarVT.getSizeInBits();
1510   unsigned int toType;
1511   if (ScalarVT.isFloatingPoint())
1512     toType = NVPTX::PTXLdStInstCode::Float;
1513   else
1514     toType = NVPTX::PTXLdStInstCode::Unsigned;
1515
1516   // Create the machine instruction DAG
1517   SDValue Chain = N->getOperand(0);
1518   SDValue N1 = N->getOperand(1);
1519   SDValue N2 = N->getOperand(2);
1520   SDValue Addr;
1521   SDValue Offset, Base;
1522   unsigned Opcode;
1523   MVT::SimpleValueType SourceVT = N1.getNode()->getSimpleValueType(0).SimpleTy;
1524
1525   if (SelectDirectAddr(N2, Addr)) {
1526     switch (SourceVT) {
1527     case MVT::i8:
1528       Opcode = NVPTX::ST_i8_avar;
1529       break;
1530     case MVT::i16:
1531       Opcode = NVPTX::ST_i16_avar;
1532       break;
1533     case MVT::i32:
1534       Opcode = NVPTX::ST_i32_avar;
1535       break;
1536     case MVT::i64:
1537       Opcode = NVPTX::ST_i64_avar;
1538       break;
1539     case MVT::f32:
1540       Opcode = NVPTX::ST_f32_avar;
1541       break;
1542     case MVT::f64:
1543       Opcode = NVPTX::ST_f64_avar;
1544       break;
1545     default:
1546       return NULL;
1547     }
1548     SDValue Ops[] = { N1, getI32Imm(isVolatile), getI32Imm(codeAddrSpace),
1549                       getI32Imm(vecType), getI32Imm(toType),
1550                       getI32Imm(toTypeWidth), Addr, Chain };
1551     NVPTXST = CurDAG->getMachineNode(Opcode, dl, MVT::Other, Ops);
1552   } else if (Subtarget.is64Bit()
1553                  ? SelectADDRsi64(N2.getNode(), N2, Base, Offset)
1554                  : SelectADDRsi(N2.getNode(), N2, Base, Offset)) {
1555     switch (SourceVT) {
1556     case MVT::i8:
1557       Opcode = NVPTX::ST_i8_asi;
1558       break;
1559     case MVT::i16:
1560       Opcode = NVPTX::ST_i16_asi;
1561       break;
1562     case MVT::i32:
1563       Opcode = NVPTX::ST_i32_asi;
1564       break;
1565     case MVT::i64:
1566       Opcode = NVPTX::ST_i64_asi;
1567       break;
1568     case MVT::f32:
1569       Opcode = NVPTX::ST_f32_asi;
1570       break;
1571     case MVT::f64:
1572       Opcode = NVPTX::ST_f64_asi;
1573       break;
1574     default:
1575       return NULL;
1576     }
1577     SDValue Ops[] = { N1, getI32Imm(isVolatile), getI32Imm(codeAddrSpace),
1578                       getI32Imm(vecType), getI32Imm(toType),
1579                       getI32Imm(toTypeWidth), Base, Offset, Chain };
1580     NVPTXST = CurDAG->getMachineNode(Opcode, dl, MVT::Other, Ops);
1581   } else if (Subtarget.is64Bit()
1582                  ? SelectADDRri64(N2.getNode(), N2, Base, Offset)
1583                  : SelectADDRri(N2.getNode(), N2, Base, Offset)) {
1584     if (Subtarget.is64Bit()) {
1585       switch (SourceVT) {
1586       case MVT::i8:
1587         Opcode = NVPTX::ST_i8_ari_64;
1588         break;
1589       case MVT::i16:
1590         Opcode = NVPTX::ST_i16_ari_64;
1591         break;
1592       case MVT::i32:
1593         Opcode = NVPTX::ST_i32_ari_64;
1594         break;
1595       case MVT::i64:
1596         Opcode = NVPTX::ST_i64_ari_64;
1597         break;
1598       case MVT::f32:
1599         Opcode = NVPTX::ST_f32_ari_64;
1600         break;
1601       case MVT::f64:
1602         Opcode = NVPTX::ST_f64_ari_64;
1603         break;
1604       default:
1605         return NULL;
1606       }
1607     } else {
1608       switch (SourceVT) {
1609       case MVT::i8:
1610         Opcode = NVPTX::ST_i8_ari;
1611         break;
1612       case MVT::i16:
1613         Opcode = NVPTX::ST_i16_ari;
1614         break;
1615       case MVT::i32:
1616         Opcode = NVPTX::ST_i32_ari;
1617         break;
1618       case MVT::i64:
1619         Opcode = NVPTX::ST_i64_ari;
1620         break;
1621       case MVT::f32:
1622         Opcode = NVPTX::ST_f32_ari;
1623         break;
1624       case MVT::f64:
1625         Opcode = NVPTX::ST_f64_ari;
1626         break;
1627       default:
1628         return NULL;
1629       }
1630     }
1631     SDValue Ops[] = { N1, getI32Imm(isVolatile), getI32Imm(codeAddrSpace),
1632                       getI32Imm(vecType), getI32Imm(toType),
1633                       getI32Imm(toTypeWidth), Base, Offset, Chain };
1634     NVPTXST = CurDAG->getMachineNode(Opcode, dl, MVT::Other, Ops);
1635   } else {
1636     if (Subtarget.is64Bit()) {
1637       switch (SourceVT) {
1638       case MVT::i8:
1639         Opcode = NVPTX::ST_i8_areg_64;
1640         break;
1641       case MVT::i16:
1642         Opcode = NVPTX::ST_i16_areg_64;
1643         break;
1644       case MVT::i32:
1645         Opcode = NVPTX::ST_i32_areg_64;
1646         break;
1647       case MVT::i64:
1648         Opcode = NVPTX::ST_i64_areg_64;
1649         break;
1650       case MVT::f32:
1651         Opcode = NVPTX::ST_f32_areg_64;
1652         break;
1653       case MVT::f64:
1654         Opcode = NVPTX::ST_f64_areg_64;
1655         break;
1656       default:
1657         return NULL;
1658       }
1659     } else {
1660       switch (SourceVT) {
1661       case MVT::i8:
1662         Opcode = NVPTX::ST_i8_areg;
1663         break;
1664       case MVT::i16:
1665         Opcode = NVPTX::ST_i16_areg;
1666         break;
1667       case MVT::i32:
1668         Opcode = NVPTX::ST_i32_areg;
1669         break;
1670       case MVT::i64:
1671         Opcode = NVPTX::ST_i64_areg;
1672         break;
1673       case MVT::f32:
1674         Opcode = NVPTX::ST_f32_areg;
1675         break;
1676       case MVT::f64:
1677         Opcode = NVPTX::ST_f64_areg;
1678         break;
1679       default:
1680         return NULL;
1681       }
1682     }
1683     SDValue Ops[] = { N1, getI32Imm(isVolatile), getI32Imm(codeAddrSpace),
1684                       getI32Imm(vecType), getI32Imm(toType),
1685                       getI32Imm(toTypeWidth), N2, Chain };
1686     NVPTXST = CurDAG->getMachineNode(Opcode, dl, MVT::Other, Ops);
1687   }
1688
1689   if (NVPTXST != NULL) {
1690     MachineSDNode::mmo_iterator MemRefs0 = MF->allocateMemRefsArray(1);
1691     MemRefs0[0] = cast<MemSDNode>(N)->getMemOperand();
1692     cast<MachineSDNode>(NVPTXST)->setMemRefs(MemRefs0, MemRefs0 + 1);
1693   }
1694
1695   return NVPTXST;
1696 }
1697
1698 SDNode *NVPTXDAGToDAGISel::SelectStoreVector(SDNode *N) {
1699   SDValue Chain = N->getOperand(0);
1700   SDValue Op1 = N->getOperand(1);
1701   SDValue Addr, Offset, Base;
1702   unsigned Opcode;
1703   SDLoc DL(N);
1704   SDNode *ST;
1705   EVT EltVT = Op1.getValueType();
1706   MemSDNode *MemSD = cast<MemSDNode>(N);
1707   EVT StoreVT = MemSD->getMemoryVT();
1708
1709   // Address Space Setting
1710   unsigned CodeAddrSpace = getCodeAddrSpace(MemSD, Subtarget);
1711
1712   if (CodeAddrSpace == NVPTX::PTXLdStInstCode::CONSTANT) {
1713     report_fatal_error("Cannot store to pointer that points to constant "
1714                        "memory space");
1715   }
1716
1717   // Volatile Setting
1718   // - .volatile is only availalble for .global and .shared
1719   bool IsVolatile = MemSD->isVolatile();
1720   if (CodeAddrSpace != NVPTX::PTXLdStInstCode::GLOBAL &&
1721       CodeAddrSpace != NVPTX::PTXLdStInstCode::SHARED &&
1722       CodeAddrSpace != NVPTX::PTXLdStInstCode::GENERIC)
1723     IsVolatile = false;
1724
1725   // Type Setting: toType + toTypeWidth
1726   // - for integer type, always use 'u'
1727   assert(StoreVT.isSimple() && "Store value is not simple");
1728   MVT ScalarVT = StoreVT.getSimpleVT().getScalarType();
1729   unsigned ToTypeWidth = ScalarVT.getSizeInBits();
1730   unsigned ToType;
1731   if (ScalarVT.isFloatingPoint())
1732     ToType = NVPTX::PTXLdStInstCode::Float;
1733   else
1734     ToType = NVPTX::PTXLdStInstCode::Unsigned;
1735
1736   SmallVector<SDValue, 12> StOps;
1737   SDValue N2;
1738   unsigned VecType;
1739
1740   switch (N->getOpcode()) {
1741   case NVPTXISD::StoreV2:
1742     VecType = NVPTX::PTXLdStInstCode::V2;
1743     StOps.push_back(N->getOperand(1));
1744     StOps.push_back(N->getOperand(2));
1745     N2 = N->getOperand(3);
1746     break;
1747   case NVPTXISD::StoreV4:
1748     VecType = NVPTX::PTXLdStInstCode::V4;
1749     StOps.push_back(N->getOperand(1));
1750     StOps.push_back(N->getOperand(2));
1751     StOps.push_back(N->getOperand(3));
1752     StOps.push_back(N->getOperand(4));
1753     N2 = N->getOperand(5);
1754     break;
1755   default:
1756     return NULL;
1757   }
1758
1759   StOps.push_back(getI32Imm(IsVolatile));
1760   StOps.push_back(getI32Imm(CodeAddrSpace));
1761   StOps.push_back(getI32Imm(VecType));
1762   StOps.push_back(getI32Imm(ToType));
1763   StOps.push_back(getI32Imm(ToTypeWidth));
1764
1765   if (SelectDirectAddr(N2, Addr)) {
1766     switch (N->getOpcode()) {
1767     default:
1768       return NULL;
1769     case NVPTXISD::StoreV2:
1770       switch (EltVT.getSimpleVT().SimpleTy) {
1771       default:
1772         return NULL;
1773       case MVT::i8:
1774         Opcode = NVPTX::STV_i8_v2_avar;
1775         break;
1776       case MVT::i16:
1777         Opcode = NVPTX::STV_i16_v2_avar;
1778         break;
1779       case MVT::i32:
1780         Opcode = NVPTX::STV_i32_v2_avar;
1781         break;
1782       case MVT::i64:
1783         Opcode = NVPTX::STV_i64_v2_avar;
1784         break;
1785       case MVT::f32:
1786         Opcode = NVPTX::STV_f32_v2_avar;
1787         break;
1788       case MVT::f64:
1789         Opcode = NVPTX::STV_f64_v2_avar;
1790         break;
1791       }
1792       break;
1793     case NVPTXISD::StoreV4:
1794       switch (EltVT.getSimpleVT().SimpleTy) {
1795       default:
1796         return NULL;
1797       case MVT::i8:
1798         Opcode = NVPTX::STV_i8_v4_avar;
1799         break;
1800       case MVT::i16:
1801         Opcode = NVPTX::STV_i16_v4_avar;
1802         break;
1803       case MVT::i32:
1804         Opcode = NVPTX::STV_i32_v4_avar;
1805         break;
1806       case MVT::f32:
1807         Opcode = NVPTX::STV_f32_v4_avar;
1808         break;
1809       }
1810       break;
1811     }
1812     StOps.push_back(Addr);
1813   } else if (Subtarget.is64Bit()
1814                  ? SelectADDRsi64(N2.getNode(), N2, Base, Offset)
1815                  : SelectADDRsi(N2.getNode(), N2, Base, Offset)) {
1816     switch (N->getOpcode()) {
1817     default:
1818       return NULL;
1819     case NVPTXISD::StoreV2:
1820       switch (EltVT.getSimpleVT().SimpleTy) {
1821       default:
1822         return NULL;
1823       case MVT::i8:
1824         Opcode = NVPTX::STV_i8_v2_asi;
1825         break;
1826       case MVT::i16:
1827         Opcode = NVPTX::STV_i16_v2_asi;
1828         break;
1829       case MVT::i32:
1830         Opcode = NVPTX::STV_i32_v2_asi;
1831         break;
1832       case MVT::i64:
1833         Opcode = NVPTX::STV_i64_v2_asi;
1834         break;
1835       case MVT::f32:
1836         Opcode = NVPTX::STV_f32_v2_asi;
1837         break;
1838       case MVT::f64:
1839         Opcode = NVPTX::STV_f64_v2_asi;
1840         break;
1841       }
1842       break;
1843     case NVPTXISD::StoreV4:
1844       switch (EltVT.getSimpleVT().SimpleTy) {
1845       default:
1846         return NULL;
1847       case MVT::i8:
1848         Opcode = NVPTX::STV_i8_v4_asi;
1849         break;
1850       case MVT::i16:
1851         Opcode = NVPTX::STV_i16_v4_asi;
1852         break;
1853       case MVT::i32:
1854         Opcode = NVPTX::STV_i32_v4_asi;
1855         break;
1856       case MVT::f32:
1857         Opcode = NVPTX::STV_f32_v4_asi;
1858         break;
1859       }
1860       break;
1861     }
1862     StOps.push_back(Base);
1863     StOps.push_back(Offset);
1864   } else if (Subtarget.is64Bit()
1865                  ? SelectADDRri64(N2.getNode(), N2, Base, Offset)
1866                  : SelectADDRri(N2.getNode(), N2, Base, Offset)) {
1867     if (Subtarget.is64Bit()) {
1868       switch (N->getOpcode()) {
1869       default:
1870         return NULL;
1871       case NVPTXISD::StoreV2:
1872         switch (EltVT.getSimpleVT().SimpleTy) {
1873         default:
1874           return NULL;
1875         case MVT::i8:
1876           Opcode = NVPTX::STV_i8_v2_ari_64;
1877           break;
1878         case MVT::i16:
1879           Opcode = NVPTX::STV_i16_v2_ari_64;
1880           break;
1881         case MVT::i32:
1882           Opcode = NVPTX::STV_i32_v2_ari_64;
1883           break;
1884         case MVT::i64:
1885           Opcode = NVPTX::STV_i64_v2_ari_64;
1886           break;
1887         case MVT::f32:
1888           Opcode = NVPTX::STV_f32_v2_ari_64;
1889           break;
1890         case MVT::f64:
1891           Opcode = NVPTX::STV_f64_v2_ari_64;
1892           break;
1893         }
1894         break;
1895       case NVPTXISD::StoreV4:
1896         switch (EltVT.getSimpleVT().SimpleTy) {
1897         default:
1898           return NULL;
1899         case MVT::i8:
1900           Opcode = NVPTX::STV_i8_v4_ari_64;
1901           break;
1902         case MVT::i16:
1903           Opcode = NVPTX::STV_i16_v4_ari_64;
1904           break;
1905         case MVT::i32:
1906           Opcode = NVPTX::STV_i32_v4_ari_64;
1907           break;
1908         case MVT::f32:
1909           Opcode = NVPTX::STV_f32_v4_ari_64;
1910           break;
1911         }
1912         break;
1913       }
1914     } else {
1915       switch (N->getOpcode()) {
1916       default:
1917         return NULL;
1918       case NVPTXISD::StoreV2:
1919         switch (EltVT.getSimpleVT().SimpleTy) {
1920         default:
1921           return NULL;
1922         case MVT::i8:
1923           Opcode = NVPTX::STV_i8_v2_ari;
1924           break;
1925         case MVT::i16:
1926           Opcode = NVPTX::STV_i16_v2_ari;
1927           break;
1928         case MVT::i32:
1929           Opcode = NVPTX::STV_i32_v2_ari;
1930           break;
1931         case MVT::i64:
1932           Opcode = NVPTX::STV_i64_v2_ari;
1933           break;
1934         case MVT::f32:
1935           Opcode = NVPTX::STV_f32_v2_ari;
1936           break;
1937         case MVT::f64:
1938           Opcode = NVPTX::STV_f64_v2_ari;
1939           break;
1940         }
1941         break;
1942       case NVPTXISD::StoreV4:
1943         switch (EltVT.getSimpleVT().SimpleTy) {
1944         default:
1945           return NULL;
1946         case MVT::i8:
1947           Opcode = NVPTX::STV_i8_v4_ari;
1948           break;
1949         case MVT::i16:
1950           Opcode = NVPTX::STV_i16_v4_ari;
1951           break;
1952         case MVT::i32:
1953           Opcode = NVPTX::STV_i32_v4_ari;
1954           break;
1955         case MVT::f32:
1956           Opcode = NVPTX::STV_f32_v4_ari;
1957           break;
1958         }
1959         break;
1960       }
1961     }
1962     StOps.push_back(Base);
1963     StOps.push_back(Offset);
1964   } else {
1965     if (Subtarget.is64Bit()) {
1966       switch (N->getOpcode()) {
1967       default:
1968         return NULL;
1969       case NVPTXISD::StoreV2:
1970         switch (EltVT.getSimpleVT().SimpleTy) {
1971         default:
1972           return NULL;
1973         case MVT::i8:
1974           Opcode = NVPTX::STV_i8_v2_areg_64;
1975           break;
1976         case MVT::i16:
1977           Opcode = NVPTX::STV_i16_v2_areg_64;
1978           break;
1979         case MVT::i32:
1980           Opcode = NVPTX::STV_i32_v2_areg_64;
1981           break;
1982         case MVT::i64:
1983           Opcode = NVPTX::STV_i64_v2_areg_64;
1984           break;
1985         case MVT::f32:
1986           Opcode = NVPTX::STV_f32_v2_areg_64;
1987           break;
1988         case MVT::f64:
1989           Opcode = NVPTX::STV_f64_v2_areg_64;
1990           break;
1991         }
1992         break;
1993       case NVPTXISD::StoreV4:
1994         switch (EltVT.getSimpleVT().SimpleTy) {
1995         default:
1996           return NULL;
1997         case MVT::i8:
1998           Opcode = NVPTX::STV_i8_v4_areg_64;
1999           break;
2000         case MVT::i16:
2001           Opcode = NVPTX::STV_i16_v4_areg_64;
2002           break;
2003         case MVT::i32:
2004           Opcode = NVPTX::STV_i32_v4_areg_64;
2005           break;
2006         case MVT::f32:
2007           Opcode = NVPTX::STV_f32_v4_areg_64;
2008           break;
2009         }
2010         break;
2011       }
2012     } else {
2013       switch (N->getOpcode()) {
2014       default:
2015         return NULL;
2016       case NVPTXISD::StoreV2:
2017         switch (EltVT.getSimpleVT().SimpleTy) {
2018         default:
2019           return NULL;
2020         case MVT::i8:
2021           Opcode = NVPTX::STV_i8_v2_areg;
2022           break;
2023         case MVT::i16:
2024           Opcode = NVPTX::STV_i16_v2_areg;
2025           break;
2026         case MVT::i32:
2027           Opcode = NVPTX::STV_i32_v2_areg;
2028           break;
2029         case MVT::i64:
2030           Opcode = NVPTX::STV_i64_v2_areg;
2031           break;
2032         case MVT::f32:
2033           Opcode = NVPTX::STV_f32_v2_areg;
2034           break;
2035         case MVT::f64:
2036           Opcode = NVPTX::STV_f64_v2_areg;
2037           break;
2038         }
2039         break;
2040       case NVPTXISD::StoreV4:
2041         switch (EltVT.getSimpleVT().SimpleTy) {
2042         default:
2043           return NULL;
2044         case MVT::i8:
2045           Opcode = NVPTX::STV_i8_v4_areg;
2046           break;
2047         case MVT::i16:
2048           Opcode = NVPTX::STV_i16_v4_areg;
2049           break;
2050         case MVT::i32:
2051           Opcode = NVPTX::STV_i32_v4_areg;
2052           break;
2053         case MVT::f32:
2054           Opcode = NVPTX::STV_f32_v4_areg;
2055           break;
2056         }
2057         break;
2058       }
2059     }
2060     StOps.push_back(N2);
2061   }
2062
2063   StOps.push_back(Chain);
2064
2065   ST = CurDAG->getMachineNode(Opcode, DL, MVT::Other, StOps);
2066
2067   MachineSDNode::mmo_iterator MemRefs0 = MF->allocateMemRefsArray(1);
2068   MemRefs0[0] = cast<MemSDNode>(N)->getMemOperand();
2069   cast<MachineSDNode>(ST)->setMemRefs(MemRefs0, MemRefs0 + 1);
2070
2071   return ST;
2072 }
2073
2074 SDNode *NVPTXDAGToDAGISel::SelectLoadParam(SDNode *Node) {
2075   SDValue Chain = Node->getOperand(0);
2076   SDValue Offset = Node->getOperand(2);
2077   SDValue Flag = Node->getOperand(3);
2078   SDLoc DL(Node);
2079   MemSDNode *Mem = cast<MemSDNode>(Node);
2080
2081   unsigned VecSize;
2082   switch (Node->getOpcode()) {
2083   default:
2084     return NULL;
2085   case NVPTXISD::LoadParam:
2086     VecSize = 1;
2087     break;
2088   case NVPTXISD::LoadParamV2:
2089     VecSize = 2;
2090     break;
2091   case NVPTXISD::LoadParamV4:
2092     VecSize = 4;
2093     break;
2094   }
2095
2096   EVT EltVT = Node->getValueType(0);
2097   EVT MemVT = Mem->getMemoryVT();
2098
2099   unsigned Opc = 0;
2100
2101   switch (VecSize) {
2102   default:
2103     return NULL;
2104   case 1:
2105     switch (MemVT.getSimpleVT().SimpleTy) {
2106     default:
2107       return NULL;
2108     case MVT::i1:
2109       Opc = NVPTX::LoadParamMemI8;
2110       break;
2111     case MVT::i8:
2112       Opc = NVPTX::LoadParamMemI8;
2113       break;
2114     case MVT::i16:
2115       Opc = NVPTX::LoadParamMemI16;
2116       break;
2117     case MVT::i32:
2118       Opc = NVPTX::LoadParamMemI32;
2119       break;
2120     case MVT::i64:
2121       Opc = NVPTX::LoadParamMemI64;
2122       break;
2123     case MVT::f32:
2124       Opc = NVPTX::LoadParamMemF32;
2125       break;
2126     case MVT::f64:
2127       Opc = NVPTX::LoadParamMemF64;
2128       break;
2129     }
2130     break;
2131   case 2:
2132     switch (MemVT.getSimpleVT().SimpleTy) {
2133     default:
2134       return NULL;
2135     case MVT::i1:
2136       Opc = NVPTX::LoadParamMemV2I8;
2137       break;
2138     case MVT::i8:
2139       Opc = NVPTX::LoadParamMemV2I8;
2140       break;
2141     case MVT::i16:
2142       Opc = NVPTX::LoadParamMemV2I16;
2143       break;
2144     case MVT::i32:
2145       Opc = NVPTX::LoadParamMemV2I32;
2146       break;
2147     case MVT::i64:
2148       Opc = NVPTX::LoadParamMemV2I64;
2149       break;
2150     case MVT::f32:
2151       Opc = NVPTX::LoadParamMemV2F32;
2152       break;
2153     case MVT::f64:
2154       Opc = NVPTX::LoadParamMemV2F64;
2155       break;
2156     }
2157     break;
2158   case 4:
2159     switch (MemVT.getSimpleVT().SimpleTy) {
2160     default:
2161       return NULL;
2162     case MVT::i1:
2163       Opc = NVPTX::LoadParamMemV4I8;
2164       break;
2165     case MVT::i8:
2166       Opc = NVPTX::LoadParamMemV4I8;
2167       break;
2168     case MVT::i16:
2169       Opc = NVPTX::LoadParamMemV4I16;
2170       break;
2171     case MVT::i32:
2172       Opc = NVPTX::LoadParamMemV4I32;
2173       break;
2174     case MVT::f32:
2175       Opc = NVPTX::LoadParamMemV4F32;
2176       break;
2177     }
2178     break;
2179   }
2180
2181   SDVTList VTs;
2182   if (VecSize == 1) {
2183     VTs = CurDAG->getVTList(EltVT, MVT::Other, MVT::Glue);
2184   } else if (VecSize == 2) {
2185     VTs = CurDAG->getVTList(EltVT, EltVT, MVT::Other, MVT::Glue);
2186   } else {
2187     EVT EVTs[] = { EltVT, EltVT, EltVT, EltVT, MVT::Other, MVT::Glue };
2188     VTs = CurDAG->getVTList(EVTs);
2189   }
2190
2191   unsigned OffsetVal = cast<ConstantSDNode>(Offset)->getZExtValue();
2192
2193   SmallVector<SDValue, 2> Ops;
2194   Ops.push_back(CurDAG->getTargetConstant(OffsetVal, MVT::i32));
2195   Ops.push_back(Chain);
2196   Ops.push_back(Flag);
2197
2198   SDNode *Ret =
2199       CurDAG->getMachineNode(Opc, DL, VTs, Ops);
2200   return Ret;
2201 }
2202
2203 SDNode *NVPTXDAGToDAGISel::SelectStoreRetval(SDNode *N) {
2204   SDLoc DL(N);
2205   SDValue Chain = N->getOperand(0);
2206   SDValue Offset = N->getOperand(1);
2207   unsigned OffsetVal = cast<ConstantSDNode>(Offset)->getZExtValue();
2208   MemSDNode *Mem = cast<MemSDNode>(N);
2209
2210   // How many elements do we have?
2211   unsigned NumElts = 1;
2212   switch (N->getOpcode()) {
2213   default:
2214     return NULL;
2215   case NVPTXISD::StoreRetval:
2216     NumElts = 1;
2217     break;
2218   case NVPTXISD::StoreRetvalV2:
2219     NumElts = 2;
2220     break;
2221   case NVPTXISD::StoreRetvalV4:
2222     NumElts = 4;
2223     break;
2224   }
2225
2226   // Build vector of operands
2227   SmallVector<SDValue, 6> Ops;
2228   for (unsigned i = 0; i < NumElts; ++i)
2229     Ops.push_back(N->getOperand(i + 2));
2230   Ops.push_back(CurDAG->getTargetConstant(OffsetVal, MVT::i32));
2231   Ops.push_back(Chain);
2232
2233   // Determine target opcode
2234   // If we have an i1, use an 8-bit store. The lowering code in
2235   // NVPTXISelLowering will have already emitted an upcast.
2236   unsigned Opcode = 0;
2237   switch (NumElts) {
2238   default:
2239     return NULL;
2240   case 1:
2241     switch (Mem->getMemoryVT().getSimpleVT().SimpleTy) {
2242     default:
2243       return NULL;
2244     case MVT::i1:
2245       Opcode = NVPTX::StoreRetvalI8;
2246       break;
2247     case MVT::i8:
2248       Opcode = NVPTX::StoreRetvalI8;
2249       break;
2250     case MVT::i16:
2251       Opcode = NVPTX::StoreRetvalI16;
2252       break;
2253     case MVT::i32:
2254       Opcode = NVPTX::StoreRetvalI32;
2255       break;
2256     case MVT::i64:
2257       Opcode = NVPTX::StoreRetvalI64;
2258       break;
2259     case MVT::f32:
2260       Opcode = NVPTX::StoreRetvalF32;
2261       break;
2262     case MVT::f64:
2263       Opcode = NVPTX::StoreRetvalF64;
2264       break;
2265     }
2266     break;
2267   case 2:
2268     switch (Mem->getMemoryVT().getSimpleVT().SimpleTy) {
2269     default:
2270       return NULL;
2271     case MVT::i1:
2272       Opcode = NVPTX::StoreRetvalV2I8;
2273       break;
2274     case MVT::i8:
2275       Opcode = NVPTX::StoreRetvalV2I8;
2276       break;
2277     case MVT::i16:
2278       Opcode = NVPTX::StoreRetvalV2I16;
2279       break;
2280     case MVT::i32:
2281       Opcode = NVPTX::StoreRetvalV2I32;
2282       break;
2283     case MVT::i64:
2284       Opcode = NVPTX::StoreRetvalV2I64;
2285       break;
2286     case MVT::f32:
2287       Opcode = NVPTX::StoreRetvalV2F32;
2288       break;
2289     case MVT::f64:
2290       Opcode = NVPTX::StoreRetvalV2F64;
2291       break;
2292     }
2293     break;
2294   case 4:
2295     switch (Mem->getMemoryVT().getSimpleVT().SimpleTy) {
2296     default:
2297       return NULL;
2298     case MVT::i1:
2299       Opcode = NVPTX::StoreRetvalV4I8;
2300       break;
2301     case MVT::i8:
2302       Opcode = NVPTX::StoreRetvalV4I8;
2303       break;
2304     case MVT::i16:
2305       Opcode = NVPTX::StoreRetvalV4I16;
2306       break;
2307     case MVT::i32:
2308       Opcode = NVPTX::StoreRetvalV4I32;
2309       break;
2310     case MVT::f32:
2311       Opcode = NVPTX::StoreRetvalV4F32;
2312       break;
2313     }
2314     break;
2315   }
2316
2317   SDNode *Ret =
2318       CurDAG->getMachineNode(Opcode, DL, MVT::Other, Ops);
2319   MachineSDNode::mmo_iterator MemRefs0 = MF->allocateMemRefsArray(1);
2320   MemRefs0[0] = cast<MemSDNode>(N)->getMemOperand();
2321   cast<MachineSDNode>(Ret)->setMemRefs(MemRefs0, MemRefs0 + 1);
2322
2323   return Ret;
2324 }
2325
2326 SDNode *NVPTXDAGToDAGISel::SelectStoreParam(SDNode *N) {
2327   SDLoc DL(N);
2328   SDValue Chain = N->getOperand(0);
2329   SDValue Param = N->getOperand(1);
2330   unsigned ParamVal = cast<ConstantSDNode>(Param)->getZExtValue();
2331   SDValue Offset = N->getOperand(2);
2332   unsigned OffsetVal = cast<ConstantSDNode>(Offset)->getZExtValue();
2333   MemSDNode *Mem = cast<MemSDNode>(N);
2334   SDValue Flag = N->getOperand(N->getNumOperands() - 1);
2335
2336   // How many elements do we have?
2337   unsigned NumElts = 1;
2338   switch (N->getOpcode()) {
2339   default:
2340     return NULL;
2341   case NVPTXISD::StoreParamU32:
2342   case NVPTXISD::StoreParamS32:
2343   case NVPTXISD::StoreParam:
2344     NumElts = 1;
2345     break;
2346   case NVPTXISD::StoreParamV2:
2347     NumElts = 2;
2348     break;
2349   case NVPTXISD::StoreParamV4:
2350     NumElts = 4;
2351     break;
2352   }
2353
2354   // Build vector of operands
2355   SmallVector<SDValue, 8> Ops;
2356   for (unsigned i = 0; i < NumElts; ++i)
2357     Ops.push_back(N->getOperand(i + 3));
2358   Ops.push_back(CurDAG->getTargetConstant(ParamVal, MVT::i32));
2359   Ops.push_back(CurDAG->getTargetConstant(OffsetVal, MVT::i32));
2360   Ops.push_back(Chain);
2361   Ops.push_back(Flag);
2362
2363   // Determine target opcode
2364   // If we have an i1, use an 8-bit store. The lowering code in
2365   // NVPTXISelLowering will have already emitted an upcast.
2366   unsigned Opcode = 0;
2367   switch (N->getOpcode()) {
2368   default:
2369     switch (NumElts) {
2370     default:
2371       return NULL;
2372     case 1:
2373       switch (Mem->getMemoryVT().getSimpleVT().SimpleTy) {
2374       default:
2375         return NULL;
2376       case MVT::i1:
2377         Opcode = NVPTX::StoreParamI8;
2378         break;
2379       case MVT::i8:
2380         Opcode = NVPTX::StoreParamI8;
2381         break;
2382       case MVT::i16:
2383         Opcode = NVPTX::StoreParamI16;
2384         break;
2385       case MVT::i32:
2386         Opcode = NVPTX::StoreParamI32;
2387         break;
2388       case MVT::i64:
2389         Opcode = NVPTX::StoreParamI64;
2390         break;
2391       case MVT::f32:
2392         Opcode = NVPTX::StoreParamF32;
2393         break;
2394       case MVT::f64:
2395         Opcode = NVPTX::StoreParamF64;
2396         break;
2397       }
2398       break;
2399     case 2:
2400       switch (Mem->getMemoryVT().getSimpleVT().SimpleTy) {
2401       default:
2402         return NULL;
2403       case MVT::i1:
2404         Opcode = NVPTX::StoreParamV2I8;
2405         break;
2406       case MVT::i8:
2407         Opcode = NVPTX::StoreParamV2I8;
2408         break;
2409       case MVT::i16:
2410         Opcode = NVPTX::StoreParamV2I16;
2411         break;
2412       case MVT::i32:
2413         Opcode = NVPTX::StoreParamV2I32;
2414         break;
2415       case MVT::i64:
2416         Opcode = NVPTX::StoreParamV2I64;
2417         break;
2418       case MVT::f32:
2419         Opcode = NVPTX::StoreParamV2F32;
2420         break;
2421       case MVT::f64:
2422         Opcode = NVPTX::StoreParamV2F64;
2423         break;
2424       }
2425       break;
2426     case 4:
2427       switch (Mem->getMemoryVT().getSimpleVT().SimpleTy) {
2428       default:
2429         return NULL;
2430       case MVT::i1:
2431         Opcode = NVPTX::StoreParamV4I8;
2432         break;
2433       case MVT::i8:
2434         Opcode = NVPTX::StoreParamV4I8;
2435         break;
2436       case MVT::i16:
2437         Opcode = NVPTX::StoreParamV4I16;
2438         break;
2439       case MVT::i32:
2440         Opcode = NVPTX::StoreParamV4I32;
2441         break;
2442       case MVT::f32:
2443         Opcode = NVPTX::StoreParamV4F32;
2444         break;
2445       }
2446       break;
2447     }
2448     break;
2449   // Special case: if we have a sign-extend/zero-extend node, insert the
2450   // conversion instruction first, and use that as the value operand to
2451   // the selected StoreParam node.
2452   case NVPTXISD::StoreParamU32: {
2453     Opcode = NVPTX::StoreParamI32;
2454     SDValue CvtNone = CurDAG->getTargetConstant(NVPTX::PTXCvtMode::NONE,
2455                                                 MVT::i32);
2456     SDNode *Cvt = CurDAG->getMachineNode(NVPTX::CVT_u32_u16, DL,
2457                                          MVT::i32, Ops[0], CvtNone);
2458     Ops[0] = SDValue(Cvt, 0);
2459     break;
2460   }
2461   case NVPTXISD::StoreParamS32: {
2462     Opcode = NVPTX::StoreParamI32;
2463     SDValue CvtNone = CurDAG->getTargetConstant(NVPTX::PTXCvtMode::NONE,
2464                                                 MVT::i32);
2465     SDNode *Cvt = CurDAG->getMachineNode(NVPTX::CVT_s32_s16, DL,
2466                                          MVT::i32, Ops[0], CvtNone);
2467     Ops[0] = SDValue(Cvt, 0);
2468     break;
2469   }
2470   }
2471
2472   SDVTList RetVTs = CurDAG->getVTList(MVT::Other, MVT::Glue);
2473   SDNode *Ret =
2474       CurDAG->getMachineNode(Opcode, DL, RetVTs, Ops);
2475   MachineSDNode::mmo_iterator MemRefs0 = MF->allocateMemRefsArray(1);
2476   MemRefs0[0] = cast<MemSDNode>(N)->getMemOperand();
2477   cast<MachineSDNode>(Ret)->setMemRefs(MemRefs0, MemRefs0 + 1);
2478
2479   return Ret;
2480 }
2481
2482 SDNode *NVPTXDAGToDAGISel::SelectTextureIntrinsic(SDNode *N) {
2483   SDValue Chain = N->getOperand(0);
2484   SDValue TexRef = N->getOperand(1);
2485   SDValue SampRef = N->getOperand(2);
2486   SDNode *Ret = NULL;
2487   unsigned Opc = 0;
2488   SmallVector<SDValue, 8> Ops;
2489
2490   switch (N->getOpcode()) {
2491   default: return NULL;
2492   case NVPTXISD::Tex1DFloatI32:
2493     Opc = NVPTX::TEX_1D_F32_I32;
2494     break;
2495   case NVPTXISD::Tex1DFloatFloat:
2496     Opc = NVPTX::TEX_1D_F32_F32;
2497     break;
2498   case NVPTXISD::Tex1DFloatFloatLevel:
2499     Opc = NVPTX::TEX_1D_F32_F32_LEVEL;
2500     break;
2501   case NVPTXISD::Tex1DFloatFloatGrad:
2502     Opc = NVPTX::TEX_1D_F32_F32_GRAD;
2503     break;
2504   case NVPTXISD::Tex1DI32I32:
2505     Opc = NVPTX::TEX_1D_I32_I32;
2506     break;
2507   case NVPTXISD::Tex1DI32Float:
2508     Opc = NVPTX::TEX_1D_I32_F32;
2509     break;
2510   case NVPTXISD::Tex1DI32FloatLevel:
2511     Opc = NVPTX::TEX_1D_I32_F32_LEVEL;
2512     break;
2513   case NVPTXISD::Tex1DI32FloatGrad:
2514     Opc = NVPTX::TEX_1D_I32_F32_GRAD;
2515     break;
2516   case NVPTXISD::Tex1DArrayFloatI32:
2517     Opc = NVPTX::TEX_1D_ARRAY_F32_I32;
2518     break;
2519   case NVPTXISD::Tex1DArrayFloatFloat:
2520     Opc = NVPTX::TEX_1D_ARRAY_F32_F32;
2521     break;
2522   case NVPTXISD::Tex1DArrayFloatFloatLevel:
2523     Opc = NVPTX::TEX_1D_ARRAY_F32_F32_LEVEL;
2524     break;
2525   case NVPTXISD::Tex1DArrayFloatFloatGrad:
2526     Opc = NVPTX::TEX_1D_ARRAY_F32_F32_GRAD;
2527     break;
2528   case NVPTXISD::Tex1DArrayI32I32:
2529     Opc = NVPTX::TEX_1D_ARRAY_I32_I32;
2530     break;
2531   case NVPTXISD::Tex1DArrayI32Float:
2532     Opc = NVPTX::TEX_1D_ARRAY_I32_F32;
2533     break;
2534   case NVPTXISD::Tex1DArrayI32FloatLevel:
2535     Opc = NVPTX::TEX_1D_ARRAY_I32_F32_LEVEL;
2536     break;
2537   case NVPTXISD::Tex1DArrayI32FloatGrad:
2538     Opc = NVPTX::TEX_1D_ARRAY_I32_F32_GRAD;
2539     break;
2540   case NVPTXISD::Tex2DFloatI32:
2541     Opc = NVPTX::TEX_2D_F32_I32;
2542     break;
2543   case NVPTXISD::Tex2DFloatFloat:
2544     Opc = NVPTX::TEX_2D_F32_F32;
2545     break;
2546   case NVPTXISD::Tex2DFloatFloatLevel:
2547     Opc = NVPTX::TEX_2D_F32_F32_LEVEL;
2548     break;
2549   case NVPTXISD::Tex2DFloatFloatGrad:
2550     Opc = NVPTX::TEX_2D_F32_F32_GRAD;
2551     break;
2552   case NVPTXISD::Tex2DI32I32:
2553     Opc = NVPTX::TEX_2D_I32_I32;
2554     break;
2555   case NVPTXISD::Tex2DI32Float:
2556     Opc = NVPTX::TEX_2D_I32_F32;
2557     break;
2558   case NVPTXISD::Tex2DI32FloatLevel:
2559     Opc = NVPTX::TEX_2D_I32_F32_LEVEL;
2560     break;
2561   case NVPTXISD::Tex2DI32FloatGrad:
2562     Opc = NVPTX::TEX_2D_I32_F32_GRAD;
2563     break;
2564   case NVPTXISD::Tex2DArrayFloatI32:
2565     Opc = NVPTX::TEX_2D_ARRAY_F32_I32;
2566     break;
2567   case NVPTXISD::Tex2DArrayFloatFloat:
2568     Opc = NVPTX::TEX_2D_ARRAY_F32_F32;
2569     break;
2570   case NVPTXISD::Tex2DArrayFloatFloatLevel:
2571     Opc = NVPTX::TEX_2D_ARRAY_F32_F32_LEVEL;
2572     break;
2573   case NVPTXISD::Tex2DArrayFloatFloatGrad:
2574     Opc = NVPTX::TEX_2D_ARRAY_F32_F32_GRAD;
2575     break;
2576   case NVPTXISD::Tex2DArrayI32I32:
2577     Opc = NVPTX::TEX_2D_ARRAY_I32_I32;
2578     break;
2579   case NVPTXISD::Tex2DArrayI32Float:
2580     Opc = NVPTX::TEX_2D_ARRAY_I32_F32;
2581     break;
2582   case NVPTXISD::Tex2DArrayI32FloatLevel:
2583     Opc = NVPTX::TEX_2D_ARRAY_I32_F32_LEVEL;
2584     break;
2585   case NVPTXISD::Tex2DArrayI32FloatGrad:
2586     Opc = NVPTX::TEX_2D_ARRAY_I32_F32_GRAD;
2587     break;
2588   case NVPTXISD::Tex3DFloatI32:
2589     Opc = NVPTX::TEX_3D_F32_I32;
2590     break;
2591   case NVPTXISD::Tex3DFloatFloat:
2592     Opc = NVPTX::TEX_3D_F32_F32;
2593     break;
2594   case NVPTXISD::Tex3DFloatFloatLevel:
2595     Opc = NVPTX::TEX_3D_F32_F32_LEVEL;
2596     break;
2597   case NVPTXISD::Tex3DFloatFloatGrad:
2598     Opc = NVPTX::TEX_3D_F32_F32_GRAD;
2599     break;
2600   case NVPTXISD::Tex3DI32I32:
2601     Opc = NVPTX::TEX_3D_I32_I32;
2602     break;
2603   case NVPTXISD::Tex3DI32Float:
2604     Opc = NVPTX::TEX_3D_I32_F32;
2605     break;
2606   case NVPTXISD::Tex3DI32FloatLevel:
2607     Opc = NVPTX::TEX_3D_I32_F32_LEVEL;
2608     break;
2609   case NVPTXISD::Tex3DI32FloatGrad:
2610     Opc = NVPTX::TEX_3D_I32_F32_GRAD;
2611     break;
2612   }
2613
2614   Ops.push_back(TexRef);
2615   Ops.push_back(SampRef);
2616
2617   // Copy over indices
2618   for (unsigned i = 3; i < N->getNumOperands(); ++i) {
2619     Ops.push_back(N->getOperand(i));
2620   }
2621
2622   Ops.push_back(Chain);
2623   Ret = CurDAG->getMachineNode(Opc, SDLoc(N), N->getVTList(), Ops);
2624   return Ret;
2625 }
2626
2627 SDNode *NVPTXDAGToDAGISel::SelectSurfaceIntrinsic(SDNode *N) {
2628   SDValue Chain = N->getOperand(0);
2629   SDValue TexHandle = N->getOperand(1);
2630   SDNode *Ret = NULL;
2631   unsigned Opc = 0;
2632   SmallVector<SDValue, 8> Ops;
2633   switch (N->getOpcode()) {
2634   default: return NULL;
2635   case NVPTXISD::Suld1DI8Trap:
2636     Opc = NVPTX::SULD_1D_I8_TRAP;
2637     Ops.push_back(TexHandle);
2638     Ops.push_back(N->getOperand(2));
2639     Ops.push_back(Chain);
2640     break;
2641   case NVPTXISD::Suld1DI16Trap:
2642     Opc = NVPTX::SULD_1D_I16_TRAP;
2643     Ops.push_back(TexHandle);
2644     Ops.push_back(N->getOperand(2));
2645     Ops.push_back(Chain);
2646     break;
2647   case NVPTXISD::Suld1DI32Trap:
2648     Opc = NVPTX::SULD_1D_I32_TRAP;
2649     Ops.push_back(TexHandle);
2650     Ops.push_back(N->getOperand(2));
2651     Ops.push_back(Chain);
2652     break;
2653   case NVPTXISD::Suld1DV2I8Trap:
2654     Opc = NVPTX::SULD_1D_V2I8_TRAP;
2655     Ops.push_back(TexHandle);
2656     Ops.push_back(N->getOperand(2));
2657     Ops.push_back(Chain);
2658     break;
2659   case NVPTXISD::Suld1DV2I16Trap:
2660     Opc = NVPTX::SULD_1D_V2I16_TRAP;
2661     Ops.push_back(TexHandle);
2662     Ops.push_back(N->getOperand(2));
2663     Ops.push_back(Chain);
2664     break;
2665   case NVPTXISD::Suld1DV2I32Trap:
2666     Opc = NVPTX::SULD_1D_V2I32_TRAP;
2667     Ops.push_back(TexHandle);
2668     Ops.push_back(N->getOperand(2));
2669     Ops.push_back(Chain);
2670     break;
2671   case NVPTXISD::Suld1DV4I8Trap:
2672     Opc = NVPTX::SULD_1D_V4I8_TRAP;
2673     Ops.push_back(TexHandle);
2674     Ops.push_back(N->getOperand(2));
2675     Ops.push_back(Chain);
2676     break;
2677   case NVPTXISD::Suld1DV4I16Trap:
2678     Opc = NVPTX::SULD_1D_V4I16_TRAP;
2679     Ops.push_back(TexHandle);
2680     Ops.push_back(N->getOperand(2));
2681     Ops.push_back(Chain);
2682     break;
2683   case NVPTXISD::Suld1DV4I32Trap:
2684     Opc = NVPTX::SULD_1D_V4I32_TRAP;
2685     Ops.push_back(TexHandle);
2686     Ops.push_back(N->getOperand(2));
2687     Ops.push_back(Chain);
2688     break;
2689   case NVPTXISD::Suld1DArrayI8Trap:
2690     Opc = NVPTX::SULD_1D_ARRAY_I8_TRAP;
2691     Ops.push_back(TexHandle);
2692     Ops.push_back(N->getOperand(2));
2693     Ops.push_back(N->getOperand(3));
2694     Ops.push_back(Chain);
2695     break;
2696   case NVPTXISD::Suld1DArrayI16Trap:
2697     Opc = NVPTX::SULD_1D_ARRAY_I16_TRAP;
2698     Ops.push_back(TexHandle);
2699     Ops.push_back(N->getOperand(2));
2700     Ops.push_back(N->getOperand(3));
2701     Ops.push_back(Chain);
2702     break;
2703   case NVPTXISD::Suld1DArrayI32Trap:
2704     Opc = NVPTX::SULD_1D_ARRAY_I32_TRAP;
2705     Ops.push_back(TexHandle);
2706     Ops.push_back(N->getOperand(2));
2707     Ops.push_back(N->getOperand(3));
2708     Ops.push_back(Chain);
2709     break;
2710   case NVPTXISD::Suld1DArrayV2I8Trap:
2711     Opc = NVPTX::SULD_1D_ARRAY_V2I8_TRAP;
2712     Ops.push_back(TexHandle);
2713     Ops.push_back(N->getOperand(2));
2714     Ops.push_back(N->getOperand(3));
2715     Ops.push_back(Chain);
2716     break;
2717   case NVPTXISD::Suld1DArrayV2I16Trap:
2718     Opc = NVPTX::SULD_1D_ARRAY_V2I16_TRAP;
2719     Ops.push_back(TexHandle);
2720     Ops.push_back(N->getOperand(2));
2721     Ops.push_back(N->getOperand(3));
2722     Ops.push_back(Chain);
2723     break;
2724   case NVPTXISD::Suld1DArrayV2I32Trap:
2725     Opc = NVPTX::SULD_1D_ARRAY_V2I32_TRAP;
2726     Ops.push_back(TexHandle);
2727     Ops.push_back(N->getOperand(2));
2728     Ops.push_back(N->getOperand(3));
2729     Ops.push_back(Chain);
2730     break;
2731   case NVPTXISD::Suld1DArrayV4I8Trap:
2732     Opc = NVPTX::SULD_1D_ARRAY_V4I8_TRAP;
2733     Ops.push_back(TexHandle);
2734     Ops.push_back(N->getOperand(2));
2735     Ops.push_back(N->getOperand(3));
2736     Ops.push_back(Chain);
2737     break;
2738   case NVPTXISD::Suld1DArrayV4I16Trap:
2739     Opc = NVPTX::SULD_1D_ARRAY_V4I16_TRAP;
2740     Ops.push_back(TexHandle);
2741     Ops.push_back(N->getOperand(2));
2742     Ops.push_back(N->getOperand(3));
2743     Ops.push_back(Chain);
2744     break;
2745   case NVPTXISD::Suld1DArrayV4I32Trap:
2746     Opc = NVPTX::SULD_1D_ARRAY_V4I32_TRAP;
2747     Ops.push_back(TexHandle);
2748     Ops.push_back(N->getOperand(2));
2749     Ops.push_back(N->getOperand(3));
2750     Ops.push_back(Chain);
2751     break;
2752   case NVPTXISD::Suld2DI8Trap:
2753     Opc = NVPTX::SULD_2D_I8_TRAP;
2754     Ops.push_back(TexHandle);
2755     Ops.push_back(N->getOperand(2));
2756     Ops.push_back(N->getOperand(3));
2757     Ops.push_back(Chain);
2758     break;
2759   case NVPTXISD::Suld2DI16Trap:
2760     Opc = NVPTX::SULD_2D_I16_TRAP;
2761     Ops.push_back(TexHandle);
2762     Ops.push_back(N->getOperand(2));
2763     Ops.push_back(N->getOperand(3));
2764     Ops.push_back(Chain);
2765     break;
2766   case NVPTXISD::Suld2DI32Trap:
2767     Opc = NVPTX::SULD_2D_I32_TRAP;
2768     Ops.push_back(TexHandle);
2769     Ops.push_back(N->getOperand(2));
2770     Ops.push_back(N->getOperand(3));
2771     Ops.push_back(Chain);
2772     break;
2773   case NVPTXISD::Suld2DV2I8Trap:
2774     Opc = NVPTX::SULD_2D_V2I8_TRAP;
2775     Ops.push_back(TexHandle);
2776     Ops.push_back(N->getOperand(2));
2777     Ops.push_back(N->getOperand(3));
2778     Ops.push_back(Chain);
2779     break;
2780   case NVPTXISD::Suld2DV2I16Trap:
2781     Opc = NVPTX::SULD_2D_V2I16_TRAP;
2782     Ops.push_back(TexHandle);
2783     Ops.push_back(N->getOperand(2));
2784     Ops.push_back(N->getOperand(3));
2785     Ops.push_back(Chain);
2786     break;
2787   case NVPTXISD::Suld2DV2I32Trap:
2788     Opc = NVPTX::SULD_2D_V2I32_TRAP;
2789     Ops.push_back(TexHandle);
2790     Ops.push_back(N->getOperand(2));
2791     Ops.push_back(N->getOperand(3));
2792     Ops.push_back(Chain);
2793     break;
2794   case NVPTXISD::Suld2DV4I8Trap:
2795     Opc = NVPTX::SULD_2D_V4I8_TRAP;
2796     Ops.push_back(TexHandle);
2797     Ops.push_back(N->getOperand(2));
2798     Ops.push_back(N->getOperand(3));
2799     Ops.push_back(Chain);
2800     break;
2801   case NVPTXISD::Suld2DV4I16Trap:
2802     Opc = NVPTX::SULD_2D_V4I16_TRAP;
2803     Ops.push_back(TexHandle);
2804     Ops.push_back(N->getOperand(2));
2805     Ops.push_back(N->getOperand(3));
2806     Ops.push_back(Chain);
2807     break;
2808   case NVPTXISD::Suld2DV4I32Trap:
2809     Opc = NVPTX::SULD_2D_V4I32_TRAP;
2810     Ops.push_back(TexHandle);
2811     Ops.push_back(N->getOperand(2));
2812     Ops.push_back(N->getOperand(3));
2813     Ops.push_back(Chain);
2814     break;
2815   case NVPTXISD::Suld2DArrayI8Trap:
2816     Opc = NVPTX::SULD_2D_ARRAY_I8_TRAP;
2817     Ops.push_back(TexHandle);
2818     Ops.push_back(N->getOperand(2));
2819     Ops.push_back(N->getOperand(3));
2820     Ops.push_back(N->getOperand(4));
2821     Ops.push_back(Chain);
2822     break;
2823   case NVPTXISD::Suld2DArrayI16Trap:
2824     Opc = NVPTX::SULD_2D_ARRAY_I16_TRAP;
2825     Ops.push_back(TexHandle);
2826     Ops.push_back(N->getOperand(2));
2827     Ops.push_back(N->getOperand(3));
2828     Ops.push_back(N->getOperand(4));
2829     Ops.push_back(Chain);
2830     break;
2831   case NVPTXISD::Suld2DArrayI32Trap:
2832     Opc = NVPTX::SULD_2D_ARRAY_I32_TRAP;
2833     Ops.push_back(TexHandle);
2834     Ops.push_back(N->getOperand(2));
2835     Ops.push_back(N->getOperand(3));
2836     Ops.push_back(N->getOperand(4));
2837     Ops.push_back(Chain);
2838     break;
2839   case NVPTXISD::Suld2DArrayV2I8Trap:
2840     Opc = NVPTX::SULD_2D_ARRAY_V2I8_TRAP;
2841     Ops.push_back(TexHandle);
2842     Ops.push_back(N->getOperand(2));
2843     Ops.push_back(N->getOperand(3));
2844     Ops.push_back(N->getOperand(4));
2845     Ops.push_back(Chain);
2846     break;
2847   case NVPTXISD::Suld2DArrayV2I16Trap:
2848     Opc = NVPTX::SULD_2D_ARRAY_V2I16_TRAP;
2849     Ops.push_back(TexHandle);
2850     Ops.push_back(N->getOperand(2));
2851     Ops.push_back(N->getOperand(3));
2852     Ops.push_back(N->getOperand(4));
2853     Ops.push_back(Chain);
2854     break;
2855   case NVPTXISD::Suld2DArrayV2I32Trap:
2856     Opc = NVPTX::SULD_2D_ARRAY_V2I32_TRAP;
2857     Ops.push_back(TexHandle);
2858     Ops.push_back(N->getOperand(2));
2859     Ops.push_back(N->getOperand(3));
2860     Ops.push_back(N->getOperand(4));
2861     Ops.push_back(Chain);
2862     break;
2863   case NVPTXISD::Suld2DArrayV4I8Trap:
2864     Opc = NVPTX::SULD_2D_ARRAY_V4I8_TRAP;
2865     Ops.push_back(TexHandle);
2866     Ops.push_back(N->getOperand(2));
2867     Ops.push_back(N->getOperand(3));
2868     Ops.push_back(N->getOperand(4));
2869     Ops.push_back(Chain);
2870     break;
2871   case NVPTXISD::Suld2DArrayV4I16Trap:
2872     Opc = NVPTX::SULD_2D_ARRAY_V4I16_TRAP;
2873     Ops.push_back(TexHandle);
2874     Ops.push_back(N->getOperand(2));
2875     Ops.push_back(N->getOperand(3));
2876     Ops.push_back(N->getOperand(4));
2877     Ops.push_back(Chain);
2878     break;
2879   case NVPTXISD::Suld2DArrayV4I32Trap:
2880     Opc = NVPTX::SULD_2D_ARRAY_V4I32_TRAP;
2881     Ops.push_back(TexHandle);
2882     Ops.push_back(N->getOperand(2));
2883     Ops.push_back(N->getOperand(3));
2884     Ops.push_back(N->getOperand(4));
2885     Ops.push_back(Chain);
2886     break;
2887   case NVPTXISD::Suld3DI8Trap:
2888     Opc = NVPTX::SULD_3D_I8_TRAP;
2889     Ops.push_back(TexHandle);
2890     Ops.push_back(N->getOperand(2));
2891     Ops.push_back(N->getOperand(3));
2892     Ops.push_back(N->getOperand(4));
2893     Ops.push_back(Chain);
2894     break;
2895   case NVPTXISD::Suld3DI16Trap:
2896     Opc = NVPTX::SULD_3D_I16_TRAP;
2897     Ops.push_back(TexHandle);
2898     Ops.push_back(N->getOperand(2));
2899     Ops.push_back(N->getOperand(3));
2900     Ops.push_back(N->getOperand(4));
2901     Ops.push_back(Chain);
2902     break;
2903   case NVPTXISD::Suld3DI32Trap:
2904     Opc = NVPTX::SULD_3D_I32_TRAP;
2905     Ops.push_back(TexHandle);
2906     Ops.push_back(N->getOperand(2));
2907     Ops.push_back(N->getOperand(3));
2908     Ops.push_back(N->getOperand(4));
2909     Ops.push_back(Chain);
2910     break;
2911   case NVPTXISD::Suld3DV2I8Trap:
2912     Opc = NVPTX::SULD_3D_V2I8_TRAP;
2913     Ops.push_back(TexHandle);
2914     Ops.push_back(N->getOperand(2));
2915     Ops.push_back(N->getOperand(3));
2916     Ops.push_back(N->getOperand(4));
2917     Ops.push_back(Chain);
2918     break;
2919   case NVPTXISD::Suld3DV2I16Trap:
2920     Opc = NVPTX::SULD_3D_V2I16_TRAP;
2921     Ops.push_back(TexHandle);
2922     Ops.push_back(N->getOperand(2));
2923     Ops.push_back(N->getOperand(3));
2924     Ops.push_back(N->getOperand(4));
2925     Ops.push_back(Chain);
2926     break;
2927   case NVPTXISD::Suld3DV2I32Trap:
2928     Opc = NVPTX::SULD_3D_V2I32_TRAP;
2929     Ops.push_back(TexHandle);
2930     Ops.push_back(N->getOperand(2));
2931     Ops.push_back(N->getOperand(3));
2932     Ops.push_back(N->getOperand(4));
2933     Ops.push_back(Chain);
2934     break;
2935   case NVPTXISD::Suld3DV4I8Trap:
2936     Opc = NVPTX::SULD_3D_V4I8_TRAP;
2937     Ops.push_back(TexHandle);
2938     Ops.push_back(N->getOperand(2));
2939     Ops.push_back(N->getOperand(3));
2940     Ops.push_back(N->getOperand(4));
2941     Ops.push_back(Chain);
2942     break;
2943   case NVPTXISD::Suld3DV4I16Trap:
2944     Opc = NVPTX::SULD_3D_V4I16_TRAP;
2945     Ops.push_back(TexHandle);
2946     Ops.push_back(N->getOperand(2));
2947     Ops.push_back(N->getOperand(3));
2948     Ops.push_back(N->getOperand(4));
2949     Ops.push_back(Chain);
2950     break;
2951   case NVPTXISD::Suld3DV4I32Trap:
2952     Opc = NVPTX::SULD_3D_V4I32_TRAP;
2953     Ops.push_back(TexHandle);
2954     Ops.push_back(N->getOperand(2));
2955     Ops.push_back(N->getOperand(3));
2956     Ops.push_back(N->getOperand(4));
2957     Ops.push_back(Chain);
2958     break;
2959   }
2960   Ret = CurDAG->getMachineNode(Opc, SDLoc(N), N->getVTList(), Ops);
2961   return Ret;
2962 }
2963
2964 // SelectDirectAddr - Match a direct address for DAG.
2965 // A direct address could be a globaladdress or externalsymbol.
2966 bool NVPTXDAGToDAGISel::SelectDirectAddr(SDValue N, SDValue &Address) {
2967   // Return true if TGA or ES.
2968   if (N.getOpcode() == ISD::TargetGlobalAddress ||
2969       N.getOpcode() == ISD::TargetExternalSymbol) {
2970     Address = N;
2971     return true;
2972   }
2973   if (N.getOpcode() == NVPTXISD::Wrapper) {
2974     Address = N.getOperand(0);
2975     return true;
2976   }
2977   if (N.getOpcode() == ISD::INTRINSIC_WO_CHAIN) {
2978     unsigned IID = cast<ConstantSDNode>(N.getOperand(0))->getZExtValue();
2979     if (IID == Intrinsic::nvvm_ptr_gen_to_param)
2980       if (N.getOperand(1).getOpcode() == NVPTXISD::MoveParam)
2981         return (SelectDirectAddr(N.getOperand(1).getOperand(0), Address));
2982   }
2983   return false;
2984 }
2985
2986 // symbol+offset
2987 bool NVPTXDAGToDAGISel::SelectADDRsi_imp(
2988     SDNode *OpNode, SDValue Addr, SDValue &Base, SDValue &Offset, MVT mvt) {
2989   if (Addr.getOpcode() == ISD::ADD) {
2990     if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Addr.getOperand(1))) {
2991       SDValue base = Addr.getOperand(0);
2992       if (SelectDirectAddr(base, Base)) {
2993         Offset = CurDAG->getTargetConstant(CN->getZExtValue(), mvt);
2994         return true;
2995       }
2996     }
2997   }
2998   return false;
2999 }
3000
3001 // symbol+offset
3002 bool NVPTXDAGToDAGISel::SelectADDRsi(SDNode *OpNode, SDValue Addr,
3003                                      SDValue &Base, SDValue &Offset) {
3004   return SelectADDRsi_imp(OpNode, Addr, Base, Offset, MVT::i32);
3005 }
3006
3007 // symbol+offset
3008 bool NVPTXDAGToDAGISel::SelectADDRsi64(SDNode *OpNode, SDValue Addr,
3009                                        SDValue &Base, SDValue &Offset) {
3010   return SelectADDRsi_imp(OpNode, Addr, Base, Offset, MVT::i64);
3011 }
3012
3013 // register+offset
3014 bool NVPTXDAGToDAGISel::SelectADDRri_imp(
3015     SDNode *OpNode, SDValue Addr, SDValue &Base, SDValue &Offset, MVT mvt) {
3016   if (FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Addr)) {
3017     Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), mvt);
3018     Offset = CurDAG->getTargetConstant(0, mvt);
3019     return true;
3020   }
3021   if (Addr.getOpcode() == ISD::TargetExternalSymbol ||
3022       Addr.getOpcode() == ISD::TargetGlobalAddress)
3023     return false; // direct calls.
3024
3025   if (Addr.getOpcode() == ISD::ADD) {
3026     if (SelectDirectAddr(Addr.getOperand(0), Addr)) {
3027       return false;
3028     }
3029     if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Addr.getOperand(1))) {
3030       if (FrameIndexSDNode *FIN =
3031               dyn_cast<FrameIndexSDNode>(Addr.getOperand(0)))
3032         // Constant offset from frame ref.
3033         Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), mvt);
3034       else
3035         Base = Addr.getOperand(0);
3036       Offset = CurDAG->getTargetConstant(CN->getZExtValue(), mvt);
3037       return true;
3038     }
3039   }
3040   return false;
3041 }
3042
3043 // register+offset
3044 bool NVPTXDAGToDAGISel::SelectADDRri(SDNode *OpNode, SDValue Addr,
3045                                      SDValue &Base, SDValue &Offset) {
3046   return SelectADDRri_imp(OpNode, Addr, Base, Offset, MVT::i32);
3047 }
3048
3049 // register+offset
3050 bool NVPTXDAGToDAGISel::SelectADDRri64(SDNode *OpNode, SDValue Addr,
3051                                        SDValue &Base, SDValue &Offset) {
3052   return SelectADDRri_imp(OpNode, Addr, Base, Offset, MVT::i64);
3053 }
3054
3055 bool NVPTXDAGToDAGISel::ChkMemSDNodeAddressSpace(SDNode *N,
3056                                                  unsigned int spN) const {
3057   const Value *Src = NULL;
3058   // Even though MemIntrinsicSDNode is a subclas of MemSDNode,
3059   // the classof() for MemSDNode does not include MemIntrinsicSDNode
3060   // (See SelectionDAGNodes.h). So we need to check for both.
3061   if (MemSDNode *mN = dyn_cast<MemSDNode>(N)) {
3062     if (spN == 0 && mN->getMemOperand()->getPseudoValue())
3063       return true;
3064     Src = mN->getMemOperand()->getValue();
3065   } else if (MemSDNode *mN = dyn_cast<MemIntrinsicSDNode>(N)) {
3066     if (spN == 0 && mN->getMemOperand()->getPseudoValue())
3067       return true;
3068     Src = mN->getMemOperand()->getValue();
3069   }
3070   if (!Src)
3071     return false;
3072   if (const PointerType *PT = dyn_cast<PointerType>(Src->getType()))
3073     return (PT->getAddressSpace() == spN);
3074   return false;
3075 }
3076
3077 /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for
3078 /// inline asm expressions.
3079 bool NVPTXDAGToDAGISel::SelectInlineAsmMemoryOperand(
3080     const SDValue &Op, char ConstraintCode, std::vector<SDValue> &OutOps) {
3081   SDValue Op0, Op1;
3082   switch (ConstraintCode) {
3083   default:
3084     return true;
3085   case 'm': // memory
3086     if (SelectDirectAddr(Op, Op0)) {
3087       OutOps.push_back(Op0);
3088       OutOps.push_back(CurDAG->getTargetConstant(0, MVT::i32));
3089       return false;
3090     }
3091     if (SelectADDRri(Op.getNode(), Op, Op0, Op1)) {
3092       OutOps.push_back(Op0);
3093       OutOps.push_back(Op1);
3094       return false;
3095     }
3096     break;
3097   }
3098   return true;
3099 }