lib/Target/AMDGPU/SIISelLowering.cpp

   1 //===-- SIISelLowering.cpp - SI DAG Lowering Implementation ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 /// \file
  11 /// \brief Custom DAG lowering for SI
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifdef _MSC_VER
  16 // Provide M_PI.
  17 #define _USE_MATH_DEFINES
  18 #include <cmath>
  19 #endif
  20
  21 #include "SIISelLowering.h"
  22 #include "AMDGPU.h"
  23 #include "AMDGPUDiagnosticInfoUnsupported.h"
  24 #include "AMDGPUIntrinsicInfo.h"
  25 #include "AMDGPUSubtarget.h"
  26 #include "SIInstrInfo.h"
  27 #include "SIMachineFunctionInfo.h"
  28 #include "SIRegisterInfo.h"
  29 #include "llvm/ADT/BitVector.h"
  30 #include "llvm/CodeGen/CallingConvLower.h"
  31 #include "llvm/CodeGen/MachineInstrBuilder.h"
  32 #include "llvm/CodeGen/MachineRegisterInfo.h"
  33 #include "llvm/CodeGen/SelectionDAG.h"
  34 #include "llvm/IR/Function.h"
  35 #include "llvm/ADT/SmallString.h"
  36
  37 using namespace llvm;
  38
  39 SITargetLowering::SITargetLowering(TargetMachine &TM,
  40                                    const AMDGPUSubtarget &STI)
  41     : AMDGPUTargetLowering(TM, STI) {
  42   addRegisterClass(MVT::i1, &AMDGPU::VReg_1RegClass);
  43   addRegisterClass(MVT::i64, &AMDGPU::SReg_64RegClass);
  44
  45   addRegisterClass(MVT::v32i8, &AMDGPU::SReg_256RegClass);
  46   addRegisterClass(MVT::v64i8, &AMDGPU::SReg_512RegClass);
  47
  48   addRegisterClass(MVT::i32, &AMDGPU::SReg_32RegClass);
  49   addRegisterClass(MVT::f32, &AMDGPU::VGPR_32RegClass);
  50
  51   addRegisterClass(MVT::f64, &AMDGPU::VReg_64RegClass);
  52   addRegisterClass(MVT::v2i32, &AMDGPU::SReg_64RegClass);
  53   addRegisterClass(MVT::v2f32, &AMDGPU::VReg_64RegClass);
  54
  55   addRegisterClass(MVT::v2i64, &AMDGPU::SReg_128RegClass);
  56   addRegisterClass(MVT::v2f64, &AMDGPU::SReg_128RegClass);
  57
  58   addRegisterClass(MVT::v4i32, &AMDGPU::SReg_128RegClass);
  59   addRegisterClass(MVT::v4f32, &AMDGPU::VReg_128RegClass);
  60
  61   addRegisterClass(MVT::v8i32, &AMDGPU::SReg_256RegClass);
  62   addRegisterClass(MVT::v8f32, &AMDGPU::VReg_256RegClass);
  63
  64   addRegisterClass(MVT::v16i32, &AMDGPU::SReg_512RegClass);
  65   addRegisterClass(MVT::v16f32, &AMDGPU::VReg_512RegClass);
  66
  67   computeRegisterProperties(STI.getRegisterInfo());
  68
  69   setOperationAction(ISD::VECTOR_SHUFFLE, MVT::v8i32, Expand);
  70   setOperationAction(ISD::VECTOR_SHUFFLE, MVT::v8f32, Expand);
  71   setOperationAction(ISD::VECTOR_SHUFFLE, MVT::v16i32, Expand);
  72   setOperationAction(ISD::VECTOR_SHUFFLE, MVT::v16f32, Expand);
  73
  74   setOperationAction(ISD::ADD, MVT::i32, Legal);
  75   setOperationAction(ISD::ADDC, MVT::i32, Legal);
  76   setOperationAction(ISD::ADDE, MVT::i32, Legal);
  77   setOperationAction(ISD::SUBC, MVT::i32, Legal);
  78   setOperationAction(ISD::SUBE, MVT::i32, Legal);
  79
  80   setOperationAction(ISD::FSIN, MVT::f32, Custom);
  81   setOperationAction(ISD::FCOS, MVT::f32, Custom);
  82
  83   setOperationAction(ISD::FMINNUM, MVT::f64, Legal);
  84   setOperationAction(ISD::FMAXNUM, MVT::f64, Legal);
  85
  86   // We need to custom lower vector stores from local memory
  87   setOperationAction(ISD::LOAD, MVT::v4i32, Custom);
  88   setOperationAction(ISD::LOAD, MVT::v8i32, Custom);
  89   setOperationAction(ISD::LOAD, MVT::v16i32, Custom);
  90
  91   setOperationAction(ISD::STORE, MVT::v8i32, Custom);
  92   setOperationAction(ISD::STORE, MVT::v16i32, Custom);
  93
  94   setOperationAction(ISD::STORE, MVT::i1, Custom);
  95   setOperationAction(ISD::STORE, MVT::v4i32, Custom);
  96
  97   setOperationAction(ISD::SELECT, MVT::i64, Custom);
  98   setOperationAction(ISD::SELECT, MVT::f64, Promote);
  99   AddPromotedToType(ISD::SELECT, MVT::f64, MVT::i64);
 100
 101   setOperationAction(ISD::SELECT_CC, MVT::f32, Expand);
 102   setOperationAction(ISD::SELECT_CC, MVT::i32, Expand);
 103   setOperationAction(ISD::SELECT_CC, MVT::i64, Expand);
 104   setOperationAction(ISD::SELECT_CC, MVT::f64, Expand);
 105
 106   setOperationAction(ISD::SETCC, MVT::v2i1, Expand);
 107   setOperationAction(ISD::SETCC, MVT::v4i1, Expand);
 108
 109   setOperationAction(ISD::BSWAP, MVT::i32, Legal);
 110   setOperationAction(ISD::BITREVERSE, MVT::i32, Legal);
 111
 112   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Legal);
 113   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v2i1, Custom);
 114   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v4i1, Custom);
 115
 116   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8, Legal);
 117   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v2i8, Custom);
 118   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v4i8, Custom);
 119
 120   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16, Legal);
 121   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v2i16, Custom);
 122   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v4i16, Custom);
 123
 124   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i32, Legal);
 125   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::Other, Custom);
 126
 127   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 128   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::f32, Custom);
 129   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::v16i8, Custom);
 130   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::v4f32, Custom);
 131
 132   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
 133   setOperationAction(ISD::BRCOND, MVT::Other, Custom);
 134
 135   for (MVT VT : MVT::integer_valuetypes()) {
 136     if (VT == MVT::i64)
 137       continue;
 138
 139     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i1, Promote);
 140     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i8, Legal);
 141     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i16, Legal);
 142     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i32, Expand);
 143
 144     setLoadExtAction(ISD::ZEXTLOAD, VT, MVT::i1, Promote);
 145     setLoadExtAction(ISD::ZEXTLOAD, VT, MVT::i8, Legal);
 146     setLoadExtAction(ISD::ZEXTLOAD, VT, MVT::i16, Legal);
 147     setLoadExtAction(ISD::ZEXTLOAD, VT, MVT::i32, Expand);
 148
 149     setLoadExtAction(ISD::EXTLOAD, VT, MVT::i1, Promote);
 150     setLoadExtAction(ISD::EXTLOAD, VT, MVT::i8, Legal);
 151     setLoadExtAction(ISD::EXTLOAD, VT, MVT::i16, Legal);
 152     setLoadExtAction(ISD::EXTLOAD, VT, MVT::i32, Expand);
 153   }
 154
 155   for (MVT VT : MVT::integer_vector_valuetypes()) {
 156     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v8i16, Expand);
 157     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v16i16, Expand);
 158   }
 159
 160   for (MVT VT : MVT::fp_valuetypes())
 161     setLoadExtAction(ISD::EXTLOAD, VT, MVT::f32, Expand);
 162
 163   setLoadExtAction(ISD::EXTLOAD, MVT::v2f64, MVT::v2f16, Expand);
 164   setLoadExtAction(ISD::EXTLOAD, MVT::v2f64, MVT::v2f32, Expand);
 165
 166   setTruncStoreAction(MVT::i64, MVT::i32, Expand);
 167   setTruncStoreAction(MVT::v8i32, MVT::v8i16, Expand);
 168   setTruncStoreAction(MVT::v16i32, MVT::v16i8, Expand);
 169   setTruncStoreAction(MVT::v16i32, MVT::v16i16, Expand);
 170
 171
 172   setTruncStoreAction(MVT::v2i64, MVT::v2i32, Expand);
 173
 174   setTruncStoreAction(MVT::v2f64, MVT::v2f32, Expand);
 175   setTruncStoreAction(MVT::v2f64, MVT::v2f16, Expand);
 176
 177   setOperationAction(ISD::LOAD, MVT::i1, Custom);
 178
 179   setOperationAction(ISD::LOAD, MVT::v2i64, Promote);
 180   AddPromotedToType(ISD::LOAD, MVT::v2i64, MVT::v4i32);
 181
 182   setOperationAction(ISD::STORE, MVT::v2i64, Promote);
 183   AddPromotedToType(ISD::STORE, MVT::v2i64, MVT::v4i32);
 184
 185   setOperationAction(ISD::ConstantPool, MVT::v2i64, Expand);
 186
 187   setOperationAction(ISD::GlobalAddress, MVT::i32, Custom);
 188   setOperationAction(ISD::GlobalAddress, MVT::i64, Custom);
 189   setOperationAction(ISD::FrameIndex, MVT::i32, Custom);
 190
 191   // These should use UDIVREM, so set them to expand
 192   setOperationAction(ISD::UDIV, MVT::i64, Expand);
 193   setOperationAction(ISD::UREM, MVT::i64, Expand);
 194
 195   setOperationAction(ISD::SELECT_CC, MVT::i1, Expand);
 196   setOperationAction(ISD::SELECT, MVT::i1, Promote);
 197
 198   setOperationAction(ISD::TRUNCATE, MVT::v2i32, Expand);
 199
 200
 201   setOperationAction(ISD::FP_ROUND, MVT::v2f32, Expand);
 202
 203   // We only support LOAD/STORE and vector manipulation ops for vectors
 204   // with > 4 elements.
 205   for (MVT VT : {MVT::v8i32, MVT::v8f32, MVT::v16i32, MVT::v16f32, MVT::v2i64, MVT::v2f64}) {
 206     for (unsigned Op = 0; Op < ISD::BUILTIN_OP_END; ++Op) {
 207       switch(Op) {
 208       case ISD::LOAD:
 209       case ISD::STORE:
 210       case ISD::BUILD_VECTOR:
 211       case ISD::BITCAST:
 212       case ISD::EXTRACT_VECTOR_ELT:
 213       case ISD::INSERT_VECTOR_ELT:
 214       case ISD::INSERT_SUBVECTOR:
 215       case ISD::EXTRACT_SUBVECTOR:
 216       case ISD::SCALAR_TO_VECTOR:
 217         break;
 218       case ISD::CONCAT_VECTORS:
 219         setOperationAction(Op, VT, Custom);
 220         break;
 221       default:
 222         setOperationAction(Op, VT, Expand);
 223         break;
 224       }
 225     }
 226   }
 227
 228   // Most operations are naturally 32-bit vector operations. We only support
 229   // load and store of i64 vectors, so promote v2i64 vector operations to v4i32.
 230   for (MVT Vec64 : { MVT::v2i64, MVT::v2f64 }) {
 231     setOperationAction(ISD::BUILD_VECTOR, Vec64, Promote);
 232     AddPromotedToType(ISD::BUILD_VECTOR, Vec64, MVT::v4i32);
 233
 234     setOperationAction(ISD::EXTRACT_VECTOR_ELT, Vec64, Promote);
 235     AddPromotedToType(ISD::EXTRACT_VECTOR_ELT, Vec64, MVT::v4i32);
 236
 237     setOperationAction(ISD::INSERT_VECTOR_ELT, Vec64, Promote);
 238     AddPromotedToType(ISD::INSERT_VECTOR_ELT, Vec64, MVT::v4i32);
 239
 240     setOperationAction(ISD::SCALAR_TO_VECTOR, Vec64, Promote);
 241     AddPromotedToType(ISD::SCALAR_TO_VECTOR, Vec64, MVT::v4i32);
 242   }
 243
 244   if (Subtarget->getGeneration() >= AMDGPUSubtarget::SEA_ISLANDS) {
 245     setOperationAction(ISD::FTRUNC, MVT::f64, Legal);
 246     setOperationAction(ISD::FCEIL, MVT::f64, Legal);
 247     setOperationAction(ISD::FRINT, MVT::f64, Legal);
 248   }
 249
 250   setOperationAction(ISD::FFLOOR, MVT::f64, Legal);
 251   setOperationAction(ISD::FDIV, MVT::f32, Custom);
 252   setOperationAction(ISD::FDIV, MVT::f64, Custom);
 253
 254   setTargetDAGCombine(ISD::FADD);
 255   setTargetDAGCombine(ISD::FSUB);
 256   setTargetDAGCombine(ISD::FMINNUM);
 257   setTargetDAGCombine(ISD::FMAXNUM);
 258   setTargetDAGCombine(ISD::SMIN);
 259   setTargetDAGCombine(ISD::SMAX);
 260   setTargetDAGCombine(ISD::UMIN);
 261   setTargetDAGCombine(ISD::UMAX);
 262   setTargetDAGCombine(ISD::SETCC);
 263   setTargetDAGCombine(ISD::AND);
 264   setTargetDAGCombine(ISD::OR);
 265   setTargetDAGCombine(ISD::UINT_TO_FP);
 266
 267   // All memory operations. Some folding on the pointer operand is done to help
 268   // matching the constant offsets in the addressing modes.
 269   setTargetDAGCombine(ISD::LOAD);
 270   setTargetDAGCombine(ISD::STORE);
 271   setTargetDAGCombine(ISD::ATOMIC_LOAD);
 272   setTargetDAGCombine(ISD::ATOMIC_STORE);
 273   setTargetDAGCombine(ISD::ATOMIC_CMP_SWAP);
 274   setTargetDAGCombine(ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS);
 275   setTargetDAGCombine(ISD::ATOMIC_SWAP);
 276   setTargetDAGCombine(ISD::ATOMIC_LOAD_ADD);
 277   setTargetDAGCombine(ISD::ATOMIC_LOAD_SUB);
 278   setTargetDAGCombine(ISD::ATOMIC_LOAD_AND);
 279   setTargetDAGCombine(ISD::ATOMIC_LOAD_OR);
 280   setTargetDAGCombine(ISD::ATOMIC_LOAD_XOR);
 281   setTargetDAGCombine(ISD::ATOMIC_LOAD_NAND);
 282   setTargetDAGCombine(ISD::ATOMIC_LOAD_MIN);
 283   setTargetDAGCombine(ISD::ATOMIC_LOAD_MAX);
 284   setTargetDAGCombine(ISD::ATOMIC_LOAD_UMIN);
 285   setTargetDAGCombine(ISD::ATOMIC_LOAD_UMAX);
 286
 287   setSchedulingPreference(Sched::RegPressure);
 288 }
 289
 290 //===----------------------------------------------------------------------===//
 291 // TargetLowering queries
 292 //===----------------------------------------------------------------------===//
 293
 294 bool SITargetLowering::isShuffleMaskLegal(const SmallVectorImpl<int> &,
 295                                           EVT) const {
 296   // SI has some legal vector types, but no legal vector operations. Say no
 297   // shuffles are legal in order to prefer scalarizing some vector operations.
 298   return false;
 299 }
 300
 301 bool SITargetLowering::isLegalFlatAddressingMode(const AddrMode &AM) const {
 302   // Flat instructions do not have offsets, and only have the register
 303   // address.
 304   return AM.BaseOffs == 0 && (AM.Scale == 0 || AM.Scale == 1);
 305 }
 306
 307 bool SITargetLowering::isLegalMUBUFAddressingMode(const AddrMode &AM) const {
 308   // MUBUF / MTBUF instructions have a 12-bit unsigned byte offset, and
 309   // additionally can do r + r + i with addr64. 32-bit has more addressing
 310   // mode options. Depending on the resource constant, it can also do
 311   // (i64 r0) + (i32 r1) * (i14 i).
 312   //
 313   // Private arrays end up using a scratch buffer most of the time, so also
 314   // assume those use MUBUF instructions. Scratch loads / stores are currently
 315   // implemented as mubuf instructions with offen bit set, so slightly
 316   // different than the normal addr64.
 317   if (!isUInt<12>(AM.BaseOffs))
 318     return false;
 319
 320   // FIXME: Since we can split immediate into soffset and immediate offset,
 321   // would it make sense to allow any immediate?
 322
 323   switch (AM.Scale) {
 324   case 0: // r + i or just i, depending on HasBaseReg.
 325     return true;
 326   case 1:
 327     return true; // We have r + r or r + i.
 328   case 2:
 329     if (AM.HasBaseReg) {
 330       // Reject 2 * r + r.
 331       return false;
 332     }
 333
 334     // Allow 2 * r as r + r
 335     // Or  2 * r + i is allowed as r + r + i.
 336     return true;
 337   default: // Don't allow n * r
 338     return false;
 339   }
 340 }
 341
 342 bool SITargetLowering::isLegalAddressingMode(const DataLayout &DL,
 343                                              const AddrMode &AM, Type *Ty,
 344                                              unsigned AS) const {
 345   // No global is ever allowed as a base.
 346   if (AM.BaseGV)
 347     return false;
 348
 349   switch (AS) {
 350   case AMDGPUAS::GLOBAL_ADDRESS: {
 351     if (Subtarget->getGeneration() >= AMDGPUSubtarget::VOLCANIC_ISLANDS) {
 352       // Assume the we will use FLAT for all global memory accesses
 353       // on VI.
 354       // FIXME: This assumption is currently wrong.  On VI we still use
 355       // MUBUF instructions for the r + i addressing mode.  As currently
 356       // implemented, the MUBUF instructions only work on buffer < 4GB.
 357       // It may be possible to support > 4GB buffers with MUBUF instructions,
 358       // by setting the stride value in the resource descriptor which would
 359       // increase the size limit to (stride * 4GB).  However, this is risky,
 360       // because it has never been validated.
 361       return isLegalFlatAddressingMode(AM);
 362     }
 363
 364     return isLegalMUBUFAddressingMode(AM);
 365   }
 366   case AMDGPUAS::CONSTANT_ADDRESS: {
 367     // If the offset isn't a multiple of 4, it probably isn't going to be
 368     // correctly aligned.
 369     if (AM.BaseOffs % 4 != 0)
 370       return isLegalMUBUFAddressingMode(AM);
 371
 372     // There are no SMRD extloads, so if we have to do a small type access we
 373     // will use a MUBUF load.
 374     // FIXME?: We also need to do this if unaligned, but we don't know the
 375     // alignment here.
 376     if (DL.getTypeStoreSize(Ty) < 4)
 377       return isLegalMUBUFAddressingMode(AM);
 378
 379     if (Subtarget->getGeneration() == AMDGPUSubtarget::SOUTHERN_ISLANDS) {
 380       // SMRD instructions have an 8-bit, dword offset on SI.
 381       if (!isUInt<8>(AM.BaseOffs / 4))
 382         return false;
 383     } else if (Subtarget->getGeneration() == AMDGPUSubtarget::SEA_ISLANDS) {
 384       // On CI+, this can also be a 32-bit literal constant offset. If it fits
 385       // in 8-bits, it can use a smaller encoding.
 386       if (!isUInt<32>(AM.BaseOffs / 4))
 387         return false;
 388     } else if (Subtarget->getGeneration() == AMDGPUSubtarget::VOLCANIC_ISLANDS) {
 389       // On VI, these use the SMEM format and the offset is 20-bit in bytes.
 390       if (!isUInt<20>(AM.BaseOffs))
 391         return false;
 392     } else
 393       llvm_unreachable("unhandled generation");
 394
 395     if (AM.Scale == 0) // r + i or just i, depending on HasBaseReg.
 396       return true;
 397
 398     if (AM.Scale == 1 && AM.HasBaseReg)
 399       return true;
 400
 401     return false;
 402   }
 403
 404   case AMDGPUAS::PRIVATE_ADDRESS:
 405   case AMDGPUAS::UNKNOWN_ADDRESS_SPACE:
 406     return isLegalMUBUFAddressingMode(AM);
 407
 408   case AMDGPUAS::LOCAL_ADDRESS:
 409   case AMDGPUAS::REGION_ADDRESS: {
 410     // Basic, single offset DS instructions allow a 16-bit unsigned immediate
 411     // field.
 412     // XXX - If doing a 4-byte aligned 8-byte type access, we effectively have
 413     // an 8-bit dword offset but we don't know the alignment here.
 414     if (!isUInt<16>(AM.BaseOffs))
 415       return false;
 416
 417     if (AM.Scale == 0) // r + i or just i, depending on HasBaseReg.
 418       return true;
 419
 420     if (AM.Scale == 1 && AM.HasBaseReg)
 421       return true;
 422
 423     return false;
 424   }
 425   case AMDGPUAS::FLAT_ADDRESS:
 426     return isLegalFlatAddressingMode(AM);
 427
 428   default:
 429     llvm_unreachable("unhandled address space");
 430   }
 431 }
 432
 433 bool SITargetLowering::allowsMisalignedMemoryAccesses(EVT VT,
 434                                                       unsigned AddrSpace,
 435                                                       unsigned Align,
 436                                                       bool *IsFast) const {
 437   if (IsFast)
 438     *IsFast = false;
 439
 440   // TODO: I think v3i32 should allow unaligned accesses on CI with DS_READ_B96,
 441   // which isn't a simple VT.
 442   if (!VT.isSimple() || VT == MVT::Other)
 443     return false;
 444
 445   // TODO - CI+ supports unaligned memory accesses, but this requires driver
 446   // support.
 447
 448   // XXX - The only mention I see of this in the ISA manual is for LDS direct
 449   // reads the "byte address and must be dword aligned". Is it also true for the
 450   // normal loads and stores?
 451   if (AddrSpace == AMDGPUAS::LOCAL_ADDRESS) {
 452     // ds_read/write_b64 require 8-byte alignment, but we can do a 4 byte
 453     // aligned, 8 byte access in a single operation using ds_read2/write2_b32
 454     // with adjacent offsets.
 455     bool AlignedBy4 = (Align % 4 == 0);
 456     if (IsFast)
 457       *IsFast = AlignedBy4;
 458     return AlignedBy4;
 459   }
 460
 461   // Smaller than dword value must be aligned.
 462   // FIXME: This should be allowed on CI+
 463   if (VT.bitsLT(MVT::i32))
 464     return false;
 465
 466   // 8.1.6 - For Dword or larger reads or writes, the two LSBs of the
 467   // byte-address are ignored, thus forcing Dword alignment.
 468   // This applies to private, global, and constant memory.
 469   if (IsFast)
 470     *IsFast = true;
 471
 472   return VT.bitsGT(MVT::i32) && Align % 4 == 0;
 473 }
 474
 475 EVT SITargetLowering::getOptimalMemOpType(uint64_t Size, unsigned DstAlign,
 476                                           unsigned SrcAlign, bool IsMemset,
 477                                           bool ZeroMemset,
 478                                           bool MemcpyStrSrc,
 479                                           MachineFunction &MF) const {
 480   // FIXME: Should account for address space here.
 481
 482   // The default fallback uses the private pointer size as a guess for a type to
 483   // use. Make sure we switch these to 64-bit accesses.
 484
 485   if (Size >= 16 && DstAlign >= 4) // XXX: Should only do for global
 486     return MVT::v4i32;
 487
 488   if (Size >= 8 && DstAlign >= 4)
 489     return MVT::v2i32;
 490
 491   // Use the default.
 492   return MVT::Other;
 493 }
 494
 495 static bool isFlatGlobalAddrSpace(unsigned AS) {
 496   return AS == AMDGPUAS::GLOBAL_ADDRESS ||
 497     AS == AMDGPUAS::FLAT_ADDRESS ||
 498     AS == AMDGPUAS::CONSTANT_ADDRESS;
 499 }
 500
 501 bool SITargetLowering::isNoopAddrSpaceCast(unsigned SrcAS,
 502                                            unsigned DestAS) const {
 503   return isFlatGlobalAddrSpace(SrcAS) &&  isFlatGlobalAddrSpace(DestAS);
 504 }
 505
 506
 507 bool SITargetLowering::isMemOpUniform(const SDNode *N) const {
 508   const MemSDNode *MemNode = cast<MemSDNode>(N);
 509   const Value *Ptr = MemNode->getMemOperand()->getValue();
 510
 511   // UndefValue means this is a load of a kernel input.  These are uniform.
 512   // Sometimes LDS instructions have constant pointers
 513   if (isa<UndefValue>(Ptr) || isa<Argument>(Ptr) || isa<Constant>(Ptr) ||
 514       isa<GlobalValue>(Ptr))
 515     return true;
 516
 517   const Instruction *I = dyn_cast_or_null<Instruction>(Ptr);
 518   return I && I->getMetadata("amdgpu.uniform");
 519 }
 520
 521 TargetLoweringBase::LegalizeTypeAction
 522 SITargetLowering::getPreferredVectorAction(EVT VT) const {
 523   if (VT.getVectorNumElements() != 1 && VT.getScalarType().bitsLE(MVT::i16))
 524     return TypeSplitVector;
 525
 526   return TargetLoweringBase::getPreferredVectorAction(VT);
 527 }
 528
 529 bool SITargetLowering::shouldConvertConstantLoadToIntImm(const APInt &Imm,
 530                                                          Type *Ty) const {
 531   const SIInstrInfo *TII =
 532       static_cast<const SIInstrInfo *>(Subtarget->getInstrInfo());
 533   return TII->isInlineConstant(Imm);
 534 }
 535
 536 SDValue SITargetLowering::LowerParameter(SelectionDAG &DAG, EVT VT, EVT MemVT,
 537                                          SDLoc SL, SDValue Chain,
 538                                          unsigned Offset, bool Signed) const {
 539   const DataLayout &DL = DAG.getDataLayout();
 540   MachineFunction &MF = DAG.getMachineFunction();
 541   const SIRegisterInfo *TRI =
 542       static_cast<const SIRegisterInfo*>(Subtarget->getRegisterInfo());
 543   unsigned InputPtrReg = TRI->getPreloadedValue(MF, SIRegisterInfo::KERNARG_SEGMENT_PTR);
 544
 545   Type *Ty = VT.getTypeForEVT(*DAG.getContext());
 546
 547   MachineRegisterInfo &MRI = DAG.getMachineFunction().getRegInfo();
 548   MVT PtrVT = getPointerTy(DL, AMDGPUAS::CONSTANT_ADDRESS);
 549   PointerType *PtrTy = PointerType::get(Ty, AMDGPUAS::CONSTANT_ADDRESS);
 550   SDValue BasePtr = DAG.getCopyFromReg(Chain, SL,
 551                                        MRI.getLiveInVirtReg(InputPtrReg), PtrVT);
 552   SDValue Ptr = DAG.getNode(ISD::ADD, SL, PtrVT, BasePtr,
 553                             DAG.getConstant(Offset, SL, PtrVT));
 554   SDValue PtrOffset = DAG.getUNDEF(PtrVT);
 555   MachinePointerInfo PtrInfo(UndefValue::get(PtrTy));
 556
 557   unsigned Align = DL.getABITypeAlignment(Ty);
 558
 559   ISD::LoadExtType ExtTy = Signed ? ISD::SEXTLOAD : ISD::ZEXTLOAD;
 560   if (MemVT.isFloatingPoint())
 561     ExtTy = ISD::EXTLOAD;
 562
 563   return DAG.getLoad(ISD::UNINDEXED, ExtTy,
 564                      VT, SL, Chain, Ptr, PtrOffset, PtrInfo, MemVT,
 565                      false, // isVolatile
 566                      true, // isNonTemporal
 567                      true, // isInvariant
 568                      Align); // Alignment
 569 }
 570
 571 SDValue SITargetLowering::LowerFormalArguments(
 572     SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
 573     const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc DL, SelectionDAG &DAG,
 574     SmallVectorImpl<SDValue> &InVals) const {
 575   const SIRegisterInfo *TRI =
 576       static_cast<const SIRegisterInfo *>(Subtarget->getRegisterInfo());
 577
 578   MachineFunction &MF = DAG.getMachineFunction();
 579   FunctionType *FType = MF.getFunction()->getFunctionType();
 580   SIMachineFunctionInfo *Info = MF.getInfo<SIMachineFunctionInfo>();
 581   const AMDGPUSubtarget &ST = MF.getSubtarget<AMDGPUSubtarget>();
 582
 583   if (Subtarget->isAmdHsaOS() && Info->getShaderType() != ShaderType::COMPUTE) {
 584     const Function *Fn = MF.getFunction();
 585     DiagnosticInfoUnsupported NoGraphicsHSA(*Fn, "non-compute shaders with HSA");
 586     DAG.getContext()->diagnose(NoGraphicsHSA);
 587     return SDValue();
 588   }
 589
 590   // FIXME: We currently assume all calling conventions are kernels.
 591
 592   SmallVector<ISD::InputArg, 16> Splits;
 593   BitVector Skipped(Ins.size());
 594
 595   for (unsigned i = 0, e = Ins.size(), PSInputNum = 0; i != e; ++i) {
 596     const ISD::InputArg &Arg = Ins[i];
 597
 598     // First check if it's a PS input addr
 599     if (Info->getShaderType() == ShaderType::PIXEL && !Arg.Flags.isInReg() &&
 600         !Arg.Flags.isByVal()) {
 601
 602       assert((PSInputNum <= 15) && "Too many PS inputs!");
 603
 604       if (!Arg.Used) {
 605         // We can safely skip PS inputs
 606         Skipped.set(i);
 607         ++PSInputNum;
 608         continue;
 609       }
 610
 611       Info->PSInputAddr |= 1 << PSInputNum++;
 612     }
 613
 614     // Second split vertices into their elements
 615     if (Info->getShaderType() != ShaderType::COMPUTE && Arg.VT.isVector()) {
 616       ISD::InputArg NewArg = Arg;
 617       NewArg.Flags.setSplit();
 618       NewArg.VT = Arg.VT.getVectorElementType();
 619
 620       // We REALLY want the ORIGINAL number of vertex elements here, e.g. a
 621       // three or five element vertex only needs three or five registers,
 622       // NOT four or eight.
 623       Type *ParamType = FType->getParamType(Arg.getOrigArgIndex());
 624       unsigned NumElements = ParamType->getVectorNumElements();
 625
 626       for (unsigned j = 0; j != NumElements; ++j) {
 627         Splits.push_back(NewArg);
 628         NewArg.PartOffset += NewArg.VT.getStoreSize();
 629       }
 630
 631     } else if (Info->getShaderType() != ShaderType::COMPUTE) {
 632       Splits.push_back(Arg);
 633     }
 634   }
 635
 636   SmallVector<CCValAssign, 16> ArgLocs;
 637   CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), ArgLocs,
 638                  *DAG.getContext());
 639
 640   // At least one interpolation mode must be enabled or else the GPU will hang.
 641   if (Info->getShaderType() == ShaderType::PIXEL &&
 642       (Info->PSInputAddr & 0x7F) == 0) {
 643     Info->PSInputAddr |= 1;
 644     CCInfo.AllocateReg(AMDGPU::VGPR0);
 645     CCInfo.AllocateReg(AMDGPU::VGPR1);
 646   }
 647
 648   if (Info->getShaderType() == ShaderType::COMPUTE) {
 649     getOriginalFunctionArgs(DAG, DAG.getMachineFunction().getFunction(), Ins,
 650                             Splits);
 651   }
 652
 653   // FIXME: How should these inputs interact with inreg / custom SGPR inputs?
 654   if (Info->hasPrivateSegmentBuffer()) {
 655     unsigned PrivateSegmentBufferReg = Info->addPrivateSegmentBuffer(*TRI);
 656     MF.addLiveIn(PrivateSegmentBufferReg, &AMDGPU::SReg_128RegClass);
 657     CCInfo.AllocateReg(PrivateSegmentBufferReg);
 658   }
 659
 660   if (Info->hasDispatchPtr()) {
 661     unsigned DispatchPtrReg = Info->addDispatchPtr(*TRI);
 662     MF.addLiveIn(DispatchPtrReg, &AMDGPU::SReg_64RegClass);
 663     CCInfo.AllocateReg(DispatchPtrReg);
 664   }
 665
 666   if (Info->hasKernargSegmentPtr()) {
 667     unsigned InputPtrReg = Info->addKernargSegmentPtr(*TRI);
 668     MF.addLiveIn(InputPtrReg, &AMDGPU::SReg_64RegClass);
 669     CCInfo.AllocateReg(InputPtrReg);
 670   }
 671
 672   AnalyzeFormalArguments(CCInfo, Splits);
 673
 674   SmallVector<SDValue, 16> Chains;
 675
 676   for (unsigned i = 0, e = Ins.size(), ArgIdx = 0; i != e; ++i) {
 677
 678     const ISD::InputArg &Arg = Ins[i];
 679     if (Skipped[i]) {
 680       InVals.push_back(DAG.getUNDEF(Arg.VT));
 681       continue;
 682     }
 683
 684     CCValAssign &VA = ArgLocs[ArgIdx++];
 685     MVT VT = VA.getLocVT();
 686
 687     if (VA.isMemLoc()) {
 688       VT = Ins[i].VT;
 689       EVT MemVT = Splits[i].VT;
 690       const unsigned Offset = Subtarget->getExplicitKernelArgOffset() +
 691                               VA.getLocMemOffset();
 692       // The first 36 bytes of the input buffer contains information about
 693       // thread group and global sizes.
 694       SDValue Arg = LowerParameter(DAG, VT, MemVT,  DL, Chain,
 695                                    Offset, Ins[i].Flags.isSExt());
 696       Chains.push_back(Arg.getValue(1));
 697
 698       auto *ParamTy =
 699         dyn_cast<PointerType>(FType->getParamType(Ins[i].getOrigArgIndex()));
 700       if (Subtarget->getGeneration() == AMDGPUSubtarget::SOUTHERN_ISLANDS &&
 701           ParamTy && ParamTy->getAddressSpace() == AMDGPUAS::LOCAL_ADDRESS) {
 702         // On SI local pointers are just offsets into LDS, so they are always
 703         // less than 16-bits.  On CI and newer they could potentially be
 704         // real pointers, so we can't guarantee their size.
 705         Arg = DAG.getNode(ISD::AssertZext, DL, Arg.getValueType(), Arg,
 706                           DAG.getValueType(MVT::i16));
 707       }
 708
 709       InVals.push_back(Arg);
 710       Info->ABIArgOffset = Offset + MemVT.getStoreSize();
 711       continue;
 712     }
 713     assert(VA.isRegLoc() && "Parameter must be in a register!");
 714
 715     unsigned Reg = VA.getLocReg();
 716
 717     if (VT == MVT::i64) {
 718       // For now assume it is a pointer
 719       Reg = TRI->getMatchingSuperReg(Reg, AMDGPU::sub0,
 720                                      &AMDGPU::SReg_64RegClass);
 721       Reg = MF.addLiveIn(Reg, &AMDGPU::SReg_64RegClass);
 722       SDValue Copy = DAG.getCopyFromReg(Chain, DL, Reg, VT);
 723       InVals.push_back(Copy);
 724       continue;
 725     }
 726
 727     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg, VT);
 728
 729     Reg = MF.addLiveIn(Reg, RC);
 730     SDValue Val = DAG.getCopyFromReg(Chain, DL, Reg, VT);
 731
 732     if (Arg.VT.isVector()) {
 733
 734       // Build a vector from the registers
 735       Type *ParamType = FType->getParamType(Arg.getOrigArgIndex());
 736       unsigned NumElements = ParamType->getVectorNumElements();
 737
 738       SmallVector<SDValue, 4> Regs;
 739       Regs.push_back(Val);
 740       for (unsigned j = 1; j != NumElements; ++j) {
 741         Reg = ArgLocs[ArgIdx++].getLocReg();
 742         Reg = MF.addLiveIn(Reg, RC);
 743
 744         SDValue Copy = DAG.getCopyFromReg(Chain, DL, Reg, VT);
 745         Regs.push_back(Copy);
 746       }
 747
 748       // Fill up the missing vector elements
 749       NumElements = Arg.VT.getVectorNumElements() - NumElements;
 750       Regs.append(NumElements, DAG.getUNDEF(VT));
 751
 752       InVals.push_back(DAG.getNode(ISD::BUILD_VECTOR, DL, Arg.VT, Regs));
 753       continue;
 754     }
 755
 756     InVals.push_back(Val);
 757   }
 758
 759   // TODO: Add GridWorkGroupCount user SGPRs when used. For now with HSA we read
 760   // these from the dispatch pointer.
 761
 762   // Start adding system SGPRs.
 763   if (Info->hasWorkGroupIDX()) {
 764     unsigned Reg = Info->addWorkGroupIDX();
 765     MF.addLiveIn(Reg, &AMDGPU::SReg_32RegClass);
 766     CCInfo.AllocateReg(Reg);
 767   } else
 768     llvm_unreachable("work group id x is always enabled");
 769
 770   if (Info->hasWorkGroupIDY()) {
 771     unsigned Reg = Info->addWorkGroupIDY();
 772     MF.addLiveIn(Reg, &AMDGPU::SReg_32RegClass);
 773     CCInfo.AllocateReg(Reg);
 774   }
 775
 776   if (Info->hasWorkGroupIDZ()) {
 777     unsigned Reg = Info->addWorkGroupIDZ();
 778     MF.addLiveIn(Reg, &AMDGPU::SReg_32RegClass);
 779     CCInfo.AllocateReg(Reg);
 780   }
 781
 782   if (Info->hasWorkGroupInfo()) {
 783     unsigned Reg = Info->addWorkGroupInfo();
 784     MF.addLiveIn(Reg, &AMDGPU::SReg_32RegClass);
 785     CCInfo.AllocateReg(Reg);
 786   }
 787
 788   if (Info->hasPrivateSegmentWaveByteOffset()) {
 789     // Scratch wave offset passed in system SGPR.
 790     unsigned PrivateSegmentWaveByteOffsetReg
 791       = Info->addPrivateSegmentWaveByteOffset();
 792
 793     MF.addLiveIn(PrivateSegmentWaveByteOffsetReg, &AMDGPU::SGPR_32RegClass);
 794     CCInfo.AllocateReg(PrivateSegmentWaveByteOffsetReg);
 795   }
 796
 797   // Now that we've figured out where the scratch register inputs are, see if
 798   // should reserve the arguments and use them directly.
 799
 800   bool HasStackObjects = MF.getFrameInfo()->hasStackObjects();
 801
 802   if (ST.isAmdHsaOS()) {
 803     // TODO: Assume we will spill without optimizations.
 804     if (HasStackObjects) {
 805       // If we have stack objects, we unquestionably need the private buffer
 806       // resource. For the HSA ABI, this will be the first 4 user SGPR
 807       // inputs. We can reserve those and use them directly.
 808
 809       unsigned PrivateSegmentBufferReg = TRI->getPreloadedValue(
 810         MF, SIRegisterInfo::PRIVATE_SEGMENT_BUFFER);
 811       Info->setScratchRSrcReg(PrivateSegmentBufferReg);
 812
 813       unsigned PrivateSegmentWaveByteOffsetReg = TRI->getPreloadedValue(
 814         MF, SIRegisterInfo::PRIVATE_SEGMENT_WAVE_BYTE_OFFSET);
 815       Info->setScratchWaveOffsetReg(PrivateSegmentWaveByteOffsetReg);
 816     } else {
 817       unsigned ReservedBufferReg
 818         = TRI->reservedPrivateSegmentBufferReg(MF);
 819       unsigned ReservedOffsetReg
 820         = TRI->reservedPrivateSegmentWaveByteOffsetReg(MF);
 821
 822       // We tentatively reserve the last registers (skipping the last two
 823       // which may contain VCC). After register allocation, we'll replace
 824       // these with the ones immediately after those which were really
 825       // allocated. In the prologue copies will be inserted from the argument
 826       // to these reserved registers.
 827       Info->setScratchRSrcReg(ReservedBufferReg);
 828       Info->setScratchWaveOffsetReg(ReservedOffsetReg);
 829     }
 830   } else {
 831     unsigned ReservedBufferReg = TRI->reservedPrivateSegmentBufferReg(MF);
 832
 833     // Without HSA, relocations are used for the scratch pointer and the
 834     // buffer resource setup is always inserted in the prologue. Scratch wave
 835     // offset is still in an input SGPR.
 836     Info->setScratchRSrcReg(ReservedBufferReg);
 837
 838     if (HasStackObjects) {
 839       unsigned ScratchWaveOffsetReg = TRI->getPreloadedValue(
 840         MF, SIRegisterInfo::PRIVATE_SEGMENT_WAVE_BYTE_OFFSET);
 841       Info->setScratchWaveOffsetReg(ScratchWaveOffsetReg);
 842     } else {
 843       unsigned ReservedOffsetReg
 844         = TRI->reservedPrivateSegmentWaveByteOffsetReg(MF);
 845       Info->setScratchWaveOffsetReg(ReservedOffsetReg);
 846     }
 847   }
 848
 849   if (Info->hasWorkItemIDX()) {
 850     unsigned Reg = TRI->getPreloadedValue(MF, SIRegisterInfo::WORKITEM_ID_X);
 851     MF.addLiveIn(Reg, &AMDGPU::VGPR_32RegClass);
 852     CCInfo.AllocateReg(Reg);
 853   } else
 854     llvm_unreachable("workitem id x should always be enabled");
 855
 856   if (Info->hasWorkItemIDY()) {
 857     unsigned Reg = TRI->getPreloadedValue(MF, SIRegisterInfo::WORKITEM_ID_Y);
 858     MF.addLiveIn(Reg, &AMDGPU::VGPR_32RegClass);
 859     CCInfo.AllocateReg(Reg);
 860   }
 861
 862   if (Info->hasWorkItemIDZ()) {
 863     unsigned Reg = TRI->getPreloadedValue(MF, SIRegisterInfo::WORKITEM_ID_Z);
 864     MF.addLiveIn(Reg, &AMDGPU::VGPR_32RegClass);
 865     CCInfo.AllocateReg(Reg);
 866   }
 867
 868   if (Chains.empty())
 869     return Chain;
 870
 871   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
 872 }
 873
 874 MachineBasicBlock * SITargetLowering::EmitInstrWithCustomInserter(
 875     MachineInstr * MI, MachineBasicBlock * BB) const {
 876
 877   switch (MI->getOpcode()) {
 878   default:
 879     return AMDGPUTargetLowering::EmitInstrWithCustomInserter(MI, BB);
 880   case AMDGPU::BRANCH:
 881     return BB;
 882   }
 883   return BB;
 884 }
 885
 886 bool SITargetLowering::enableAggressiveFMAFusion(EVT VT) const {
 887   // This currently forces unfolding various combinations of fsub into fma with
 888   // free fneg'd operands. As long as we have fast FMA (controlled by
 889   // isFMAFasterThanFMulAndFAdd), we should perform these.
 890
 891   // When fma is quarter rate, for f64 where add / sub are at best half rate,
 892   // most of these combines appear to be cycle neutral but save on instruction
 893   // count / code size.
 894   return true;
 895 }
 896
 897 EVT SITargetLowering::getSetCCResultType(const DataLayout &DL, LLVMContext &Ctx,
 898                                          EVT VT) const {
 899   if (!VT.isVector()) {
 900     return MVT::i1;
 901   }
 902   return EVT::getVectorVT(Ctx, MVT::i1, VT.getVectorNumElements());
 903 }
 904
 905 MVT SITargetLowering::getScalarShiftAmountTy(const DataLayout &, EVT) const {
 906   return MVT::i32;
 907 }
 908
 909 // Answering this is somewhat tricky and depends on the specific device which
 910 // have different rates for fma or all f64 operations.
 911 //
 912 // v_fma_f64 and v_mul_f64 always take the same number of cycles as each other
 913 // regardless of which device (although the number of cycles differs between
 914 // devices), so it is always profitable for f64.
 915 //
 916 // v_fma_f32 takes 4 or 16 cycles depending on the device, so it is profitable
 917 // only on full rate devices. Normally, we should prefer selecting v_mad_f32
 918 // which we can always do even without fused FP ops since it returns the same
 919 // result as the separate operations and since it is always full
 920 // rate. Therefore, we lie and report that it is not faster for f32. v_mad_f32
 921 // however does not support denormals, so we do report fma as faster if we have
 922 // a fast fma device and require denormals.
 923 //
 924 bool SITargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
 925   VT = VT.getScalarType();
 926
 927   if (!VT.isSimple())
 928     return false;
 929
 930   switch (VT.getSimpleVT().SimpleTy) {
 931   case MVT::f32:
 932     // This is as fast on some subtargets. However, we always have full rate f32
 933     // mad available which returns the same result as the separate operations
 934     // which we should prefer over fma. We can't use this if we want to support
 935     // denormals, so only report this in these cases.
 936     return Subtarget->hasFP32Denormals() && Subtarget->hasFastFMAF32();
 937   case MVT::f64:
 938     return true;
 939   default:
 940     break;
 941   }
 942
 943   return false;
 944 }
 945
 946 //===----------------------------------------------------------------------===//
 947 // Custom DAG Lowering Operations
 948 //===----------------------------------------------------------------------===//
 949
 950 SDValue SITargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
 951   switch (Op.getOpcode()) {
 952   default: return AMDGPUTargetLowering::LowerOperation(Op, DAG);
 953   case ISD::FrameIndex: return LowerFrameIndex(Op, DAG);
 954   case ISD::BRCOND: return LowerBRCOND(Op, DAG);
 955   case ISD::LOAD: {
 956     SDValue Result = LowerLOAD(Op, DAG);
 957     assert((!Result.getNode() ||
 958             Result.getNode()->getNumValues() == 2) &&
 959            "Load should return a value and a chain");
 960     return Result;
 961   }
 962
 963   case ISD::FSIN:
 964   case ISD::FCOS:
 965     return LowerTrig(Op, DAG);
 966   case ISD::SELECT: return LowerSELECT(Op, DAG);
 967   case ISD::FDIV: return LowerFDIV(Op, DAG);
 968   case ISD::STORE: return LowerSTORE(Op, DAG);
 969   case ISD::GlobalAddress: {
 970     MachineFunction &MF = DAG.getMachineFunction();
 971     SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
 972     return LowerGlobalAddress(MFI, Op, DAG);
 973   }
 974   case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, DAG);
 975   case ISD::INTRINSIC_VOID: return LowerINTRINSIC_VOID(Op, DAG);
 976   }
 977   return SDValue();
 978 }
 979
 980 /// \brief Helper function for LowerBRCOND
 981 static SDNode *findUser(SDValue Value, unsigned Opcode) {
 982
 983   SDNode *Parent = Value.getNode();
 984   for (SDNode::use_iterator I = Parent->use_begin(), E = Parent->use_end();
 985        I != E; ++I) {
 986
 987     if (I.getUse().get() != Value)
 988       continue;
 989
 990     if (I->getOpcode() == Opcode)
 991       return *I;
 992   }
 993   return nullptr;
 994 }
 995
 996 SDValue SITargetLowering::LowerFrameIndex(SDValue Op, SelectionDAG &DAG) const {
 997
 998   SDLoc SL(Op);
 999   FrameIndexSDNode *FINode = cast<FrameIndexSDNode>(Op);
1000   unsigned FrameIndex = FINode->getIndex();
1001
1002   // A FrameIndex node represents a 32-bit offset into scratch memory.  If
1003   // the high bit of a frame index offset were to be set, this would mean
1004   // that it represented an offset of ~2GB * 64 = ~128GB from the start of the
1005   // scratch buffer, with 64 being the number of threads per wave.
1006   //
1007   // If we know the machine uses less than 128GB of scratch, then we can
1008   // amrk the high bit of the FrameIndex node as known zero,
1009   // which is important, because it means in most situations we can
1010   // prove that values derived from FrameIndex nodes are non-negative.
1011   // This enables us to take advantage of more addressing modes when
1012   // accessing scratch buffers, since for scratch reads/writes, the register
1013   // offset must always be positive.
1014
1015   SDValue TFI = DAG.getTargetFrameIndex(FrameIndex, MVT::i32);
1016   if (Subtarget->enableHugeScratchBuffer())
1017     return TFI;
1018
1019   return DAG.getNode(ISD::AssertZext, SL, MVT::i32, TFI,
1020                     DAG.getValueType(EVT::getIntegerVT(*DAG.getContext(), 31)));
1021 }
1022
1023 /// This transforms the control flow intrinsics to get the branch destination as
1024 /// last parameter, also switches branch target with BR if the need arise
1025 SDValue SITargetLowering::LowerBRCOND(SDValue BRCOND,
1026                                       SelectionDAG &DAG) const {
1027
1028   SDLoc DL(BRCOND);
1029
1030   SDNode *Intr = BRCOND.getOperand(1).getNode();
1031   SDValue Target = BRCOND.getOperand(2);
1032   SDNode *BR = nullptr;
1033
1034   if (Intr->getOpcode() == ISD::SETCC) {
1035     // As long as we negate the condition everything is fine
1036     SDNode *SetCC = Intr;
1037     assert(SetCC->getConstantOperandVal(1) == 1);
1038     assert(cast<CondCodeSDNode>(SetCC->getOperand(2).getNode())->get() ==
1039            ISD::SETNE);
1040     Intr = SetCC->getOperand(0).getNode();
1041
1042   } else {
1043     // Get the target from BR if we don't negate the condition
1044     BR = findUser(BRCOND, ISD::BR);
1045     Target = BR->getOperand(1);
1046   }
1047
1048   assert(Intr->getOpcode() == ISD::INTRINSIC_W_CHAIN);
1049
1050   // Build the result and
1051   ArrayRef<EVT> Res(Intr->value_begin() + 1, Intr->value_end());
1052
1053   // operands of the new intrinsic call
1054   SmallVector<SDValue, 4> Ops;
1055   Ops.push_back(BRCOND.getOperand(0));
1056   Ops.append(Intr->op_begin() + 1, Intr->op_end());
1057   Ops.push_back(Target);
1058
1059   // build the new intrinsic call
1060   SDNode *Result = DAG.getNode(
1061     Res.size() > 1 ? ISD::INTRINSIC_W_CHAIN : ISD::INTRINSIC_VOID, DL,
1062     DAG.getVTList(Res), Ops).getNode();
1063
1064   if (BR) {
1065     // Give the branch instruction our target
1066     SDValue Ops[] = {
1067       BR->getOperand(0),
1068       BRCOND.getOperand(2)
1069     };
1070     SDValue NewBR = DAG.getNode(ISD::BR, DL, BR->getVTList(), Ops);
1071     DAG.ReplaceAllUsesWith(BR, NewBR.getNode());
1072     BR = NewBR.getNode();
1073   }
1074
1075   SDValue Chain = SDValue(Result, Result->getNumValues() - 1);
1076
1077   // Copy the intrinsic results to registers
1078   for (unsigned i = 1, e = Intr->getNumValues() - 1; i != e; ++i) {
1079     SDNode *CopyToReg = findUser(SDValue(Intr, i), ISD::CopyToReg);
1080     if (!CopyToReg)
1081       continue;
1082
1083     Chain = DAG.getCopyToReg(
1084       Chain, DL,
1085       CopyToReg->getOperand(1),
1086       SDValue(Result, i - 1),
1087       SDValue());
1088
1089     DAG.ReplaceAllUsesWith(SDValue(CopyToReg, 0), CopyToReg->getOperand(0));
1090   }
1091
1092   // Remove the old intrinsic from the chain
1093   DAG.ReplaceAllUsesOfValueWith(
1094     SDValue(Intr, Intr->getNumValues() - 1),
1095     Intr->getOperand(0));
1096
1097   return Chain;
1098 }
1099
1100 SDValue SITargetLowering::LowerGlobalAddress(AMDGPUMachineFunction *MFI,
1101                                              SDValue Op,
1102                                              SelectionDAG &DAG) const {
1103   GlobalAddressSDNode *GSD = cast<GlobalAddressSDNode>(Op);
1104
1105   if (GSD->getAddressSpace() != AMDGPUAS::CONSTANT_ADDRESS)
1106     return AMDGPUTargetLowering::LowerGlobalAddress(MFI, Op, DAG);
1107
1108   SDLoc DL(GSD);
1109   const GlobalValue *GV = GSD->getGlobal();
1110   MVT PtrVT = getPointerTy(DAG.getDataLayout(), GSD->getAddressSpace());
1111
1112   SDValue GA = DAG.getTargetGlobalAddress(GV, DL, MVT::i32);
1113   return DAG.getNode(AMDGPUISD::CONST_DATA_PTR, DL, PtrVT, GA);
1114 }
1115
1116 SDValue SITargetLowering::copyToM0(SelectionDAG &DAG, SDValue Chain, SDLoc DL,
1117                                    SDValue V) const {
1118   // We can't use CopyToReg, because MachineCSE won't combine COPY instructions,
1119   // so we will end up with redundant moves to m0.
1120   //
1121   // We can't use S_MOV_B32, because there is no way to specify m0 as the
1122   // destination register.
1123   //
1124   // We have to use them both.  Machine cse will combine all the S_MOV_B32
1125   // instructions and the register coalescer eliminate the extra copies.
1126   SDNode *M0 = DAG.getMachineNode(AMDGPU::S_MOV_B32, DL, V.getValueType(), V);
1127   return DAG.getCopyToReg(Chain, DL, DAG.getRegister(AMDGPU::M0, MVT::i32),
1128                           SDValue(M0, 0), SDValue()); // Glue
1129                                                       // A Null SDValue creates
1130                                                       // a glue result.
1131 }
1132
1133 SDValue SITargetLowering::lowerImplicitZextParam(SelectionDAG &DAG,
1134                                                  SDValue Op,
1135                                                  MVT VT,
1136                                                  unsigned Offset) const {
1137   SDLoc SL(Op);
1138   SDValue Param = LowerParameter(DAG, MVT::i32, MVT::i32, SL,
1139                                  DAG.getEntryNode(), Offset, false);
1140   // The local size values will have the hi 16-bits as zero.
1141   return DAG.getNode(ISD::AssertZext, SL, MVT::i32, Param,
1142                      DAG.getValueType(VT));
1143 }
1144
1145 SDValue SITargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
1146                                                   SelectionDAG &DAG) const {
1147   MachineFunction &MF = DAG.getMachineFunction();
1148   auto MFI = MF.getInfo<SIMachineFunctionInfo>();
1149   const SIRegisterInfo *TRI =
1150       static_cast<const SIRegisterInfo *>(Subtarget->getRegisterInfo());
1151
1152   EVT VT = Op.getValueType();
1153   SDLoc DL(Op);
1154   unsigned IntrinsicID = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
1155
1156   // TODO: Should this propagate fast-math-flags?
1157
1158   switch (IntrinsicID) {
1159   case Intrinsic::amdgcn_dispatch_ptr:
1160     if (!Subtarget->isAmdHsaOS()) {
1161       DiagnosticInfoUnsupported BadIntrin(*MF.getFunction(),
1162                                           "hsa intrinsic without hsa target");
1163       DAG.getContext()->diagnose(BadIntrin);
1164       return DAG.getUNDEF(VT);
1165     }
1166
1167     return CreateLiveInRegister(DAG, &AMDGPU::SReg_64RegClass,
1168       TRI->getPreloadedValue(MF, SIRegisterInfo::DISPATCH_PTR), VT);
1169
1170   case Intrinsic::r600_read_ngroups_x:
1171     return LowerParameter(DAG, VT, VT, DL, DAG.getEntryNode(),
1172                           SI::KernelInputOffsets::NGROUPS_X, false);
1173   case Intrinsic::r600_read_ngroups_y:
1174     return LowerParameter(DAG, VT, VT, DL, DAG.getEntryNode(),
1175                           SI::KernelInputOffsets::NGROUPS_Y, false);
1176   case Intrinsic::r600_read_ngroups_z:
1177     return LowerParameter(DAG, VT, VT, DL, DAG.getEntryNode(),
1178                           SI::KernelInputOffsets::NGROUPS_Z, false);
1179   case Intrinsic::r600_read_global_size_x:
1180     return LowerParameter(DAG, VT, VT, DL, DAG.getEntryNode(),
1181                           SI::KernelInputOffsets::GLOBAL_SIZE_X, false);
1182   case Intrinsic::r600_read_global_size_y:
1183     return LowerParameter(DAG, VT, VT, DL, DAG.getEntryNode(),
1184                           SI::KernelInputOffsets::GLOBAL_SIZE_Y, false);
1185   case Intrinsic::r600_read_global_size_z:
1186     return LowerParameter(DAG, VT, VT, DL, DAG.getEntryNode(),
1187                           SI::KernelInputOffsets::GLOBAL_SIZE_Z, false);
1188   case Intrinsic::r600_read_local_size_x:
1189     return lowerImplicitZextParam(DAG, Op, MVT::i16,
1190                                   SI::KernelInputOffsets::LOCAL_SIZE_X);
1191   case Intrinsic::r600_read_local_size_y:
1192     return lowerImplicitZextParam(DAG, Op, MVT::i16,
1193                                   SI::KernelInputOffsets::LOCAL_SIZE_Y);
1194   case Intrinsic::r600_read_local_size_z:
1195     return lowerImplicitZextParam(DAG, Op, MVT::i16,
1196                                   SI::KernelInputOffsets::LOCAL_SIZE_Z);
1197   case Intrinsic::AMDGPU_read_workdim:
1198     // Really only 2 bits.
1199     return lowerImplicitZextParam(DAG, Op, MVT::i8,
1200                                   getImplicitParameterOffset(MFI, GRID_DIM));
1201   case Intrinsic::r600_read_tgid_x:
1202     return CreateLiveInRegister(DAG, &AMDGPU::SReg_32RegClass,
1203       TRI->getPreloadedValue(MF, SIRegisterInfo::WORKGROUP_ID_X), VT);
1204   case Intrinsic::r600_read_tgid_y:
1205     return CreateLiveInRegister(DAG, &AMDGPU::SReg_32RegClass,
1206       TRI->getPreloadedValue(MF, SIRegisterInfo::WORKGROUP_ID_Y), VT);
1207   case Intrinsic::r600_read_tgid_z:
1208     return CreateLiveInRegister(DAG, &AMDGPU::SReg_32RegClass,
1209       TRI->getPreloadedValue(MF, SIRegisterInfo::WORKGROUP_ID_Z), VT);
1210   case Intrinsic::r600_read_tidig_x:
1211     return CreateLiveInRegister(DAG, &AMDGPU::VGPR_32RegClass,
1212       TRI->getPreloadedValue(MF, SIRegisterInfo::WORKITEM_ID_X), VT);
1213   case Intrinsic::r600_read_tidig_y:
1214     return CreateLiveInRegister(DAG, &AMDGPU::VGPR_32RegClass,
1215       TRI->getPreloadedValue(MF, SIRegisterInfo::WORKITEM_ID_Y), VT);
1216   case Intrinsic::r600_read_tidig_z:
1217     return CreateLiveInRegister(DAG, &AMDGPU::VGPR_32RegClass,
1218       TRI->getPreloadedValue(MF, SIRegisterInfo::WORKITEM_ID_Z), VT);
1219   case AMDGPUIntrinsic::SI_load_const: {
1220     SDValue Ops[] = {
1221       Op.getOperand(1),
1222       Op.getOperand(2)
1223     };
1224
1225     MachineMemOperand *MMO = MF.getMachineMemOperand(
1226       MachinePointerInfo(),
1227       MachineMemOperand::MOLoad | MachineMemOperand::MOInvariant,
1228       VT.getStoreSize(), 4);
1229     return DAG.getMemIntrinsicNode(AMDGPUISD::LOAD_CONSTANT, DL,
1230                                    Op->getVTList(), Ops, VT, MMO);
1231   }
1232   case AMDGPUIntrinsic::SI_sample:
1233     return LowerSampleIntrinsic(AMDGPUISD::SAMPLE, Op, DAG);
1234   case AMDGPUIntrinsic::SI_sampleb:
1235     return LowerSampleIntrinsic(AMDGPUISD::SAMPLEB, Op, DAG);
1236   case AMDGPUIntrinsic::SI_sampled:
1237     return LowerSampleIntrinsic(AMDGPUISD::SAMPLED, Op, DAG);
1238   case AMDGPUIntrinsic::SI_samplel:
1239     return LowerSampleIntrinsic(AMDGPUISD::SAMPLEL, Op, DAG);
1240   case AMDGPUIntrinsic::SI_vs_load_input:
1241     return DAG.getNode(AMDGPUISD::LOAD_INPUT, DL, VT,
1242                        Op.getOperand(1),
1243                        Op.getOperand(2),
1244                        Op.getOperand(3));
1245
1246   case AMDGPUIntrinsic::AMDGPU_fract:
1247   case AMDGPUIntrinsic::AMDIL_fraction: // Legacy name.
1248     return DAG.getNode(ISD::FSUB, DL, VT, Op.getOperand(1),
1249                        DAG.getNode(ISD::FFLOOR, DL, VT, Op.getOperand(1)));
1250   case AMDGPUIntrinsic::SI_fs_constant: {
1251     SDValue M0 = copyToM0(DAG, DAG.getEntryNode(), DL, Op.getOperand(3));
1252     SDValue Glue = M0.getValue(1);
1253     return DAG.getNode(AMDGPUISD::INTERP_MOV, DL, MVT::f32,
1254                        DAG.getConstant(2, DL, MVT::i32), // P0
1255                        Op.getOperand(1), Op.getOperand(2), Glue);
1256   }
1257   case AMDGPUIntrinsic::SI_packf16:
1258     if (Op.getOperand(1).isUndef() && Op.getOperand(2).isUndef())
1259       return DAG.getUNDEF(MVT::i32);
1260     return Op;
1261   case AMDGPUIntrinsic::SI_fs_interp: {
1262     SDValue IJ = Op.getOperand(4);
1263     SDValue I = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, IJ,
1264                             DAG.getConstant(0, DL, MVT::i32));
1265     SDValue J = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, IJ,
1266                             DAG.getConstant(1, DL, MVT::i32));
1267     SDValue M0 = copyToM0(DAG, DAG.getEntryNode(), DL, Op.getOperand(3));
1268     SDValue Glue = M0.getValue(1);
1269     SDValue P1 = DAG.getNode(AMDGPUISD::INTERP_P1, DL,
1270                              DAG.getVTList(MVT::f32, MVT::Glue),
1271                              I, Op.getOperand(1), Op.getOperand(2), Glue);
1272     Glue = SDValue(P1.getNode(), 1);
1273     return DAG.getNode(AMDGPUISD::INTERP_P2, DL, MVT::f32, P1, J,
1274                              Op.getOperand(1), Op.getOperand(2), Glue);
1275   }
1276   case Intrinsic::amdgcn_interp_p1: {
1277     SDValue M0 = copyToM0(DAG, DAG.getEntryNode(), DL, Op.getOperand(4));
1278     SDValue Glue = M0.getValue(1);
1279     return DAG.getNode(AMDGPUISD::INTERP_P1, DL, MVT::f32, Op.getOperand(1),
1280                        Op.getOperand(2), Op.getOperand(3), Glue);
1281   }
1282   case Intrinsic::amdgcn_interp_p2: {
1283     SDValue M0 = copyToM0(DAG, DAG.getEntryNode(), DL, Op.getOperand(5));
1284     SDValue Glue = SDValue(M0.getNode(), 1);
1285     return DAG.getNode(AMDGPUISD::INTERP_P2, DL, MVT::f32, Op.getOperand(1),
1286                        Op.getOperand(2), Op.getOperand(3), Op.getOperand(4),
1287                        Glue);
1288   }
1289   default:
1290     return AMDGPUTargetLowering::LowerOperation(Op, DAG);
1291   }
1292 }
1293
1294 SDValue SITargetLowering::LowerINTRINSIC_VOID(SDValue Op,
1295                                               SelectionDAG &DAG) const {
1296   MachineFunction &MF = DAG.getMachineFunction();
1297   SDLoc DL(Op);
1298   SDValue Chain = Op.getOperand(0);
1299   unsigned IntrinsicID = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
1300
1301   switch (IntrinsicID) {
1302   case AMDGPUIntrinsic::SI_sendmsg: {
1303     Chain = copyToM0(DAG, Chain, DL, Op.getOperand(3));
1304     SDValue Glue = Chain.getValue(1);
1305     return DAG.getNode(AMDGPUISD::SENDMSG, DL, MVT::Other, Chain,
1306                        Op.getOperand(2), Glue);
1307   }
1308   case AMDGPUIntrinsic::SI_tbuffer_store: {
1309     SDValue Ops[] = {
1310       Chain,
1311       Op.getOperand(2),
1312       Op.getOperand(3),
1313       Op.getOperand(4),
1314       Op.getOperand(5),
1315       Op.getOperand(6),
1316       Op.getOperand(7),
1317       Op.getOperand(8),
1318       Op.getOperand(9),
1319       Op.getOperand(10),
1320       Op.getOperand(11),
1321       Op.getOperand(12),
1322       Op.getOperand(13),
1323       Op.getOperand(14)
1324     };
1325
1326     EVT VT = Op.getOperand(3).getValueType();
1327
1328     MachineMemOperand *MMO = MF.getMachineMemOperand(
1329       MachinePointerInfo(),
1330       MachineMemOperand::MOStore,
1331       VT.getStoreSize(), 4);
1332     return DAG.getMemIntrinsicNode(AMDGPUISD::TBUFFER_STORE_FORMAT, DL,
1333                                    Op->getVTList(), Ops, VT, MMO);
1334   }
1335   default:
1336     return SDValue();
1337   }
1338 }
1339
1340 SDValue SITargetLowering::LowerLOAD(SDValue Op, SelectionDAG &DAG) const {
1341   SDLoc DL(Op);
1342   LoadSDNode *Load = cast<LoadSDNode>(Op);
1343
1344   if (Op.getValueType().isVector()) {
1345     assert(Op.getValueType().getVectorElementType() == MVT::i32 &&
1346            "Custom lowering for non-i32 vectors hasn't been implemented.");
1347     unsigned NumElements = Op.getValueType().getVectorNumElements();
1348     assert(NumElements != 2 && "v2 loads are supported for all address spaces.");
1349
1350     switch (Load->getAddressSpace()) {
1351       default: break;
1352       case AMDGPUAS::CONSTANT_ADDRESS:
1353       if (isMemOpUniform(Load))
1354         break;
1355         // Non-uniform loads will be selected to MUBUF instructions, so they
1356         // have the same legalization requires ments as global and private
1357         // loads.
1358         //
1359         // Fall-through
1360       case AMDGPUAS::GLOBAL_ADDRESS:
1361       case AMDGPUAS::PRIVATE_ADDRESS:
1362         if (NumElements >= 8)
1363           return SplitVectorLoad(Op, DAG);
1364
1365         // v4 loads are supported for private and global memory.
1366         if (NumElements <= 4)
1367           break;
1368         // fall-through
1369       case AMDGPUAS::LOCAL_ADDRESS:
1370         // If properly aligned, if we split we might be able to use ds_read_b64.
1371         return SplitVectorLoad(Op, DAG);
1372     }
1373   }
1374
1375   return AMDGPUTargetLowering::LowerLOAD(Op, DAG);
1376 }
1377
1378 SDValue SITargetLowering::LowerSampleIntrinsic(unsigned Opcode,
1379                                                const SDValue &Op,
1380                                                SelectionDAG &DAG) const {
1381   return DAG.getNode(Opcode, SDLoc(Op), Op.getValueType(), Op.getOperand(1),
1382                      Op.getOperand(2),
1383                      Op.getOperand(3),
1384                      Op.getOperand(4));
1385 }
1386
1387 SDValue SITargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
1388   if (Op.getValueType() != MVT::i64)
1389     return SDValue();
1390
1391   SDLoc DL(Op);
1392   SDValue Cond = Op.getOperand(0);
1393
1394   SDValue Zero = DAG.getConstant(0, DL, MVT::i32);
1395   SDValue One = DAG.getConstant(1, DL, MVT::i32);
1396
1397   SDValue LHS = DAG.getNode(ISD::BITCAST, DL, MVT::v2i32, Op.getOperand(1));
1398   SDValue RHS = DAG.getNode(ISD::BITCAST, DL, MVT::v2i32, Op.getOperand(2));
1399
1400   SDValue Lo0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, LHS, Zero);
1401   SDValue Lo1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, RHS, Zero);
1402
1403   SDValue Lo = DAG.getSelect(DL, MVT::i32, Cond, Lo0, Lo1);
1404
1405   SDValue Hi0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, LHS, One);
1406   SDValue Hi1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, RHS, One);
1407
1408   SDValue Hi = DAG.getSelect(DL, MVT::i32, Cond, Hi0, Hi1);
1409
1410   SDValue Res = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v2i32, Lo, Hi);
1411   return DAG.getNode(ISD::BITCAST, DL, MVT::i64, Res);
1412 }
1413
1414 // Catch division cases where we can use shortcuts with rcp and rsq
1415 // instructions.
1416 SDValue SITargetLowering::LowerFastFDIV(SDValue Op, SelectionDAG &DAG) const {
1417   SDLoc SL(Op);
1418   SDValue LHS = Op.getOperand(0);
1419   SDValue RHS = Op.getOperand(1);
1420   EVT VT = Op.getValueType();
1421   bool Unsafe = DAG.getTarget().Options.UnsafeFPMath;
1422
1423   if (const ConstantFPSDNode *CLHS = dyn_cast<ConstantFPSDNode>(LHS)) {
1424     if ((Unsafe || (VT == MVT::f32 && !Subtarget->hasFP32Denormals())) &&
1425         CLHS->isExactlyValue(1.0)) {
1426       // v_rcp_f32 and v_rsq_f32 do not support denormals, and according to
1427       // the CI documentation has a worst case error of 1 ulp.
1428       // OpenCL requires <= 2.5 ulp for 1.0 / x, so it should always be OK to
1429       // use it as long as we aren't trying to use denormals.
1430
1431       // 1.0 / sqrt(x) -> rsq(x)
1432       //
1433       // XXX - Is UnsafeFPMath sufficient to do this for f64? The maximum ULP
1434       // error seems really high at 2^29 ULP.
1435       if (RHS.getOpcode() == ISD::FSQRT)
1436         return DAG.getNode(AMDGPUISD::RSQ, SL, VT, RHS.getOperand(0));
1437
1438       // 1.0 / x -> rcp(x)
1439       return DAG.getNode(AMDGPUISD::RCP, SL, VT, RHS);
1440     }
1441   }
1442
1443   if (Unsafe) {
1444     // Turn into multiply by the reciprocal.
1445     // x / y -> x * (1.0 / y)
1446     SDNodeFlags Flags;
1447     Flags.setUnsafeAlgebra(true);
1448     SDValue Recip = DAG.getNode(AMDGPUISD::RCP, SL, VT, RHS);
1449     return DAG.getNode(ISD::FMUL, SL, VT, LHS, Recip, &Flags);
1450   }
1451
1452   return SDValue();
1453 }
1454
1455 SDValue SITargetLowering::LowerFDIV32(SDValue Op, SelectionDAG &DAG) const {
1456   SDValue FastLowered = LowerFastFDIV(Op, DAG);
1457   if (FastLowered.getNode())
1458     return FastLowered;
1459
1460   // This uses v_rcp_f32 which does not handle denormals. Let this hit a
1461   // selection error for now rather than do something incorrect.
1462   if (Subtarget->hasFP32Denormals())
1463     return SDValue();
1464
1465   SDLoc SL(Op);
1466   SDValue LHS = Op.getOperand(0);
1467   SDValue RHS = Op.getOperand(1);
1468
1469   SDValue r1 = DAG.getNode(ISD::FABS, SL, MVT::f32, RHS);
1470
1471   const APFloat K0Val(BitsToFloat(0x6f800000));
1472   const SDValue K0 = DAG.getConstantFP(K0Val, SL, MVT::f32);
1473
1474   const APFloat K1Val(BitsToFloat(0x2f800000));
1475   const SDValue K1 = DAG.getConstantFP(K1Val, SL, MVT::f32);
1476
1477   const SDValue One = DAG.getConstantFP(1.0, SL, MVT::f32);
1478
1479   EVT SetCCVT =
1480       getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), MVT::f32);
1481
1482   SDValue r2 = DAG.getSetCC(SL, SetCCVT, r1, K0, ISD::SETOGT);
1483
1484   SDValue r3 = DAG.getNode(ISD::SELECT, SL, MVT::f32, r2, K1, One);
1485
1486   // TODO: Should this propagate fast-math-flags?
1487
1488   r1 = DAG.getNode(ISD::FMUL, SL, MVT::f32, RHS, r3);
1489
1490   SDValue r0 = DAG.getNode(AMDGPUISD::RCP, SL, MVT::f32, r1);
1491
1492   SDValue Mul = DAG.getNode(ISD::FMUL, SL, MVT::f32, LHS, r0);
1493
1494   return DAG.getNode(ISD::FMUL, SL, MVT::f32, r3, Mul);
1495 }
1496
1497 SDValue SITargetLowering::LowerFDIV64(SDValue Op, SelectionDAG &DAG) const {
1498   if (DAG.getTarget().Options.UnsafeFPMath)
1499     return LowerFastFDIV(Op, DAG);
1500
1501   SDLoc SL(Op);
1502   SDValue X = Op.getOperand(0);
1503   SDValue Y = Op.getOperand(1);
1504
1505   const SDValue One = DAG.getConstantFP(1.0, SL, MVT::f64);
1506
1507   SDVTList ScaleVT = DAG.getVTList(MVT::f64, MVT::i1);
1508
1509   SDValue DivScale0 = DAG.getNode(AMDGPUISD::DIV_SCALE, SL, ScaleVT, Y, Y, X);
1510
1511   SDValue NegDivScale0 = DAG.getNode(ISD::FNEG, SL, MVT::f64, DivScale0);
1512
1513   SDValue Rcp = DAG.getNode(AMDGPUISD::RCP, SL, MVT::f64, DivScale0);
1514
1515   SDValue Fma0 = DAG.getNode(ISD::FMA, SL, MVT::f64, NegDivScale0, Rcp, One);
1516
1517   SDValue Fma1 = DAG.getNode(ISD::FMA, SL, MVT::f64, Rcp, Fma0, Rcp);
1518
1519   SDValue Fma2 = DAG.getNode(ISD::FMA, SL, MVT::f64, NegDivScale0, Fma1, One);
1520
1521   SDValue DivScale1 = DAG.getNode(AMDGPUISD::DIV_SCALE, SL, ScaleVT, X, Y, X);
1522
1523   SDValue Fma3 = DAG.getNode(ISD::FMA, SL, MVT::f64, Fma1, Fma2, Fma1);
1524   SDValue Mul = DAG.getNode(ISD::FMUL, SL, MVT::f64, DivScale1, Fma3);
1525
1526   SDValue Fma4 = DAG.getNode(ISD::FMA, SL, MVT::f64,
1527                              NegDivScale0, Mul, DivScale1);
1528
1529   SDValue Scale;
1530
1531   if (Subtarget->getGeneration() == AMDGPUSubtarget::SOUTHERN_ISLANDS) {
1532     // Workaround a hardware bug on SI where the condition output from div_scale
1533     // is not usable.
1534
1535     const SDValue Hi = DAG.getConstant(1, SL, MVT::i32);
1536
1537     // Figure out if the scale to use for div_fmas.
1538     SDValue NumBC = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, X);
1539     SDValue DenBC = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, Y);
1540     SDValue Scale0BC = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, DivScale0);
1541     SDValue Scale1BC = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, DivScale1);
1542
1543     SDValue NumHi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, NumBC, Hi);
1544     SDValue DenHi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, DenBC, Hi);
1545
1546     SDValue Scale0Hi
1547       = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, Scale0BC, Hi);
1548     SDValue Scale1Hi
1549       = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, Scale1BC, Hi);
1550
1551     SDValue CmpDen = DAG.getSetCC(SL, MVT::i1, DenHi, Scale0Hi, ISD::SETEQ);
1552     SDValue CmpNum = DAG.getSetCC(SL, MVT::i1, NumHi, Scale1Hi, ISD::SETEQ);
1553     Scale = DAG.getNode(ISD::XOR, SL, MVT::i1, CmpNum, CmpDen);
1554   } else {
1555     Scale = DivScale1.getValue(1);
1556   }
1557
1558   SDValue Fmas = DAG.getNode(AMDGPUISD::DIV_FMAS, SL, MVT::f64,
1559                              Fma4, Fma3, Mul, Scale);
1560
1561   return DAG.getNode(AMDGPUISD::DIV_FIXUP, SL, MVT::f64, Fmas, Y, X);
1562 }
1563
1564 SDValue SITargetLowering::LowerFDIV(SDValue Op, SelectionDAG &DAG) const {
1565   EVT VT = Op.getValueType();
1566
1567   if (VT == MVT::f32)
1568     return LowerFDIV32(Op, DAG);
1569
1570   if (VT == MVT::f64)
1571     return LowerFDIV64(Op, DAG);
1572
1573   llvm_unreachable("Unexpected type for fdiv");
1574 }
1575
1576 SDValue SITargetLowering::LowerSTORE(SDValue Op, SelectionDAG &DAG) const {
1577   SDLoc DL(Op);
1578   StoreSDNode *Store = cast<StoreSDNode>(Op);
1579   EVT VT = Store->getMemoryVT();
1580
1581   // These stores are legal.
1582   if (Store->getAddressSpace() == AMDGPUAS::PRIVATE_ADDRESS) {
1583     if (VT.isVector() && VT.getVectorNumElements() > 4)
1584       return ScalarizeVectorStore(Op, DAG);
1585     return SDValue();
1586   }
1587
1588   SDValue Ret = AMDGPUTargetLowering::LowerSTORE(Op, DAG);
1589   if (Ret.getNode())
1590     return Ret;
1591
1592   if (VT.isVector() && VT.getVectorNumElements() >= 8)
1593       return SplitVectorStore(Op, DAG);
1594
1595   if (VT == MVT::i1)
1596     return DAG.getTruncStore(Store->getChain(), DL,
1597                         DAG.getSExtOrTrunc(Store->getValue(), DL, MVT::i32),
1598                         Store->getBasePtr(), MVT::i1, Store->getMemOperand());
1599
1600   return SDValue();
1601 }
1602
1603 SDValue SITargetLowering::LowerTrig(SDValue Op, SelectionDAG &DAG) const {
1604   SDLoc DL(Op);
1605   EVT VT = Op.getValueType();
1606   SDValue Arg = Op.getOperand(0);
1607   // TODO: Should this propagate fast-math-flags?
1608   SDValue FractPart = DAG.getNode(AMDGPUISD::FRACT, DL, VT,
1609                                   DAG.getNode(ISD::FMUL, DL, VT, Arg,
1610                                               DAG.getConstantFP(0.5/M_PI, DL,
1611                                                                 VT)));
1612
1613   switch (Op.getOpcode()) {
1614   case ISD::FCOS:
1615     return DAG.getNode(AMDGPUISD::COS_HW, SDLoc(Op), VT, FractPart);
1616   case ISD::FSIN:
1617     return DAG.getNode(AMDGPUISD::SIN_HW, SDLoc(Op), VT, FractPart);
1618   default:
1619     llvm_unreachable("Wrong trig opcode");
1620   }
1621 }
1622
1623 //===----------------------------------------------------------------------===//
1624 // Custom DAG optimizations
1625 //===----------------------------------------------------------------------===//
1626
1627 SDValue SITargetLowering::performUCharToFloatCombine(SDNode *N,
1628                                                      DAGCombinerInfo &DCI) const {
1629   EVT VT = N->getValueType(0);
1630   EVT ScalarVT = VT.getScalarType();
1631   if (ScalarVT != MVT::f32)
1632     return SDValue();
1633
1634   SelectionDAG &DAG = DCI.DAG;
1635   SDLoc DL(N);
1636
1637   SDValue Src = N->getOperand(0);
1638   EVT SrcVT = Src.getValueType();
1639
1640   // TODO: We could try to match extracting the higher bytes, which would be
1641   // easier if i8 vectors weren't promoted to i32 vectors, particularly after
1642   // types are legalized. v4i8 -> v4f32 is probably the only case to worry
1643   // about in practice.
1644   if (DCI.isAfterLegalizeVectorOps() && SrcVT == MVT::i32) {
1645     if (DAG.MaskedValueIsZero(Src, APInt::getHighBitsSet(32, 24))) {
1646       SDValue Cvt = DAG.getNode(AMDGPUISD::CVT_F32_UBYTE0, DL, VT, Src);
1647       DCI.AddToWorklist(Cvt.getNode());
1648       return Cvt;
1649     }
1650   }
1651
1652   // We are primarily trying to catch operations on illegal vector types
1653   // before they are expanded.
1654   // For scalars, we can use the more flexible method of checking masked bits
1655   // after legalization.
1656   if (!DCI.isBeforeLegalize() ||
1657       !SrcVT.isVector() ||
1658       SrcVT.getVectorElementType() != MVT::i8) {
1659     return SDValue();
1660   }
1661
1662   assert(DCI.isBeforeLegalize() && "Unexpected legal type");
1663
1664   // Weird sized vectors are a pain to handle, but we know 3 is really the same
1665   // size as 4.
1666   unsigned NElts = SrcVT.getVectorNumElements();
1667   if (!SrcVT.isSimple() && NElts != 3)
1668     return SDValue();
1669
1670   // Handle v4i8 -> v4f32 extload. Replace the v4i8 with a legal i32 load to
1671   // prevent a mess from expanding to v4i32 and repacking.
1672   if (ISD::isNormalLoad(Src.getNode()) && Src.hasOneUse()) {
1673     EVT LoadVT = getEquivalentMemType(*DAG.getContext(), SrcVT);
1674     EVT RegVT = getEquivalentLoadRegType(*DAG.getContext(), SrcVT);
1675     EVT FloatVT = EVT::getVectorVT(*DAG.getContext(), MVT::f32, NElts);
1676     LoadSDNode *Load = cast<LoadSDNode>(Src);
1677
1678     unsigned AS = Load->getAddressSpace();
1679     unsigned Align = Load->getAlignment();
1680     Type *Ty = LoadVT.getTypeForEVT(*DAG.getContext());
1681     unsigned ABIAlignment = DAG.getDataLayout().getABITypeAlignment(Ty);
1682
1683     // Don't try to replace the load if we have to expand it due to alignment
1684     // problems. Otherwise we will end up scalarizing the load, and trying to
1685     // repack into the vector for no real reason.
1686     if (Align < ABIAlignment &&
1687         !allowsMisalignedMemoryAccesses(LoadVT, AS, Align, nullptr)) {
1688       return SDValue();
1689     }
1690
1691     SDValue NewLoad = DAG.getExtLoad(ISD::ZEXTLOAD, DL, RegVT,
1692                                      Load->getChain(),
1693                                      Load->getBasePtr(),
1694                                      LoadVT,
1695                                      Load->getMemOperand());
1696
1697     // Make sure successors of the original load stay after it by updating
1698     // them to use the new Chain.
1699     DAG.ReplaceAllUsesOfValueWith(SDValue(Load, 1), NewLoad.getValue(1));
1700
1701     SmallVector<SDValue, 4> Elts;
1702     if (RegVT.isVector())
1703       DAG.ExtractVectorElements(NewLoad, Elts);
1704     else
1705       Elts.push_back(NewLoad);
1706
1707     SmallVector<SDValue, 4> Ops;
1708
1709     unsigned EltIdx = 0;
1710     for (SDValue Elt : Elts) {
1711       unsigned ComponentsInElt = std::min(4u, NElts - 4 * EltIdx);
1712       for (unsigned I = 0; I < ComponentsInElt; ++I) {
1713         unsigned Opc = AMDGPUISD::CVT_F32_UBYTE0 + I;
1714         SDValue Cvt = DAG.getNode(Opc, DL, MVT::f32, Elt);
1715         DCI.AddToWorklist(Cvt.getNode());
1716         Ops.push_back(Cvt);
1717       }
1718
1719       ++EltIdx;
1720     }
1721
1722     assert(Ops.size() == NElts);
1723
1724     return DAG.getNode(ISD::BUILD_VECTOR, DL, FloatVT, Ops);
1725   }
1726
1727   return SDValue();
1728 }
1729
1730 /// \brief Return true if the given offset Size in bytes can be folded into
1731 /// the immediate offsets of a memory instruction for the given address space.
1732 static bool canFoldOffset(unsigned OffsetSize, unsigned AS,
1733                           const AMDGPUSubtarget &STI) {
1734   switch (AS) {
1735   case AMDGPUAS::GLOBAL_ADDRESS: {
1736     // MUBUF instructions a 12-bit offset in bytes.
1737     return isUInt<12>(OffsetSize);
1738   }
1739   case AMDGPUAS::CONSTANT_ADDRESS: {
1740     // SMRD instructions have an 8-bit offset in dwords on SI and
1741     // a 20-bit offset in bytes on VI.
1742     if (STI.getGeneration() >= AMDGPUSubtarget::VOLCANIC_ISLANDS)
1743       return isUInt<20>(OffsetSize);
1744     else
1745       return (OffsetSize % 4 == 0) && isUInt<8>(OffsetSize / 4);
1746   }
1747   case AMDGPUAS::LOCAL_ADDRESS:
1748   case AMDGPUAS::REGION_ADDRESS: {
1749     // The single offset versions have a 16-bit offset in bytes.
1750     return isUInt<16>(OffsetSize);
1751   }
1752   case AMDGPUAS::PRIVATE_ADDRESS:
1753   // Indirect register addressing does not use any offsets.
1754   default:
1755     return 0;
1756   }
1757 }
1758
1759 // (shl (add x, c1), c2) -> add (shl x, c2), (shl c1, c2)
1760
1761 // This is a variant of
1762 // (mul (add x, c1), c2) -> add (mul x, c2), (mul c1, c2),
1763 //
1764 // The normal DAG combiner will do this, but only if the add has one use since
1765 // that would increase the number of instructions.
1766 //
1767 // This prevents us from seeing a constant offset that can be folded into a
1768 // memory instruction's addressing mode. If we know the resulting add offset of
1769 // a pointer can be folded into an addressing offset, we can replace the pointer
1770 // operand with the add of new constant offset. This eliminates one of the uses,
1771 // and may allow the remaining use to also be simplified.
1772 //
1773 SDValue SITargetLowering::performSHLPtrCombine(SDNode *N,
1774                                                unsigned AddrSpace,
1775                                                DAGCombinerInfo &DCI) const {
1776   SDValue N0 = N->getOperand(0);
1777   SDValue N1 = N->getOperand(1);
1778
1779   if (N0.getOpcode() != ISD::ADD)
1780     return SDValue();
1781
1782   const ConstantSDNode *CN1 = dyn_cast<ConstantSDNode>(N1);
1783   if (!CN1)
1784     return SDValue();
1785
1786   const ConstantSDNode *CAdd = dyn_cast<ConstantSDNode>(N0.getOperand(1));
1787   if (!CAdd)
1788     return SDValue();
1789
1790   // If the resulting offset is too large, we can't fold it into the addressing
1791   // mode offset.
1792   APInt Offset = CAdd->getAPIntValue() << CN1->getAPIntValue();
1793   if (!canFoldOffset(Offset.getZExtValue(), AddrSpace, *Subtarget))
1794     return SDValue();
1795
1796   SelectionDAG &DAG = DCI.DAG;
1797   SDLoc SL(N);
1798   EVT VT = N->getValueType(0);
1799
1800   SDValue ShlX = DAG.getNode(ISD::SHL, SL, VT, N0.getOperand(0), N1);
1801   SDValue COffset = DAG.getConstant(Offset, SL, MVT::i32);
1802
1803   return DAG.getNode(ISD::ADD, SL, VT, ShlX, COffset);
1804 }
1805
1806 SDValue SITargetLowering::performAndCombine(SDNode *N,
1807                                             DAGCombinerInfo &DCI) const {
1808   if (DCI.isBeforeLegalize())
1809     return SDValue();
1810
1811   SelectionDAG &DAG = DCI.DAG;
1812
1813   // (and (fcmp ord x, x), (fcmp une (fabs x), inf)) ->
1814   // fp_class x, ~(s_nan | q_nan | n_infinity | p_infinity)
1815   SDValue LHS = N->getOperand(0);
1816   SDValue RHS = N->getOperand(1);
1817
1818   if (LHS.getOpcode() == ISD::SETCC &&
1819       RHS.getOpcode() == ISD::SETCC) {
1820     ISD::CondCode LCC = cast<CondCodeSDNode>(LHS.getOperand(2))->get();
1821     ISD::CondCode RCC = cast<CondCodeSDNode>(RHS.getOperand(2))->get();
1822
1823     SDValue X = LHS.getOperand(0);
1824     SDValue Y = RHS.getOperand(0);
1825     if (Y.getOpcode() != ISD::FABS || Y.getOperand(0) != X)
1826       return SDValue();
1827
1828     if (LCC == ISD::SETO) {
1829       if (X != LHS.getOperand(1))
1830         return SDValue();
1831
1832       if (RCC == ISD::SETUNE) {
1833         const ConstantFPSDNode *C1 = dyn_cast<ConstantFPSDNode>(RHS.getOperand(1));
1834         if (!C1 || !C1->isInfinity() || C1->isNegative())
1835           return SDValue();
1836
1837         const uint32_t Mask = SIInstrFlags::N_NORMAL |
1838                               SIInstrFlags::N_SUBNORMAL |
1839                               SIInstrFlags::N_ZERO |
1840                               SIInstrFlags::P_ZERO |
1841                               SIInstrFlags::P_SUBNORMAL |
1842                               SIInstrFlags::P_NORMAL;
1843
1844         static_assert(((~(SIInstrFlags::S_NAN |
1845                           SIInstrFlags::Q_NAN |
1846                           SIInstrFlags::N_INFINITY |
1847                           SIInstrFlags::P_INFINITY)) & 0x3ff) == Mask,
1848                       "mask not equal");
1849
1850         SDLoc DL(N);
1851         return DAG.getNode(AMDGPUISD::FP_CLASS, DL, MVT::i1,
1852                            X, DAG.getConstant(Mask, DL, MVT::i32));
1853       }
1854     }
1855   }
1856
1857   return SDValue();
1858 }
1859
1860 SDValue SITargetLowering::performOrCombine(SDNode *N,
1861                                            DAGCombinerInfo &DCI) const {
1862   SelectionDAG &DAG = DCI.DAG;
1863   SDValue LHS = N->getOperand(0);
1864   SDValue RHS = N->getOperand(1);
1865
1866   // or (fp_class x, c1), (fp_class x, c2) -> fp_class x, (c1 | c2)
1867   if (LHS.getOpcode() == AMDGPUISD::FP_CLASS &&
1868       RHS.getOpcode() == AMDGPUISD::FP_CLASS) {
1869     SDValue Src = LHS.getOperand(0);
1870     if (Src != RHS.getOperand(0))
1871       return SDValue();
1872
1873     const ConstantSDNode *CLHS = dyn_cast<ConstantSDNode>(LHS.getOperand(1));
1874     const ConstantSDNode *CRHS = dyn_cast<ConstantSDNode>(RHS.getOperand(1));
1875     if (!CLHS || !CRHS)
1876       return SDValue();
1877
1878     // Only 10 bits are used.
1879     static const uint32_t MaxMask = 0x3ff;
1880
1881     uint32_t NewMask = (CLHS->getZExtValue() | CRHS->getZExtValue()) & MaxMask;
1882     SDLoc DL(N);
1883     return DAG.getNode(AMDGPUISD::FP_CLASS, DL, MVT::i1,
1884                        Src, DAG.getConstant(NewMask, DL, MVT::i32));
1885   }
1886
1887   return SDValue();
1888 }
1889
1890 SDValue SITargetLowering::performClassCombine(SDNode *N,
1891                                               DAGCombinerInfo &DCI) const {
1892   SelectionDAG &DAG = DCI.DAG;
1893   SDValue Mask = N->getOperand(1);
1894
1895   // fp_class x, 0 -> false
1896   if (const ConstantSDNode *CMask = dyn_cast<ConstantSDNode>(Mask)) {
1897     if (CMask->isNullValue())
1898       return DAG.getConstant(0, SDLoc(N), MVT::i1);
1899   }
1900
1901   return SDValue();
1902 }
1903
1904 static unsigned minMaxOpcToMin3Max3Opc(unsigned Opc) {
1905   switch (Opc) {
1906   case ISD::FMAXNUM:
1907     return AMDGPUISD::FMAX3;
1908   case ISD::SMAX:
1909     return AMDGPUISD::SMAX3;
1910   case ISD::UMAX:
1911     return AMDGPUISD::UMAX3;
1912   case ISD::FMINNUM:
1913     return AMDGPUISD::FMIN3;
1914   case ISD::SMIN:
1915     return AMDGPUISD::SMIN3;
1916   case ISD::UMIN:
1917     return AMDGPUISD::UMIN3;
1918   default:
1919     llvm_unreachable("Not a min/max opcode");
1920   }
1921 }
1922
1923 SDValue SITargetLowering::performMin3Max3Combine(SDNode *N,
1924                                                  DAGCombinerInfo &DCI) const {
1925   SelectionDAG &DAG = DCI.DAG;
1926
1927   unsigned Opc = N->getOpcode();
1928   SDValue Op0 = N->getOperand(0);
1929   SDValue Op1 = N->getOperand(1);
1930
1931   // Only do this if the inner op has one use since this will just increases
1932   // register pressure for no benefit.
1933
1934   // max(max(a, b), c)
1935   if (Op0.getOpcode() == Opc && Op0.hasOneUse()) {
1936     SDLoc DL(N);
1937     return DAG.getNode(minMaxOpcToMin3Max3Opc(Opc),
1938                        DL,
1939                        N->getValueType(0),
1940                        Op0.getOperand(0),
1941                        Op0.getOperand(1),
1942                        Op1);
1943   }
1944
1945   // max(a, max(b, c))
1946   if (Op1.getOpcode() == Opc && Op1.hasOneUse()) {
1947     SDLoc DL(N);
1948     return DAG.getNode(minMaxOpcToMin3Max3Opc(Opc),
1949                        DL,
1950                        N->getValueType(0),
1951                        Op0,
1952                        Op1.getOperand(0),
1953                        Op1.getOperand(1));
1954   }
1955
1956   return SDValue();
1957 }
1958
1959 SDValue SITargetLowering::performSetCCCombine(SDNode *N,
1960                                               DAGCombinerInfo &DCI) const {
1961   SelectionDAG &DAG = DCI.DAG;
1962   SDLoc SL(N);
1963
1964   SDValue LHS = N->getOperand(0);
1965   SDValue RHS = N->getOperand(1);
1966   EVT VT = LHS.getValueType();
1967
1968   if (VT != MVT::f32 && VT != MVT::f64)
1969     return SDValue();
1970
1971   // Match isinf pattern
1972   // (fcmp oeq (fabs x), inf) -> (fp_class x, (p_infinity | n_infinity))
1973   ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get();
1974   if (CC == ISD::SETOEQ && LHS.getOpcode() == ISD::FABS) {
1975     const ConstantFPSDNode *CRHS = dyn_cast<ConstantFPSDNode>(RHS);
1976     if (!CRHS)
1977       return SDValue();
1978
1979     const APFloat &APF = CRHS->getValueAPF();
1980     if (APF.isInfinity() && !APF.isNegative()) {
1981       unsigned Mask = SIInstrFlags::P_INFINITY | SIInstrFlags::N_INFINITY;
1982       return DAG.getNode(AMDGPUISD::FP_CLASS, SL, MVT::i1, LHS.getOperand(0),
1983                          DAG.getConstant(Mask, SL, MVT::i32));
1984     }
1985   }
1986
1987   return SDValue();
1988 }
1989
1990 SDValue SITargetLowering::PerformDAGCombine(SDNode *N,
1991                                             DAGCombinerInfo &DCI) const {
1992   SelectionDAG &DAG = DCI.DAG;
1993   SDLoc DL(N);
1994
1995   switch (N->getOpcode()) {
1996   default:
1997     return AMDGPUTargetLowering::PerformDAGCombine(N, DCI);
1998   case ISD::SETCC:
1999     return performSetCCCombine(N, DCI);
2000   case ISD::FMAXNUM: // TODO: What about fmax_legacy?
2001   case ISD::FMINNUM:
2002   case ISD::SMAX:
2003   case ISD::SMIN:
2004   case ISD::UMAX:
2005   case ISD::UMIN: {
2006     if (DCI.getDAGCombineLevel() >= AfterLegalizeDAG &&
2007         N->getValueType(0) != MVT::f64 &&
2008         getTargetMachine().getOptLevel() > CodeGenOpt::None)
2009       return performMin3Max3Combine(N, DCI);
2010     break;
2011   }
2012
2013   case AMDGPUISD::CVT_F32_UBYTE0:
2014   case AMDGPUISD::CVT_F32_UBYTE1:
2015   case AMDGPUISD::CVT_F32_UBYTE2:
2016   case AMDGPUISD::CVT_F32_UBYTE3: {
2017     unsigned Offset = N->getOpcode() - AMDGPUISD::CVT_F32_UBYTE0;
2018
2019     SDValue Src = N->getOperand(0);
2020     APInt Demanded = APInt::getBitsSet(32, 8 * Offset, 8 * Offset + 8);
2021
2022     APInt KnownZero, KnownOne;
2023     TargetLowering::TargetLoweringOpt TLO(DAG, !DCI.isBeforeLegalize(),
2024                                           !DCI.isBeforeLegalizeOps());
2025     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2026     if (TLO.ShrinkDemandedConstant(Src, Demanded) ||
2027         TLI.SimplifyDemandedBits(Src, Demanded, KnownZero, KnownOne, TLO)) {
2028       DCI.CommitTargetLoweringOpt(TLO);
2029     }
2030
2031     break;
2032   }
2033
2034   case ISD::UINT_TO_FP: {
2035     return performUCharToFloatCombine(N, DCI);
2036   }
2037   case ISD::FADD: {
2038     if (DCI.getDAGCombineLevel() < AfterLegalizeDAG)
2039       break;
2040
2041     EVT VT = N->getValueType(0);
2042     if (VT != MVT::f32)
2043       break;
2044
2045     // Only do this if we are not trying to support denormals. v_mad_f32 does
2046     // not support denormals ever.
2047     if (Subtarget->hasFP32Denormals())
2048       break;
2049
2050     SDValue LHS = N->getOperand(0);
2051     SDValue RHS = N->getOperand(1);
2052
2053     // These should really be instruction patterns, but writing patterns with
2054     // source modiifiers is a pain.
2055
2056     // fadd (fadd (a, a), b) -> mad 2.0, a, b
2057     if (LHS.getOpcode() == ISD::FADD) {
2058       SDValue A = LHS.getOperand(0);
2059       if (A == LHS.getOperand(1)) {
2060         const SDValue Two = DAG.getConstantFP(2.0, DL, MVT::f32);
2061         return DAG.getNode(ISD::FMAD, DL, VT, Two, A, RHS);
2062       }
2063     }
2064
2065     // fadd (b, fadd (a, a)) -> mad 2.0, a, b
2066     if (RHS.getOpcode() == ISD::FADD) {
2067       SDValue A = RHS.getOperand(0);
2068       if (A == RHS.getOperand(1)) {
2069         const SDValue Two = DAG.getConstantFP(2.0, DL, MVT::f32);
2070         return DAG.getNode(ISD::FMAD, DL, VT, Two, A, LHS);
2071       }
2072     }
2073
2074     return SDValue();
2075   }
2076   case ISD::FSUB: {
2077     if (DCI.getDAGCombineLevel() < AfterLegalizeDAG)
2078       break;
2079
2080     EVT VT = N->getValueType(0);
2081
2082     // Try to get the fneg to fold into the source modifier. This undoes generic
2083     // DAG combines and folds them into the mad.
2084     //
2085     // Only do this if we are not trying to support denormals. v_mad_f32 does
2086     // not support denormals ever.
2087     if (VT == MVT::f32 &&
2088         !Subtarget->hasFP32Denormals()) {
2089       SDValue LHS = N->getOperand(0);
2090       SDValue RHS = N->getOperand(1);
2091       if (LHS.getOpcode() == ISD::FADD) {
2092         // (fsub (fadd a, a), c) -> mad 2.0, a, (fneg c)
2093
2094         SDValue A = LHS.getOperand(0);
2095         if (A == LHS.getOperand(1)) {
2096           const SDValue Two = DAG.getConstantFP(2.0, DL, MVT::f32);
2097           SDValue NegRHS = DAG.getNode(ISD::FNEG, DL, VT, RHS);
2098
2099           return DAG.getNode(ISD::FMAD, DL, VT, Two, A, NegRHS);
2100         }
2101       }
2102
2103       if (RHS.getOpcode() == ISD::FADD) {
2104         // (fsub c, (fadd a, a)) -> mad -2.0, a, c
2105
2106         SDValue A = RHS.getOperand(0);
2107         if (A == RHS.getOperand(1)) {
2108           const SDValue NegTwo = DAG.getConstantFP(-2.0, DL, MVT::f32);
2109           return DAG.getNode(ISD::FMAD, DL, VT, NegTwo, A, LHS);
2110         }
2111       }
2112
2113       return SDValue();
2114     }
2115
2116     break;
2117   }
2118   case ISD::LOAD:
2119   case ISD::STORE:
2120   case ISD::ATOMIC_LOAD:
2121   case ISD::ATOMIC_STORE:
2122   case ISD::ATOMIC_CMP_SWAP:
2123   case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS:
2124   case ISD::ATOMIC_SWAP:
2125   case ISD::ATOMIC_LOAD_ADD:
2126   case ISD::ATOMIC_LOAD_SUB:
2127   case ISD::ATOMIC_LOAD_AND:
2128   case ISD::ATOMIC_LOAD_OR:
2129   case ISD::ATOMIC_LOAD_XOR:
2130   case ISD::ATOMIC_LOAD_NAND:
2131   case ISD::ATOMIC_LOAD_MIN:
2132   case ISD::ATOMIC_LOAD_MAX:
2133   case ISD::ATOMIC_LOAD_UMIN:
2134   case ISD::ATOMIC_LOAD_UMAX: { // TODO: Target mem intrinsics.
2135     if (DCI.isBeforeLegalize())
2136       break;
2137
2138     MemSDNode *MemNode = cast<MemSDNode>(N);
2139     SDValue Ptr = MemNode->getBasePtr();
2140
2141     // TODO: We could also do this for multiplies.
2142     unsigned AS = MemNode->getAddressSpace();
2143     if (Ptr.getOpcode() == ISD::SHL && AS != AMDGPUAS::PRIVATE_ADDRESS) {
2144       SDValue NewPtr = performSHLPtrCombine(Ptr.getNode(), AS, DCI);
2145       if (NewPtr) {
2146         SmallVector<SDValue, 8> NewOps(MemNode->op_begin(), MemNode->op_end());
2147
2148         NewOps[N->getOpcode() == ISD::STORE ? 2 : 1] = NewPtr;
2149         return SDValue(DAG.UpdateNodeOperands(MemNode, NewOps), 0);
2150       }
2151     }
2152     break;
2153   }
2154   case ISD::AND:
2155     return performAndCombine(N, DCI);
2156   case ISD::OR:
2157     return performOrCombine(N, DCI);
2158   case AMDGPUISD::FP_CLASS:
2159     return performClassCombine(N, DCI);
2160   }
2161   return AMDGPUTargetLowering::PerformDAGCombine(N, DCI);
2162 }
2163
2164 /// \brief Analyze the possible immediate value Op
2165 ///
2166 /// Returns -1 if it isn't an immediate, 0 if it's and inline immediate
2167 /// and the immediate value if it's a literal immediate
2168 int32_t SITargetLowering::analyzeImmediate(const SDNode *N) const {
2169
2170   const SIInstrInfo *TII =
2171       static_cast<const SIInstrInfo *>(Subtarget->getInstrInfo());
2172
2173   if (const ConstantSDNode *Node = dyn_cast<ConstantSDNode>(N)) {
2174     if (TII->isInlineConstant(Node->getAPIntValue()))
2175       return 0;
2176
2177     uint64_t Val = Node->getZExtValue();
2178     return isUInt<32>(Val) ? Val : -1;
2179   }
2180
2181   if (const ConstantFPSDNode *Node = dyn_cast<ConstantFPSDNode>(N)) {
2182     if (TII->isInlineConstant(Node->getValueAPF().bitcastToAPInt()))
2183       return 0;
2184
2185     if (Node->getValueType(0) == MVT::f32)
2186       return FloatToBits(Node->getValueAPF().convertToFloat());
2187
2188     return -1;
2189   }
2190
2191   return -1;
2192 }
2193
2194 /// \brief Helper function for adjustWritemask
2195 static unsigned SubIdx2Lane(unsigned Idx) {
2196   switch (Idx) {
2197   default: return 0;
2198   case AMDGPU::sub0: return 0;
2199   case AMDGPU::sub1: return 1;
2200   case AMDGPU::sub2: return 2;
2201   case AMDGPU::sub3: return 3;
2202   }
2203 }
2204
2205 /// \brief Adjust the writemask of MIMG instructions
2206 void SITargetLowering::adjustWritemask(MachineSDNode *&Node,
2207                                        SelectionDAG &DAG) const {
2208   SDNode *Users[4] = { };
2209   unsigned Lane = 0;
2210   unsigned OldDmask = Node->getConstantOperandVal(0);
2211   unsigned NewDmask = 0;
2212
2213   // Try to figure out the used register components
2214   for (SDNode::use_iterator I = Node->use_begin(), E = Node->use_end();
2215        I != E; ++I) {
2216
2217     // Abort if we can't understand the usage
2218     if (!I->isMachineOpcode() ||
2219         I->getMachineOpcode() != TargetOpcode::EXTRACT_SUBREG)
2220       return;
2221
2222     // Lane means which subreg of %VGPRa_VGPRb_VGPRc_VGPRd is used.
2223     // Note that subregs are packed, i.e. Lane==0 is the first bit set
2224     // in OldDmask, so it can be any of X,Y,Z,W; Lane==1 is the second bit
2225     // set, etc.
2226     Lane = SubIdx2Lane(I->getConstantOperandVal(1));
2227
2228     // Set which texture component corresponds to the lane.
2229     unsigned Comp;
2230     for (unsigned i = 0, Dmask = OldDmask; i <= Lane; i++) {
2231       assert(Dmask);
2232       Comp = countTrailingZeros(Dmask);
2233       Dmask &= ~(1 << Comp);
2234     }
2235
2236     // Abort if we have more than one user per component
2237     if (Users[Lane])
2238       return;
2239
2240     Users[Lane] = *I;
2241     NewDmask |= 1 << Comp;
2242   }
2243
2244   // Abort if there's no change
2245   if (NewDmask == OldDmask)
2246     return;
2247
2248   // Adjust the writemask in the node
2249   std::vector<SDValue> Ops;
2250   Ops.push_back(DAG.getTargetConstant(NewDmask, SDLoc(Node), MVT::i32));
2251   Ops.insert(Ops.end(), Node->op_begin() + 1, Node->op_end());
2252   Node = (MachineSDNode*)DAG.UpdateNodeOperands(Node, Ops);
2253
2254   // If we only got one lane, replace it with a copy
2255   // (if NewDmask has only one bit set...)
2256   if (NewDmask && (NewDmask & (NewDmask-1)) == 0) {
2257     SDValue RC = DAG.getTargetConstant(AMDGPU::VGPR_32RegClassID, SDLoc(),
2258                                        MVT::i32);
2259     SDNode *Copy = DAG.getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
2260                                       SDLoc(), Users[Lane]->getValueType(0),
2261                                       SDValue(Node, 0), RC);
2262     DAG.ReplaceAllUsesWith(Users[Lane], Copy);
2263     return;
2264   }
2265
2266   // Update the users of the node with the new indices
2267   for (unsigned i = 0, Idx = AMDGPU::sub0; i < 4; ++i) {
2268
2269     SDNode *User = Users[i];
2270     if (!User)
2271       continue;
2272
2273     SDValue Op = DAG.getTargetConstant(Idx, SDLoc(User), MVT::i32);
2274     DAG.UpdateNodeOperands(User, User->getOperand(0), Op);
2275
2276     switch (Idx) {
2277     default: break;
2278     case AMDGPU::sub0: Idx = AMDGPU::sub1; break;
2279     case AMDGPU::sub1: Idx = AMDGPU::sub2; break;
2280     case AMDGPU::sub2: Idx = AMDGPU::sub3; break;
2281     }
2282   }
2283 }
2284
2285 static bool isFrameIndexOp(SDValue Op) {
2286   if (Op.getOpcode() == ISD::AssertZext)
2287     Op = Op.getOperand(0);
2288
2289   return isa<FrameIndexSDNode>(Op);
2290 }
2291
2292 /// \brief Legalize target independent instructions (e.g. INSERT_SUBREG)
2293 /// with frame index operands.
2294 /// LLVM assumes that inputs are to these instructions are registers.
2295 void SITargetLowering::legalizeTargetIndependentNode(SDNode *Node,
2296                                                      SelectionDAG &DAG) const {
2297
2298   SmallVector<SDValue, 8> Ops;
2299   for (unsigned i = 0; i < Node->getNumOperands(); ++i) {
2300     if (!isFrameIndexOp(Node->getOperand(i))) {
2301       Ops.push_back(Node->getOperand(i));
2302       continue;
2303     }
2304
2305     SDLoc DL(Node);
2306     Ops.push_back(SDValue(DAG.getMachineNode(AMDGPU::S_MOV_B32, DL,
2307                                      Node->getOperand(i).getValueType(),
2308                                      Node->getOperand(i)), 0));
2309   }
2310
2311   DAG.UpdateNodeOperands(Node, Ops);
2312 }
2313
2314 /// \brief Fold the instructions after selecting them.
2315 SDNode *SITargetLowering::PostISelFolding(MachineSDNode *Node,
2316                                           SelectionDAG &DAG) const {
2317   const SIInstrInfo *TII =
2318       static_cast<const SIInstrInfo *>(Subtarget->getInstrInfo());
2319
2320   if (TII->isMIMG(Node->getMachineOpcode()))
2321     adjustWritemask(Node, DAG);
2322
2323   if (Node->getMachineOpcode() == AMDGPU::INSERT_SUBREG ||
2324       Node->getMachineOpcode() == AMDGPU::REG_SEQUENCE) {
2325     legalizeTargetIndependentNode(Node, DAG);
2326     return Node;
2327   }
2328   return Node;
2329 }
2330
2331 /// \brief Assign the register class depending on the number of
2332 /// bits set in the writemask
2333 void SITargetLowering::AdjustInstrPostInstrSelection(MachineInstr *MI,
2334                                                      SDNode *Node) const {
2335   const SIInstrInfo *TII =
2336       static_cast<const SIInstrInfo *>(Subtarget->getInstrInfo());
2337
2338   MachineRegisterInfo &MRI = MI->getParent()->getParent()->getRegInfo();
2339
2340   if (TII->isVOP3(MI->getOpcode())) {
2341     // Make sure constant bus requirements are respected.
2342     TII->legalizeOperandsVOP3(MRI, MI);
2343     return;
2344   }
2345
2346   if (TII->isMIMG(*MI)) {
2347     unsigned VReg = MI->getOperand(0).getReg();
2348     unsigned Writemask = MI->getOperand(1).getImm();
2349     unsigned BitsSet = 0;
2350     for (unsigned i = 0; i < 4; ++i)
2351       BitsSet += Writemask & (1 << i) ? 1 : 0;
2352
2353     const TargetRegisterClass *RC;
2354     switch (BitsSet) {
2355     default: return;
2356     case 1:  RC = &AMDGPU::VGPR_32RegClass; break;
2357     case 2:  RC = &AMDGPU::VReg_64RegClass; break;
2358     case 3:  RC = &AMDGPU::VReg_96RegClass; break;
2359     }
2360
2361     unsigned NewOpcode = TII->getMaskedMIMGOp(MI->getOpcode(), BitsSet);
2362     MI->setDesc(TII->get(NewOpcode));
2363     MRI.setRegClass(VReg, RC);
2364     return;
2365   }
2366
2367   // Replace unused atomics with the no return version.
2368   int NoRetAtomicOp = AMDGPU::getAtomicNoRetOp(MI->getOpcode());
2369   if (NoRetAtomicOp != -1) {
2370     if (!Node->hasAnyUseOfValue(0)) {
2371       MI->setDesc(TII->get(NoRetAtomicOp));
2372       MI->RemoveOperand(0);
2373     }
2374
2375     return;
2376   }
2377 }
2378
2379 static SDValue buildSMovImm32(SelectionDAG &DAG, SDLoc DL, uint64_t Val) {
2380   SDValue K = DAG.getTargetConstant(Val, DL, MVT::i32);
2381   return SDValue(DAG.getMachineNode(AMDGPU::S_MOV_B32, DL, MVT::i32, K), 0);
2382 }
2383
2384 MachineSDNode *SITargetLowering::wrapAddr64Rsrc(SelectionDAG &DAG,
2385                                                 SDLoc DL,
2386                                                 SDValue Ptr) const {
2387   const SIInstrInfo *TII =
2388     static_cast<const SIInstrInfo *>(Subtarget->getInstrInfo());
2389
2390   // Build the half of the subregister with the constants before building the
2391   // full 128-bit register. If we are building multiple resource descriptors,
2392   // this will allow CSEing of the 2-component register.
2393   const SDValue Ops0[] = {
2394     DAG.getTargetConstant(AMDGPU::SGPR_64RegClassID, DL, MVT::i32),
2395     buildSMovImm32(DAG, DL, 0),
2396     DAG.getTargetConstant(AMDGPU::sub0, DL, MVT::i32),
2397     buildSMovImm32(DAG, DL, TII->getDefaultRsrcDataFormat() >> 32),
2398     DAG.getTargetConstant(AMDGPU::sub1, DL, MVT::i32)
2399   };
2400
2401   SDValue SubRegHi = SDValue(DAG.getMachineNode(AMDGPU::REG_SEQUENCE, DL,
2402                                                 MVT::v2i32, Ops0), 0);
2403
2404   // Combine the constants and the pointer.
2405   const SDValue Ops1[] = {
2406     DAG.getTargetConstant(AMDGPU::SReg_128RegClassID, DL, MVT::i32),
2407     Ptr,
2408     DAG.getTargetConstant(AMDGPU::sub0_sub1, DL, MVT::i32),
2409     SubRegHi,
2410     DAG.getTargetConstant(AMDGPU::sub2_sub3, DL, MVT::i32)
2411   };
2412
2413   return DAG.getMachineNode(AMDGPU::REG_SEQUENCE, DL, MVT::v4i32, Ops1);
2414 }
2415
2416 /// \brief Return a resource descriptor with the 'Add TID' bit enabled
2417 ///        The TID (Thread ID) is multiplied by the stride value (bits [61:48]
2418 ///        of the resource descriptor) to create an offset, which is added to
2419 ///        the resource pointer.
2420 MachineSDNode *SITargetLowering::buildRSRC(SelectionDAG &DAG,
2421                                            SDLoc DL,
2422                                            SDValue Ptr,
2423                                            uint32_t RsrcDword1,
2424                                            uint64_t RsrcDword2And3) const {
2425   SDValue PtrLo = DAG.getTargetExtractSubreg(AMDGPU::sub0, DL, MVT::i32, Ptr);
2426   SDValue PtrHi = DAG.getTargetExtractSubreg(AMDGPU::sub1, DL, MVT::i32, Ptr);
2427   if (RsrcDword1) {
2428     PtrHi = SDValue(DAG.getMachineNode(AMDGPU::S_OR_B32, DL, MVT::i32, PtrHi,
2429                                      DAG.getConstant(RsrcDword1, DL, MVT::i32)),
2430                     0);
2431   }
2432
2433   SDValue DataLo = buildSMovImm32(DAG, DL,
2434                                   RsrcDword2And3 & UINT64_C(0xFFFFFFFF));
2435   SDValue DataHi = buildSMovImm32(DAG, DL, RsrcDword2And3 >> 32);
2436
2437   const SDValue Ops[] = {
2438     DAG.getTargetConstant(AMDGPU::SReg_128RegClassID, DL, MVT::i32),
2439     PtrLo,
2440     DAG.getTargetConstant(AMDGPU::sub0, DL, MVT::i32),
2441     PtrHi,
2442     DAG.getTargetConstant(AMDGPU::sub1, DL, MVT::i32),
2443     DataLo,
2444     DAG.getTargetConstant(AMDGPU::sub2, DL, MVT::i32),
2445     DataHi,
2446     DAG.getTargetConstant(AMDGPU::sub3, DL, MVT::i32)
2447   };
2448
2449   return DAG.getMachineNode(AMDGPU::REG_SEQUENCE, DL, MVT::v4i32, Ops);
2450 }
2451
2452 SDValue SITargetLowering::CreateLiveInRegister(SelectionDAG &DAG,
2453                                                const TargetRegisterClass *RC,
2454                                                unsigned Reg, EVT VT) const {
2455   SDValue VReg = AMDGPUTargetLowering::CreateLiveInRegister(DAG, RC, Reg, VT);
2456
2457   return DAG.getCopyFromReg(DAG.getEntryNode(), SDLoc(DAG.getEntryNode()),
2458                             cast<RegisterSDNode>(VReg)->getReg(), VT);
2459 }
2460
2461 //===----------------------------------------------------------------------===//
2462 //                         SI Inline Assembly Support
2463 //===----------------------------------------------------------------------===//
2464
2465 std::pair<unsigned, const TargetRegisterClass *>
2466 SITargetLowering::getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
2467                                                StringRef Constraint,
2468                                                MVT VT) const {
2469
2470   if (Constraint.size() == 1) {
2471     switch (Constraint[0]) {
2472     case 's':
2473     case 'r':
2474       switch (VT.getSizeInBits()) {
2475       default:
2476         return std::make_pair(0U, nullptr);
2477       case 32:
2478         return std::make_pair(0U, &AMDGPU::SGPR_32RegClass);
2479       case 64:
2480         return std::make_pair(0U, &AMDGPU::SGPR_64RegClass);
2481       case 128:
2482         return std::make_pair(0U, &AMDGPU::SReg_128RegClass);
2483       case 256:
2484         return std::make_pair(0U, &AMDGPU::SReg_256RegClass);
2485       }
2486
2487     case 'v':
2488       switch (VT.getSizeInBits()) {
2489       default:
2490         return std::make_pair(0U, nullptr);
2491       case 32:
2492         return std::make_pair(0U, &AMDGPU::VGPR_32RegClass);
2493       case 64:
2494         return std::make_pair(0U, &AMDGPU::VReg_64RegClass);
2495       case 96:
2496         return std::make_pair(0U, &AMDGPU::VReg_96RegClass);
2497       case 128:
2498         return std::make_pair(0U, &AMDGPU::VReg_128RegClass);
2499       case 256:
2500         return std::make_pair(0U, &AMDGPU::VReg_256RegClass);
2501       case 512:
2502         return std::make_pair(0U, &AMDGPU::VReg_512RegClass);
2503       }
2504     }
2505   }
2506
2507   if (Constraint.size() > 1) {
2508     const TargetRegisterClass *RC = nullptr;
2509     if (Constraint[1] == 'v') {
2510       RC = &AMDGPU::VGPR_32RegClass;
2511     } else if (Constraint[1] == 's') {
2512       RC = &AMDGPU::SGPR_32RegClass;
2513     }
2514
2515     if (RC) {
2516       uint32_t Idx;
2517       bool Failed = Constraint.substr(2).getAsInteger(10, Idx);
2518       if (!Failed && Idx < RC->getNumRegs())
2519         return std::make_pair(RC->getRegister(Idx), RC);
2520     }
2521   }
2522   return TargetLowering::getRegForInlineAsmConstraint(TRI, Constraint, VT);
2523 }
2524
2525 SITargetLowering::ConstraintType
2526 SITargetLowering::getConstraintType(StringRef Constraint) const {
2527   if (Constraint.size() == 1) {
2528     switch (Constraint[0]) {
2529     default: break;
2530     case 's':
2531     case 'v':
2532       return C_RegisterClass;
2533     }
2534   }
2535   return TargetLowering::getConstraintType(Constraint);
2536 }