lib/Target/NVPTX/NVPTXInstrInfo.td

   1 //===- NVPTXInstrInfo.td - NVPTX Instruction defs -------------*- tblgen-*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the PTX instructions in TableGen format.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 include "NVPTXInstrFormats.td"
  15
  16 // A NOP instruction
  17 def NOP : NVPTXInst<(outs), (ins), "", []>;
  18
  19 // List of vector specific properties
  20 def isVecLD      : VecInstTypeEnum<1>;
  21 def isVecST      : VecInstTypeEnum<2>;
  22 def isVecBuild   : VecInstTypeEnum<3>;
  23 def isVecShuffle : VecInstTypeEnum<4>;
  24 def isVecExtract : VecInstTypeEnum<5>;
  25 def isVecInsert  : VecInstTypeEnum<6>;
  26 def isVecDest    : VecInstTypeEnum<7>;
  27 def isVecOther   : VecInstTypeEnum<15>;
  28
  29 //===----------------------------------------------------------------------===//
  30 // NVPTX Operand Definitions.
  31 //===----------------------------------------------------------------------===//
  32
  33 def brtarget    : Operand<OtherVT>;
  34
  35 // CVT conversion modes
  36 // These must match the enum in NVPTX.h
  37 def CvtNONE : PatLeaf<(i32 0x0)>;
  38 def CvtRNI  : PatLeaf<(i32 0x1)>;
  39 def CvtRZI  : PatLeaf<(i32 0x2)>;
  40 def CvtRMI  : PatLeaf<(i32 0x3)>;
  41 def CvtRPI  : PatLeaf<(i32 0x4)>;
  42 def CvtRN   : PatLeaf<(i32 0x5)>;
  43 def CvtRZ   : PatLeaf<(i32 0x6)>;
  44 def CvtRM   : PatLeaf<(i32 0x7)>;
  45 def CvtRP   : PatLeaf<(i32 0x8)>;
  46
  47 def CvtNONE_FTZ : PatLeaf<(i32 0x10)>;
  48 def CvtRNI_FTZ  : PatLeaf<(i32 0x11)>;
  49 def CvtRZI_FTZ  : PatLeaf<(i32 0x12)>;
  50 def CvtRMI_FTZ  : PatLeaf<(i32 0x13)>;
  51 def CvtRPI_FTZ  : PatLeaf<(i32 0x14)>;
  52 def CvtRN_FTZ   : PatLeaf<(i32 0x15)>;
  53 def CvtRZ_FTZ   : PatLeaf<(i32 0x16)>;
  54 def CvtRM_FTZ   : PatLeaf<(i32 0x17)>;
  55 def CvtRP_FTZ   : PatLeaf<(i32 0x18)>;
  56
  57 def CvtSAT      : PatLeaf<(i32 0x20)>;
  58 def CvtSAT_FTZ  : PatLeaf<(i32 0x30)>;
  59
  60 def CvtMode : Operand<i32> {
  61   let PrintMethod = "printCvtMode";
  62 }
  63
  64 // Compare modes
  65 // These must match the enum in NVPTX.h
  66 def CmpEQ   : PatLeaf<(i32 0)>;
  67 def CmpNE   : PatLeaf<(i32 1)>;
  68 def CmpLT   : PatLeaf<(i32 2)>;
  69 def CmpLE   : PatLeaf<(i32 3)>;
  70 def CmpGT   : PatLeaf<(i32 4)>;
  71 def CmpGE   : PatLeaf<(i32 5)>;
  72 def CmpLO   : PatLeaf<(i32 6)>;
  73 def CmpLS   : PatLeaf<(i32 7)>;
  74 def CmpHI   : PatLeaf<(i32 8)>;
  75 def CmpHS   : PatLeaf<(i32 9)>;
  76 def CmpEQU  : PatLeaf<(i32 10)>;
  77 def CmpNEU  : PatLeaf<(i32 11)>;
  78 def CmpLTU  : PatLeaf<(i32 12)>;
  79 def CmpLEU  : PatLeaf<(i32 13)>;
  80 def CmpGTU  : PatLeaf<(i32 14)>;
  81 def CmpGEU  : PatLeaf<(i32 15)>;
  82 def CmpNUM  : PatLeaf<(i32 16)>;
  83 def CmpNAN  : PatLeaf<(i32 17)>;
  84
  85 def CmpEQ_FTZ   : PatLeaf<(i32 0x100)>;
  86 def CmpNE_FTZ   : PatLeaf<(i32 0x101)>;
  87 def CmpLT_FTZ   : PatLeaf<(i32 0x102)>;
  88 def CmpLE_FTZ   : PatLeaf<(i32 0x103)>;
  89 def CmpGT_FTZ   : PatLeaf<(i32 0x104)>;
  90 def CmpGE_FTZ   : PatLeaf<(i32 0x105)>;
  91 def CmpLO_FTZ   : PatLeaf<(i32 0x106)>;
  92 def CmpLS_FTZ   : PatLeaf<(i32 0x107)>;
  93 def CmpHI_FTZ   : PatLeaf<(i32 0x108)>;
  94 def CmpHS_FTZ   : PatLeaf<(i32 0x109)>;
  95 def CmpEQU_FTZ  : PatLeaf<(i32 0x10A)>;
  96 def CmpNEU_FTZ  : PatLeaf<(i32 0x10B)>;
  97 def CmpLTU_FTZ  : PatLeaf<(i32 0x10C)>;
  98 def CmpLEU_FTZ  : PatLeaf<(i32 0x10D)>;
  99 def CmpGTU_FTZ  : PatLeaf<(i32 0x10E)>;
 100 def CmpGEU_FTZ  : PatLeaf<(i32 0x10F)>;
 101 def CmpNUM_FTZ  : PatLeaf<(i32 0x110)>;
 102 def CmpNAN_FTZ  : PatLeaf<(i32 0x111)>;
 103
 104 def CmpMode : Operand<i32> {
 105   let PrintMethod = "printCmpMode";
 106 }
 107
 108 def F32ConstZero : Operand<f32>, PatLeaf<(f32 fpimm)>, SDNodeXForm<fpimm, [{
 109     return CurDAG->getTargetConstantFP(0.0, MVT::f32);
 110   }]>;
 111 def F32ConstOne : Operand<f32>, PatLeaf<(f32 fpimm)>, SDNodeXForm<fpimm, [{
 112     return CurDAG->getTargetConstantFP(1.0, MVT::f32);
 113   }]>;
 114
 115 //===----------------------------------------------------------------------===//
 116 // NVPTX Instruction Predicate Definitions
 117 //===----------------------------------------------------------------------===//
 118
 119
 120 def hasAtomRedG32 : Predicate<"Subtarget.hasAtomRedG32()">;
 121 def hasAtomRedS32 : Predicate<"Subtarget.hasAtomRedS32()">;
 122 def hasAtomRedGen32 : Predicate<"Subtarget.hasAtomRedGen32()">;
 123 def useAtomRedG32forGen32 :
 124   Predicate<"!Subtarget.hasAtomRedGen32() && Subtarget.hasAtomRedG32()">;
 125 def hasBrkPt : Predicate<"Subtarget.hasBrkPt()">;
 126 def hasAtomRedG64 : Predicate<"Subtarget.hasAtomRedG64()">;
 127 def hasAtomRedS64 : Predicate<"Subtarget.hasAtomRedS64()">;
 128 def hasAtomRedGen64 : Predicate<"Subtarget.hasAtomRedGen64()">;
 129 def useAtomRedG64forGen64 :
 130   Predicate<"!Subtarget.hasAtomRedGen64() && Subtarget.hasAtomRedG64()">;
 131 def hasAtomAddF32 : Predicate<"Subtarget.hasAtomAddF32()">;
 132 def hasVote : Predicate<"Subtarget.hasVote()">;
 133 def hasDouble : Predicate<"Subtarget.hasDouble()">;
 134 def reqPTX20 : Predicate<"Subtarget.reqPTX20()">;
 135 def hasLDG : Predicate<"Subtarget.hasLDG()">;
 136 def hasLDU : Predicate<"Subtarget.hasLDU()">;
 137 def hasGenericLdSt : Predicate<"Subtarget.hasGenericLdSt()">;
 138
 139 def doF32FTZ : Predicate<"useF32FTZ()">;
 140 def doNoF32FTZ : Predicate<"!useF32FTZ()">;
 141
 142 def doFMAF32      : Predicate<"doFMAF32">;
 143 def doFMAF32_ftz  : Predicate<"(doFMAF32 && useF32FTZ())">;
 144 def doFMAF32AGG      : Predicate<"doFMAF32AGG">;
 145 def doFMAF32AGG_ftz  : Predicate<"(doFMAF32AGG && useF32FTZ())">;
 146 def doFMAF64      : Predicate<"doFMAF64">;
 147 def doFMAF64AGG      : Predicate<"doFMAF64AGG">;
 148
 149 def doMulWide      : Predicate<"doMulWide">;
 150
 151 def allowFMA : Predicate<"allowFMA">;
 152 def allowFMA_ftz : Predicate<"(allowFMA && useF32FTZ())">;
 153
 154 def do_DIVF32_APPROX : Predicate<"getDivF32Level()==0">;
 155 def do_DIVF32_FULL : Predicate<"getDivF32Level()==1">;
 156
 157 def do_SQRTF32_APPROX : Predicate<"!usePrecSqrtF32()">;
 158 def do_SQRTF32_RN : Predicate<"usePrecSqrtF32()">;
 159
 160 def hasHWROT32 : Predicate<"Subtarget.hasHWROT32()">;
 161
 162 def true : Predicate<"1">;
 163
 164 def hasPTX31 : Predicate<"Subtarget.getPTXVersion() >= 31">;
 165
 166
 167 //===----------------------------------------------------------------------===//
 168 // Some Common Instruction Class Templates
 169 //===----------------------------------------------------------------------===//
 170
 171 multiclass I3<string OpcStr, SDNode OpNode> {
 172   def i64rr : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$a, Int64Regs:$b),
 173                      !strconcat(OpcStr, "64 \t$dst, $a, $b;"),
 174                      [(set Int64Regs:$dst, (OpNode Int64Regs:$a,
 175                        Int64Regs:$b))]>;
 176   def i64ri : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$a, i64imm:$b),
 177                      !strconcat(OpcStr, "64 \t$dst, $a, $b;"),
 178                      [(set Int64Regs:$dst, (OpNode Int64Regs:$a, imm:$b))]>;
 179   def i32rr : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$a, Int32Regs:$b),
 180                      !strconcat(OpcStr, "32 \t$dst, $a, $b;"),
 181                      [(set Int32Regs:$dst, (OpNode Int32Regs:$a,
 182                        Int32Regs:$b))]>;
 183   def i32ri : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$a, i32imm:$b),
 184                      !strconcat(OpcStr, "32 \t$dst, $a, $b;"),
 185                      [(set Int32Regs:$dst, (OpNode Int32Regs:$a, imm:$b))]>;
 186   def i16rr : NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$a, Int16Regs:$b),
 187                      !strconcat(OpcStr, "16 \t$dst, $a, $b;"),
 188                      [(set Int16Regs:$dst, (OpNode Int16Regs:$a,
 189                        Int16Regs:$b))]>;
 190   def i16ri : NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$a, i16imm:$b),
 191                      !strconcat(OpcStr, "16 \t$dst, $a, $b;"),
 192                      [(set Int16Regs:$dst, (OpNode Int16Regs:$a, (imm):$b))]>;
 193 }
 194
 195 multiclass ADD_SUB_INT_32<string OpcStr, SDNode OpNode> {
 196    def i32rr : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$a,
 197        Int32Regs:$b),
 198                       !strconcat(OpcStr, ".s32 \t$dst, $a, $b;"),
 199                       [(set Int32Regs:$dst, (OpNode Int32Regs:$a,
 200                         Int32Regs:$b))]>;
 201    def i32ri : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$a, i32imm:$b),
 202                       !strconcat(OpcStr, ".s32 \t$dst, $a, $b;"),
 203                       [(set Int32Regs:$dst, (OpNode Int32Regs:$a, imm:$b))]>;
 204 }
 205
 206 multiclass F3<string OpcStr, SDNode OpNode> {
 207    def f64rr : NVPTXInst<(outs Float64Regs:$dst),
 208                       (ins Float64Regs:$a, Float64Regs:$b),
 209                       !strconcat(OpcStr, ".f64 \t$dst, $a, $b;"),
 210                       [(set Float64Regs:$dst,
 211                         (OpNode Float64Regs:$a, Float64Regs:$b))]>,
 212                       Requires<[allowFMA]>;
 213    def f64ri : NVPTXInst<(outs Float64Regs:$dst),
 214                       (ins Float64Regs:$a, f64imm:$b),
 215                       !strconcat(OpcStr, ".f64 \t$dst, $a, $b;"),
 216                       [(set Float64Regs:$dst,
 217                         (OpNode Float64Regs:$a, fpimm:$b))]>,
 218                       Requires<[allowFMA]>;
 219    def f32rr_ftz : NVPTXInst<(outs Float32Regs:$dst),
 220                       (ins Float32Regs:$a, Float32Regs:$b),
 221                       !strconcat(OpcStr, ".ftz.f32 \t$dst, $a, $b;"),
 222                       [(set Float32Regs:$dst,
 223                         (OpNode Float32Regs:$a, Float32Regs:$b))]>,
 224                       Requires<[allowFMA_ftz]>;
 225    def f32ri_ftz : NVPTXInst<(outs Float32Regs:$dst),
 226                       (ins Float32Regs:$a, f32imm:$b),
 227                       !strconcat(OpcStr, ".ftz.f32 \t$dst, $a, $b;"),
 228                       [(set Float32Regs:$dst,
 229                         (OpNode Float32Regs:$a, fpimm:$b))]>,
 230                       Requires<[allowFMA_ftz]>;
 231    def f32rr : NVPTXInst<(outs Float32Regs:$dst),
 232                       (ins Float32Regs:$a, Float32Regs:$b),
 233                       !strconcat(OpcStr, ".f32 \t$dst, $a, $b;"),
 234                       [(set Float32Regs:$dst,
 235                         (OpNode Float32Regs:$a, Float32Regs:$b))]>,
 236                       Requires<[allowFMA]>;
 237    def f32ri : NVPTXInst<(outs Float32Regs:$dst),
 238                       (ins Float32Regs:$a, f32imm:$b),
 239                       !strconcat(OpcStr, ".f32 \t$dst, $a, $b;"),
 240                       [(set Float32Regs:$dst,
 241                         (OpNode Float32Regs:$a, fpimm:$b))]>,
 242                       Requires<[allowFMA]>;
 243 }
 244
 245 multiclass F3_rn<string OpcStr, SDNode OpNode> {
 246    def f64rr : NVPTXInst<(outs Float64Regs:$dst),
 247                       (ins Float64Regs:$a, Float64Regs:$b),
 248                       !strconcat(OpcStr, ".rn.f64 \t$dst, $a, $b;"),
 249                       [(set Float64Regs:$dst,
 250                         (OpNode Float64Regs:$a, Float64Regs:$b))]>;
 251    def f64ri : NVPTXInst<(outs Float64Regs:$dst),
 252                       (ins Float64Regs:$a, f64imm:$b),
 253                       !strconcat(OpcStr, ".rn.f64 \t$dst, $a, $b;"),
 254                       [(set Float64Regs:$dst,
 255                         (OpNode Float64Regs:$a, fpimm:$b))]>;
 256    def f32rr_ftz : NVPTXInst<(outs Float32Regs:$dst),
 257                       (ins Float32Regs:$a, Float32Regs:$b),
 258                       !strconcat(OpcStr, ".rn.ftz.f32 \t$dst, $a, $b;"),
 259                       [(set Float32Regs:$dst,
 260                         (OpNode Float32Regs:$a, Float32Regs:$b))]>,
 261                       Requires<[doF32FTZ]>;
 262    def f32ri_ftz : NVPTXInst<(outs Float32Regs:$dst),
 263                       (ins Float32Regs:$a, f32imm:$b),
 264                       !strconcat(OpcStr, ".rn.ftz.f32 \t$dst, $a, $b;"),
 265                       [(set Float32Regs:$dst,
 266                         (OpNode Float32Regs:$a, fpimm:$b))]>,
 267                       Requires<[doF32FTZ]>;
 268    def f32rr : NVPTXInst<(outs Float32Regs:$dst),
 269                       (ins Float32Regs:$a, Float32Regs:$b),
 270                       !strconcat(OpcStr, ".rn.f32 \t$dst, $a, $b;"),
 271                       [(set Float32Regs:$dst,
 272                         (OpNode Float32Regs:$a, Float32Regs:$b))]>;
 273    def f32ri : NVPTXInst<(outs Float32Regs:$dst),
 274                       (ins Float32Regs:$a, f32imm:$b),
 275                       !strconcat(OpcStr, ".rn.f32 \t$dst, $a, $b;"),
 276                       [(set Float32Regs:$dst,
 277                         (OpNode Float32Regs:$a, fpimm:$b))]>;
 278 }
 279
 280 multiclass F2<string OpcStr, SDNode OpNode> {
 281    def f64 : NVPTXInst<(outs Float64Regs:$dst), (ins Float64Regs:$a),
 282                       !strconcat(OpcStr, ".f64 \t$dst, $a;"),
 283                       [(set Float64Regs:$dst, (OpNode Float64Regs:$a))]>;
 284    def f32_ftz : NVPTXInst<(outs Float32Regs:$dst), (ins Float32Regs:$a),
 285                       !strconcat(OpcStr, ".ftz.f32 \t$dst, $a;"),
 286                       [(set Float32Regs:$dst, (OpNode Float32Regs:$a))]>,
 287                       Requires<[doF32FTZ]>;
 288    def f32 : NVPTXInst<(outs Float32Regs:$dst), (ins Float32Regs:$a),
 289                       !strconcat(OpcStr, ".f32 \t$dst, $a;"),
 290                       [(set Float32Regs:$dst, (OpNode Float32Regs:$a))]>;
 291 }
 292
 293 //===----------------------------------------------------------------------===//
 294 // NVPTX Instructions.
 295 //===----------------------------------------------------------------------===//
 296
 297 //-----------------------------------
 298 // General Type Conversion
 299 //-----------------------------------
 300
 301 let neverHasSideEffects = 1 in {
 302 // Generate a cvt to the given type from all possible types.
 303 // Each instance takes a CvtMode immediate that defines the conversion mode to
 304 // use.  It can be CvtNONE to omit a conversion mode.
 305 multiclass CVT_FROM_ALL<string FromName, RegisterClass RC> {
 306   def _s16 : NVPTXInst<(outs RC:$dst),
 307                        (ins Int16Regs:$src, CvtMode:$mode),
 308                        !strconcat("cvt${mode:base}${mode:ftz}${mode:sat}.",
 309                        FromName, ".s16\t$dst, $src;"),
 310                        []>;
 311   def _u16 : NVPTXInst<(outs RC:$dst),
 312                        (ins Int16Regs:$src, CvtMode:$mode),
 313                        !strconcat("cvt${mode:base}${mode:ftz}${mode:sat}.",
 314                        FromName, ".u16\t$dst, $src;"),
 315                        []>;
 316   def _f16 : NVPTXInst<(outs RC:$dst),
 317                        (ins Int16Regs:$src, CvtMode:$mode),
 318                        !strconcat("cvt${mode:base}${mode:ftz}${mode:sat}.",
 319                        FromName, ".f16\t$dst, $src;"),
 320                        []>;
 321   def _s32 : NVPTXInst<(outs RC:$dst),
 322                        (ins Int32Regs:$src, CvtMode:$mode),
 323                        !strconcat("cvt${mode:base}${mode:ftz}${mode:sat}.",
 324                        FromName, ".s32\t$dst, $src;"),
 325                        []>;
 326   def _u32 : NVPTXInst<(outs RC:$dst),
 327                        (ins Int32Regs:$src, CvtMode:$mode),
 328                        !strconcat("cvt${mode:base}${mode:ftz}${mode:sat}.",
 329                        FromName, ".u32\t$dst, $src;"),
 330                        []>;
 331   def _s64 : NVPTXInst<(outs RC:$dst),
 332                        (ins Int64Regs:$src, CvtMode:$mode),
 333                        !strconcat("cvt${mode:base}${mode:ftz}${mode:sat}.",
 334                        FromName, ".s64\t$dst, $src;"),
 335                        []>;
 336   def _u64 : NVPTXInst<(outs RC:$dst),
 337                        (ins Int64Regs:$src, CvtMode:$mode),
 338                        !strconcat("cvt${mode:base}${mode:ftz}${mode:sat}.",
 339                        FromName, ".u64\t$dst, $src;"),
 340                        []>;
 341   def _f32 : NVPTXInst<(outs RC:$dst),
 342                        (ins Float32Regs:$src, CvtMode:$mode),
 343                        !strconcat("cvt${mode:base}${mode:ftz}${mode:sat}.",
 344                        FromName, ".f32\t$dst, $src;"),
 345                        []>;
 346   def _f64 : NVPTXInst<(outs RC:$dst),
 347                        (ins Float64Regs:$src, CvtMode:$mode),
 348                        !strconcat("cvt${mode:base}${mode:ftz}${mode:sat}.",
 349                        FromName, ".f64\t$dst, $src;"),
 350                        []>;
 351 }
 352
 353 // Generate a cvt to all possible types.
 354 defm CVT_s16 : CVT_FROM_ALL<"s16", Int16Regs>;
 355 defm CVT_u16 : CVT_FROM_ALL<"u16", Int16Regs>;
 356 defm CVT_f16 : CVT_FROM_ALL<"f16", Int16Regs>;
 357 defm CVT_s32 : CVT_FROM_ALL<"s32", Int32Regs>;
 358 defm CVT_u32 : CVT_FROM_ALL<"u32", Int32Regs>;
 359 defm CVT_s64 : CVT_FROM_ALL<"s64", Int64Regs>;
 360 defm CVT_u64 : CVT_FROM_ALL<"u64", Int64Regs>;
 361 defm CVT_f32 : CVT_FROM_ALL<"f32", Float32Regs>;
 362 defm CVT_f64 : CVT_FROM_ALL<"f64", Float64Regs>;
 363
 364 // This set of cvt is different from the above. The type of the source
 365 // and target are the same.
 366 //
 367 def CVT_INREG_s16_s8 : NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$src),
 368                         "cvt.s16.s8 \t$dst, $src;", []>;
 369 def CVT_INREG_s32_s8 : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$src),
 370                         "cvt.s32.s8 \t$dst, $src;", []>;
 371 def CVT_INREG_s32_s16 : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$src),
 372                         "cvt.s32.s16 \t$dst, $src;", []>;
 373 def CVT_INREG_s64_s8 : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$src),
 374                         "cvt.s64.s8 \t$dst, $src;", []>;
 375 def CVT_INREG_s64_s16 : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$src),
 376                         "cvt.s64.s16 \t$dst, $src;", []>;
 377 def CVT_INREG_s64_s32 : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$src),
 378                         "cvt.s64.s32 \t$dst, $src;", []>;
 379 }
 380
 381 //-----------------------------------
 382 // Integer Arithmetic
 383 //-----------------------------------
 384
 385 multiclass ADD_SUB_i1<SDNode OpNode> {
 386    def _rr: NVPTXInst<(outs Int1Regs:$dst), (ins Int1Regs:$a, Int1Regs:$b),
 387           "xor.pred \t$dst, $a, $b;",
 388       [(set Int1Regs:$dst, (OpNode Int1Regs:$a, Int1Regs:$b))]>;
 389    def _ri: NVPTXInst<(outs Int1Regs:$dst), (ins Int1Regs:$a, i1imm:$b),
 390           "xor.pred \t$dst, $a, $b;",
 391       [(set Int1Regs:$dst, (OpNode Int1Regs:$a, (imm):$b))]>;
 392 }
 393
 394 defm ADD_i1 : ADD_SUB_i1<add>;
 395 defm SUB_i1 : ADD_SUB_i1<sub>;
 396
 397
 398 defm ADD : I3<"add.s", add>;
 399 defm SUB : I3<"sub.s", sub>;
 400
 401 defm ADDCC : ADD_SUB_INT_32<"add.cc", addc>;
 402 defm SUBCC : ADD_SUB_INT_32<"sub.cc", subc>;
 403
 404 defm ADDCCC : ADD_SUB_INT_32<"addc.cc", adde>;
 405 defm SUBCCC : ADD_SUB_INT_32<"subc.cc", sube>;
 406
 407 //mul.wide PTX instruction
 408 def SInt32Const : PatLeaf<(imm), [{
 409   const APInt &v = N->getAPIntValue();
 410   if (v.isSignedIntN(32))
 411     return true;
 412   return false;
 413 }]>;
 414
 415 def UInt32Const : PatLeaf<(imm), [{
 416   const APInt &v = N->getAPIntValue();
 417   if (v.isIntN(32))
 418     return true;
 419   return false;
 420 }]>;
 421
 422 def SInt16Const : PatLeaf<(imm), [{
 423   const APInt &v = N->getAPIntValue();
 424   if (v.isSignedIntN(16))
 425     return true;
 426   return false;
 427 }]>;
 428
 429 def UInt16Const : PatLeaf<(imm), [{
 430   const APInt &v = N->getAPIntValue();
 431   if (v.isIntN(16))
 432     return true;
 433   return false;
 434 }]>;
 435
 436 def Int5Const : PatLeaf<(imm), [{
 437   const APInt &v = N->getAPIntValue();
 438   // Check if 0 <= v < 32
 439   // Only then the result from (x << v) will be i32
 440   if (v.sge(0) && v.slt(32))
 441     return true;
 442   return false;
 443 }]>;
 444
 445 def Int4Const : PatLeaf<(imm), [{
 446   const APInt &v = N->getAPIntValue();
 447   // Check if 0 <= v < 16
 448   // Only then the result from (x << v) will be i16
 449   if (v.sge(0) && v.slt(16))
 450     return true;
 451   return false;
 452 }]>;
 453
 454 def SHL2MUL32 : SDNodeXForm<imm, [{
 455   const APInt &v = N->getAPIntValue();
 456   APInt temp(32, 1);
 457   return CurDAG->getTargetConstant(temp.shl(v), MVT::i32);
 458 }]>;
 459
 460 def SHL2MUL16 : SDNodeXForm<imm, [{
 461   const APInt &v = N->getAPIntValue();
 462   APInt temp(16, 1);
 463   return CurDAG->getTargetConstant(temp.shl(v), MVT::i16);
 464 }]>;
 465
 466 def MULWIDES64 : NVPTXInst<(outs Int64Regs:$dst),
 467                            (ins Int32Regs:$a, Int32Regs:$b),
 468                            "mul.wide.s32 \t$dst, $a, $b;", []>;
 469 def MULWIDES64Imm : NVPTXInst<(outs Int64Regs:$dst),
 470                             (ins Int32Regs:$a, i64imm:$b),
 471                            "mul.wide.s32 \t$dst, $a, $b;", []>;
 472
 473 def MULWIDEU64 : NVPTXInst<(outs Int64Regs:$dst),
 474                            (ins Int32Regs:$a, Int32Regs:$b),
 475                            "mul.wide.u32 \t$dst, $a, $b;", []>;
 476 def MULWIDEU64Imm : NVPTXInst<(outs Int64Regs:$dst),
 477                             (ins Int32Regs:$a, i64imm:$b),
 478                            "mul.wide.u32 \t$dst, $a, $b;", []>;
 479
 480 def MULWIDES32 : NVPTXInst<(outs Int32Regs:$dst),
 481                             (ins Int16Regs:$a, Int16Regs:$b),
 482                            "mul.wide.s16 \t$dst, $a, $b;", []>;
 483 def MULWIDES32Imm : NVPTXInst<(outs Int32Regs:$dst),
 484                             (ins Int16Regs:$a, i32imm:$b),
 485                            "mul.wide.s16 \t$dst, $a, $b;", []>;
 486
 487 def MULWIDEU32 : NVPTXInst<(outs Int32Regs:$dst),
 488                             (ins Int16Regs:$a, Int16Regs:$b),
 489                            "mul.wide.u16 \t$dst, $a, $b;", []>;
 490 def MULWIDEU32Imm : NVPTXInst<(outs Int32Regs:$dst),
 491                             (ins Int16Regs:$a, i32imm:$b),
 492                            "mul.wide.u16 \t$dst, $a, $b;", []>;
 493
 494 def : Pat<(shl (sext Int32Regs:$a), (i32 Int5Const:$b)),
 495           (MULWIDES64Imm Int32Regs:$a, (SHL2MUL32 node:$b))>,
 496           Requires<[doMulWide]>;
 497 def : Pat<(shl (zext Int32Regs:$a), (i32 Int5Const:$b)),
 498           (MULWIDEU64Imm Int32Regs:$a, (SHL2MUL32 node:$b))>,
 499           Requires<[doMulWide]>;
 500
 501 def : Pat<(shl (sext Int16Regs:$a), (i16 Int4Const:$b)),
 502           (MULWIDES32Imm Int16Regs:$a, (SHL2MUL16 node:$b))>,
 503           Requires<[doMulWide]>;
 504 def : Pat<(shl (zext Int16Regs:$a), (i16 Int4Const:$b)),
 505           (MULWIDEU32Imm Int16Regs:$a, (SHL2MUL16 node:$b))>,
 506           Requires<[doMulWide]>;
 507
 508 def : Pat<(mul (sext Int32Regs:$a), (sext Int32Regs:$b)),
 509           (MULWIDES64 Int32Regs:$a, Int32Regs:$b)>,
 510           Requires<[doMulWide]>;
 511 def : Pat<(mul (sext Int32Regs:$a), (i64 SInt32Const:$b)),
 512           (MULWIDES64Imm Int32Regs:$a, (i64 SInt32Const:$b))>,
 513           Requires<[doMulWide]>;
 514
 515 def : Pat<(mul (zext Int32Regs:$a), (zext Int32Regs:$b)),
 516           (MULWIDEU64 Int32Regs:$a, Int32Regs:$b)>, Requires<[doMulWide]>;
 517 def : Pat<(mul (zext Int32Regs:$a), (i64 UInt32Const:$b)),
 518           (MULWIDEU64Imm Int32Regs:$a, (i64 UInt32Const:$b))>,
 519           Requires<[doMulWide]>;
 520
 521 def : Pat<(mul (sext Int16Regs:$a), (sext Int16Regs:$b)),
 522           (MULWIDES32 Int16Regs:$a, Int16Regs:$b)>, Requires<[doMulWide]>;
 523 def : Pat<(mul (sext Int16Regs:$a), (i32 SInt16Const:$b)),
 524           (MULWIDES32Imm Int16Regs:$a, (i32 SInt16Const:$b))>,
 525           Requires<[doMulWide]>;
 526
 527 def : Pat<(mul (zext Int16Regs:$a), (zext Int16Regs:$b)),
 528           (MULWIDEU32 Int16Regs:$a, Int16Regs:$b)>, Requires<[doMulWide]>;
 529 def : Pat<(mul (zext Int16Regs:$a), (i32 UInt16Const:$b)),
 530           (MULWIDEU32Imm Int16Regs:$a, (i32 UInt16Const:$b))>,
 531           Requires<[doMulWide]>;
 532
 533 defm MULT : I3<"mul.lo.s", mul>;
 534
 535 defm MULTHS : I3<"mul.hi.s", mulhs>;
 536 defm MULTHU : I3<"mul.hi.u", mulhu>;
 537
 538 defm SDIV : I3<"div.s", sdiv>;
 539 defm UDIV : I3<"div.u", udiv>;
 540
 541 defm SREM : I3<"rem.s", srem>;
 542 // The ri version will not be selected as DAGCombiner::visitSREM will lower it.
 543 defm UREM : I3<"rem.u", urem>;
 544 // The ri version will not be selected as DAGCombiner::visitUREM will lower it.
 545
 546 def MAD16rrr : NVPTXInst<(outs Int16Regs:$dst),
 547                       (ins Int16Regs:$a, Int16Regs:$b, Int16Regs:$c),
 548                       "mad.lo.s16 \t$dst, $a, $b, $c;",
 549                       [(set Int16Regs:$dst, (add
 550                         (mul Int16Regs:$a, Int16Regs:$b), Int16Regs:$c))]>;
 551 def MAD16rri : NVPTXInst<(outs Int16Regs:$dst),
 552                       (ins Int16Regs:$a, Int16Regs:$b, i16imm:$c),
 553                       "mad.lo.s16 \t$dst, $a, $b, $c;",
 554                       [(set Int16Regs:$dst, (add
 555                         (mul Int16Regs:$a, Int16Regs:$b), imm:$c))]>;
 556 def MAD16rir : NVPTXInst<(outs Int16Regs:$dst),
 557                       (ins Int16Regs:$a, i16imm:$b, Int16Regs:$c),
 558                       "mad.lo.s16 \t$dst, $a, $b, $c;",
 559                       [(set Int16Regs:$dst, (add
 560                         (mul Int16Regs:$a, imm:$b), Int16Regs:$c))]>;
 561 def MAD16rii : NVPTXInst<(outs Int16Regs:$dst),
 562     (ins Int16Regs:$a, i16imm:$b, i16imm:$c),
 563                       "mad.lo.s16 \t$dst, $a, $b, $c;",
 564                       [(set Int16Regs:$dst, (add (mul Int16Regs:$a, imm:$b),
 565                         imm:$c))]>;
 566
 567 def MAD32rrr : NVPTXInst<(outs Int32Regs:$dst),
 568                       (ins Int32Regs:$a, Int32Regs:$b, Int32Regs:$c),
 569                       "mad.lo.s32 \t$dst, $a, $b, $c;",
 570                       [(set Int32Regs:$dst, (add
 571                         (mul Int32Regs:$a, Int32Regs:$b), Int32Regs:$c))]>;
 572 def MAD32rri : NVPTXInst<(outs Int32Regs:$dst),
 573                       (ins Int32Regs:$a, Int32Regs:$b, i32imm:$c),
 574                       "mad.lo.s32 \t$dst, $a, $b, $c;",
 575                       [(set Int32Regs:$dst, (add
 576                         (mul Int32Regs:$a, Int32Regs:$b), imm:$c))]>;
 577 def MAD32rir : NVPTXInst<(outs Int32Regs:$dst),
 578                       (ins Int32Regs:$a, i32imm:$b, Int32Regs:$c),
 579                       "mad.lo.s32 \t$dst, $a, $b, $c;",
 580                       [(set Int32Regs:$dst, (add
 581                         (mul Int32Regs:$a, imm:$b), Int32Regs:$c))]>;
 582 def MAD32rii : NVPTXInst<(outs Int32Regs:$dst),
 583                       (ins Int32Regs:$a, i32imm:$b, i32imm:$c),
 584                       "mad.lo.s32 \t$dst, $a, $b, $c;",
 585                       [(set Int32Regs:$dst, (add
 586                         (mul Int32Regs:$a, imm:$b), imm:$c))]>;
 587
 588 def MAD64rrr : NVPTXInst<(outs Int64Regs:$dst),
 589                       (ins Int64Regs:$a, Int64Regs:$b, Int64Regs:$c),
 590                       "mad.lo.s64 \t$dst, $a, $b, $c;",
 591                       [(set Int64Regs:$dst, (add
 592                         (mul Int64Regs:$a, Int64Regs:$b), Int64Regs:$c))]>;
 593 def MAD64rri : NVPTXInst<(outs Int64Regs:$dst),
 594                       (ins Int64Regs:$a, Int64Regs:$b, i64imm:$c),
 595                       "mad.lo.s64 \t$dst, $a, $b, $c;",
 596                       [(set Int64Regs:$dst, (add
 597                         (mul Int64Regs:$a, Int64Regs:$b), imm:$c))]>;
 598 def MAD64rir : NVPTXInst<(outs Int64Regs:$dst),
 599                       (ins Int64Regs:$a, i64imm:$b, Int64Regs:$c),
 600                       "mad.lo.s64 \t$dst, $a, $b, $c;",
 601                       [(set Int64Regs:$dst, (add
 602                         (mul Int64Regs:$a, imm:$b), Int64Regs:$c))]>;
 603 def MAD64rii : NVPTXInst<(outs Int64Regs:$dst),
 604                       (ins Int64Regs:$a, i64imm:$b, i64imm:$c),
 605                       "mad.lo.s64 \t$dst, $a, $b, $c;",
 606                       [(set Int64Regs:$dst, (add
 607                         (mul Int64Regs:$a, imm:$b), imm:$c))]>;
 608
 609
 610 def INEG16 : NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$src),
 611                      "neg.s16 \t$dst, $src;",
 612          [(set Int16Regs:$dst, (ineg Int16Regs:$src))]>;
 613 def INEG32 : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$src),
 614                      "neg.s32 \t$dst, $src;",
 615          [(set Int32Regs:$dst, (ineg Int32Regs:$src))]>;
 616 def INEG64 : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$src),
 617                      "neg.s64 \t$dst, $src;",
 618          [(set Int64Regs:$dst, (ineg Int64Regs:$src))]>;
 619
 620 //-----------------------------------
 621 // Floating Point Arithmetic
 622 //-----------------------------------
 623
 624 // Constant 1.0f
 625 def FloatConst1 : PatLeaf<(fpimm), [{
 626     if (&(N->getValueAPF().getSemantics()) != &llvm::APFloat::IEEEsingle)
 627       return false;
 628     float f = (float)N->getValueAPF().convertToFloat();
 629     return (f==1.0f);
 630 }]>;
 631 // Constand (double)1.0
 632 def DoubleConst1 : PatLeaf<(fpimm), [{
 633     if (&(N->getValueAPF().getSemantics()) != &llvm::APFloat::IEEEdouble)
 634       return false;
 635     double d = (double)N->getValueAPF().convertToDouble();
 636     return (d==1.0);
 637 }]>;
 638
 639 defm FADD : F3<"add", fadd>;
 640 defm FSUB : F3<"sub", fsub>;
 641 defm FMUL : F3<"mul", fmul>;
 642
 643 defm FADD_rn : F3_rn<"add", fadd>;
 644 defm FSUB_rn : F3_rn<"sub", fsub>;
 645 defm FMUL_rn : F3_rn<"mul", fmul>;
 646
 647 defm FABS : F2<"abs", fabs>;
 648 defm FNEG : F2<"neg", fneg>;
 649 defm FSQRT : F2<"sqrt.rn", fsqrt>;
 650
 651 //
 652 // F64 division
 653 //
 654 def FDIV641r : NVPTXInst<(outs Float64Regs:$dst),
 655                       (ins f64imm:$a, Float64Regs:$b),
 656                       "rcp.rn.f64 \t$dst, $b;",
 657                       [(set Float64Regs:$dst,
 658                         (fdiv DoubleConst1:$a, Float64Regs:$b))]>;
 659 def FDIV64rr : NVPTXInst<(outs Float64Regs:$dst),
 660                       (ins Float64Regs:$a, Float64Regs:$b),
 661                       "div.rn.f64 \t$dst, $a, $b;",
 662                       [(set Float64Regs:$dst,
 663                         (fdiv Float64Regs:$a, Float64Regs:$b))]>;
 664 def FDIV64ri : NVPTXInst<(outs Float64Regs:$dst),
 665                       (ins Float64Regs:$a, f64imm:$b),
 666                       "div.rn.f64 \t$dst, $a, $b;",
 667                       [(set Float64Regs:$dst,
 668                         (fdiv Float64Regs:$a, fpimm:$b))]>;
 669
 670 //
 671 // F32 Approximate reciprocal
 672 //
 673 def FDIV321r_ftz : NVPTXInst<(outs Float32Regs:$dst),
 674                       (ins f32imm:$a, Float32Regs:$b),
 675                       "rcp.approx.ftz.f32 \t$dst, $b;",
 676                       [(set Float32Regs:$dst,
 677                         (fdiv FloatConst1:$a, Float32Regs:$b))]>,
 678                       Requires<[do_DIVF32_APPROX, doF32FTZ]>;
 679 def FDIV321r : NVPTXInst<(outs Float32Regs:$dst),
 680                         (ins f32imm:$a, Float32Regs:$b),
 681                        "rcp.approx.f32 \t$dst, $b;",
 682                       [(set Float32Regs:$dst,
 683                         (fdiv FloatConst1:$a, Float32Regs:$b))]>,
 684                       Requires<[do_DIVF32_APPROX]>;
 685 //
 686 // F32 Approximate division
 687 //
 688 def FDIV32approxrr_ftz : NVPTXInst<(outs Float32Regs:$dst),
 689                       (ins Float32Regs:$a, Float32Regs:$b),
 690                       "div.approx.ftz.f32 \t$dst, $a, $b;",
 691                       [(set Float32Regs:$dst,
 692                         (fdiv Float32Regs:$a, Float32Regs:$b))]>,
 693                       Requires<[do_DIVF32_APPROX, doF32FTZ]>;
 694 def FDIV32approxri_ftz : NVPTXInst<(outs Float32Regs:$dst),
 695                       (ins Float32Regs:$a, f32imm:$b),
 696                       "div.approx.ftz.f32 \t$dst, $a, $b;",
 697                       [(set Float32Regs:$dst,
 698                         (fdiv Float32Regs:$a, fpimm:$b))]>,
 699                       Requires<[do_DIVF32_APPROX, doF32FTZ]>;
 700 def FDIV32approxrr     : NVPTXInst<(outs Float32Regs:$dst),
 701                       (ins Float32Regs:$a, Float32Regs:$b),
 702                       "div.approx.f32 \t$dst, $a, $b;",
 703                       [(set Float32Regs:$dst,
 704                         (fdiv Float32Regs:$a, Float32Regs:$b))]>,
 705                       Requires<[do_DIVF32_APPROX]>;
 706 def FDIV32approxri : NVPTXInst<(outs Float32Regs:$dst),
 707                       (ins Float32Regs:$a, f32imm:$b),
 708                       "div.approx.f32 \t$dst, $a, $b;",
 709                       [(set Float32Regs:$dst,
 710                         (fdiv Float32Regs:$a, fpimm:$b))]>,
 711                       Requires<[do_DIVF32_APPROX]>;
 712 //
 713 // F32 Semi-accurate reciprocal
 714 //
 715 // rcp.approx gives the same result as div.full(1.0f, a) and is faster.
 716 //
 717 def FDIV321r_approx_ftz : NVPTXInst<(outs Float32Regs:$dst),
 718                       (ins f32imm:$a, Float32Regs:$b),
 719                       "rcp.approx.ftz.f32 \t$dst, $b;",
 720                       [(set Float32Regs:$dst,
 721                         (fdiv FloatConst1:$a, Float32Regs:$b))]>,
 722                       Requires<[do_DIVF32_FULL, doF32FTZ]>;
 723 def FDIV321r_approx : NVPTXInst<(outs Float32Regs:$dst),
 724                       (ins f32imm:$a, Float32Regs:$b),
 725                       "rcp.approx.f32 \t$dst, $b;",
 726                       [(set Float32Regs:$dst,
 727                         (fdiv FloatConst1:$a, Float32Regs:$b))]>,
 728                       Requires<[do_DIVF32_FULL]>;
 729 //
 730 // F32 Semi-accurate division
 731 //
 732 def FDIV32rr_ftz : NVPTXInst<(outs Float32Regs:$dst),
 733                       (ins Float32Regs:$a, Float32Regs:$b),
 734                       "div.full.ftz.f32 \t$dst, $a, $b;",
 735                       [(set Float32Regs:$dst,
 736                         (fdiv Float32Regs:$a, Float32Regs:$b))]>,
 737                       Requires<[do_DIVF32_FULL, doF32FTZ]>;
 738 def FDIV32ri_ftz : NVPTXInst<(outs Float32Regs:$dst),
 739                       (ins Float32Regs:$a, f32imm:$b),
 740                       "div.full.ftz.f32 \t$dst, $a, $b;",
 741                       [(set Float32Regs:$dst,
 742                         (fdiv Float32Regs:$a, fpimm:$b))]>,
 743                       Requires<[do_DIVF32_FULL, doF32FTZ]>;
 744 def FDIV32rr : NVPTXInst<(outs Float32Regs:$dst),
 745                       (ins Float32Regs:$a, Float32Regs:$b),
 746                       "div.full.f32 \t$dst, $a, $b;",
 747                       [(set Float32Regs:$dst,
 748                         (fdiv Float32Regs:$a, Float32Regs:$b))]>,
 749                       Requires<[do_DIVF32_FULL]>;
 750 def FDIV32ri : NVPTXInst<(outs Float32Regs:$dst),
 751                       (ins Float32Regs:$a, f32imm:$b),
 752                       "div.full.f32 \t$dst, $a, $b;",
 753                       [(set Float32Regs:$dst,
 754                         (fdiv Float32Regs:$a, fpimm:$b))]>,
 755                       Requires<[do_DIVF32_FULL]>;
 756 //
 757 // F32 Accurate reciprocal
 758 //
 759 def FDIV321r_prec_ftz : NVPTXInst<(outs Float32Regs:$dst),
 760                         (ins f32imm:$a, Float32Regs:$b),
 761                        "rcp.rn.ftz.f32 \t$dst, $b;",
 762                       [(set Float32Regs:$dst,
 763                         (fdiv FloatConst1:$a, Float32Regs:$b))]>,
 764                       Requires<[reqPTX20, doF32FTZ]>;
 765 def FDIV321r_prec : NVPTXInst<(outs Float32Regs:$dst),
 766                       (ins f32imm:$a, Float32Regs:$b),
 767                        "rcp.rn.f32 \t$dst, $b;",
 768                       [(set Float32Regs:$dst,
 769                         (fdiv FloatConst1:$a, Float32Regs:$b))]>,
 770                       Requires<[reqPTX20]>;
 771 //
 772 // F32 Accurate division
 773 //
 774 def FDIV32rr_prec_ftz : NVPTXInst<(outs Float32Regs:$dst),
 775                       (ins Float32Regs:$a, Float32Regs:$b),
 776                       "div.rn.ftz.f32 \t$dst, $a, $b;",
 777                       [(set Float32Regs:$dst,
 778                         (fdiv Float32Regs:$a, Float32Regs:$b))]>,
 779                       Requires<[doF32FTZ, reqPTX20]>;
 780 def FDIV32ri_prec_ftz : NVPTXInst<(outs Float32Regs:$dst),
 781                       (ins Float32Regs:$a, f32imm:$b),
 782                       "div.rn.ftz.f32 \t$dst, $a, $b;",
 783                       [(set Float32Regs:$dst,
 784                         (fdiv Float32Regs:$a, fpimm:$b))]>,
 785                       Requires<[doF32FTZ, reqPTX20]>;
 786 def FDIV32rr_prec : NVPTXInst<(outs Float32Regs:$dst),
 787                       (ins Float32Regs:$a, Float32Regs:$b),
 788                       "div.rn.f32 \t$dst, $a, $b;",
 789                       [(set Float32Regs:$dst,
 790                         (fdiv Float32Regs:$a, Float32Regs:$b))]>,
 791                       Requires<[reqPTX20]>;
 792 def FDIV32ri_prec : NVPTXInst<(outs Float32Regs:$dst),
 793                       (ins Float32Regs:$a, f32imm:$b),
 794                       "div.rn.f32 \t$dst, $a, $b;",
 795                       [(set Float32Regs:$dst,
 796                         (fdiv Float32Regs:$a, fpimm:$b))]>,
 797                       Requires<[reqPTX20]>;
 798
 799 //
 800 // F32 rsqrt
 801 //
 802
 803 def RSQRTF32approx1r : NVPTXInst<(outs Float32Regs:$dst), (ins Float32Regs:$b),
 804                        "rsqrt.approx.f32 \t$dst, $b;", []>;
 805
 806 def: Pat<(fdiv FloatConst1, (int_nvvm_sqrt_f Float32Regs:$b)),
 807          (RSQRTF32approx1r Float32Regs:$b)>,
 808          Requires<[do_DIVF32_FULL, do_SQRTF32_APPROX, doNoF32FTZ]>;
 809
 810 multiclass FPCONTRACT32<string OpcStr, Predicate Pred> {
 811    def rrr : NVPTXInst<(outs Float32Regs:$dst),
 812                       (ins Float32Regs:$a, Float32Regs:$b, Float32Regs:$c),
 813                       !strconcat(OpcStr, " \t$dst, $a, $b, $c;"),
 814                       [(set Float32Regs:$dst, (fadd
 815                         (fmul Float32Regs:$a, Float32Regs:$b),
 816                         Float32Regs:$c))]>, Requires<[Pred]>;
 817    // This is to WAR a weird bug in Tablegen that does not automatically
 818    // generate the following permutated rule rrr2 from the above rrr.
 819    // So we explicitly add it here. This happens to FMA32 only.
 820    // See the comments at FMAD32 and FMA32 for more information.
 821    def rrr2 : NVPTXInst<(outs Float32Regs:$dst),
 822                         (ins Float32Regs:$a, Float32Regs:$b, Float32Regs:$c),
 823                       !strconcat(OpcStr, " \t$dst, $a, $b, $c;"),
 824                       [(set Float32Regs:$dst, (fadd Float32Regs:$c,
 825                         (fmul Float32Regs:$a, Float32Regs:$b)))]>,
 826                       Requires<[Pred]>;
 827    def rri : NVPTXInst<(outs Float32Regs:$dst),
 828                       (ins Float32Regs:$a, Float32Regs:$b, f32imm:$c),
 829                       !strconcat(OpcStr, " \t$dst, $a, $b, $c;"),
 830                       [(set Float32Regs:$dst, (fadd
 831                         (fmul Float32Regs:$a, Float32Regs:$b), fpimm:$c))]>,
 832                       Requires<[Pred]>;
 833    def rir : NVPTXInst<(outs Float32Regs:$dst),
 834                       (ins Float32Regs:$a, f32imm:$b, Float32Regs:$c),
 835                       !strconcat(OpcStr, " \t$dst, $a, $b, $c;"),
 836                       [(set Float32Regs:$dst, (fadd
 837                         (fmul Float32Regs:$a, fpimm:$b), Float32Regs:$c))]>,
 838                       Requires<[Pred]>;
 839    def rii : NVPTXInst<(outs Float32Regs:$dst),
 840                       (ins Float32Regs:$a, f32imm:$b, f32imm:$c),
 841                       !strconcat(OpcStr, " \t$dst, $a, $b, $c;"),
 842                       [(set Float32Regs:$dst, (fadd
 843                         (fmul Float32Regs:$a, fpimm:$b), fpimm:$c))]>,
 844                       Requires<[Pred]>;
 845 }
 846
 847 multiclass FPCONTRACT64<string OpcStr, Predicate Pred> {
 848    def rrr : NVPTXInst<(outs Float64Regs:$dst),
 849                       (ins Float64Regs:$a, Float64Regs:$b, Float64Regs:$c),
 850                       !strconcat(OpcStr, " \t$dst, $a, $b, $c;"),
 851                       [(set Float64Regs:$dst, (fadd
 852                         (fmul Float64Regs:$a, Float64Regs:$b),
 853                         Float64Regs:$c))]>, Requires<[Pred]>;
 854    def rri : NVPTXInst<(outs Float64Regs:$dst),
 855                       (ins Float64Regs:$a, Float64Regs:$b, f64imm:$c),
 856                       !strconcat(OpcStr, " \t$dst, $a, $b, $c;"),
 857                       [(set Float64Regs:$dst, (fadd (fmul Float64Regs:$a,
 858                         Float64Regs:$b), fpimm:$c))]>, Requires<[Pred]>;
 859    def rir : NVPTXInst<(outs Float64Regs:$dst),
 860                       (ins Float64Regs:$a, f64imm:$b, Float64Regs:$c),
 861                       !strconcat(OpcStr, " \t$dst, $a, $b, $c;"),
 862                       [(set Float64Regs:$dst, (fadd
 863                         (fmul Float64Regs:$a, fpimm:$b), Float64Regs:$c))]>,
 864                       Requires<[Pred]>;
 865    def rii : NVPTXInst<(outs Float64Regs:$dst),
 866                       (ins Float64Regs:$a, f64imm:$b, f64imm:$c),
 867                       !strconcat(OpcStr, " \t$dst, $a, $b, $c;"),
 868                       [(set Float64Regs:$dst, (fadd
 869                         (fmul Float64Regs:$a, fpimm:$b), fpimm:$c))]>,
 870                       Requires<[Pred]>;
 871 }
 872
 873 // Due to a unknown reason (most likely a bug in tablegen), tablegen does not
 874 // automatically generate the rrr2 rule from
 875 // the rrr rule (see FPCONTRACT32) for FMA32, though it does for FMAD32.
 876 // If we reverse the order of the following two lines, then rrr2 rule will be
 877 // generated for FMA32, but not for rrr.
 878 // Therefore, we manually write the rrr2 rule in FPCONTRACT32.
 879 defm FMA32_ftz  : FPCONTRACT32<"fma.rn.ftz.f32", doFMAF32_ftz>;
 880 defm FMA32  : FPCONTRACT32<"fma.rn.f32", doFMAF32>;
 881 defm FMA64  : FPCONTRACT64<"fma.rn.f64", doFMAF64>;
 882
 883 // b*c-a => fmad(b, c, -a)
 884 multiclass FPCONTRACT32_SUB_PAT_MAD<NVPTXInst Inst, Predicate Pred> {
 885   def : Pat<(fsub (fmul Float32Regs:$b, Float32Regs:$c), Float32Regs:$a),
 886           (Inst Float32Regs:$b, Float32Regs:$c, (FNEGf32 Float32Regs:$a))>,
 887           Requires<[Pred]>;
 888 }
 889
 890 // a-b*c => fmad(-b,c, a)
 891 // - legal because a-b*c <=> a+(-b*c) <=> a+(-b)*c
 892 // b*c-a => fmad(b, c, -a)
 893 // - legal because b*c-a <=> b*c+(-a)
 894 multiclass FPCONTRACT32_SUB_PAT<NVPTXInst Inst, Predicate Pred> {
 895   def : Pat<(fsub Float32Regs:$a, (fmul Float32Regs:$b, Float32Regs:$c)),
 896           (Inst (FNEGf32 Float32Regs:$b), Float32Regs:$c, Float32Regs:$a)>,
 897           Requires<[Pred]>;
 898   def : Pat<(fsub (fmul Float32Regs:$b, Float32Regs:$c), Float32Regs:$a),
 899           (Inst Float32Regs:$b, Float32Regs:$c, (FNEGf32 Float32Regs:$a))>,
 900           Requires<[Pred]>;
 901 }
 902
 903 // a-b*c => fmad(-b,c, a)
 904 // b*c-a => fmad(b, c, -a)
 905 multiclass FPCONTRACT64_SUB_PAT<NVPTXInst Inst, Predicate Pred> {
 906   def : Pat<(fsub Float64Regs:$a, (fmul Float64Regs:$b, Float64Regs:$c)),
 907           (Inst (FNEGf64 Float64Regs:$b), Float64Regs:$c, Float64Regs:$a)>,
 908           Requires<[Pred]>;
 909
 910   def : Pat<(fsub (fmul Float64Regs:$b, Float64Regs:$c), Float64Regs:$a),
 911           (Inst Float64Regs:$b, Float64Regs:$c, (FNEGf64 Float64Regs:$a))>,
 912           Requires<[Pred]>;
 913 }
 914
 915 defm FMAF32ext_ftz  : FPCONTRACT32_SUB_PAT<FMA32_ftzrrr, doFMAF32AGG_ftz>;
 916 defm FMAF32ext  : FPCONTRACT32_SUB_PAT<FMA32rrr, doFMAF32AGG>;
 917 defm FMAF64ext  : FPCONTRACT64_SUB_PAT<FMA64rrr, doFMAF64AGG>;
 918
 919 def SINF:  NVPTXInst<(outs Float32Regs:$dst), (ins Float32Regs:$src),
 920                       "sin.approx.f32 \t$dst, $src;",
 921                       [(set Float32Regs:$dst, (fsin Float32Regs:$src))]>;
 922 def COSF:  NVPTXInst<(outs Float32Regs:$dst), (ins Float32Regs:$src),
 923                       "cos.approx.f32 \t$dst, $src;",
 924                       [(set Float32Regs:$dst, (fcos Float32Regs:$src))]>;
 925
 926 // Lower (frem x, y) into (sub x, (mul (floor (div x, y)) y))
 927 // e.g. "poor man's fmod()"
 928
 929 // frem - f32 FTZ
 930 def : Pat<(frem Float32Regs:$x, Float32Regs:$y),
 931           (FSUBf32rr_ftz Float32Regs:$x, (FMULf32rr_ftz (CVT_f32_f32
 932             (FDIV32rr_prec_ftz Float32Regs:$x, Float32Regs:$y), CvtRMI_FTZ),
 933              Float32Regs:$y))>,
 934           Requires<[doF32FTZ]>;
 935 def : Pat<(frem Float32Regs:$x, fpimm:$y),
 936           (FSUBf32rr_ftz Float32Regs:$x, (FMULf32ri_ftz (CVT_f32_f32
 937             (FDIV32ri_prec_ftz Float32Regs:$x, fpimm:$y), CvtRMI_FTZ),
 938              fpimm:$y))>,
 939           Requires<[doF32FTZ]>;
 940
 941 // frem - f32
 942 def : Pat<(frem Float32Regs:$x, Float32Regs:$y),
 943           (FSUBf32rr Float32Regs:$x, (FMULf32rr (CVT_f32_f32
 944             (FDIV32rr_prec Float32Regs:$x, Float32Regs:$y), CvtRMI),
 945              Float32Regs:$y))>;
 946 def : Pat<(frem Float32Regs:$x, fpimm:$y),
 947           (FSUBf32rr Float32Regs:$x, (FMULf32ri (CVT_f32_f32
 948             (FDIV32ri_prec Float32Regs:$x, fpimm:$y), CvtRMI),
 949              fpimm:$y))>;
 950
 951 // frem - f64
 952 def : Pat<(frem Float64Regs:$x, Float64Regs:$y),
 953           (FSUBf64rr Float64Regs:$x, (FMULf64rr (CVT_f64_f64
 954             (FDIV64rr Float64Regs:$x, Float64Regs:$y), CvtRMI),
 955              Float64Regs:$y))>;
 956 def : Pat<(frem Float64Regs:$x, fpimm:$y),
 957           (FSUBf64rr Float64Regs:$x, (FMULf64ri (CVT_f64_f64
 958             (FDIV64ri Float64Regs:$x, fpimm:$y), CvtRMI),
 959              fpimm:$y))>;
 960
 961 //-----------------------------------
 962 // Logical Arithmetic
 963 //-----------------------------------
 964
 965 multiclass LOG_FORMAT<string OpcStr, SDNode OpNode> {
 966   def b1rr:  NVPTXInst<(outs Int1Regs:$dst), (ins Int1Regs:$a, Int1Regs:$b),
 967                       !strconcat(OpcStr, ".pred  \t$dst, $a, $b;"),
 968                       [(set Int1Regs:$dst, (OpNode Int1Regs:$a, Int1Regs:$b))]>;
 969   def b1ri:  NVPTXInst<(outs Int1Regs:$dst), (ins Int1Regs:$a, i1imm:$b),
 970                       !strconcat(OpcStr, ".pred  \t$dst, $a, $b;"),
 971                       [(set Int1Regs:$dst, (OpNode Int1Regs:$a, imm:$b))]>;
 972   def b16rr:  NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$a, Int16Regs:$b),
 973                       !strconcat(OpcStr, ".b16  \t$dst, $a, $b;"),
 974                       [(set Int16Regs:$dst, (OpNode Int16Regs:$a,
 975                         Int16Regs:$b))]>;
 976   def b16ri:  NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$a, i16imm:$b),
 977                       !strconcat(OpcStr, ".b16  \t$dst, $a, $b;"),
 978                       [(set Int16Regs:$dst, (OpNode Int16Regs:$a, imm:$b))]>;
 979   def b32rr:  NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$a, Int32Regs:$b),
 980                       !strconcat(OpcStr, ".b32  \t$dst, $a, $b;"),
 981                       [(set Int32Regs:$dst, (OpNode Int32Regs:$a,
 982                         Int32Regs:$b))]>;
 983   def b32ri:  NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$a, i32imm:$b),
 984                       !strconcat(OpcStr, ".b32  \t$dst, $a, $b;"),
 985                       [(set Int32Regs:$dst, (OpNode Int32Regs:$a, imm:$b))]>;
 986   def b64rr:  NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$a, Int64Regs:$b),
 987                       !strconcat(OpcStr, ".b64  \t$dst, $a, $b;"),
 988                       [(set Int64Regs:$dst, (OpNode Int64Regs:$a,
 989                         Int64Regs:$b))]>;
 990   def b64ri:  NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$a, i64imm:$b),
 991                       !strconcat(OpcStr, ".b64  \t$dst, $a, $b;"),
 992                       [(set Int64Regs:$dst, (OpNode Int64Regs:$a, imm:$b))]>;
 993 }
 994
 995 defm OR  : LOG_FORMAT<"or", or>;
 996 defm AND : LOG_FORMAT<"and", and>;
 997 defm XOR : LOG_FORMAT<"xor", xor>;
 998
 999 def NOT1:  NVPTXInst<(outs Int1Regs:$dst), (ins Int1Regs:$src),
1000                       "not.pred \t$dst, $src;",
1001                       [(set Int1Regs:$dst, (not Int1Regs:$src))]>;
1002 def NOT16:  NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$src),
1003                       "not.b16 \t$dst, $src;",
1004                       [(set Int16Regs:$dst, (not Int16Regs:$src))]>;
1005 def NOT32:  NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$src),
1006                       "not.b32 \t$dst, $src;",
1007                       [(set Int32Regs:$dst, (not Int32Regs:$src))]>;
1008 def NOT64:  NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$src),
1009                       "not.b64 \t$dst, $src;",
1010                       [(set Int64Regs:$dst, (not Int64Regs:$src))]>;
1011
1012 // For shifts, the second src operand must be 32-bit value
1013 multiclass LSHIFT_FORMAT<string OpcStr, SDNode OpNode> {
1014    def i64rr : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$a,
1015                       Int32Regs:$b),
1016                       !strconcat(OpcStr, "64 \t$dst, $a, $b;"),
1017                       [(set Int64Regs:$dst, (OpNode Int64Regs:$a,
1018                         Int32Regs:$b))]>;
1019    def i64ri : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$a, i32imm:$b),
1020                       !strconcat(OpcStr, "64 \t$dst, $a, $b;"),
1021                       [(set Int64Regs:$dst, (OpNode Int64Regs:$a,
1022                         (i32 imm:$b)))]>;
1023    def i32rr : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$a,
1024                       Int32Regs:$b),
1025                       !strconcat(OpcStr, "32 \t$dst, $a, $b;"),
1026                       [(set Int32Regs:$dst, (OpNode Int32Regs:$a,
1027                         Int32Regs:$b))]>;
1028    def i32ri : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$a, i32imm:$b),
1029                       !strconcat(OpcStr, "32 \t$dst, $a, $b;"),
1030                       [(set Int32Regs:$dst, (OpNode Int32Regs:$a,
1031                         (i32 imm:$b)))]>;
1032    def i32ii : NVPTXInst<(outs Int32Regs:$dst), (ins i32imm:$a, i32imm:$b),
1033                       !strconcat(OpcStr, "32 \t$dst, $a, $b;"),
1034                       [(set Int32Regs:$dst, (OpNode (i32 imm:$a),
1035                         (i32 imm:$b)))]>;
1036    def i16rr : NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$a,
1037                       Int32Regs:$b),
1038                       !strconcat(OpcStr, "16 \t$dst, $a, $b;"),
1039                       [(set Int16Regs:$dst, (OpNode Int16Regs:$a,
1040                         Int32Regs:$b))]>;
1041    def i16ri : NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$a, i32imm:$b),
1042                       !strconcat(OpcStr, "16 \t$dst, $a, $b;"),
1043                       [(set Int16Regs:$dst, (OpNode Int16Regs:$a,
1044                         (i32 imm:$b)))]>;
1045 }
1046
1047 defm SHL : LSHIFT_FORMAT<"shl.b", shl>;
1048
1049 // For shifts, the second src operand must be 32-bit value
1050 // Need to add cvt for the 8-bits.
1051 multiclass RSHIFT_FORMAT<string OpcStr, SDNode OpNode> {
1052    def i64rr : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$a,
1053                       Int32Regs:$b),
1054                       !strconcat(OpcStr, "64 \t$dst, $a, $b;"),
1055                       [(set Int64Regs:$dst, (OpNode Int64Regs:$a,
1056                         Int32Regs:$b))]>;
1057    def i64ri : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$a, i32imm:$b),
1058                       !strconcat(OpcStr, "64 \t$dst, $a, $b;"),
1059                       [(set Int64Regs:$dst, (OpNode Int64Regs:$a,
1060                         (i32 imm:$b)))]>;
1061    def i32rr : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$a,
1062                       Int32Regs:$b),
1063                       !strconcat(OpcStr, "32 \t$dst, $a, $b;"),
1064                       [(set Int32Regs:$dst, (OpNode Int32Regs:$a,
1065                         Int32Regs:$b))]>;
1066    def i32ri : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$a, i32imm:$b),
1067                       !strconcat(OpcStr, "32 \t$dst, $a, $b;"),
1068                       [(set Int32Regs:$dst, (OpNode Int32Regs:$a,
1069                         (i32 imm:$b)))]>;
1070    def i32ii : NVPTXInst<(outs Int32Regs:$dst), (ins i32imm:$a, i32imm:$b),
1071                       !strconcat(OpcStr, "32 \t$dst, $a, $b;"),
1072                       [(set Int32Regs:$dst, (OpNode (i32 imm:$a),
1073                         (i32 imm:$b)))]>;
1074    def i16rr : NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$a,
1075                       Int32Regs:$b),
1076                       !strconcat(OpcStr, "16 \t$dst, $a, $b;"),
1077                       [(set Int16Regs:$dst, (OpNode Int16Regs:$a,
1078                         Int32Regs:$b))]>;
1079    def i16ri : NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$a, i32imm:$b),
1080                       !strconcat(OpcStr, "16 \t$dst, $a, $b;"),
1081                       [(set Int16Regs:$dst, (OpNode Int16Regs:$a,
1082                         (i32 imm:$b)))]>;
1083 }
1084
1085 defm SRA : RSHIFT_FORMAT<"shr.s", sra>;
1086 defm SRL : RSHIFT_FORMAT<"shr.u", srl>;
1087
1088 // 32bit
1089 def ROT32imm_sw : NVPTXInst<(outs Int32Regs:$dst),
1090   (ins Int32Regs:$src, i32imm:$amt1, i32imm:$amt2),
1091     !strconcat("{{\n\t",
1092     !strconcat(".reg .b32 %lhs;\n\t",
1093     !strconcat(".reg .b32 %rhs;\n\t",
1094     !strconcat("shl.b32 \t%lhs, $src, $amt1;\n\t",
1095     !strconcat("shr.b32 \t%rhs, $src, $amt2;\n\t",
1096     !strconcat("add.u32 \t$dst, %lhs, %rhs;\n\t",
1097     !strconcat("}}", ""))))))),
1098     []>;
1099
1100 def SUB_FRM_32 : SDNodeXForm<imm, [{
1101     return CurDAG->getTargetConstant(32-N->getZExtValue(), MVT::i32);
1102 }]>;
1103
1104 def : Pat<(rotl Int32Regs:$src, (i32 imm:$amt)),
1105           (ROT32imm_sw Int32Regs:$src, imm:$amt, (SUB_FRM_32 node:$amt))>;
1106 def : Pat<(rotr Int32Regs:$src, (i32 imm:$amt)),
1107           (ROT32imm_sw Int32Regs:$src, (SUB_FRM_32 node:$amt), imm:$amt)>;
1108
1109 def ROTL32reg_sw : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$src,
1110     Int32Regs:$amt),
1111     !strconcat("{{\n\t",
1112     !strconcat(".reg .b32 %lhs;\n\t",
1113     !strconcat(".reg .b32 %rhs;\n\t",
1114     !strconcat(".reg .b32 %amt2;\n\t",
1115     !strconcat("shl.b32 \t%lhs, $src, $amt;\n\t",
1116     !strconcat("sub.s32 \t%amt2, 32, $amt;\n\t",
1117     !strconcat("shr.b32 \t%rhs, $src, %amt2;\n\t",
1118     !strconcat("add.u32 \t$dst, %lhs, %rhs;\n\t",
1119     !strconcat("}}", ""))))))))),
1120     [(set Int32Regs:$dst, (rotl Int32Regs:$src, Int32Regs:$amt))]>;
1121
1122 def ROTR32reg_sw : NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$src,
1123     Int32Regs:$amt),
1124     !strconcat("{{\n\t",
1125     !strconcat(".reg .b32 %lhs;\n\t",
1126     !strconcat(".reg .b32 %rhs;\n\t",
1127     !strconcat(".reg .b32 %amt2;\n\t",
1128     !strconcat("shr.b32 \t%lhs, $src, $amt;\n\t",
1129     !strconcat("sub.s32 \t%amt2, 32, $amt;\n\t",
1130     !strconcat("shl.b32 \t%rhs, $src, %amt2;\n\t",
1131     !strconcat("add.u32 \t$dst, %lhs, %rhs;\n\t",
1132     !strconcat("}}", ""))))))))),
1133     [(set Int32Regs:$dst, (rotr Int32Regs:$src, Int32Regs:$amt))]>;
1134
1135 // 64bit
1136 def ROT64imm_sw : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$src,
1137     i32imm:$amt1, i32imm:$amt2),
1138     !strconcat("{{\n\t",
1139     !strconcat(".reg .b64 %lhs;\n\t",
1140     !strconcat(".reg .b64 %rhs;\n\t",
1141     !strconcat("shl.b64 \t%lhs, $src, $amt1;\n\t",
1142     !strconcat("shr.b64 \t%rhs, $src, $amt2;\n\t",
1143     !strconcat("add.u64 \t$dst, %lhs, %rhs;\n\t",
1144     !strconcat("}}", ""))))))),
1145     []>;
1146
1147 def SUB_FRM_64 : SDNodeXForm<imm, [{
1148     return CurDAG->getTargetConstant(64-N->getZExtValue(), MVT::i32);
1149 }]>;
1150
1151 def : Pat<(rotl Int64Regs:$src, (i32 imm:$amt)),
1152           (ROT64imm_sw Int64Regs:$src, imm:$amt, (SUB_FRM_64 node:$amt))>;
1153 def : Pat<(rotr Int64Regs:$src, (i32 imm:$amt)),
1154           (ROT64imm_sw Int64Regs:$src, (SUB_FRM_64 node:$amt), imm:$amt)>;
1155
1156 def ROTL64reg_sw : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$src,
1157     Int32Regs:$amt),
1158     !strconcat("{{\n\t",
1159     !strconcat(".reg .b64 %lhs;\n\t",
1160     !strconcat(".reg .b64 %rhs;\n\t",
1161     !strconcat(".reg .u32 %amt2;\n\t",
1162     !strconcat("shl.b64 \t%lhs, $src, $amt;\n\t",
1163     !strconcat("sub.u32 \t%amt2, 64, $amt;\n\t",
1164     !strconcat("shr.b64 \t%rhs, $src, %amt2;\n\t",
1165     !strconcat("add.u64 \t$dst, %lhs, %rhs;\n\t",
1166     !strconcat("}}", ""))))))))),
1167     [(set Int64Regs:$dst, (rotl Int64Regs:$src, Int32Regs:$amt))]>;
1168
1169 def ROTR64reg_sw : NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$src,
1170     Int32Regs:$amt),
1171     !strconcat("{{\n\t",
1172     !strconcat(".reg .b64 %lhs;\n\t",
1173     !strconcat(".reg .b64 %rhs;\n\t",
1174     !strconcat(".reg .u32 %amt2;\n\t",
1175     !strconcat("shr.b64 \t%lhs, $src, $amt;\n\t",
1176     !strconcat("sub.u32 \t%amt2, 64, $amt;\n\t",
1177     !strconcat("shl.b64 \t%rhs, $src, %amt2;\n\t",
1178     !strconcat("add.u64 \t$dst, %lhs, %rhs;\n\t",
1179     !strconcat("}}", ""))))))))),
1180     [(set Int64Regs:$dst, (rotr Int64Regs:$src, Int32Regs:$amt))]>;
1181
1182 // BFE - bit-field extract
1183
1184 multiclass BFE<string TyStr, RegisterClass RC> {
1185   // BFE supports both 32-bit and 64-bit values, but the start and length
1186   // operands are always 32-bit
1187   def rrr
1188     : NVPTXInst<(outs RC:$d),
1189                 (ins RC:$a, Int32Regs:$b, Int32Regs:$c),
1190                 !strconcat("bfe.", TyStr, " \t$d, $a, $b, $c;"), []>;
1191   def rri
1192     : NVPTXInst<(outs RC:$d),
1193                 (ins RC:$a, Int32Regs:$b, i32imm:$c),
1194                 !strconcat("bfe.", TyStr, " \t$d, $a, $b, $c;"), []>;
1195   def rii
1196     : NVPTXInst<(outs RC:$d),
1197                 (ins RC:$a, i32imm:$b, i32imm:$c),
1198                 !strconcat("bfe.", TyStr, " \t$d, $a, $b, $c;"), []>;
1199 }
1200
1201 defm BFE_S32 : BFE<"s32", Int32Regs>;
1202 defm BFE_U32 : BFE<"u32", Int32Regs>;
1203 defm BFE_S64 : BFE<"s64", Int64Regs>;
1204 defm BFE_U64 : BFE<"u64", Int64Regs>;
1205
1206 //-----------------------------------
1207 // General Comparison
1208 //-----------------------------------
1209
1210 // General setp instructions
1211 multiclass SETP<string TypeStr, RegisterClass RC, Operand ImmCls> {
1212   def rr : NVPTXInst<(outs Int1Regs:$dst),
1213                      (ins RC:$a, RC:$b, CmpMode:$cmp),
1214             !strconcat("setp${cmp:base}${cmp:ftz}.", TypeStr, "\t$dst, $a, $b;"),
1215                      []>;
1216   def ri : NVPTXInst<(outs Int1Regs:$dst),
1217                      (ins RC:$a, ImmCls:$b, CmpMode:$cmp),
1218             !strconcat("setp${cmp:base}${cmp:ftz}.", TypeStr, "\t$dst, $a, $b;"),
1219                      []>;
1220   def ir : NVPTXInst<(outs Int1Regs:$dst),
1221                      (ins ImmCls:$a, RC:$b, CmpMode:$cmp),
1222             !strconcat("setp${cmp:base}${cmp:ftz}.", TypeStr, "\t$dst, $a, $b;"),
1223                      []>;
1224 }
1225
1226 defm SETP_b16 : SETP<"b16", Int16Regs, i16imm>;
1227 defm SETP_s16 : SETP<"s16", Int16Regs, i16imm>;
1228 defm SETP_u16 : SETP<"u16", Int16Regs, i16imm>;
1229 defm SETP_b32 : SETP<"b32", Int32Regs, i32imm>;
1230 defm SETP_s32 : SETP<"s32", Int32Regs, i32imm>;
1231 defm SETP_u32 : SETP<"u32", Int32Regs, i32imm>;
1232 defm SETP_b64 : SETP<"b64", Int64Regs, i64imm>;
1233 defm SETP_s64 : SETP<"s64", Int64Regs, i64imm>;
1234 defm SETP_u64 : SETP<"u64", Int64Regs, i64imm>;
1235 defm SETP_f32 : SETP<"f32", Float32Regs, f32imm>;
1236 defm SETP_f64 : SETP<"f64", Float64Regs, f64imm>;
1237
1238 // General set instructions
1239 multiclass SET<string TypeStr, RegisterClass RC, Operand ImmCls> {
1240   def rr : NVPTXInst<(outs Int32Regs:$dst),
1241                      (ins RC:$a, RC:$b, CmpMode:$cmp),
1242                      !strconcat("set$cmp.", TypeStr, "\t$dst, $a, $b;"), []>;
1243   def ri : NVPTXInst<(outs Int32Regs:$dst),
1244                      (ins RC:$a, ImmCls:$b, CmpMode:$cmp),
1245                      !strconcat("set$cmp.", TypeStr, "\t$dst, $a, $b;"), []>;
1246   def ir : NVPTXInst<(outs Int32Regs:$dst),
1247                      (ins ImmCls:$a, RC:$b, CmpMode:$cmp),
1248                      !strconcat("set$cmp.", TypeStr, "\t$dst, $a, $b;"), []>;
1249 }
1250
1251 defm SET_b16 : SET<"b16", Int16Regs, i16imm>;
1252 defm SET_s16 : SET<"s16", Int16Regs, i16imm>;
1253 defm SET_u16 : SET<"u16", Int16Regs, i16imm>;
1254 defm SET_b32 : SET<"b32", Int32Regs, i32imm>;
1255 defm SET_s32 : SET<"s32", Int32Regs, i32imm>;
1256 defm SET_u32 : SET<"u32", Int32Regs, i32imm>;
1257 defm SET_b64 : SET<"b64", Int64Regs, i64imm>;
1258 defm SET_s64 : SET<"s64", Int64Regs, i64imm>;
1259 defm SET_u64 : SET<"u64", Int64Regs, i64imm>;
1260 defm SET_f32 : SET<"f32", Float32Regs, f32imm>;
1261 defm SET_f64 : SET<"f64", Float64Regs, f64imm>;
1262
1263 //-----------------------------------
1264 // General Selection
1265 //-----------------------------------
1266
1267 // General selp instructions
1268 multiclass SELP<string TypeStr, RegisterClass RC, Operand ImmCls> {
1269   def rr : NVPTXInst<(outs RC:$dst),
1270                      (ins RC:$a, RC:$b, Int1Regs:$p),
1271                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"), []>;
1272   def ri : NVPTXInst<(outs RC:$dst),
1273                      (ins RC:$a, ImmCls:$b, Int1Regs:$p),
1274                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"), []>;
1275   def ir : NVPTXInst<(outs RC:$dst),
1276                      (ins ImmCls:$a, RC:$b, Int1Regs:$p),
1277                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"), []>;
1278   def ii : NVPTXInst<(outs RC:$dst),
1279                      (ins ImmCls:$a, ImmCls:$b, Int1Regs:$p),
1280                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"), []>;
1281 }
1282
1283 multiclass SELP_PATTERN<string TypeStr, RegisterClass RC, Operand ImmCls,
1284                         SDNode ImmNode> {
1285   def rr : NVPTXInst<(outs RC:$dst),
1286                      (ins RC:$a, RC:$b, Int1Regs:$p),
1287                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"),
1288                      [(set RC:$dst, (select Int1Regs:$p, RC:$a, RC:$b))]>;
1289   def ri : NVPTXInst<(outs RC:$dst),
1290                      (ins RC:$a, ImmCls:$b, Int1Regs:$p),
1291                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"),
1292                      [(set RC:$dst, (select Int1Regs:$p, RC:$a, ImmNode:$b))]>;
1293   def ir : NVPTXInst<(outs RC:$dst),
1294                      (ins ImmCls:$a, RC:$b, Int1Regs:$p),
1295                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"),
1296                      [(set RC:$dst, (select Int1Regs:$p, ImmNode:$a, RC:$b))]>;
1297   def ii : NVPTXInst<(outs RC:$dst),
1298                      (ins ImmCls:$a, ImmCls:$b, Int1Regs:$p),
1299                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"),
1300                  [(set RC:$dst, (select Int1Regs:$p, ImmNode:$a, ImmNode:$b))]>;
1301 }
1302
1303 defm SELP_b16 : SELP_PATTERN<"b16", Int16Regs, i16imm, imm>;
1304 defm SELP_s16 : SELP<"s16", Int16Regs, i16imm>;
1305 defm SELP_u16 : SELP<"u16", Int16Regs, i16imm>;
1306 defm SELP_b32 : SELP_PATTERN<"b32", Int32Regs, i32imm, imm>;
1307 defm SELP_s32 : SELP<"s32", Int32Regs, i32imm>;
1308 defm SELP_u32 : SELP<"u32", Int32Regs, i32imm>;
1309 defm SELP_b64 : SELP_PATTERN<"b64", Int64Regs, i64imm, imm>;
1310 defm SELP_s64 : SELP<"s64", Int64Regs, i64imm>;
1311 defm SELP_u64 : SELP<"u64", Int64Regs, i64imm>;
1312 defm SELP_f32 : SELP_PATTERN<"f32", Float32Regs, f32imm, fpimm>;
1313 defm SELP_f64 : SELP_PATTERN<"f64", Float64Regs, f64imm, fpimm>;
1314
1315 // Special select for predicate operands
1316 def : Pat<(i1 (select Int1Regs:$p, Int1Regs:$a, Int1Regs:$b)),
1317               (ORb1rr (ANDb1rr Int1Regs:$p, Int1Regs:$a),
1318               (ANDb1rr (NOT1 Int1Regs:$p), Int1Regs:$b))>;
1319
1320 //-----------------------------------
1321 // Data Movement (Load / Store, Move)
1322 //-----------------------------------
1323
1324 def ADDRri : ComplexPattern<i32, 2, "SelectADDRri", [frameindex],
1325   [SDNPWantRoot]>;
1326 def ADDRri64 : ComplexPattern<i64, 2, "SelectADDRri64", [frameindex],
1327   [SDNPWantRoot]>;
1328
1329 def MEMri : Operand<i32> {
1330   let PrintMethod = "printMemOperand";
1331   let MIOperandInfo = (ops Int32Regs, i32imm);
1332 }
1333 def MEMri64 : Operand<i64> {
1334   let PrintMethod = "printMemOperand";
1335   let MIOperandInfo = (ops Int64Regs, i64imm);
1336 }
1337
1338 def imem : Operand<iPTR> {
1339     let PrintMethod = "printOperand";
1340 }
1341
1342 def imemAny : Operand<iPTRAny> {
1343     let PrintMethod = "printOperand";
1344 }
1345
1346 def LdStCode : Operand<i32> {
1347     let PrintMethod = "printLdStCode";
1348 }
1349
1350 def SDTWrapper : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>, SDTCisPtrTy<0>]>;
1351 def Wrapper    : SDNode<"NVPTXISD::Wrapper", SDTWrapper>;
1352
1353 def MOV_ADDR : NVPTXInst<(outs Int32Regs:$dst), (ins imem:$a),
1354                      "mov.u32 \t$dst, $a;",
1355                      [(set Int32Regs:$dst, (Wrapper tglobaladdr:$a))]>;
1356
1357 def MOV_ADDR64 : NVPTXInst<(outs Int64Regs:$dst), (ins imem:$a),
1358                      "mov.u64 \t$dst, $a;",
1359                      [(set Int64Regs:$dst, (Wrapper tglobaladdr:$a))]>;
1360
1361 // Get pointer to local stack
1362 def MOV_DEPOT_ADDR
1363   : NVPTXInst<(outs Int32Regs:$d), (ins i32imm:$num),
1364               "mov.u32 \t$d, __local_depot$num;", []>;
1365 def MOV_DEPOT_ADDR_64
1366   : NVPTXInst<(outs Int64Regs:$d), (ins i32imm:$num),
1367               "mov.u64 \t$d, __local_depot$num;", []>;
1368
1369
1370 // copyPhysreg is hard-coded in NVPTXInstrInfo.cpp
1371 let IsSimpleMove=1 in {
1372 def IMOV1rr: NVPTXInst<(outs Int1Regs:$dst), (ins Int1Regs:$sss),
1373                    "mov.pred \t$dst, $sss;", []>;
1374 def IMOV16rr: NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$sss),
1375                     "mov.u16 \t$dst, $sss;", []>;
1376 def IMOV32rr: NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$sss),
1377                     "mov.u32 \t$dst, $sss;", []>;
1378 def IMOV64rr: NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$sss),
1379                     "mov.u64 \t$dst, $sss;", []>;
1380
1381 def FMOV32rr: NVPTXInst<(outs Float32Regs:$dst), (ins Float32Regs:$src),
1382                     "mov.f32 \t$dst, $src;", []>;
1383 def FMOV64rr: NVPTXInst<(outs Float64Regs:$dst), (ins Float64Regs:$src),
1384                     "mov.f64 \t$dst, $src;", []>;
1385 }
1386 def IMOV1ri: NVPTXInst<(outs Int1Regs:$dst), (ins i1imm:$src),
1387                     "mov.pred \t$dst, $src;",
1388           [(set Int1Regs:$dst, imm:$src)]>;
1389 def IMOV16ri: NVPTXInst<(outs Int16Regs:$dst), (ins i16imm:$src),
1390                     "mov.u16 \t$dst, $src;",
1391           [(set Int16Regs:$dst, imm:$src)]>;
1392 def IMOV32ri: NVPTXInst<(outs Int32Regs:$dst), (ins i32imm:$src),
1393                     "mov.u32 \t$dst, $src;",
1394           [(set Int32Regs:$dst, imm:$src)]>;
1395 def IMOV64i: NVPTXInst<(outs Int64Regs:$dst), (ins i64imm:$src),
1396                     "mov.u64 \t$dst, $src;",
1397           [(set Int64Regs:$dst, imm:$src)]>;
1398
1399 def FMOV32ri: NVPTXInst<(outs Float32Regs:$dst), (ins f32imm:$src),
1400                     "mov.f32 \t$dst, $src;",
1401           [(set Float32Regs:$dst, fpimm:$src)]>;
1402 def FMOV64ri: NVPTXInst<(outs Float64Regs:$dst), (ins f64imm:$src),
1403                     "mov.f64 \t$dst, $src;",
1404           [(set Float64Regs:$dst, fpimm:$src)]>;
1405
1406 def : Pat<(i32 (Wrapper texternalsym:$dst)), (IMOV32ri texternalsym:$dst)>;
1407
1408 //---- Copy Frame Index ----
1409 def LEA_ADDRi : NVPTXInst<(outs Int32Regs:$dst), (ins MEMri:$addr),
1410                         "add.u32 \t$dst, ${addr:add};",
1411                         [(set Int32Regs:$dst, ADDRri:$addr)]>;
1412 def LEA_ADDRi64 : NVPTXInst<(outs Int64Regs:$dst), (ins MEMri64:$addr),
1413                         "add.u64 \t$dst, ${addr:add};",
1414                         [(set Int64Regs:$dst, ADDRri64:$addr)]>;
1415
1416 //-----------------------------------
1417 // Comparison and Selection
1418 //-----------------------------------
1419
1420 multiclass ISET_FORMAT<PatFrag OpNode, PatLeaf Mode,
1421                        Instruction setp_16rr,
1422                        Instruction setp_16ri,
1423                        Instruction setp_16ir,
1424                        Instruction setp_32rr,
1425                        Instruction setp_32ri,
1426                        Instruction setp_32ir,
1427                        Instruction setp_64rr,
1428                        Instruction setp_64ri,
1429                        Instruction setp_64ir,
1430                        Instruction set_16rr,
1431                        Instruction set_16ri,
1432                        Instruction set_16ir,
1433                        Instruction set_32rr,
1434                        Instruction set_32ri,
1435                        Instruction set_32ir,
1436                        Instruction set_64rr,
1437                        Instruction set_64ri,
1438                        Instruction set_64ir> {
1439   // i16 -> pred
1440   def : Pat<(i1 (OpNode Int16Regs:$a, Int16Regs:$b)),
1441             (setp_16rr Int16Regs:$a, Int16Regs:$b, Mode)>;
1442   def : Pat<(i1 (OpNode Int16Regs:$a, imm:$b)),
1443             (setp_16ri Int16Regs:$a, imm:$b, Mode)>;
1444   def : Pat<(i1 (OpNode imm:$a, Int16Regs:$b)),
1445             (setp_16ir imm:$a, Int16Regs:$b, Mode)>;
1446   // i32 -> pred
1447   def : Pat<(i1 (OpNode Int32Regs:$a, Int32Regs:$b)),
1448             (setp_32rr Int32Regs:$a, Int32Regs:$b, Mode)>;
1449   def : Pat<(i1 (OpNode Int32Regs:$a, imm:$b)),
1450             (setp_32ri Int32Regs:$a, imm:$b, Mode)>;
1451   def : Pat<(i1 (OpNode imm:$a, Int32Regs:$b)),
1452             (setp_32ir imm:$a, Int32Regs:$b, Mode)>;
1453   // i64 -> pred
1454   def : Pat<(i1 (OpNode Int64Regs:$a, Int64Regs:$b)),
1455             (setp_64rr Int64Regs:$a, Int64Regs:$b, Mode)>;
1456   def : Pat<(i1 (OpNode Int64Regs:$a, imm:$b)),
1457             (setp_64ri Int64Regs:$a, imm:$b, Mode)>;
1458   def : Pat<(i1 (OpNode imm:$a, Int64Regs:$b)),
1459             (setp_64ir imm:$a, Int64Regs:$b, Mode)>;
1460
1461   // i16 -> i32
1462   def : Pat<(i32 (OpNode Int16Regs:$a, Int16Regs:$b)),
1463             (set_16rr Int16Regs:$a, Int16Regs:$b, Mode)>;
1464   def : Pat<(i32 (OpNode Int16Regs:$a, imm:$b)),
1465             (set_16ri Int16Regs:$a, imm:$b, Mode)>;
1466   def : Pat<(i32 (OpNode imm:$a, Int16Regs:$b)),
1467             (set_16ir imm:$a, Int16Regs:$b, Mode)>;
1468   // i32 -> i32
1469   def : Pat<(i32 (OpNode Int32Regs:$a, Int32Regs:$b)),
1470             (set_32rr Int32Regs:$a, Int32Regs:$b, Mode)>;
1471   def : Pat<(i32 (OpNode Int32Regs:$a, imm:$b)),
1472             (set_32ri Int32Regs:$a, imm:$b, Mode)>;
1473   def : Pat<(i32 (OpNode imm:$a, Int32Regs:$b)),
1474             (set_32ir imm:$a, Int32Regs:$b, Mode)>;
1475   // i64 -> i32
1476   def : Pat<(i32 (OpNode Int64Regs:$a, Int64Regs:$b)),
1477             (set_64rr Int64Regs:$a, Int64Regs:$b, Mode)>;
1478   def : Pat<(i32 (OpNode Int64Regs:$a, imm:$b)),
1479             (set_64ri Int64Regs:$a, imm:$b, Mode)>;
1480   def : Pat<(i32 (OpNode imm:$a, Int64Regs:$b)),
1481             (set_64ir imm:$a, Int64Regs:$b, Mode)>;
1482 }
1483
1484 multiclass ISET_FORMAT_SIGNED<PatFrag OpNode, PatLeaf Mode>
1485   : ISET_FORMAT<OpNode, Mode,
1486                 SETP_s16rr, SETP_s16ri, SETP_s16ir,
1487                 SETP_s32rr, SETP_s32ri, SETP_s32ir,
1488                 SETP_s64rr, SETP_s64ri, SETP_s64ir,
1489                 SET_s16rr, SET_s16ri, SET_s16ir,
1490                 SET_s32rr, SET_s32ri, SET_s32ir,
1491                 SET_s64rr, SET_s64ri, SET_s64ir> {
1492   // TableGen doesn't like empty multiclasses
1493   def : PatLeaf<(i32 0)>;
1494 }
1495
1496 multiclass ISET_FORMAT_UNSIGNED<PatFrag OpNode, PatLeaf Mode>
1497   : ISET_FORMAT<OpNode, Mode,
1498                 SETP_u16rr, SETP_u16ri, SETP_u16ir,
1499                 SETP_u32rr, SETP_u32ri, SETP_u32ir,
1500                 SETP_u64rr, SETP_u64ri, SETP_u64ir,
1501                 SET_u16rr, SET_u16ri, SET_u16ir,
1502                 SET_u32rr, SET_u32ri, SET_u32ir,
1503                 SET_u64rr, SET_u64ri, SET_u64ir> {
1504   // TableGen doesn't like empty multiclasses
1505   def : PatLeaf<(i32 0)>;
1506 }
1507
1508 defm : ISET_FORMAT_SIGNED<setgt, CmpGT>;
1509 defm : ISET_FORMAT_UNSIGNED<setugt, CmpGT>;
1510 defm : ISET_FORMAT_SIGNED<setlt, CmpLT>;
1511 defm : ISET_FORMAT_UNSIGNED<setult, CmpLT>;
1512 defm : ISET_FORMAT_SIGNED<setge, CmpGE>;
1513 defm : ISET_FORMAT_UNSIGNED<setuge, CmpGE>;
1514 defm : ISET_FORMAT_SIGNED<setle, CmpLE>;
1515 defm : ISET_FORMAT_UNSIGNED<setule, CmpLE>;
1516 defm : ISET_FORMAT_SIGNED<seteq, CmpEQ>;
1517 defm : ISET_FORMAT_UNSIGNED<setueq, CmpEQ>;
1518 defm : ISET_FORMAT_SIGNED<setne, CmpNE>;
1519 defm : ISET_FORMAT_UNSIGNED<setune, CmpNE>;
1520
1521 // i1 compares
1522 def : Pat<(setne Int1Regs:$a, Int1Regs:$b),
1523           (XORb1rr Int1Regs:$a, Int1Regs:$b)>;
1524 def : Pat<(setune Int1Regs:$a, Int1Regs:$b),
1525           (XORb1rr Int1Regs:$a, Int1Regs:$b)>;
1526
1527 def : Pat<(seteq Int1Regs:$a, Int1Regs:$b),
1528           (NOT1 (XORb1rr Int1Regs:$a, Int1Regs:$b))>;
1529 def : Pat<(setueq Int1Regs:$a, Int1Regs:$b),
1530           (NOT1 (XORb1rr Int1Regs:$a, Int1Regs:$b))>;
1531
1532 // i1 compare -> i32
1533 def : Pat<(i32 (setne Int1Regs:$a, Int1Regs:$b)),
1534           (SELP_u32ii -1, 0, (XORb1rr Int1Regs:$a, Int1Regs:$b))>;
1535 def : Pat<(i32 (setne Int1Regs:$a, Int1Regs:$b)),
1536           (SELP_u32ii 0, -1, (XORb1rr Int1Regs:$a, Int1Regs:$b))>;
1537
1538
1539
1540 multiclass FSET_FORMAT<PatFrag OpNode, PatLeaf Mode, PatLeaf ModeFTZ> {
1541   // f32 -> pred
1542   def : Pat<(i1 (OpNode Float32Regs:$a, Float32Regs:$b)),
1543             (SETP_f32rr Float32Regs:$a, Float32Regs:$b, ModeFTZ)>,
1544         Requires<[doF32FTZ]>;
1545   def : Pat<(i1 (OpNode Float32Regs:$a, Float32Regs:$b)),
1546             (SETP_f32rr Float32Regs:$a, Float32Regs:$b, Mode)>;
1547   def : Pat<(i1 (OpNode Float32Regs:$a, fpimm:$b)),
1548             (SETP_f32ri Float32Regs:$a, fpimm:$b, ModeFTZ)>,
1549         Requires<[doF32FTZ]>;
1550   def : Pat<(i1 (OpNode Float32Regs:$a, fpimm:$b)),
1551             (SETP_f32ri Float32Regs:$a, fpimm:$b, Mode)>;
1552   def : Pat<(i1 (OpNode fpimm:$a, Float32Regs:$b)),
1553             (SETP_f32ir fpimm:$a, Float32Regs:$b, ModeFTZ)>,
1554         Requires<[doF32FTZ]>;
1555   def : Pat<(i1 (OpNode fpimm:$a, Float32Regs:$b)),
1556             (SETP_f32ir fpimm:$a, Float32Regs:$b, Mode)>;
1557
1558   // f64 -> pred
1559   def : Pat<(i1 (OpNode Float64Regs:$a, Float64Regs:$b)),
1560             (SETP_f64rr Float64Regs:$a, Float64Regs:$b, Mode)>;
1561   def : Pat<(i1 (OpNode Float64Regs:$a, fpimm:$b)),
1562             (SETP_f64ri Float64Regs:$a, fpimm:$b, Mode)>;
1563   def : Pat<(i1 (OpNode fpimm:$a, Float64Regs:$b)),
1564             (SETP_f64ir fpimm:$a, Float64Regs:$b, Mode)>;
1565
1566   // f32 -> i32
1567   def : Pat<(i32 (OpNode Float32Regs:$a, Float32Regs:$b)),
1568             (SET_f32rr Float32Regs:$a, Float32Regs:$b, ModeFTZ)>,
1569         Requires<[doF32FTZ]>;
1570   def : Pat<(i32 (OpNode Float32Regs:$a, Float32Regs:$b)),
1571             (SET_f32rr Float32Regs:$a, Float32Regs:$b, Mode)>;
1572   def : Pat<(i32 (OpNode Float32Regs:$a, fpimm:$b)),
1573             (SET_f32ri Float32Regs:$a, fpimm:$b, ModeFTZ)>,
1574         Requires<[doF32FTZ]>;
1575   def : Pat<(i32 (OpNode Float32Regs:$a, fpimm:$b)),
1576             (SET_f32ri Float32Regs:$a, fpimm:$b, Mode)>;
1577   def : Pat<(i32 (OpNode fpimm:$a, Float32Regs:$b)),
1578             (SET_f32ir fpimm:$a, Float32Regs:$b, ModeFTZ)>,
1579         Requires<[doF32FTZ]>;
1580   def : Pat<(i32 (OpNode fpimm:$a, Float32Regs:$b)),
1581             (SET_f32ir fpimm:$a, Float32Regs:$b, Mode)>;
1582
1583   // f64 -> i32
1584   def : Pat<(i32 (OpNode Float64Regs:$a, Float64Regs:$b)),
1585             (SET_f64rr Float64Regs:$a, Float64Regs:$b, Mode)>;
1586   def : Pat<(i32 (OpNode Float64Regs:$a, fpimm:$b)),
1587             (SET_f64ri Float64Regs:$a, fpimm:$b, Mode)>;
1588   def : Pat<(i32 (OpNode fpimm:$a, Float64Regs:$b)),
1589             (SET_f64ir fpimm:$a, Float64Regs:$b, Mode)>;
1590 }
1591
1592 defm FSetGT : FSET_FORMAT<setogt, CmpGT, CmpGT_FTZ>;
1593 defm FSetLT : FSET_FORMAT<setolt, CmpLT, CmpLT_FTZ>;
1594 defm FSetGE : FSET_FORMAT<setoge, CmpGE, CmpGE_FTZ>;
1595 defm FSetLE : FSET_FORMAT<setole, CmpLE, CmpLE_FTZ>;
1596 defm FSetEQ : FSET_FORMAT<setoeq, CmpEQ, CmpEQ_FTZ>;
1597 defm FSetNE : FSET_FORMAT<setone, CmpNE, CmpNE_FTZ>;
1598
1599 defm FSetUGT : FSET_FORMAT<setugt, CmpGTU, CmpGTU_FTZ>;
1600 defm FSetULT : FSET_FORMAT<setult, CmpLTU, CmpLTU_FTZ>;
1601 defm FSetUGE : FSET_FORMAT<setuge, CmpGEU, CmpGEU_FTZ>;
1602 defm FSetULE : FSET_FORMAT<setule, CmpLEU, CmpLEU_FTZ>;
1603 defm FSetUEQ : FSET_FORMAT<setueq, CmpEQU, CmpEQU_FTZ>;
1604 defm FSetUNE : FSET_FORMAT<setune, CmpNEU, CmpNEU_FTZ>;
1605
1606 defm FSetNUM : FSET_FORMAT<seto, CmpNUM, CmpNUM_FTZ>;
1607 defm FSetNAN : FSET_FORMAT<setuo, CmpNAN, CmpNAN_FTZ>;
1608
1609 //def ld_param         : SDNode<"NVPTXISD::LOAD_PARAM", SDTLoad,
1610 //                        [SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>;
1611
1612 def SDTDeclareParamProfile : SDTypeProfile<0, 3, [SDTCisInt<0>, SDTCisInt<1>,
1613   SDTCisInt<2>]>;
1614 def SDTDeclareScalarParamProfile : SDTypeProfile<0, 3, [SDTCisInt<0>,
1615   SDTCisInt<1>, SDTCisInt<2>]>;
1616 def SDTLoadParamProfile : SDTypeProfile<1, 2, [SDTCisInt<1>, SDTCisInt<2>]>;
1617 def SDTLoadParamV2Profile : SDTypeProfile<2, 2, [SDTCisSameAs<0, 1>, SDTCisInt<2>, SDTCisInt<3>]>;
1618 def SDTLoadParamV4Profile : SDTypeProfile<4, 2, [SDTCisInt<4>, SDTCisInt<5>]>;
1619 def SDTPrintCallProfile : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
1620 def SDTPrintCallUniProfile : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
1621 def SDTStoreParamProfile : SDTypeProfile<0, 3, [SDTCisInt<0>, SDTCisInt<1>]>;
1622 def SDTStoreParamV2Profile : SDTypeProfile<0, 4, [SDTCisInt<0>, SDTCisInt<1>]>;
1623 def SDTStoreParamV4Profile : SDTypeProfile<0, 6, [SDTCisInt<0>, SDTCisInt<1>]>;
1624 def SDTStoreParam32Profile : SDTypeProfile<0, 3, [SDTCisInt<0>, SDTCisInt<1>]>;
1625 def SDTCallArgProfile : SDTypeProfile<0, 2, [SDTCisInt<0>]>;
1626 def SDTCallArgMarkProfile : SDTypeProfile<0, 0, []>;
1627 def SDTCallVoidProfile : SDTypeProfile<0, 1, []>;
1628 def SDTCallValProfile : SDTypeProfile<1, 0, []>;
1629 def SDTMoveParamProfile : SDTypeProfile<1, 1, []>;
1630 def SDTStoreRetvalProfile : SDTypeProfile<0, 2, [SDTCisInt<0>]>;
1631 def SDTStoreRetvalV2Profile : SDTypeProfile<0, 3, [SDTCisInt<0>]>;
1632 def SDTStoreRetvalV4Profile : SDTypeProfile<0, 5, [SDTCisInt<0>]>;
1633 def SDTPseudoUseParamProfile : SDTypeProfile<0, 1, []>;
1634
1635 def DeclareParam : SDNode<"NVPTXISD::DeclareParam", SDTDeclareParamProfile,
1636                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1637 def DeclareScalarParam : SDNode<"NVPTXISD::DeclareScalarParam",
1638   SDTDeclareScalarParamProfile,
1639                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1640 def DeclareRetParam : SDNode<"NVPTXISD::DeclareRetParam",
1641   SDTDeclareParamProfile,
1642                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1643 def DeclareRet   : SDNode<"NVPTXISD::DeclareRet", SDTDeclareScalarParamProfile,
1644                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1645 def LoadParam    : SDNode<"NVPTXISD::LoadParam", SDTLoadParamProfile,
1646                          [SDNPHasChain, SDNPMayLoad, SDNPOutGlue, SDNPInGlue]>;
1647 def LoadParamV2  : SDNode<"NVPTXISD::LoadParamV2", SDTLoadParamV2Profile,
1648                          [SDNPHasChain, SDNPMayLoad, SDNPOutGlue, SDNPInGlue]>;
1649 def LoadParamV4  : SDNode<"NVPTXISD::LoadParamV4", SDTLoadParamV4Profile,
1650                          [SDNPHasChain, SDNPMayLoad, SDNPOutGlue, SDNPInGlue]>;
1651 def PrintCall    : SDNode<"NVPTXISD::PrintCall", SDTPrintCallProfile,
1652                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1653 def PrintCallUni : SDNode<"NVPTXISD::PrintCallUni", SDTPrintCallUniProfile,
1654                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1655 def StoreParam   : SDNode<"NVPTXISD::StoreParam", SDTStoreParamProfile,
1656                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1657 def StoreParamV2 : SDNode<"NVPTXISD::StoreParamV2", SDTStoreParamV2Profile,
1658                          [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1659 def StoreParamV4 : SDNode<"NVPTXISD::StoreParamV4", SDTStoreParamV4Profile,
1660                          [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1661 def StoreParamU32 : SDNode<"NVPTXISD::StoreParamU32", SDTStoreParam32Profile,
1662                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1663 def StoreParamS32 : SDNode<"NVPTXISD::StoreParamS32", SDTStoreParam32Profile,
1664                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1665 def CallArgBegin : SDNode<"NVPTXISD::CallArgBegin", SDTCallArgMarkProfile,
1666                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1667 def CallArg      : SDNode<"NVPTXISD::CallArg", SDTCallArgProfile,
1668                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1669 def LastCallArg  : SDNode<"NVPTXISD::LastCallArg", SDTCallArgProfile,
1670                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1671 def CallArgEnd   : SDNode<"NVPTXISD::CallArgEnd", SDTCallVoidProfile,
1672                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1673 def CallVoid     : SDNode<"NVPTXISD::CallVoid", SDTCallVoidProfile,
1674                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1675 def Prototype    : SDNode<"NVPTXISD::Prototype", SDTCallVoidProfile,
1676                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1677 def CallVal      : SDNode<"NVPTXISD::CallVal", SDTCallValProfile,
1678                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1679 def MoveParam    : SDNode<"NVPTXISD::MoveParam", SDTMoveParamProfile,
1680                          []>;
1681 def StoreRetval  : SDNode<"NVPTXISD::StoreRetval", SDTStoreRetvalProfile,
1682                          [SDNPHasChain, SDNPSideEffect]>;
1683 def StoreRetvalV2  : SDNode<"NVPTXISD::StoreRetvalV2", SDTStoreRetvalV2Profile,
1684                            [SDNPHasChain, SDNPSideEffect]>;
1685 def StoreRetvalV4  : SDNode<"NVPTXISD::StoreRetvalV4", SDTStoreRetvalV4Profile,
1686                            [SDNPHasChain, SDNPSideEffect]>;
1687 def PseudoUseParam : SDNode<"NVPTXISD::PseudoUseParam",
1688   SDTPseudoUseParamProfile,
1689                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1690 def RETURNNode   : SDNode<"NVPTXISD::RETURN", SDTCallArgMarkProfile,
1691                          [SDNPHasChain, SDNPSideEffect]>;
1692
1693 class LoadParamMemInst<NVPTXRegClass regclass, string opstr> :
1694       NVPTXInst<(outs regclass:$dst), (ins i32imm:$b),
1695                 !strconcat(!strconcat("ld.param", opstr),
1696                 "\t$dst, [retval0+$b];"),
1697                 []>;
1698
1699 class LoadParamRegInst<NVPTXRegClass regclass, string opstr> :
1700       NVPTXInst<(outs regclass:$dst), (ins i32imm:$b),
1701                 !strconcat(!strconcat("mov", opstr),
1702                 "\t$dst, retval$b;"),
1703                 [(set regclass:$dst, (LoadParam (i32 0), (i32 imm:$b)))]>;
1704
1705 class LoadParamV2MemInst<NVPTXRegClass regclass, string opstr> :
1706       NVPTXInst<(outs regclass:$dst, regclass:$dst2), (ins i32imm:$b),
1707                 !strconcat(!strconcat("ld.param.v2", opstr),
1708                 "\t{{$dst, $dst2}}, [retval0+$b];"), []>;
1709
1710 class LoadParamV4MemInst<NVPTXRegClass regclass, string opstr> :
1711       NVPTXInst<(outs regclass:$dst, regclass:$dst2, regclass:$dst3,
1712                       regclass:$dst4),
1713                 (ins i32imm:$b),
1714                 !strconcat(!strconcat("ld.param.v4", opstr),
1715                 "\t{{$dst, $dst2, $dst3, $dst4}}, [retval0+$b];"), []>;
1716
1717 class StoreParamInst<NVPTXRegClass regclass, string opstr> :
1718       NVPTXInst<(outs), (ins regclass:$val, i32imm:$a, i32imm:$b),
1719                 !strconcat(!strconcat("st.param", opstr),
1720                 "\t[param$a+$b], $val;"),
1721                 []>;
1722
1723 class StoreParamV2Inst<NVPTXRegClass regclass, string opstr> :
1724       NVPTXInst<(outs), (ins regclass:$val, regclass:$val2,
1725                              i32imm:$a, i32imm:$b),
1726                 !strconcat(!strconcat("st.param.v2", opstr),
1727                 "\t[param$a+$b], {{$val, $val2}};"),
1728                 []>;
1729
1730 class StoreParamV4Inst<NVPTXRegClass regclass, string opstr> :
1731       NVPTXInst<(outs), (ins regclass:$val, regclass:$val1, regclass:$val2,
1732                              regclass:$val3, i32imm:$a, i32imm:$b),
1733                 !strconcat(!strconcat("st.param.v4", opstr),
1734                 "\t[param$a+$b], {{$val, $val2, $val3, $val4}};"),
1735                 []>;
1736
1737 class StoreRetvalInst<NVPTXRegClass regclass, string opstr> :
1738       NVPTXInst<(outs), (ins regclass:$val, i32imm:$a),
1739                 !strconcat(!strconcat("st.param", opstr),
1740                 "\t[func_retval0+$a], $val;"),
1741                 []>;
1742
1743 class StoreRetvalV2Inst<NVPTXRegClass regclass, string opstr> :
1744       NVPTXInst<(outs), (ins regclass:$val, regclass:$val2, i32imm:$a),
1745                 !strconcat(!strconcat("st.param.v2", opstr),
1746                 "\t[func_retval0+$a], {{$val, $val2}};"),
1747                 []>;
1748
1749 class StoreRetvalV4Inst<NVPTXRegClass regclass, string opstr> :
1750       NVPTXInst<(outs),
1751                 (ins regclass:$val, regclass:$val2, regclass:$val3,
1752                      regclass:$val4, i32imm:$a),
1753                 !strconcat(!strconcat("st.param.v4", opstr),
1754                 "\t[func_retval0+$a], {{$val, $val2, $val3, $val4}};"),
1755                 []>;
1756
1757 def PrintCallRetInst1 : NVPTXInst<(outs), (ins),
1758 "call (retval0), ",
1759                                 [(PrintCall (i32 1))]>;
1760 def PrintCallRetInst2 : NVPTXInst<(outs), (ins),
1761 "call (retval0, retval1), ",
1762                                 [(PrintCall (i32 2))]>;
1763 def PrintCallRetInst3 : NVPTXInst<(outs), (ins),
1764 "call (retval0, retval1, retval2), ",
1765                                 [(PrintCall (i32 3))]>;
1766 def PrintCallRetInst4 : NVPTXInst<(outs), (ins),
1767 "call (retval0, retval1, retval2, retval3), ",
1768                                 [(PrintCall (i32 4))]>;
1769 def PrintCallRetInst5 : NVPTXInst<(outs), (ins),
1770 "call (retval0, retval1, retval2, retval3, retval4), ",
1771                                 [(PrintCall (i32 5))]>;
1772 def PrintCallRetInst6 : NVPTXInst<(outs), (ins),
1773 "call (retval0, retval1, retval2, retval3, retval4, retval5), ",
1774                                 [(PrintCall (i32 6))]>;
1775 def PrintCallRetInst7 : NVPTXInst<(outs), (ins),
1776 "call (retval0, retval1, retval2, retval3, retval4, retval5, retval6), ",
1777                                 [(PrintCall (i32 7))]>;
1778 def PrintCallRetInst8 : NVPTXInst<(outs), (ins),
1779 !strconcat("call (retval0, retval1, retval2, retval3, retval4",
1780            ", retval5, retval6, retval7), "),
1781                                 [(PrintCall (i32 8))]>;
1782
1783 def PrintCallNoRetInst : NVPTXInst<(outs), (ins), "call ",
1784                                 [(PrintCall (i32 0))]>;
1785
1786 def PrintCallUniRetInst1 : NVPTXInst<(outs), (ins),
1787 "call.uni (retval0), ",
1788                                 [(PrintCallUni (i32 1))]>;
1789 def PrintCallUniRetInst2 : NVPTXInst<(outs), (ins),
1790 "call.uni (retval0, retval1), ",
1791                                 [(PrintCallUni (i32 2))]>;
1792 def PrintCallUniRetInst3 : NVPTXInst<(outs), (ins),
1793 "call.uni (retval0, retval1, retval2), ",
1794                                 [(PrintCallUni (i32 3))]>;
1795 def PrintCallUniRetInst4 : NVPTXInst<(outs), (ins),
1796 "call.uni (retval0, retval1, retval2, retval3), ",
1797                                 [(PrintCallUni (i32 4))]>;
1798 def PrintCallUniRetInst5 : NVPTXInst<(outs), (ins),
1799 "call.uni (retval0, retval1, retval2, retval3, retval4), ",
1800                                 [(PrintCallUni (i32 5))]>;
1801 def PrintCallUniRetInst6 : NVPTXInst<(outs), (ins),
1802 "call.uni (retval0, retval1, retval2, retval3, retval4, retval5), ",
1803                                 [(PrintCallUni (i32 6))]>;
1804 def PrintCallUniRetInst7 : NVPTXInst<(outs), (ins),
1805 "call.uni (retval0, retval1, retval2, retval3, retval4, retval5, retval6), ",
1806                                 [(PrintCallUni (i32 7))]>;
1807 def PrintCallUniRetInst8 : NVPTXInst<(outs), (ins),
1808 !strconcat("call.uni (retval0, retval1, retval2, retval3, retval4",
1809            ", retval5, retval6, retval7), "),
1810                                 [(PrintCallUni (i32 8))]>;
1811
1812 def PrintCallUniNoRetInst : NVPTXInst<(outs), (ins), "call.uni ",
1813                                 [(PrintCallUni (i32 0))]>;
1814
1815 def LoadParamMemI64    : LoadParamMemInst<Int64Regs, ".b64">;
1816 def LoadParamMemI32    : LoadParamMemInst<Int32Regs, ".b32">;
1817 def LoadParamMemI16    : LoadParamMemInst<Int16Regs, ".b16">;
1818 def LoadParamMemI8     : LoadParamMemInst<Int16Regs, ".b8">;
1819 def LoadParamMemV2I64  : LoadParamV2MemInst<Int64Regs, ".b64">;
1820 def LoadParamMemV2I32  : LoadParamV2MemInst<Int32Regs, ".b32">;
1821 def LoadParamMemV2I16  : LoadParamV2MemInst<Int16Regs, ".b16">;
1822 def LoadParamMemV2I8   : LoadParamV2MemInst<Int16Regs, ".b8">;
1823 def LoadParamMemV4I32  : LoadParamV4MemInst<Int32Regs, ".b32">;
1824 def LoadParamMemV4I16  : LoadParamV4MemInst<Int16Regs, ".b16">;
1825 def LoadParamMemV4I8   : LoadParamV4MemInst<Int16Regs, ".b8">;
1826 def LoadParamMemF32    : LoadParamMemInst<Float32Regs, ".f32">;
1827 def LoadParamMemF64    : LoadParamMemInst<Float64Regs, ".f64">;
1828 def LoadParamMemV2F32  : LoadParamV2MemInst<Float32Regs, ".f32">;
1829 def LoadParamMemV2F64  : LoadParamV2MemInst<Float64Regs, ".f64">;
1830 def LoadParamMemV4F32  : LoadParamV4MemInst<Float32Regs, ".f32">;
1831
1832 def StoreParamI64    : StoreParamInst<Int64Regs, ".b64">;
1833 def StoreParamI32    : StoreParamInst<Int32Regs, ".b32">;
1834
1835 def StoreParamI16    : StoreParamInst<Int16Regs, ".b16">;
1836 def StoreParamI8     : StoreParamInst<Int16Regs, ".b8">;
1837 def StoreParamV2I64  : StoreParamV2Inst<Int64Regs, ".b64">;
1838 def StoreParamV2I32  : StoreParamV2Inst<Int32Regs, ".b32">;
1839 def StoreParamV2I16  : StoreParamV2Inst<Int16Regs, ".b16">;
1840 def StoreParamV2I8   : StoreParamV2Inst<Int16Regs, ".b8">;
1841
1842 // FIXME: StoreParamV4Inst crashes llvm-tblgen :(
1843 //def StoreParamV4I32    : StoreParamV4Inst<Int32Regs, ".b32">;
1844 def StoreParamV4I32    : NVPTXInst<(outs), (ins Int32Regs:$val, Int32Regs:$val2,
1845                                                Int32Regs:$val3, Int32Regs:$val4,
1846                                                 i32imm:$a, i32imm:$b),
1847                    "st.param.b32\t[param$a+$b], {{$val, $val2, $val3, $val4}};",
1848                          []>;
1849
1850 def StoreParamV4I16    : NVPTXInst<(outs), (ins Int16Regs:$val, Int16Regs:$val2,
1851                                                Int16Regs:$val3, Int16Regs:$val4,
1852                                                 i32imm:$a, i32imm:$b),
1853                 "st.param.v4.b16\t[param$a+$b], {{$val, $val2, $val3, $val4}};",
1854                          []>;
1855
1856 def StoreParamV4I8     : NVPTXInst<(outs), (ins Int16Regs:$val, Int16Regs:$val2,
1857                                                 Int16Regs:$val3, Int16Regs:$val4,
1858                                                 i32imm:$a, i32imm:$b),
1859                  "st.param.v4.b8\t[param$a+$b], {{$val, $val2, $val3, $val4}};",
1860                          []>;
1861
1862 def StoreParamF32    : StoreParamInst<Float32Regs, ".f32">;
1863 def StoreParamF64    : StoreParamInst<Float64Regs, ".f64">;
1864 def StoreParamV2F32    : StoreParamV2Inst<Float32Regs, ".f32">;
1865 def StoreParamV2F64    : StoreParamV2Inst<Float64Regs, ".f64">;
1866 // FIXME: StoreParamV4Inst crashes llvm-tblgen :(
1867 //def StoreParamV4F32    : StoreParamV4Inst<Float32Regs, ".f32">;
1868 def StoreParamV4F32    : NVPTXInst<(outs),
1869                                    (ins Float32Regs:$val, Float32Regs:$val2,
1870                                         Float32Regs:$val3, Float32Regs:$val4,
1871                                         i32imm:$a, i32imm:$b),
1872                 "st.param.v4.f32\t[param$a+$b], {{$val, $val2, $val3, $val4}};",
1873                         []>;
1874
1875
1876 def StoreRetvalI64    : StoreRetvalInst<Int64Regs, ".b64">;
1877 def StoreRetvalI32    : StoreRetvalInst<Int32Regs, ".b32">;
1878 def StoreRetvalI16    : StoreRetvalInst<Int16Regs, ".b16">;
1879 def StoreRetvalI8     : StoreRetvalInst<Int16Regs, ".b8">;
1880 def StoreRetvalV2I64  : StoreRetvalV2Inst<Int64Regs, ".b64">;
1881 def StoreRetvalV2I32  : StoreRetvalV2Inst<Int32Regs, ".b32">;
1882 def StoreRetvalV2I16  : StoreRetvalV2Inst<Int16Regs, ".b16">;
1883 def StoreRetvalV2I8   : StoreRetvalV2Inst<Int16Regs, ".b8">;
1884 def StoreRetvalV4I32  : StoreRetvalV4Inst<Int32Regs, ".b32">;
1885 def StoreRetvalV4I16  : StoreRetvalV4Inst<Int16Regs, ".b16">;
1886 def StoreRetvalV4I8   : StoreRetvalV4Inst<Int16Regs, ".b8">;
1887
1888 def StoreRetvalF64    : StoreRetvalInst<Float64Regs, ".f64">;
1889 def StoreRetvalF32    : StoreRetvalInst<Float32Regs, ".f32">;
1890 def StoreRetvalV2F64  : StoreRetvalV2Inst<Float64Regs, ".f64">;
1891 def StoreRetvalV2F32  : StoreRetvalV2Inst<Float32Regs, ".f32">;
1892 def StoreRetvalV4F32  : StoreRetvalV4Inst<Float32Regs, ".f32">;
1893
1894 def CallArgBeginInst : NVPTXInst<(outs), (ins), "(", [(CallArgBegin)]>;
1895 def CallArgEndInst1  : NVPTXInst<(outs), (ins), ");", [(CallArgEnd (i32 1))]>;
1896 def CallArgEndInst0  : NVPTXInst<(outs), (ins), ")", [(CallArgEnd (i32 0))]>;
1897 def RETURNInst       : NVPTXInst<(outs), (ins), "ret;", [(RETURNNode)]>;
1898
1899 class CallArgInst<NVPTXRegClass regclass> :
1900       NVPTXInst<(outs), (ins regclass:$a), "$a, ",
1901                 [(CallArg (i32 0), regclass:$a)]>;
1902
1903 class LastCallArgInst<NVPTXRegClass regclass> :
1904       NVPTXInst<(outs), (ins regclass:$a), "$a",
1905                 [(LastCallArg (i32 0), regclass:$a)]>;
1906
1907 def CallArgI64     : CallArgInst<Int64Regs>;
1908 def CallArgI32     : CallArgInst<Int32Regs>;
1909 def CallArgI16     : CallArgInst<Int16Regs>;
1910
1911 def CallArgF64     : CallArgInst<Float64Regs>;
1912 def CallArgF32     : CallArgInst<Float32Regs>;
1913
1914 def LastCallArgI64 : LastCallArgInst<Int64Regs>;
1915 def LastCallArgI32 : LastCallArgInst<Int32Regs>;
1916 def LastCallArgI16 : LastCallArgInst<Int16Regs>;
1917
1918 def LastCallArgF64 : LastCallArgInst<Float64Regs>;
1919 def LastCallArgF32 : LastCallArgInst<Float32Regs>;
1920
1921 def CallArgI32imm : NVPTXInst<(outs), (ins i32imm:$a), "$a, ",
1922                               [(CallArg (i32 0), (i32 imm:$a))]>;
1923 def LastCallArgI32imm : NVPTXInst<(outs), (ins i32imm:$a), "$a",
1924                               [(LastCallArg (i32 0), (i32 imm:$a))]>;
1925
1926 def CallArgParam : NVPTXInst<(outs), (ins i32imm:$a), "param$a, ",
1927                              [(CallArg (i32 1), (i32 imm:$a))]>;
1928 def LastCallArgParam : NVPTXInst<(outs), (ins i32imm:$a), "param$a",
1929                              [(LastCallArg (i32 1), (i32 imm:$a))]>;
1930
1931 def CallVoidInst : NVPTXInst<(outs), (ins imem:$addr),
1932                              "$addr, ",
1933                              [(CallVoid (Wrapper tglobaladdr:$addr))]>;
1934 def CallVoidInstReg : NVPTXInst<(outs), (ins Int32Regs:$addr),
1935                              "$addr, ",
1936                              [(CallVoid Int32Regs:$addr)]>;
1937 def CallVoidInstReg64 : NVPTXInst<(outs), (ins Int64Regs:$addr),
1938                              "$addr, ",
1939                              [(CallVoid Int64Regs:$addr)]>;
1940 def PrototypeInst : NVPTXInst<(outs), (ins i32imm:$val),
1941                              ", prototype_$val;",
1942                              [(Prototype (i32 imm:$val))]>;
1943
1944 def DeclareRetMemInst : NVPTXInst<(outs),
1945   (ins i32imm:$align, i32imm:$size, i32imm:$num),
1946          ".param .align $align .b8 retval$num[$size];",
1947          [(DeclareRetParam (i32 imm:$align), (i32 imm:$size), (i32 imm:$num))]>;
1948 def DeclareRetScalarInst : NVPTXInst<(outs), (ins i32imm:$size, i32imm:$num),
1949          ".param .b$size retval$num;",
1950          [(DeclareRet (i32 1), (i32 imm:$size), (i32 imm:$num))]>;
1951 def DeclareRetRegInst : NVPTXInst<(outs), (ins i32imm:$size, i32imm:$num),
1952          ".reg .b$size retval$num;",
1953          [(DeclareRet (i32 2), (i32 imm:$size), (i32 imm:$num))]>;
1954
1955 def DeclareParamInst : NVPTXInst<(outs),
1956   (ins i32imm:$align, i32imm:$a, i32imm:$size),
1957          ".param .align $align .b8 param$a[$size];",
1958          [(DeclareParam (i32 imm:$align), (i32 imm:$a), (i32 imm:$size))]>;
1959 def DeclareScalarParamInst : NVPTXInst<(outs), (ins i32imm:$a, i32imm:$size),
1960          ".param .b$size param$a;",
1961          [(DeclareScalarParam (i32 imm:$a), (i32 imm:$size), (i32 0))]>;
1962 def DeclareScalarRegInst : NVPTXInst<(outs), (ins i32imm:$a, i32imm:$size),
1963          ".reg .b$size param$a;",
1964          [(DeclareScalarParam (i32 imm:$a), (i32 imm:$size), (i32 1))]>;
1965
1966 class MoveParamInst<NVPTXRegClass regclass, string asmstr> :
1967       NVPTXInst<(outs regclass:$dst), (ins regclass:$src),
1968                 !strconcat(!strconcat("mov", asmstr), "\t$dst, $src;"),
1969                 [(set regclass:$dst, (MoveParam regclass:$src))]>;
1970
1971 def MoveParamI64 : MoveParamInst<Int64Regs, ".b64">;
1972 def MoveParamI32 : MoveParamInst<Int32Regs, ".b32">;
1973 def MoveParamI16 : NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$src),
1974                    "cvt.u16.u32\t$dst, $src;",
1975                    [(set Int16Regs:$dst, (MoveParam Int16Regs:$src))]>;
1976 def MoveParamF64 : MoveParamInst<Float64Regs, ".f64">;
1977 def MoveParamF32 : MoveParamInst<Float32Regs, ".f32">;
1978
1979 class PseudoUseParamInst<NVPTXRegClass regclass> :
1980       NVPTXInst<(outs), (ins regclass:$src),
1981       "// Pseudo use of $src",
1982       [(PseudoUseParam regclass:$src)]>;
1983
1984 def PseudoUseParamI64 : PseudoUseParamInst<Int64Regs>;
1985 def PseudoUseParamI32 : PseudoUseParamInst<Int32Regs>;
1986 def PseudoUseParamI16 : PseudoUseParamInst<Int16Regs>;
1987 def PseudoUseParamF64 : PseudoUseParamInst<Float64Regs>;
1988 def PseudoUseParamF32 : PseudoUseParamInst<Float32Regs>;
1989
1990
1991 //
1992 // Load / Store Handling
1993 //
1994 multiclass LD<NVPTXRegClass regclass> {
1995   def _avar : NVPTXInst<(outs regclass:$dst),
1996     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
1997       i32imm:$fromWidth, imem:$addr),
1998 !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
1999            "$fromWidth \t$dst, [$addr];"), []>;
2000   def _areg : NVPTXInst<(outs regclass:$dst),
2001     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2002       i32imm:$fromWidth, Int32Regs:$addr),
2003 !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2004            "$fromWidth \t$dst, [$addr];"), []>;
2005   def _areg_64 : NVPTXInst<(outs regclass:$dst),
2006     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2007      i32imm:$fromWidth, Int64Regs:$addr),
2008      !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$fromWidth",
2009                 " \t$dst, [$addr];"), []>;
2010   def _ari : NVPTXInst<(outs regclass:$dst),
2011     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2012       i32imm:$fromWidth, Int32Regs:$addr, i32imm:$offset),
2013 !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2014            "$fromWidth \t$dst, [$addr+$offset];"), []>;
2015   def _ari_64 : NVPTXInst<(outs regclass:$dst),
2016     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2017      i32imm:$fromWidth, Int64Regs:$addr, i32imm:$offset),
2018     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$fromWidth",
2019                " \t$dst, [$addr+$offset];"), []>;
2020   def _asi : NVPTXInst<(outs regclass:$dst),
2021     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2022       i32imm:$fromWidth, imem:$addr, i32imm:$offset),
2023 !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2024            "$fromWidth \t$dst, [$addr+$offset];"), []>;
2025 }
2026
2027 let mayLoad=1, neverHasSideEffects=1 in {
2028 defm LD_i8  : LD<Int16Regs>;
2029 defm LD_i16 : LD<Int16Regs>;
2030 defm LD_i32 : LD<Int32Regs>;
2031 defm LD_i64 : LD<Int64Regs>;
2032 defm LD_f32 : LD<Float32Regs>;
2033 defm LD_f64 : LD<Float64Regs>;
2034 }
2035
2036 multiclass ST<NVPTXRegClass regclass> {
2037   def _avar : NVPTXInst<(outs),
2038     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2039       LdStCode:$Sign, i32imm:$toWidth, imem:$addr),
2040 !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth",
2041            " \t[$addr], $src;"), []>;
2042   def _areg : NVPTXInst<(outs),
2043     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2044       LdStCode:$Sign, i32imm:$toWidth, Int32Regs:$addr),
2045 !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth",
2046            " \t[$addr], $src;"), []>;
2047   def _areg_64 : NVPTXInst<(outs),
2048     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2049      LdStCode:$Sign, i32imm:$toWidth, Int64Regs:$addr),
2050   !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth ",
2051                "\t[$addr], $src;"), []>;
2052   def _ari : NVPTXInst<(outs),
2053     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2054       LdStCode:$Sign, i32imm:$toWidth, Int32Regs:$addr, i32imm:$offset),
2055 !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth",
2056            " \t[$addr+$offset], $src;"), []>;
2057   def _ari_64 : NVPTXInst<(outs),
2058     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2059      LdStCode:$Sign, i32imm:$toWidth, Int64Regs:$addr, i32imm:$offset),
2060   !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth ",
2061                "\t[$addr+$offset], $src;"), []>;
2062   def _asi : NVPTXInst<(outs),
2063     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2064       LdStCode:$Sign, i32imm:$toWidth, imem:$addr, i32imm:$offset),
2065 !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth",
2066            " \t[$addr+$offset], $src;"), []>;
2067 }
2068
2069 let mayStore=1, neverHasSideEffects=1 in {
2070 defm ST_i8  : ST<Int16Regs>;
2071 defm ST_i16 : ST<Int16Regs>;
2072 defm ST_i32 : ST<Int32Regs>;
2073 defm ST_i64 : ST<Int64Regs>;
2074 defm ST_f32 : ST<Float32Regs>;
2075 defm ST_f64 : ST<Float64Regs>;
2076 }
2077
2078 // The following is used only in and after vector elementizations.
2079 // Vector elementization happens at the machine instruction level, so the
2080 // following instruction
2081 // never appears in the DAG.
2082 multiclass LD_VEC<NVPTXRegClass regclass> {
2083   def _v2_avar : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2084     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2085       i32imm:$fromWidth, imem:$addr),
2086     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2087                "$fromWidth \t{{$dst1, $dst2}}, [$addr];"), []>;
2088   def _v2_areg : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2089     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2090       i32imm:$fromWidth, Int32Regs:$addr),
2091     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2092                "$fromWidth \t{{$dst1, $dst2}}, [$addr];"), []>;
2093   def _v2_areg_64 : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2094     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2095      i32imm:$fromWidth, Int64Regs:$addr),
2096     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2097                "$fromWidth \t{{$dst1, $dst2}}, [$addr];"), []>;
2098   def _v2_ari : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2099     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2100       i32imm:$fromWidth, Int32Regs:$addr, i32imm:$offset),
2101     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2102                "$fromWidth \t{{$dst1, $dst2}}, [$addr+$offset];"), []>;
2103   def _v2_ari_64 : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2104     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2105      i32imm:$fromWidth, Int64Regs:$addr, i32imm:$offset),
2106     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2107                "$fromWidth \t{{$dst1, $dst2}}, [$addr+$offset];"), []>;
2108   def _v2_asi : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2109     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2110       i32imm:$fromWidth, imem:$addr, i32imm:$offset),
2111     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2112                "$fromWidth \t{{$dst1, $dst2}}, [$addr+$offset];"), []>;
2113   def _v4_avar : NVPTXInst<(outs regclass:$dst1, regclass:$dst2,
2114       regclass:$dst3, regclass:$dst4),
2115     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2116       i32imm:$fromWidth, imem:$addr),
2117     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2118                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr];"), []>;
2119   def _v4_areg : NVPTXInst<(outs regclass:$dst1, regclass:$dst2, regclass:$dst3,
2120       regclass:$dst4),
2121     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2122       i32imm:$fromWidth, Int32Regs:$addr),
2123     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2124                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr];"), []>;
2125   def _v4_areg_64 : NVPTXInst<(outs regclass:$dst1, regclass:$dst2,
2126                                regclass:$dst3, regclass:$dst4),
2127     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2128      i32imm:$fromWidth, Int64Regs:$addr),
2129     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2130                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr];"), []>;
2131   def _v4_ari : NVPTXInst<(outs regclass:$dst1, regclass:$dst2, regclass:$dst3,
2132       regclass:$dst4),
2133     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2134       i32imm:$fromWidth, Int32Regs:$addr, i32imm:$offset),
2135     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2136                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr+$offset];"),
2137                 []>;
2138   def _v4_ari_64 : NVPTXInst<(outs regclass:$dst1, regclass:$dst2,
2139                               regclass:$dst3, regclass:$dst4),
2140     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2141      i32imm:$fromWidth, Int64Regs:$addr, i32imm:$offset),
2142     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2143                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr+$offset];"),
2144     []>;
2145   def _v4_asi : NVPTXInst<(outs regclass:$dst1, regclass:$dst2, regclass:$dst3,
2146       regclass:$dst4),
2147     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2148       i32imm:$fromWidth, imem:$addr, i32imm:$offset),
2149     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2150                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr+$offset];"),
2151                 []>;
2152 }
2153 let mayLoad=1, neverHasSideEffects=1 in {
2154 defm LDV_i8  : LD_VEC<Int16Regs>;
2155 defm LDV_i16 : LD_VEC<Int16Regs>;
2156 defm LDV_i32 : LD_VEC<Int32Regs>;
2157 defm LDV_i64 : LD_VEC<Int64Regs>;
2158 defm LDV_f32 : LD_VEC<Float32Regs>;
2159 defm LDV_f64 : LD_VEC<Float64Regs>;
2160 }
2161
2162 multiclass ST_VEC<NVPTXRegClass regclass> {
2163   def _v2_avar : NVPTXInst<(outs),
2164     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2165       LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, imem:$addr),
2166     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2167                "$fromWidth \t[$addr], {{$src1, $src2}};"), []>;
2168   def _v2_areg : NVPTXInst<(outs),
2169     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2170       LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, Int32Regs:$addr),
2171     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2172                "$fromWidth \t[$addr], {{$src1, $src2}};"), []>;
2173   def _v2_areg_64 : NVPTXInst<(outs),
2174     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2175      LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, Int64Regs:$addr),
2176     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2177                "$fromWidth \t[$addr], {{$src1, $src2}};"), []>;
2178   def _v2_ari : NVPTXInst<(outs),
2179     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2180       LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, Int32Regs:$addr,
2181       i32imm:$offset),
2182     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2183                "$fromWidth \t[$addr+$offset], {{$src1, $src2}};"), []>;
2184   def _v2_ari_64 : NVPTXInst<(outs),
2185     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2186      LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, Int64Regs:$addr,
2187      i32imm:$offset),
2188     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2189                "$fromWidth \t[$addr+$offset], {{$src1, $src2}};"), []>;
2190   def _v2_asi : NVPTXInst<(outs),
2191     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2192       LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, imem:$addr,
2193       i32imm:$offset),
2194     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2195                "$fromWidth \t[$addr+$offset], {{$src1, $src2}};"), []>;
2196   def _v4_avar : NVPTXInst<(outs),
2197     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2198       LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2199       i32imm:$fromWidth, imem:$addr),
2200     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2201                "$fromWidth \t[$addr], {{$src1, $src2, $src3, $src4}};"), []>;
2202   def _v4_areg : NVPTXInst<(outs),
2203     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2204       LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2205       i32imm:$fromWidth, Int32Regs:$addr),
2206     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2207                "$fromWidth \t[$addr], {{$src1, $src2, $src3, $src4}};"), []>;
2208   def _v4_areg_64 : NVPTXInst<(outs),
2209     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2210      LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2211      i32imm:$fromWidth, Int64Regs:$addr),
2212     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2213                "$fromWidth \t[$addr], {{$src1, $src2, $src3, $src4}};"), []>;
2214   def _v4_ari : NVPTXInst<(outs),
2215     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2216       LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2217       i32imm:$fromWidth, Int32Regs:$addr, i32imm:$offset),
2218     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2219                "$fromWidth \t[$addr+$offset], {{$src1, $src2, $src3, $src4}};"),
2220     []>;
2221   def _v4_ari_64 : NVPTXInst<(outs),
2222     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2223      LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2224      i32imm:$fromWidth, Int64Regs:$addr, i32imm:$offset),
2225     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2226                "$fromWidth \t[$addr+$offset], {{$src1, $src2, $src3, $src4}};"),
2227      []>;
2228   def _v4_asi : NVPTXInst<(outs),
2229     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2230       LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2231       i32imm:$fromWidth, imem:$addr, i32imm:$offset),
2232     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2233                "$fromWidth \t[$addr+$offset], {{$src1, $src2, $src3, $src4}};"),
2234     []>;
2235 }
2236 let mayStore=1, neverHasSideEffects=1 in {
2237 defm STV_i8  : ST_VEC<Int16Regs>;
2238 defm STV_i16 : ST_VEC<Int16Regs>;
2239 defm STV_i32 : ST_VEC<Int32Regs>;
2240 defm STV_i64 : ST_VEC<Int64Regs>;
2241 defm STV_f32 : ST_VEC<Float32Regs>;
2242 defm STV_f64 : ST_VEC<Float64Regs>;
2243 }
2244
2245
2246 //---- Conversion ----
2247
2248 class F_BITCONVERT<string SzStr, NVPTXRegClass regclassIn,
2249   NVPTXRegClass regclassOut> :
2250            NVPTXInst<(outs regclassOut:$d), (ins regclassIn:$a),
2251            !strconcat("mov.b", !strconcat(SzStr, " \t $d, $a;")),
2252      [(set regclassOut:$d, (bitconvert regclassIn:$a))]>;
2253
2254 def BITCONVERT_32_I2F : F_BITCONVERT<"32", Int32Regs, Float32Regs>;
2255 def BITCONVERT_32_F2I : F_BITCONVERT<"32", Float32Regs, Int32Regs>;
2256 def BITCONVERT_64_I2F : F_BITCONVERT<"64", Int64Regs, Float64Regs>;
2257 def BITCONVERT_64_F2I : F_BITCONVERT<"64", Float64Regs, Int64Regs>;
2258
2259 // NOTE: pred->fp are currently sub-optimal due to an issue in TableGen where
2260 // we cannot specify floating-point literals in isel patterns.  Therefore, we
2261 // use an integer selp to select either 1 or 0 and then cvt to floating-point.
2262
2263 // sint -> f32
2264 def : Pat<(f32 (sint_to_fp Int1Regs:$a)),
2265           (CVT_f32_s32 (SELP_u32ii 1, 0, Int1Regs:$a), CvtRN)>;
2266 def : Pat<(f32 (sint_to_fp Int16Regs:$a)),
2267           (CVT_f32_s16 Int16Regs:$a, CvtRN)>;
2268 def : Pat<(f32 (sint_to_fp Int32Regs:$a)),
2269           (CVT_f32_s32 Int32Regs:$a, CvtRN)>;
2270 def : Pat<(f32 (sint_to_fp Int64Regs:$a)),
2271           (CVT_f32_s64 Int64Regs:$a, CvtRN)>;
2272
2273 // uint -> f32
2274 def : Pat<(f32 (uint_to_fp Int1Regs:$a)),
2275           (CVT_f32_u32 (SELP_u32ii 1, 0, Int1Regs:$a), CvtRN)>;
2276 def : Pat<(f32 (uint_to_fp Int16Regs:$a)),
2277           (CVT_f32_u16 Int16Regs:$a, CvtRN)>;
2278 def : Pat<(f32 (uint_to_fp Int32Regs:$a)),
2279           (CVT_f32_u32 Int32Regs:$a, CvtRN)>;
2280 def : Pat<(f32 (uint_to_fp Int64Regs:$a)),
2281           (CVT_f32_u64 Int64Regs:$a, CvtRN)>;
2282
2283 // sint -> f64
2284 def : Pat<(f64 (sint_to_fp Int1Regs:$a)),
2285           (CVT_f64_s32 (SELP_u32ii 1, 0, Int1Regs:$a), CvtRN)>;
2286 def : Pat<(f64 (sint_to_fp Int16Regs:$a)),
2287           (CVT_f64_s16 Int16Regs:$a, CvtRN)>;
2288 def : Pat<(f64 (sint_to_fp Int32Regs:$a)),
2289           (CVT_f64_s32 Int32Regs:$a, CvtRN)>;
2290 def : Pat<(f64 (sint_to_fp Int64Regs:$a)),
2291           (CVT_f64_s64 Int64Regs:$a, CvtRN)>;
2292
2293 // uint -> f64
2294 def : Pat<(f64 (uint_to_fp Int1Regs:$a)),
2295           (CVT_f64_u32 (SELP_u32ii 1, 0, Int1Regs:$a), CvtRN)>;
2296 def : Pat<(f64 (uint_to_fp Int16Regs:$a)),
2297           (CVT_f64_u16 Int16Regs:$a, CvtRN)>;
2298 def : Pat<(f64 (uint_to_fp Int32Regs:$a)),
2299           (CVT_f64_u32 Int32Regs:$a, CvtRN)>;
2300 def : Pat<(f64 (uint_to_fp Int64Regs:$a)),
2301           (CVT_f64_u64 Int64Regs:$a, CvtRN)>;
2302
2303
2304 // f32 -> sint
2305 def : Pat<(i1 (fp_to_sint Float32Regs:$a)),
2306           (SETP_b32ri (BITCONVERT_32_F2I Float32Regs:$a), 0, CmpEQ)>;
2307 def : Pat<(i16 (fp_to_sint Float32Regs:$a)),
2308           (CVT_s16_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2309 def : Pat<(i16 (fp_to_sint Float32Regs:$a)),
2310           (CVT_s16_f32 Float32Regs:$a, CvtRZI)>;
2311 def : Pat<(i32 (fp_to_sint Float32Regs:$a)),
2312           (CVT_s32_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2313 def : Pat<(i32 (fp_to_sint Float32Regs:$a)),
2314           (CVT_s32_f32 Float32Regs:$a, CvtRZI)>;
2315 def : Pat<(i64 (fp_to_sint Float32Regs:$a)),
2316           (CVT_s64_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2317 def : Pat<(i64 (fp_to_sint Float32Regs:$a)),
2318           (CVT_s64_f32 Float32Regs:$a, CvtRZI)>;
2319
2320 // f32 -> uint
2321 def : Pat<(i1 (fp_to_uint Float32Regs:$a)),
2322           (SETP_b32ri (BITCONVERT_32_F2I Float32Regs:$a), 0, CmpEQ)>;
2323 def : Pat<(i16 (fp_to_uint Float32Regs:$a)),
2324           (CVT_u16_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2325 def : Pat<(i16 (fp_to_uint Float32Regs:$a)),
2326           (CVT_u16_f32 Float32Regs:$a, CvtRZI)>;
2327 def : Pat<(i32 (fp_to_uint Float32Regs:$a)),
2328           (CVT_u32_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2329 def : Pat<(i32 (fp_to_uint Float32Regs:$a)),
2330           (CVT_u32_f32 Float32Regs:$a, CvtRZI)>;
2331 def : Pat<(i64 (fp_to_uint Float32Regs:$a)),
2332           (CVT_u64_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2333 def : Pat<(i64 (fp_to_uint Float32Regs:$a)),
2334           (CVT_u64_f32 Float32Regs:$a, CvtRZI)>;
2335
2336 // f64 -> sint
2337 def : Pat<(i1 (fp_to_sint Float64Regs:$a)),
2338           (SETP_b64ri (BITCONVERT_64_F2I Float64Regs:$a), 0, CmpEQ)>;
2339 def : Pat<(i16 (fp_to_sint Float64Regs:$a)),
2340           (CVT_s16_f64 Float64Regs:$a, CvtRZI)>;
2341 def : Pat<(i32 (fp_to_sint Float64Regs:$a)),
2342           (CVT_s32_f64 Float64Regs:$a, CvtRZI)>;
2343 def : Pat<(i64 (fp_to_sint Float64Regs:$a)),
2344           (CVT_s64_f64 Float64Regs:$a, CvtRZI)>;
2345
2346 // f64 -> uint
2347 def : Pat<(i1 (fp_to_uint Float64Regs:$a)),
2348           (SETP_b64ri (BITCONVERT_64_F2I Float64Regs:$a), 0, CmpEQ)>;
2349 def : Pat<(i16 (fp_to_uint Float64Regs:$a)),
2350           (CVT_u16_f64 Float64Regs:$a, CvtRZI)>;
2351 def : Pat<(i32 (fp_to_uint Float64Regs:$a)),
2352           (CVT_u32_f64 Float64Regs:$a, CvtRZI)>;
2353 def : Pat<(i64 (fp_to_uint Float64Regs:$a)),
2354           (CVT_u64_f64 Float64Regs:$a, CvtRZI)>;
2355
2356 // sext i1
2357 def : Pat<(i16 (sext Int1Regs:$a)),
2358           (SELP_s16ii -1, 0, Int1Regs:$a)>;
2359 def : Pat<(i32 (sext Int1Regs:$a)),
2360           (SELP_s32ii -1, 0, Int1Regs:$a)>;
2361 def : Pat<(i64 (sext Int1Regs:$a)),
2362           (SELP_s64ii -1, 0, Int1Regs:$a)>;
2363
2364 // zext i1
2365 def : Pat<(i16 (zext Int1Regs:$a)),
2366           (SELP_u16ii 1, 0, Int1Regs:$a)>;
2367 def : Pat<(i32 (zext Int1Regs:$a)),
2368           (SELP_u32ii 1, 0, Int1Regs:$a)>;
2369 def : Pat<(i64 (zext Int1Regs:$a)),
2370           (SELP_u64ii 1, 0, Int1Regs:$a)>;
2371
2372 // anyext i1
2373 def : Pat<(i16 (anyext Int1Regs:$a)),
2374           (SELP_u16ii -1, 0, Int1Regs:$a)>;
2375 def : Pat<(i32 (anyext Int1Regs:$a)),
2376           (SELP_u32ii -1, 0, Int1Regs:$a)>;
2377 def : Pat<(i64 (anyext Int1Regs:$a)),
2378           (SELP_u64ii -1, 0, Int1Regs:$a)>;
2379
2380 // sext i16
2381 def : Pat<(i32 (sext Int16Regs:$a)),
2382           (CVT_s32_s16 Int16Regs:$a, CvtNONE)>;
2383 def : Pat<(i64 (sext Int16Regs:$a)),
2384           (CVT_s64_s16 Int16Regs:$a, CvtNONE)>;
2385
2386 // zext i16
2387 def : Pat<(i32 (zext Int16Regs:$a)),
2388           (CVT_u32_u16 Int16Regs:$a, CvtNONE)>;
2389 def : Pat<(i64 (zext Int16Regs:$a)),
2390           (CVT_u64_u16 Int16Regs:$a, CvtNONE)>;
2391
2392 // anyext i16
2393 def : Pat<(i32 (anyext Int16Regs:$a)),
2394           (CVT_u32_u16 Int16Regs:$a, CvtNONE)>;
2395 def : Pat<(i64 (anyext Int16Regs:$a)),
2396           (CVT_u64_u16 Int16Regs:$a, CvtNONE)>;
2397
2398 // sext i32
2399 def : Pat<(i64 (sext Int32Regs:$a)),
2400           (CVT_s64_s32 Int32Regs:$a, CvtNONE)>;
2401
2402 // zext i32
2403 def : Pat<(i64 (zext Int32Regs:$a)),
2404           (CVT_u64_u32 Int32Regs:$a, CvtNONE)>;
2405
2406 // anyext i32
2407 def : Pat<(i64 (anyext Int32Regs:$a)),
2408           (CVT_u64_u32 Int32Regs:$a, CvtNONE)>;
2409
2410
2411 // truncate i64
2412 def : Pat<(i32 (trunc Int64Regs:$a)),
2413           (CVT_u32_u64 Int64Regs:$a, CvtNONE)>;
2414 def : Pat<(i16 (trunc Int64Regs:$a)),
2415           (CVT_u16_u64 Int64Regs:$a, CvtNONE)>;
2416 def : Pat<(i1 (trunc Int64Regs:$a)),
2417           (SETP_b64ri (ANDb64ri Int64Regs:$a, 1), 1, CmpEQ)>;
2418
2419 // truncate i32
2420 def : Pat<(i16 (trunc Int32Regs:$a)),
2421           (CVT_u16_u32 Int32Regs:$a, CvtNONE)>;
2422 def : Pat<(i1 (trunc Int32Regs:$a)),
2423           (SETP_b32ri (ANDb32ri Int32Regs:$a, 1), 1, CmpEQ)>;
2424
2425 // truncate i16
2426 def : Pat<(i1 (trunc Int16Regs:$a)),
2427           (SETP_b16ri (ANDb16ri Int16Regs:$a, 1), 1, CmpEQ)>;
2428
2429 // sext_inreg
2430 def : Pat<(sext_inreg Int16Regs:$a, i8), (CVT_INREG_s16_s8 Int16Regs:$a)>;
2431 def : Pat<(sext_inreg Int32Regs:$a, i8), (CVT_INREG_s32_s8 Int32Regs:$a)>;
2432 def : Pat<(sext_inreg Int32Regs:$a, i16), (CVT_INREG_s32_s16 Int32Regs:$a)>;
2433 def : Pat<(sext_inreg Int64Regs:$a, i8), (CVT_INREG_s64_s8 Int64Regs:$a)>;
2434 def : Pat<(sext_inreg Int64Regs:$a, i16), (CVT_INREG_s64_s16 Int64Regs:$a)>;
2435 def : Pat<(sext_inreg Int64Regs:$a, i32), (CVT_INREG_s64_s32 Int64Regs:$a)>;
2436
2437
2438 // Select instructions with 32-bit predicates
2439 def : Pat<(select Int32Regs:$pred, Int16Regs:$a, Int16Regs:$b),
2440           (SELP_b16rr Int16Regs:$a, Int16Regs:$b,
2441           (SETP_b32ri (ANDb32ri Int32Regs:$pred, 1), 1, CmpEQ))>;
2442 def : Pat<(select Int32Regs:$pred, Int32Regs:$a, Int32Regs:$b),
2443           (SELP_b32rr Int32Regs:$a, Int32Regs:$b,
2444           (SETP_b32ri (ANDb32ri Int32Regs:$pred, 1), 1, CmpEQ))>;
2445 def : Pat<(select Int32Regs:$pred, Int64Regs:$a, Int64Regs:$b),
2446           (SELP_b64rr Int64Regs:$a, Int64Regs:$b,
2447           (SETP_b32ri (ANDb32ri Int32Regs:$pred, 1), 1, CmpEQ))>;
2448 def : Pat<(select Int32Regs:$pred, Float32Regs:$a, Float32Regs:$b),
2449           (SELP_f32rr Float32Regs:$a, Float32Regs:$b,
2450           (SETP_b32ri (ANDb32ri Int32Regs:$pred, 1), 1, CmpEQ))>;
2451 def : Pat<(select Int32Regs:$pred, Float64Regs:$a, Float64Regs:$b),
2452           (SELP_f64rr Float64Regs:$a, Float64Regs:$b,
2453           (SETP_b32ri (ANDb32ri Int32Regs:$pred, 1), 1, CmpEQ))>;
2454
2455
2456 // pack a set of smaller int registers to a larger int register
2457 def V4I16toI64 : NVPTXInst<(outs Int64Regs:$d),
2458                           (ins Int16Regs:$s1, Int16Regs:$s2,
2459                                Int16Regs:$s3, Int16Regs:$s4),
2460                           "mov.b64\t$d, {{$s1, $s2, $s3, $s4}};",
2461                           []>;
2462 def V2I16toI32 : NVPTXInst<(outs Int32Regs:$d),
2463                           (ins Int16Regs:$s1, Int16Regs:$s2),
2464                           "mov.b32\t$d, {{$s1, $s2}};",
2465                           []>;
2466 def V2I32toI64 : NVPTXInst<(outs Int64Regs:$d),
2467                           (ins Int32Regs:$s1, Int32Regs:$s2),
2468                           "mov.b64\t$d, {{$s1, $s2}};",
2469                           []>;
2470 def V2F32toF64 : NVPTXInst<(outs Float64Regs:$d),
2471                           (ins Float32Regs:$s1, Float32Regs:$s2),
2472                           "mov.b64\t$d, {{$s1, $s2}};",
2473                           []>;
2474
2475 // unpack a larger int register to a set of smaller int registers
2476 def I64toV4I16 : NVPTXInst<(outs Int16Regs:$d1, Int16Regs:$d2,
2477                                  Int16Regs:$d3, Int16Regs:$d4),
2478                            (ins Int64Regs:$s),
2479                            "mov.b64\t{{$d1, $d2, $d3, $d4}}, $s;",
2480                           []>;
2481 def I32toV2I16 : NVPTXInst<(outs Int16Regs:$d1, Int16Regs:$d2),
2482                            (ins Int32Regs:$s),
2483                            "mov.b32\t{{$d1, $d2}}, $s;",
2484                           []>;
2485 def I64toV2I32 : NVPTXInst<(outs Int32Regs:$d1, Int32Regs:$d2),
2486                            (ins Int64Regs:$s),
2487                            "mov.b64\t{{$d1, $d2}}, $s;",
2488                           []>;
2489 def F64toV2F32 : NVPTXInst<(outs Float32Regs:$d1, Float32Regs:$d2),
2490                            (ins Float64Regs:$s),
2491                            "mov.b64\t{{$d1, $d2}}, $s;",
2492                           []>;
2493
2494 // Count leading zeros
2495 def CLZr32 : NVPTXInst<(outs Int32Regs:$d), (ins Int32Regs:$a),
2496                        "clz.b32\t$d, $a;",
2497                        []>;
2498 def CLZr64 : NVPTXInst<(outs Int32Regs:$d), (ins Int64Regs:$a),
2499                        "clz.b64\t$d, $a;",
2500                        []>;
2501
2502 // 32-bit has a direct PTX instruction
2503 def : Pat<(ctlz Int32Regs:$a),
2504           (CLZr32 Int32Regs:$a)>;
2505 def : Pat<(ctlz_zero_undef Int32Regs:$a),
2506           (CLZr32 Int32Regs:$a)>;
2507
2508 // For 64-bit, the result in PTX is actually 32-bit so we zero-extend
2509 // to 64-bit to match the LLVM semantics
2510 def : Pat<(ctlz Int64Regs:$a),
2511           (CVT_u64_u32 (CLZr64 Int64Regs:$a), CvtNONE)>;
2512 def : Pat<(ctlz_zero_undef Int64Regs:$a),
2513           (CVT_u64_u32 (CLZr64 Int64Regs:$a), CvtNONE)>;
2514
2515 // For 16-bit, we zero-extend to 32-bit, then trunc the result back
2516 // to 16-bits (ctlz of a 16-bit value is guaranteed to require less
2517 // than 16 bits to store). We also need to subtract 16 because the
2518 // high-order 16 zeros were counted.
2519 def : Pat<(ctlz Int16Regs:$a),
2520           (SUBi16ri (CVT_u16_u32 (CLZr32
2521             (CVT_u32_u16 Int16Regs:$a, CvtNONE)),
2522            CvtNONE), 16)>;
2523 def : Pat<(ctlz_zero_undef Int16Regs:$a),
2524           (SUBi16ri (CVT_u16_u32 (CLZr32
2525             (CVT_u32_u16 Int16Regs:$a, CvtNONE)),
2526            CvtNONE), 16)>;
2527
2528 // Population count
2529 def POPCr32 : NVPTXInst<(outs Int32Regs:$d), (ins Int32Regs:$a),
2530                         "popc.b32\t$d, $a;",
2531                         []>;
2532 def POPCr64 : NVPTXInst<(outs Int32Regs:$d), (ins Int64Regs:$a),
2533                         "popc.b64\t$d, $a;",
2534                         []>;
2535
2536 // 32-bit has a direct PTX instruction
2537 def : Pat<(ctpop Int32Regs:$a),
2538           (POPCr32 Int32Regs:$a)>;
2539
2540 // For 64-bit, the result in PTX is actually 32-bit so we zero-extend
2541 // to 64-bit to match the LLVM semantics
2542 def : Pat<(ctpop Int64Regs:$a),
2543           (CVT_u64_u32 (POPCr64 Int64Regs:$a), CvtNONE)>;
2544
2545 // For 16-bit, we zero-extend to 32-bit, then trunc the result back
2546 // to 16-bits (ctpop of a 16-bit value is guaranteed to require less
2547 // than 16 bits to store)
2548 def : Pat<(ctpop Int16Regs:$a),
2549           (CVT_u16_u32 (POPCr32 (CVT_u32_u16 Int16Regs:$a, CvtNONE)),
2550            CvtNONE)>;
2551
2552 // fround f64 -> f32
2553 def : Pat<(f32 (fround Float64Regs:$a)),
2554           (CVT_f32_f64 Float64Regs:$a, CvtRN_FTZ)>, Requires<[doF32FTZ]>;
2555 def : Pat<(f32 (fround Float64Regs:$a)),
2556           (CVT_f32_f64 Float64Regs:$a, CvtRN)>;
2557
2558 // fextend f32 -> f64
2559 def : Pat<(f64 (fextend Float32Regs:$a)),
2560           (CVT_f64_f32 Float32Regs:$a, CvtNONE_FTZ)>, Requires<[doF32FTZ]>;
2561 def : Pat<(f64 (fextend Float32Regs:$a)),
2562           (CVT_f64_f32 Float32Regs:$a, CvtNONE)>;
2563
2564 def retflag       : SDNode<"NVPTXISD::RET_FLAG", SDTNone,
2565                            [SDNPHasChain, SDNPOptInGlue]>;
2566
2567 //-----------------------------------
2568 // Control-flow
2569 //-----------------------------------
2570
2571 let isTerminator=1 in {
2572    let isReturn=1, isBarrier=1 in
2573       def Return : NVPTXInst<(outs), (ins), "ret;", [(retflag)]>;
2574
2575    let isBranch=1 in
2576       def CBranch : NVPTXInst<(outs), (ins Int1Regs:$a, brtarget:$target),
2577                           "@$a bra \t$target;",
2578                            [(brcond Int1Regs:$a, bb:$target)]>;
2579    let isBranch=1 in
2580       def CBranchOther : NVPTXInst<(outs), (ins Int1Regs:$a, brtarget:$target),
2581                           "@!$a bra \t$target;",
2582                            []>;
2583
2584    let isBranch=1, isBarrier=1 in
2585       def GOTO : NVPTXInst<(outs), (ins brtarget:$target),
2586                         "bra.uni \t$target;",
2587                   [(br bb:$target)]>;
2588 }
2589
2590 def : Pat<(brcond Int32Regs:$a, bb:$target),
2591           (CBranch (SETP_u32ri Int32Regs:$a, 0, CmpNE), bb:$target)>;
2592
2593 // SelectionDAGBuilder::visitSWitchCase() will invert the condition of a
2594 // conditional branch if
2595 // the target block is the next block so that the code can fall through to the
2596 // target block.
2597 // The invertion is done by 'xor condition, 1', which will be translated to
2598 // (setne condition, -1).
2599 // Since ptx supports '@!pred bra target', we should use it.
2600 def : Pat<(brcond (i1 (setne Int1Regs:$a, -1)), bb:$target),
2601   (CBranchOther Int1Regs:$a, bb:$target)>;
2602
2603 // Call
2604 def SDT_NVPTXCallSeqStart : SDCallSeqStart<[ SDTCisVT<0, i32> ]>;
2605 def SDT_NVPTXCallSeqEnd   : SDCallSeqEnd<[ SDTCisVT<0, i32>,
2606                                         SDTCisVT<1, i32> ]>;
2607
2608 def callseq_start : SDNode<"ISD::CALLSEQ_START", SDT_NVPTXCallSeqStart,
2609                            [SDNPHasChain, SDNPOutGlue, SDNPSideEffect]>;
2610 def callseq_end   : SDNode<"ISD::CALLSEQ_END",   SDT_NVPTXCallSeqEnd,
2611                            [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue,
2612                            SDNPSideEffect]>;
2613
2614 def SDT_NVPTXCall : SDTypeProfile<0, 1, [SDTCisVT<0, i32>]>;
2615 def call          : SDNode<"NVPTXISD::CALL", SDT_NVPTXCall,
2616                            [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
2617 def calltarget : Operand<i32>;
2618 let isCall=1 in {
2619    def CALL : NVPTXInst<(outs), (ins calltarget:$dst),
2620                   "call \t$dst, (1);", []>;
2621 }
2622
2623 def : Pat<(call tglobaladdr:$dst),
2624           (CALL tglobaladdr:$dst)>;
2625 def : Pat<(call texternalsym:$dst),
2626           (CALL texternalsym:$dst)>;
2627
2628 // Pseudo instructions.
2629 class Pseudo<dag outs, dag ins, string asmstr, list<dag> pattern>
2630    : NVPTXInst<outs, ins, asmstr, pattern>;
2631
2632 // @TODO: We use some tricks here to emit curly braces.  Can we clean this up
2633 // a bit without TableGen modifications?
2634 def Callseq_Start : NVPTXInst<(outs), (ins i32imm:$amt),
2635   "// Callseq Start $amt\n\t{{\n\t.reg .b32 temp_param_reg;\n\t// <end>}}",
2636                                [(callseq_start timm:$amt)]>;
2637 def Callseq_End : NVPTXInst<(outs), (ins i32imm:$amt1, i32imm:$amt2),
2638   "\n\t//{{\n\t}}// Callseq End $amt1",
2639                             [(callseq_end timm:$amt1, timm:$amt2)]>;
2640
2641 // trap instruction
2642
2643 def trapinst : NVPTXInst<(outs), (ins),
2644                          "trap;",
2645                          [(trap)]>;
2646
2647 // Call prototype wrapper
2648 def SDTCallPrototype : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
2649 def CallPrototype
2650   : SDNode<"NVPTXISD::CallPrototype", SDTCallPrototype,
2651            [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
2652 def ProtoIdent : Operand<i32> {
2653   let PrintMethod = "printProtoIdent";
2654 }
2655 def CALL_PROTOTYPE
2656   : NVPTXInst<(outs), (ins ProtoIdent:$ident),
2657               "$ident", [(CallPrototype (i32 texternalsym:$ident))]>;
2658
2659
2660
2661 include "NVPTXIntrinsics.td"
2662
2663
2664 //-----------------------------------
2665 // Notes
2666 //-----------------------------------
2667 // BSWAP is currently expanded. The following is a more efficient
2668 // - for < sm_20, use vector scalar mov, as tesla support native 16-bit register
2669 // - for sm_20, use pmpt (use vector scalar mov to get the pack and
2670 //   unpack). sm_20 supports native 32-bit register, but not native 16-bit
2671 // register.