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
1183 //-----------------------------------
1184 // General Comparison
1185 //-----------------------------------
1186
1187 // General setp instructions
1188 multiclass SETP<string TypeStr, RegisterClass RC, Operand ImmCls> {
1189   def rr : NVPTXInst<(outs Int1Regs:$dst),
1190                      (ins RC:$a, RC:$b, CmpMode:$cmp),
1191             !strconcat("setp${cmp:base}${cmp:ftz}.", TypeStr, "\t$dst, $a, $b;"),
1192                      []>;
1193   def ri : NVPTXInst<(outs Int1Regs:$dst),
1194                      (ins RC:$a, ImmCls:$b, CmpMode:$cmp),
1195             !strconcat("setp${cmp:base}${cmp:ftz}.", TypeStr, "\t$dst, $a, $b;"),
1196                      []>;
1197   def ir : NVPTXInst<(outs Int1Regs:$dst),
1198                      (ins ImmCls:$a, RC:$b, CmpMode:$cmp),
1199             !strconcat("setp${cmp:base}${cmp:ftz}.", TypeStr, "\t$dst, $a, $b;"),
1200                      []>;
1201 }
1202
1203 defm SETP_b16 : SETP<"b16", Int16Regs, i16imm>;
1204 defm SETP_s16 : SETP<"s16", Int16Regs, i16imm>;
1205 defm SETP_u16 : SETP<"u16", Int16Regs, i16imm>;
1206 defm SETP_b32 : SETP<"b32", Int32Regs, i32imm>;
1207 defm SETP_s32 : SETP<"s32", Int32Regs, i32imm>;
1208 defm SETP_u32 : SETP<"u32", Int32Regs, i32imm>;
1209 defm SETP_b64 : SETP<"b64", Int64Regs, i64imm>;
1210 defm SETP_s64 : SETP<"s64", Int64Regs, i64imm>;
1211 defm SETP_u64 : SETP<"u64", Int64Regs, i64imm>;
1212 defm SETP_f32 : SETP<"f32", Float32Regs, f32imm>;
1213 defm SETP_f64 : SETP<"f64", Float64Regs, f64imm>;
1214
1215 // General set instructions
1216 multiclass SET<string TypeStr, RegisterClass RC, Operand ImmCls> {
1217   def rr : NVPTXInst<(outs Int32Regs:$dst),
1218                      (ins RC:$a, RC:$b, CmpMode:$cmp),
1219                      !strconcat("set$cmp.", TypeStr, "\t$dst, $a, $b;"), []>;
1220   def ri : NVPTXInst<(outs Int32Regs:$dst),
1221                      (ins RC:$a, ImmCls:$b, CmpMode:$cmp),
1222                      !strconcat("set$cmp.", TypeStr, "\t$dst, $a, $b;"), []>;
1223   def ir : NVPTXInst<(outs Int32Regs:$dst),
1224                      (ins ImmCls:$a, RC:$b, CmpMode:$cmp),
1225                      !strconcat("set$cmp.", TypeStr, "\t$dst, $a, $b;"), []>;
1226 }
1227
1228 defm SET_b16 : SET<"b16", Int16Regs, i16imm>;
1229 defm SET_s16 : SET<"s16", Int16Regs, i16imm>;
1230 defm SET_u16 : SET<"u16", Int16Regs, i16imm>;
1231 defm SET_b32 : SET<"b32", Int32Regs, i32imm>;
1232 defm SET_s32 : SET<"s32", Int32Regs, i32imm>;
1233 defm SET_u32 : SET<"u32", Int32Regs, i32imm>;
1234 defm SET_b64 : SET<"b64", Int64Regs, i64imm>;
1235 defm SET_s64 : SET<"s64", Int64Regs, i64imm>;
1236 defm SET_u64 : SET<"u64", Int64Regs, i64imm>;
1237 defm SET_f32 : SET<"f32", Float32Regs, f32imm>;
1238 defm SET_f64 : SET<"f64", Float64Regs, f64imm>;
1239
1240 //-----------------------------------
1241 // General Selection
1242 //-----------------------------------
1243
1244 // General selp instructions
1245 multiclass SELP<string TypeStr, RegisterClass RC, Operand ImmCls> {
1246   def rr : NVPTXInst<(outs RC:$dst),
1247                      (ins RC:$a, RC:$b, Int1Regs:$p),
1248                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"), []>;
1249   def ri : NVPTXInst<(outs RC:$dst),
1250                      (ins RC:$a, ImmCls:$b, Int1Regs:$p),
1251                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"), []>;
1252   def ir : NVPTXInst<(outs RC:$dst),
1253                      (ins ImmCls:$a, RC:$b, Int1Regs:$p),
1254                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"), []>;
1255   def ii : NVPTXInst<(outs RC:$dst),
1256                      (ins ImmCls:$a, ImmCls:$b, Int1Regs:$p),
1257                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"), []>;
1258 }
1259
1260 multiclass SELP_PATTERN<string TypeStr, RegisterClass RC, Operand ImmCls,
1261                         SDNode ImmNode> {
1262   def rr : NVPTXInst<(outs RC:$dst),
1263                      (ins RC:$a, RC:$b, Int1Regs:$p),
1264                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"),
1265                      [(set RC:$dst, (select Int1Regs:$p, RC:$a, RC:$b))]>;
1266   def ri : NVPTXInst<(outs RC:$dst),
1267                      (ins RC:$a, ImmCls:$b, Int1Regs:$p),
1268                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"),
1269                      [(set RC:$dst, (select Int1Regs:$p, RC:$a, ImmNode:$b))]>;
1270   def ir : NVPTXInst<(outs RC:$dst),
1271                      (ins ImmCls:$a, RC:$b, Int1Regs:$p),
1272                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"),
1273                      [(set RC:$dst, (select Int1Regs:$p, ImmNode:$a, RC:$b))]>;
1274   def ii : NVPTXInst<(outs RC:$dst),
1275                      (ins ImmCls:$a, ImmCls:$b, Int1Regs:$p),
1276                      !strconcat("selp.", TypeStr, "\t$dst, $a, $b, $p;"),
1277                  [(set RC:$dst, (select Int1Regs:$p, ImmNode:$a, ImmNode:$b))]>;
1278 }
1279
1280 defm SELP_b16 : SELP_PATTERN<"b16", Int16Regs, i16imm, imm>;
1281 defm SELP_s16 : SELP<"s16", Int16Regs, i16imm>;
1282 defm SELP_u16 : SELP<"u16", Int16Regs, i16imm>;
1283 defm SELP_b32 : SELP_PATTERN<"b32", Int32Regs, i32imm, imm>;
1284 defm SELP_s32 : SELP<"s32", Int32Regs, i32imm>;
1285 defm SELP_u32 : SELP<"u32", Int32Regs, i32imm>;
1286 defm SELP_b64 : SELP_PATTERN<"b64", Int64Regs, i64imm, imm>;
1287 defm SELP_s64 : SELP<"s64", Int64Regs, i64imm>;
1288 defm SELP_u64 : SELP<"u64", Int64Regs, i64imm>;
1289 defm SELP_f32 : SELP_PATTERN<"f32", Float32Regs, f32imm, fpimm>;
1290 defm SELP_f64 : SELP_PATTERN<"f64", Float64Regs, f64imm, fpimm>;
1291
1292 // Special select for predicate operands
1293 def : Pat<(i1 (select Int1Regs:$p, Int1Regs:$a, Int1Regs:$b)),
1294               (ORb1rr (ANDb1rr Int1Regs:$p, Int1Regs:$a),
1295               (ANDb1rr (NOT1 Int1Regs:$p), Int1Regs:$b))>;
1296
1297 //-----------------------------------
1298 // Data Movement (Load / Store, Move)
1299 //-----------------------------------
1300
1301 def ADDRri : ComplexPattern<i32, 2, "SelectADDRri", [frameindex],
1302   [SDNPWantRoot]>;
1303 def ADDRri64 : ComplexPattern<i64, 2, "SelectADDRri64", [frameindex],
1304   [SDNPWantRoot]>;
1305
1306 def MEMri : Operand<i32> {
1307   let PrintMethod = "printMemOperand";
1308   let MIOperandInfo = (ops Int32Regs, i32imm);
1309 }
1310 def MEMri64 : Operand<i64> {
1311   let PrintMethod = "printMemOperand";
1312   let MIOperandInfo = (ops Int64Regs, i64imm);
1313 }
1314
1315 def imem : Operand<iPTR> {
1316     let PrintMethod = "printOperand";
1317 }
1318
1319 def imemAny : Operand<iPTRAny> {
1320     let PrintMethod = "printOperand";
1321 }
1322
1323 def LdStCode : Operand<i32> {
1324     let PrintMethod = "printLdStCode";
1325 }
1326
1327 def SDTWrapper : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>, SDTCisPtrTy<0>]>;
1328 def Wrapper    : SDNode<"NVPTXISD::Wrapper", SDTWrapper>;
1329
1330 def MOV_ADDR : NVPTXInst<(outs Int32Regs:$dst), (ins imem:$a),
1331                      "mov.u32 \t$dst, $a;",
1332                      [(set Int32Regs:$dst, (Wrapper tglobaladdr:$a))]>;
1333
1334 def MOV_ADDR64 : NVPTXInst<(outs Int64Regs:$dst), (ins imem:$a),
1335                      "mov.u64 \t$dst, $a;",
1336                      [(set Int64Regs:$dst, (Wrapper tglobaladdr:$a))]>;
1337
1338 // Get pointer to local stack
1339 def MOV_DEPOT_ADDR
1340   : NVPTXInst<(outs Int32Regs:$d), (ins i32imm:$num),
1341               "mov.u32 \t$d, __local_depot$num;", []>;
1342 def MOV_DEPOT_ADDR_64
1343   : NVPTXInst<(outs Int64Regs:$d), (ins i32imm:$num),
1344               "mov.u64 \t$d, __local_depot$num;", []>;
1345
1346
1347 // copyPhysreg is hard-coded in NVPTXInstrInfo.cpp
1348 let IsSimpleMove=1 in {
1349 def IMOV1rr: NVPTXInst<(outs Int1Regs:$dst), (ins Int1Regs:$sss),
1350                    "mov.pred \t$dst, $sss;", []>;
1351 def IMOV16rr: NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$sss),
1352                     "mov.u16 \t$dst, $sss;", []>;
1353 def IMOV32rr: NVPTXInst<(outs Int32Regs:$dst), (ins Int32Regs:$sss),
1354                     "mov.u32 \t$dst, $sss;", []>;
1355 def IMOV64rr: NVPTXInst<(outs Int64Regs:$dst), (ins Int64Regs:$sss),
1356                     "mov.u64 \t$dst, $sss;", []>;
1357
1358 def FMOV32rr: NVPTXInst<(outs Float32Regs:$dst), (ins Float32Regs:$src),
1359                     "mov.f32 \t$dst, $src;", []>;
1360 def FMOV64rr: NVPTXInst<(outs Float64Regs:$dst), (ins Float64Regs:$src),
1361                     "mov.f64 \t$dst, $src;", []>;
1362 }
1363 def IMOV1ri: NVPTXInst<(outs Int1Regs:$dst), (ins i1imm:$src),
1364                     "mov.pred \t$dst, $src;",
1365           [(set Int1Regs:$dst, imm:$src)]>;
1366 def IMOV16ri: NVPTXInst<(outs Int16Regs:$dst), (ins i16imm:$src),
1367                     "mov.u16 \t$dst, $src;",
1368           [(set Int16Regs:$dst, imm:$src)]>;
1369 def IMOV32ri: NVPTXInst<(outs Int32Regs:$dst), (ins i32imm:$src),
1370                     "mov.u32 \t$dst, $src;",
1371           [(set Int32Regs:$dst, imm:$src)]>;
1372 def IMOV64i: NVPTXInst<(outs Int64Regs:$dst), (ins i64imm:$src),
1373                     "mov.u64 \t$dst, $src;",
1374           [(set Int64Regs:$dst, imm:$src)]>;
1375
1376 def FMOV32ri: NVPTXInst<(outs Float32Regs:$dst), (ins f32imm:$src),
1377                     "mov.f32 \t$dst, $src;",
1378           [(set Float32Regs:$dst, fpimm:$src)]>;
1379 def FMOV64ri: NVPTXInst<(outs Float64Regs:$dst), (ins f64imm:$src),
1380                     "mov.f64 \t$dst, $src;",
1381           [(set Float64Regs:$dst, fpimm:$src)]>;
1382
1383 def : Pat<(i32 (Wrapper texternalsym:$dst)), (IMOV32ri texternalsym:$dst)>;
1384
1385 //---- Copy Frame Index ----
1386 def LEA_ADDRi : NVPTXInst<(outs Int32Regs:$dst), (ins MEMri:$addr),
1387                         "add.u32 \t$dst, ${addr:add};",
1388                         [(set Int32Regs:$dst, ADDRri:$addr)]>;
1389 def LEA_ADDRi64 : NVPTXInst<(outs Int64Regs:$dst), (ins MEMri64:$addr),
1390                         "add.u64 \t$dst, ${addr:add};",
1391                         [(set Int64Regs:$dst, ADDRri64:$addr)]>;
1392
1393 //-----------------------------------
1394 // Comparison and Selection
1395 //-----------------------------------
1396
1397 multiclass ISET_FORMAT<PatFrag OpNode, PatLeaf Mode,
1398                        Instruction setp_16rr,
1399                        Instruction setp_16ri,
1400                        Instruction setp_16ir,
1401                        Instruction setp_32rr,
1402                        Instruction setp_32ri,
1403                        Instruction setp_32ir,
1404                        Instruction setp_64rr,
1405                        Instruction setp_64ri,
1406                        Instruction setp_64ir,
1407                        Instruction set_16rr,
1408                        Instruction set_16ri,
1409                        Instruction set_16ir,
1410                        Instruction set_32rr,
1411                        Instruction set_32ri,
1412                        Instruction set_32ir,
1413                        Instruction set_64rr,
1414                        Instruction set_64ri,
1415                        Instruction set_64ir> {
1416   // i16 -> pred
1417   def : Pat<(i1 (OpNode Int16Regs:$a, Int16Regs:$b)),
1418             (setp_16rr Int16Regs:$a, Int16Regs:$b, Mode)>;
1419   def : Pat<(i1 (OpNode Int16Regs:$a, imm:$b)),
1420             (setp_16ri Int16Regs:$a, imm:$b, Mode)>;
1421   def : Pat<(i1 (OpNode imm:$a, Int16Regs:$b)),
1422             (setp_16ir imm:$a, Int16Regs:$b, Mode)>;
1423   // i32 -> pred
1424   def : Pat<(i1 (OpNode Int32Regs:$a, Int32Regs:$b)),
1425             (setp_32rr Int32Regs:$a, Int32Regs:$b, Mode)>;
1426   def : Pat<(i1 (OpNode Int32Regs:$a, imm:$b)),
1427             (setp_32ri Int32Regs:$a, imm:$b, Mode)>;
1428   def : Pat<(i1 (OpNode imm:$a, Int32Regs:$b)),
1429             (setp_32ir imm:$a, Int32Regs:$b, Mode)>;
1430   // i64 -> pred
1431   def : Pat<(i1 (OpNode Int64Regs:$a, Int64Regs:$b)),
1432             (setp_64rr Int64Regs:$a, Int64Regs:$b, Mode)>;
1433   def : Pat<(i1 (OpNode Int64Regs:$a, imm:$b)),
1434             (setp_64ri Int64Regs:$a, imm:$b, Mode)>;
1435   def : Pat<(i1 (OpNode imm:$a, Int64Regs:$b)),
1436             (setp_64ir imm:$a, Int64Regs:$b, Mode)>;
1437
1438   // i16 -> i32
1439   def : Pat<(i32 (OpNode Int16Regs:$a, Int16Regs:$b)),
1440             (set_16rr Int16Regs:$a, Int16Regs:$b, Mode)>;
1441   def : Pat<(i32 (OpNode Int16Regs:$a, imm:$b)),
1442             (set_16ri Int16Regs:$a, imm:$b, Mode)>;
1443   def : Pat<(i32 (OpNode imm:$a, Int16Regs:$b)),
1444             (set_16ir imm:$a, Int16Regs:$b, Mode)>;
1445   // i32 -> i32
1446   def : Pat<(i32 (OpNode Int32Regs:$a, Int32Regs:$b)),
1447             (set_32rr Int32Regs:$a, Int32Regs:$b, Mode)>;
1448   def : Pat<(i32 (OpNode Int32Regs:$a, imm:$b)),
1449             (set_32ri Int32Regs:$a, imm:$b, Mode)>;
1450   def : Pat<(i32 (OpNode imm:$a, Int32Regs:$b)),
1451             (set_32ir imm:$a, Int32Regs:$b, Mode)>;
1452   // i64 -> i32
1453   def : Pat<(i32 (OpNode Int64Regs:$a, Int64Regs:$b)),
1454             (set_64rr Int64Regs:$a, Int64Regs:$b, Mode)>;
1455   def : Pat<(i32 (OpNode Int64Regs:$a, imm:$b)),
1456             (set_64ri Int64Regs:$a, imm:$b, Mode)>;
1457   def : Pat<(i32 (OpNode imm:$a, Int64Regs:$b)),
1458             (set_64ir imm:$a, Int64Regs:$b, Mode)>;
1459 }
1460
1461 multiclass ISET_FORMAT_SIGNED<PatFrag OpNode, PatLeaf Mode>
1462   : ISET_FORMAT<OpNode, Mode,
1463                 SETP_s16rr, SETP_s16ri, SETP_s16ir,
1464                 SETP_s32rr, SETP_s32ri, SETP_s32ir,
1465                 SETP_s64rr, SETP_s64ri, SETP_s64ir,
1466                 SET_s16rr, SET_s16ri, SET_s16ir,
1467                 SET_s32rr, SET_s32ri, SET_s32ir,
1468                 SET_s64rr, SET_s64ri, SET_s64ir> {
1469   // TableGen doesn't like empty multiclasses
1470   def : PatLeaf<(i32 0)>;
1471 }
1472
1473 multiclass ISET_FORMAT_UNSIGNED<PatFrag OpNode, PatLeaf Mode>
1474   : ISET_FORMAT<OpNode, Mode,
1475                 SETP_u16rr, SETP_u16ri, SETP_u16ir,
1476                 SETP_u32rr, SETP_u32ri, SETP_u32ir,
1477                 SETP_u64rr, SETP_u64ri, SETP_u64ir,
1478                 SET_u16rr, SET_u16ri, SET_u16ir,
1479                 SET_u32rr, SET_u32ri, SET_u32ir,
1480                 SET_u64rr, SET_u64ri, SET_u64ir> {
1481   // TableGen doesn't like empty multiclasses
1482   def : PatLeaf<(i32 0)>;
1483 }
1484
1485 defm : ISET_FORMAT_SIGNED<setgt, CmpGT>;
1486 defm : ISET_FORMAT_UNSIGNED<setugt, CmpGT>;
1487 defm : ISET_FORMAT_SIGNED<setlt, CmpLT>;
1488 defm : ISET_FORMAT_UNSIGNED<setult, CmpLT>;
1489 defm : ISET_FORMAT_SIGNED<setge, CmpGE>;
1490 defm : ISET_FORMAT_UNSIGNED<setuge, CmpGE>;
1491 defm : ISET_FORMAT_SIGNED<setle, CmpLE>;
1492 defm : ISET_FORMAT_UNSIGNED<setule, CmpLE>;
1493 defm : ISET_FORMAT_SIGNED<seteq, CmpEQ>;
1494 defm : ISET_FORMAT_UNSIGNED<setueq, CmpEQ>;
1495 defm : ISET_FORMAT_SIGNED<setne, CmpNE>;
1496 defm : ISET_FORMAT_UNSIGNED<setune, CmpNE>;
1497
1498 // i1 compares
1499 def : Pat<(setne Int1Regs:$a, Int1Regs:$b),
1500           (XORb1rr Int1Regs:$a, Int1Regs:$b)>;
1501 def : Pat<(setune Int1Regs:$a, Int1Regs:$b),
1502           (XORb1rr Int1Regs:$a, Int1Regs:$b)>;
1503
1504 def : Pat<(seteq Int1Regs:$a, Int1Regs:$b),
1505           (NOT1 (XORb1rr Int1Regs:$a, Int1Regs:$b))>;
1506 def : Pat<(setueq Int1Regs:$a, Int1Regs:$b),
1507           (NOT1 (XORb1rr Int1Regs:$a, Int1Regs:$b))>;
1508
1509 // i1 compare -> i32
1510 def : Pat<(i32 (setne Int1Regs:$a, Int1Regs:$b)),
1511           (SELP_u32ii -1, 0, (XORb1rr Int1Regs:$a, Int1Regs:$b))>;
1512 def : Pat<(i32 (setne Int1Regs:$a, Int1Regs:$b)),
1513           (SELP_u32ii 0, -1, (XORb1rr Int1Regs:$a, Int1Regs:$b))>;
1514
1515
1516
1517 multiclass FSET_FORMAT<PatFrag OpNode, PatLeaf Mode, PatLeaf ModeFTZ> {
1518   // f32 -> pred
1519   def : Pat<(i1 (OpNode Float32Regs:$a, Float32Regs:$b)),
1520             (SETP_f32rr Float32Regs:$a, Float32Regs:$b, ModeFTZ)>,
1521         Requires<[doF32FTZ]>;
1522   def : Pat<(i1 (OpNode Float32Regs:$a, Float32Regs:$b)),
1523             (SETP_f32rr Float32Regs:$a, Float32Regs:$b, Mode)>;
1524   def : Pat<(i1 (OpNode Float32Regs:$a, fpimm:$b)),
1525             (SETP_f32ri Float32Regs:$a, fpimm:$b, ModeFTZ)>,
1526         Requires<[doF32FTZ]>;
1527   def : Pat<(i1 (OpNode Float32Regs:$a, fpimm:$b)),
1528             (SETP_f32ri Float32Regs:$a, fpimm:$b, Mode)>;
1529   def : Pat<(i1 (OpNode fpimm:$a, Float32Regs:$b)),
1530             (SETP_f32ir fpimm:$a, Float32Regs:$b, ModeFTZ)>,
1531         Requires<[doF32FTZ]>;
1532   def : Pat<(i1 (OpNode fpimm:$a, Float32Regs:$b)),
1533             (SETP_f32ir fpimm:$a, Float32Regs:$b, Mode)>;
1534
1535   // f64 -> pred
1536   def : Pat<(i1 (OpNode Float64Regs:$a, Float64Regs:$b)),
1537             (SETP_f64rr Float64Regs:$a, Float64Regs:$b, Mode)>;
1538   def : Pat<(i1 (OpNode Float64Regs:$a, fpimm:$b)),
1539             (SETP_f64ri Float64Regs:$a, fpimm:$b, Mode)>;
1540   def : Pat<(i1 (OpNode fpimm:$a, Float64Regs:$b)),
1541             (SETP_f64ir fpimm:$a, Float64Regs:$b, Mode)>;
1542
1543   // f32 -> i32
1544   def : Pat<(i32 (OpNode Float32Regs:$a, Float32Regs:$b)),
1545             (SET_f32rr Float32Regs:$a, Float32Regs:$b, ModeFTZ)>,
1546         Requires<[doF32FTZ]>;
1547   def : Pat<(i32 (OpNode Float32Regs:$a, Float32Regs:$b)),
1548             (SET_f32rr Float32Regs:$a, Float32Regs:$b, Mode)>;
1549   def : Pat<(i32 (OpNode Float32Regs:$a, fpimm:$b)),
1550             (SET_f32ri Float32Regs:$a, fpimm:$b, ModeFTZ)>,
1551         Requires<[doF32FTZ]>;
1552   def : Pat<(i32 (OpNode Float32Regs:$a, fpimm:$b)),
1553             (SET_f32ri Float32Regs:$a, fpimm:$b, Mode)>;
1554   def : Pat<(i32 (OpNode fpimm:$a, Float32Regs:$b)),
1555             (SET_f32ir fpimm:$a, Float32Regs:$b, ModeFTZ)>,
1556         Requires<[doF32FTZ]>;
1557   def : Pat<(i32 (OpNode fpimm:$a, Float32Regs:$b)),
1558             (SET_f32ir fpimm:$a, Float32Regs:$b, Mode)>;
1559
1560   // f64 -> i32
1561   def : Pat<(i32 (OpNode Float64Regs:$a, Float64Regs:$b)),
1562             (SET_f64rr Float64Regs:$a, Float64Regs:$b, Mode)>;
1563   def : Pat<(i32 (OpNode Float64Regs:$a, fpimm:$b)),
1564             (SET_f64ri Float64Regs:$a, fpimm:$b, Mode)>;
1565   def : Pat<(i32 (OpNode fpimm:$a, Float64Regs:$b)),
1566             (SET_f64ir fpimm:$a, Float64Regs:$b, Mode)>;
1567 }
1568
1569 defm FSetGT : FSET_FORMAT<setogt, CmpGT, CmpGT_FTZ>;
1570 defm FSetLT : FSET_FORMAT<setolt, CmpLT, CmpLT_FTZ>;
1571 defm FSetGE : FSET_FORMAT<setoge, CmpGE, CmpGE_FTZ>;
1572 defm FSetLE : FSET_FORMAT<setole, CmpLE, CmpLE_FTZ>;
1573 defm FSetEQ : FSET_FORMAT<setoeq, CmpEQ, CmpEQ_FTZ>;
1574 defm FSetNE : FSET_FORMAT<setone, CmpNE, CmpNE_FTZ>;
1575
1576 defm FSetUGT : FSET_FORMAT<setugt, CmpGTU, CmpGTU_FTZ>;
1577 defm FSetULT : FSET_FORMAT<setult, CmpLTU, CmpLTU_FTZ>;
1578 defm FSetUGE : FSET_FORMAT<setuge, CmpGEU, CmpGEU_FTZ>;
1579 defm FSetULE : FSET_FORMAT<setule, CmpLEU, CmpLEU_FTZ>;
1580 defm FSetUEQ : FSET_FORMAT<setueq, CmpEQU, CmpEQU_FTZ>;
1581 defm FSetUNE : FSET_FORMAT<setune, CmpNEU, CmpNEU_FTZ>;
1582
1583 defm FSetNUM : FSET_FORMAT<seto, CmpNUM, CmpNUM_FTZ>;
1584 defm FSetNAN : FSET_FORMAT<setuo, CmpNAN, CmpNAN_FTZ>;
1585
1586 //def ld_param         : SDNode<"NVPTXISD::LOAD_PARAM", SDTLoad,
1587 //                        [SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>;
1588
1589 def SDTDeclareParamProfile : SDTypeProfile<0, 3, [SDTCisInt<0>, SDTCisInt<1>,
1590   SDTCisInt<2>]>;
1591 def SDTDeclareScalarParamProfile : SDTypeProfile<0, 3, [SDTCisInt<0>,
1592   SDTCisInt<1>, SDTCisInt<2>]>;
1593 def SDTLoadParamProfile : SDTypeProfile<1, 2, [SDTCisInt<1>, SDTCisInt<2>]>;
1594 def SDTLoadParamV2Profile : SDTypeProfile<2, 2, [SDTCisSameAs<0, 1>, SDTCisInt<2>, SDTCisInt<3>]>;
1595 def SDTLoadParamV4Profile : SDTypeProfile<4, 2, [SDTCisInt<4>, SDTCisInt<5>]>;
1596 def SDTPrintCallProfile : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
1597 def SDTPrintCallUniProfile : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
1598 def SDTStoreParamProfile : SDTypeProfile<0, 3, [SDTCisInt<0>, SDTCisInt<1>]>;
1599 def SDTStoreParamV2Profile : SDTypeProfile<0, 4, [SDTCisInt<0>, SDTCisInt<1>]>;
1600 def SDTStoreParamV4Profile : SDTypeProfile<0, 6, [SDTCisInt<0>, SDTCisInt<1>]>;
1601 def SDTStoreParam32Profile : SDTypeProfile<0, 3, [SDTCisInt<0>, SDTCisInt<1>]>;
1602 def SDTCallArgProfile : SDTypeProfile<0, 2, [SDTCisInt<0>]>;
1603 def SDTCallArgMarkProfile : SDTypeProfile<0, 0, []>;
1604 def SDTCallVoidProfile : SDTypeProfile<0, 1, []>;
1605 def SDTCallValProfile : SDTypeProfile<1, 0, []>;
1606 def SDTMoveParamProfile : SDTypeProfile<1, 1, []>;
1607 def SDTStoreRetvalProfile : SDTypeProfile<0, 2, [SDTCisInt<0>]>;
1608 def SDTStoreRetvalV2Profile : SDTypeProfile<0, 3, [SDTCisInt<0>]>;
1609 def SDTStoreRetvalV4Profile : SDTypeProfile<0, 5, [SDTCisInt<0>]>;
1610 def SDTPseudoUseParamProfile : SDTypeProfile<0, 1, []>;
1611
1612 def DeclareParam : SDNode<"NVPTXISD::DeclareParam", SDTDeclareParamProfile,
1613                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1614 def DeclareScalarParam : SDNode<"NVPTXISD::DeclareScalarParam",
1615   SDTDeclareScalarParamProfile,
1616                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1617 def DeclareRetParam : SDNode<"NVPTXISD::DeclareRetParam",
1618   SDTDeclareParamProfile,
1619                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1620 def DeclareRet   : SDNode<"NVPTXISD::DeclareRet", SDTDeclareScalarParamProfile,
1621                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1622 def LoadParam    : SDNode<"NVPTXISD::LoadParam", SDTLoadParamProfile,
1623                          [SDNPHasChain, SDNPMayLoad, SDNPOutGlue, SDNPInGlue]>;
1624 def LoadParamV2  : SDNode<"NVPTXISD::LoadParamV2", SDTLoadParamV2Profile,
1625                          [SDNPHasChain, SDNPMayLoad, SDNPOutGlue, SDNPInGlue]>;
1626 def LoadParamV4  : SDNode<"NVPTXISD::LoadParamV4", SDTLoadParamV4Profile,
1627                          [SDNPHasChain, SDNPMayLoad, SDNPOutGlue, SDNPInGlue]>;
1628 def PrintCall    : SDNode<"NVPTXISD::PrintCall", SDTPrintCallProfile,
1629                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1630 def PrintCallUni : SDNode<"NVPTXISD::PrintCallUni", SDTPrintCallUniProfile,
1631                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1632 def StoreParam   : SDNode<"NVPTXISD::StoreParam", SDTStoreParamProfile,
1633                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1634 def StoreParamV2 : SDNode<"NVPTXISD::StoreParamV2", SDTStoreParamV2Profile,
1635                          [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1636 def StoreParamV4 : SDNode<"NVPTXISD::StoreParamV4", SDTStoreParamV4Profile,
1637                          [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1638 def StoreParamU32 : SDNode<"NVPTXISD::StoreParamU32", SDTStoreParam32Profile,
1639                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1640 def StoreParamS32 : SDNode<"NVPTXISD::StoreParamS32", SDTStoreParam32Profile,
1641                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1642 def CallArgBegin : SDNode<"NVPTXISD::CallArgBegin", SDTCallArgMarkProfile,
1643                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1644 def CallArg      : SDNode<"NVPTXISD::CallArg", SDTCallArgProfile,
1645                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1646 def LastCallArg  : SDNode<"NVPTXISD::LastCallArg", SDTCallArgProfile,
1647                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1648 def CallArgEnd   : SDNode<"NVPTXISD::CallArgEnd", SDTCallVoidProfile,
1649                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1650 def CallVoid     : SDNode<"NVPTXISD::CallVoid", SDTCallVoidProfile,
1651                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1652 def Prototype    : SDNode<"NVPTXISD::Prototype", SDTCallVoidProfile,
1653                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1654 def CallVal      : SDNode<"NVPTXISD::CallVal", SDTCallValProfile,
1655                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1656 def MoveParam    : SDNode<"NVPTXISD::MoveParam", SDTMoveParamProfile,
1657                          []>;
1658 def StoreRetval  : SDNode<"NVPTXISD::StoreRetval", SDTStoreRetvalProfile,
1659                          [SDNPHasChain, SDNPSideEffect]>;
1660 def StoreRetvalV2  : SDNode<"NVPTXISD::StoreRetvalV2", SDTStoreRetvalV2Profile,
1661                            [SDNPHasChain, SDNPSideEffect]>;
1662 def StoreRetvalV4  : SDNode<"NVPTXISD::StoreRetvalV4", SDTStoreRetvalV4Profile,
1663                            [SDNPHasChain, SDNPSideEffect]>;
1664 def PseudoUseParam : SDNode<"NVPTXISD::PseudoUseParam",
1665   SDTPseudoUseParamProfile,
1666                        [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
1667 def RETURNNode   : SDNode<"NVPTXISD::RETURN", SDTCallArgMarkProfile,
1668                          [SDNPHasChain, SDNPSideEffect]>;
1669
1670 class LoadParamMemInst<NVPTXRegClass regclass, string opstr> :
1671       NVPTXInst<(outs regclass:$dst), (ins i32imm:$b),
1672                 !strconcat(!strconcat("ld.param", opstr),
1673                 "\t$dst, [retval0+$b];"),
1674                 []>;
1675
1676 class LoadParamRegInst<NVPTXRegClass regclass, string opstr> :
1677       NVPTXInst<(outs regclass:$dst), (ins i32imm:$b),
1678                 !strconcat(!strconcat("mov", opstr),
1679                 "\t$dst, retval$b;"),
1680                 [(set regclass:$dst, (LoadParam (i32 0), (i32 imm:$b)))]>;
1681
1682 class LoadParamV2MemInst<NVPTXRegClass regclass, string opstr> :
1683       NVPTXInst<(outs regclass:$dst, regclass:$dst2), (ins i32imm:$b),
1684                 !strconcat(!strconcat("ld.param.v2", opstr),
1685                 "\t{{$dst, $dst2}}, [retval0+$b];"), []>;
1686
1687 class LoadParamV4MemInst<NVPTXRegClass regclass, string opstr> :
1688       NVPTXInst<(outs regclass:$dst, regclass:$dst2, regclass:$dst3,
1689                       regclass:$dst4),
1690                 (ins i32imm:$b),
1691                 !strconcat(!strconcat("ld.param.v4", opstr),
1692                 "\t{{$dst, $dst2, $dst3, $dst4}}, [retval0+$b];"), []>;
1693
1694 class StoreParamInst<NVPTXRegClass regclass, string opstr> :
1695       NVPTXInst<(outs), (ins regclass:$val, i32imm:$a, i32imm:$b),
1696                 !strconcat(!strconcat("st.param", opstr),
1697                 "\t[param$a+$b], $val;"),
1698                 []>;
1699
1700 class StoreParamV2Inst<NVPTXRegClass regclass, string opstr> :
1701       NVPTXInst<(outs), (ins regclass:$val, regclass:$val2,
1702                              i32imm:$a, i32imm:$b),
1703                 !strconcat(!strconcat("st.param.v2", opstr),
1704                 "\t[param$a+$b], {{$val, $val2}};"),
1705                 []>;
1706
1707 class StoreParamV4Inst<NVPTXRegClass regclass, string opstr> :
1708       NVPTXInst<(outs), (ins regclass:$val, regclass:$val1, regclass:$val2,
1709                              regclass:$val3, i32imm:$a, i32imm:$b),
1710                 !strconcat(!strconcat("st.param.v4", opstr),
1711                 "\t[param$a+$b], {{$val, $val2, $val3, $val4}};"),
1712                 []>;
1713
1714 class StoreRetvalInst<NVPTXRegClass regclass, string opstr> :
1715       NVPTXInst<(outs), (ins regclass:$val, i32imm:$a),
1716                 !strconcat(!strconcat("st.param", opstr),
1717                 "\t[func_retval0+$a], $val;"),
1718                 []>;
1719
1720 class StoreRetvalV2Inst<NVPTXRegClass regclass, string opstr> :
1721       NVPTXInst<(outs), (ins regclass:$val, regclass:$val2, i32imm:$a),
1722                 !strconcat(!strconcat("st.param.v2", opstr),
1723                 "\t[func_retval0+$a], {{$val, $val2}};"),
1724                 []>;
1725
1726 class StoreRetvalV4Inst<NVPTXRegClass regclass, string opstr> :
1727       NVPTXInst<(outs),
1728                 (ins regclass:$val, regclass:$val2, regclass:$val3,
1729                      regclass:$val4, i32imm:$a),
1730                 !strconcat(!strconcat("st.param.v4", opstr),
1731                 "\t[func_retval0+$a], {{$val, $val2, $val3, $val4}};"),
1732                 []>;
1733
1734 def PrintCallRetInst1 : NVPTXInst<(outs), (ins),
1735 "call (retval0), ",
1736                                 [(PrintCall (i32 1))]>;
1737 def PrintCallRetInst2 : NVPTXInst<(outs), (ins),
1738 "call (retval0, retval1), ",
1739                                 [(PrintCall (i32 2))]>;
1740 def PrintCallRetInst3 : NVPTXInst<(outs), (ins),
1741 "call (retval0, retval1, retval2), ",
1742                                 [(PrintCall (i32 3))]>;
1743 def PrintCallRetInst4 : NVPTXInst<(outs), (ins),
1744 "call (retval0, retval1, retval2, retval3), ",
1745                                 [(PrintCall (i32 4))]>;
1746 def PrintCallRetInst5 : NVPTXInst<(outs), (ins),
1747 "call (retval0, retval1, retval2, retval3, retval4), ",
1748                                 [(PrintCall (i32 5))]>;
1749 def PrintCallRetInst6 : NVPTXInst<(outs), (ins),
1750 "call (retval0, retval1, retval2, retval3, retval4, retval5), ",
1751                                 [(PrintCall (i32 6))]>;
1752 def PrintCallRetInst7 : NVPTXInst<(outs), (ins),
1753 "call (retval0, retval1, retval2, retval3, retval4, retval5, retval6), ",
1754                                 [(PrintCall (i32 7))]>;
1755 def PrintCallRetInst8 : NVPTXInst<(outs), (ins),
1756 !strconcat("call (retval0, retval1, retval2, retval3, retval4",
1757            ", retval5, retval6, retval7), "),
1758                                 [(PrintCall (i32 8))]>;
1759
1760 def PrintCallNoRetInst : NVPTXInst<(outs), (ins), "call ",
1761                                 [(PrintCall (i32 0))]>;
1762
1763 def PrintCallUniRetInst1 : NVPTXInst<(outs), (ins),
1764 "call.uni (retval0), ",
1765                                 [(PrintCallUni (i32 1))]>;
1766 def PrintCallUniRetInst2 : NVPTXInst<(outs), (ins),
1767 "call.uni (retval0, retval1), ",
1768                                 [(PrintCallUni (i32 2))]>;
1769 def PrintCallUniRetInst3 : NVPTXInst<(outs), (ins),
1770 "call.uni (retval0, retval1, retval2), ",
1771                                 [(PrintCallUni (i32 3))]>;
1772 def PrintCallUniRetInst4 : NVPTXInst<(outs), (ins),
1773 "call.uni (retval0, retval1, retval2, retval3), ",
1774                                 [(PrintCallUni (i32 4))]>;
1775 def PrintCallUniRetInst5 : NVPTXInst<(outs), (ins),
1776 "call.uni (retval0, retval1, retval2, retval3, retval4), ",
1777                                 [(PrintCallUni (i32 5))]>;
1778 def PrintCallUniRetInst6 : NVPTXInst<(outs), (ins),
1779 "call.uni (retval0, retval1, retval2, retval3, retval4, retval5), ",
1780                                 [(PrintCallUni (i32 6))]>;
1781 def PrintCallUniRetInst7 : NVPTXInst<(outs), (ins),
1782 "call.uni (retval0, retval1, retval2, retval3, retval4, retval5, retval6), ",
1783                                 [(PrintCallUni (i32 7))]>;
1784 def PrintCallUniRetInst8 : NVPTXInst<(outs), (ins),
1785 !strconcat("call.uni (retval0, retval1, retval2, retval3, retval4",
1786            ", retval5, retval6, retval7), "),
1787                                 [(PrintCallUni (i32 8))]>;
1788
1789 def PrintCallUniNoRetInst : NVPTXInst<(outs), (ins), "call.uni ",
1790                                 [(PrintCallUni (i32 0))]>;
1791
1792 def LoadParamMemI64    : LoadParamMemInst<Int64Regs, ".b64">;
1793 def LoadParamMemI32    : LoadParamMemInst<Int32Regs, ".b32">;
1794 def LoadParamMemI16    : LoadParamMemInst<Int16Regs, ".b16">;
1795 def LoadParamMemI8     : LoadParamMemInst<Int16Regs, ".b8">;
1796 def LoadParamMemV2I64  : LoadParamV2MemInst<Int64Regs, ".b64">;
1797 def LoadParamMemV2I32  : LoadParamV2MemInst<Int32Regs, ".b32">;
1798 def LoadParamMemV2I16  : LoadParamV2MemInst<Int16Regs, ".b16">;
1799 def LoadParamMemV2I8   : LoadParamV2MemInst<Int16Regs, ".b8">;
1800 def LoadParamMemV4I32  : LoadParamV4MemInst<Int32Regs, ".b32">;
1801 def LoadParamMemV4I16  : LoadParamV4MemInst<Int16Regs, ".b16">;
1802 def LoadParamMemV4I8   : LoadParamV4MemInst<Int16Regs, ".b8">;
1803 def LoadParamMemF32    : LoadParamMemInst<Float32Regs, ".f32">;
1804 def LoadParamMemF64    : LoadParamMemInst<Float64Regs, ".f64">;
1805 def LoadParamMemV2F32  : LoadParamV2MemInst<Float32Regs, ".f32">;
1806 def LoadParamMemV2F64  : LoadParamV2MemInst<Float64Regs, ".f64">;
1807 def LoadParamMemV4F32  : LoadParamV4MemInst<Float32Regs, ".f32">;
1808
1809 def StoreParamI64    : StoreParamInst<Int64Regs, ".b64">;
1810 def StoreParamI32    : StoreParamInst<Int32Regs, ".b32">;
1811
1812 def StoreParamI16    : StoreParamInst<Int16Regs, ".b16">;
1813 def StoreParamI8     : StoreParamInst<Int16Regs, ".b8">;
1814 def StoreParamV2I64  : StoreParamV2Inst<Int64Regs, ".b64">;
1815 def StoreParamV2I32  : StoreParamV2Inst<Int32Regs, ".b32">;
1816 def StoreParamV2I16  : StoreParamV2Inst<Int16Regs, ".b16">;
1817 def StoreParamV2I8   : StoreParamV2Inst<Int16Regs, ".b8">;
1818
1819 // FIXME: StoreParamV4Inst crashes llvm-tblgen :(
1820 //def StoreParamV4I32    : StoreParamV4Inst<Int32Regs, ".b32">;
1821 def StoreParamV4I32    : NVPTXInst<(outs), (ins Int32Regs:$val, Int32Regs:$val2,
1822                                                Int32Regs:$val3, Int32Regs:$val4,
1823                                                 i32imm:$a, i32imm:$b),
1824                    "st.param.b32\t[param$a+$b], {{$val, $val2, $val3, $val4}};",
1825                          []>;
1826
1827 def StoreParamV4I16    : NVPTXInst<(outs), (ins Int16Regs:$val, Int16Regs:$val2,
1828                                                Int16Regs:$val3, Int16Regs:$val4,
1829                                                 i32imm:$a, i32imm:$b),
1830                 "st.param.v4.b16\t[param$a+$b], {{$val, $val2, $val3, $val4}};",
1831                          []>;
1832
1833 def StoreParamV4I8     : NVPTXInst<(outs), (ins Int16Regs:$val, Int16Regs:$val2,
1834                                                 Int16Regs:$val3, Int16Regs:$val4,
1835                                                 i32imm:$a, i32imm:$b),
1836                  "st.param.v4.b8\t[param$a+$b], {{$val, $val2, $val3, $val4}};",
1837                          []>;
1838
1839 def StoreParamF32    : StoreParamInst<Float32Regs, ".f32">;
1840 def StoreParamF64    : StoreParamInst<Float64Regs, ".f64">;
1841 def StoreParamV2F32    : StoreParamV2Inst<Float32Regs, ".f32">;
1842 def StoreParamV2F64    : StoreParamV2Inst<Float64Regs, ".f64">;
1843 // FIXME: StoreParamV4Inst crashes llvm-tblgen :(
1844 //def StoreParamV4F32    : StoreParamV4Inst<Float32Regs, ".f32">;
1845 def StoreParamV4F32    : NVPTXInst<(outs),
1846                                    (ins Float32Regs:$val, Float32Regs:$val2,
1847                                         Float32Regs:$val3, Float32Regs:$val4,
1848                                         i32imm:$a, i32imm:$b),
1849                 "st.param.v4.f32\t[param$a+$b], {{$val, $val2, $val3, $val4}};",
1850                         []>;
1851
1852
1853 def StoreRetvalI64    : StoreRetvalInst<Int64Regs, ".b64">;
1854 def StoreRetvalI32    : StoreRetvalInst<Int32Regs, ".b32">;
1855 def StoreRetvalI16    : StoreRetvalInst<Int16Regs, ".b16">;
1856 def StoreRetvalI8     : StoreRetvalInst<Int16Regs, ".b8">;
1857 def StoreRetvalV2I64  : StoreRetvalV2Inst<Int64Regs, ".b64">;
1858 def StoreRetvalV2I32  : StoreRetvalV2Inst<Int32Regs, ".b32">;
1859 def StoreRetvalV2I16  : StoreRetvalV2Inst<Int16Regs, ".b16">;
1860 def StoreRetvalV2I8   : StoreRetvalV2Inst<Int16Regs, ".b8">;
1861 def StoreRetvalV4I32  : StoreRetvalV4Inst<Int32Regs, ".b32">;
1862 def StoreRetvalV4I16  : StoreRetvalV4Inst<Int16Regs, ".b16">;
1863 def StoreRetvalV4I8   : StoreRetvalV4Inst<Int16Regs, ".b8">;
1864
1865 def StoreRetvalF64    : StoreRetvalInst<Float64Regs, ".f64">;
1866 def StoreRetvalF32    : StoreRetvalInst<Float32Regs, ".f32">;
1867 def StoreRetvalV2F64  : StoreRetvalV2Inst<Float64Regs, ".f64">;
1868 def StoreRetvalV2F32  : StoreRetvalV2Inst<Float32Regs, ".f32">;
1869 def StoreRetvalV4F32  : StoreRetvalV4Inst<Float32Regs, ".f32">;
1870
1871 def CallArgBeginInst : NVPTXInst<(outs), (ins), "(", [(CallArgBegin)]>;
1872 def CallArgEndInst1  : NVPTXInst<(outs), (ins), ");", [(CallArgEnd (i32 1))]>;
1873 def CallArgEndInst0  : NVPTXInst<(outs), (ins), ")", [(CallArgEnd (i32 0))]>;
1874 def RETURNInst       : NVPTXInst<(outs), (ins), "ret;", [(RETURNNode)]>;
1875
1876 class CallArgInst<NVPTXRegClass regclass> :
1877       NVPTXInst<(outs), (ins regclass:$a), "$a, ",
1878                 [(CallArg (i32 0), regclass:$a)]>;
1879
1880 class LastCallArgInst<NVPTXRegClass regclass> :
1881       NVPTXInst<(outs), (ins regclass:$a), "$a",
1882                 [(LastCallArg (i32 0), regclass:$a)]>;
1883
1884 def CallArgI64     : CallArgInst<Int64Regs>;
1885 def CallArgI32     : CallArgInst<Int32Regs>;
1886 def CallArgI16     : CallArgInst<Int16Regs>;
1887
1888 def CallArgF64     : CallArgInst<Float64Regs>;
1889 def CallArgF32     : CallArgInst<Float32Regs>;
1890
1891 def LastCallArgI64 : LastCallArgInst<Int64Regs>;
1892 def LastCallArgI32 : LastCallArgInst<Int32Regs>;
1893 def LastCallArgI16 : LastCallArgInst<Int16Regs>;
1894
1895 def LastCallArgF64 : LastCallArgInst<Float64Regs>;
1896 def LastCallArgF32 : LastCallArgInst<Float32Regs>;
1897
1898 def CallArgI32imm : NVPTXInst<(outs), (ins i32imm:$a), "$a, ",
1899                               [(CallArg (i32 0), (i32 imm:$a))]>;
1900 def LastCallArgI32imm : NVPTXInst<(outs), (ins i32imm:$a), "$a",
1901                               [(LastCallArg (i32 0), (i32 imm:$a))]>;
1902
1903 def CallArgParam : NVPTXInst<(outs), (ins i32imm:$a), "param$a, ",
1904                              [(CallArg (i32 1), (i32 imm:$a))]>;
1905 def LastCallArgParam : NVPTXInst<(outs), (ins i32imm:$a), "param$a",
1906                              [(LastCallArg (i32 1), (i32 imm:$a))]>;
1907
1908 def CallVoidInst : NVPTXInst<(outs), (ins imem:$addr),
1909                              "$addr, ",
1910                              [(CallVoid (Wrapper tglobaladdr:$addr))]>;
1911 def CallVoidInstReg : NVPTXInst<(outs), (ins Int32Regs:$addr),
1912                              "$addr, ",
1913                              [(CallVoid Int32Regs:$addr)]>;
1914 def CallVoidInstReg64 : NVPTXInst<(outs), (ins Int64Regs:$addr),
1915                              "$addr, ",
1916                              [(CallVoid Int64Regs:$addr)]>;
1917 def PrototypeInst : NVPTXInst<(outs), (ins i32imm:$val),
1918                              ", prototype_$val;",
1919                              [(Prototype (i32 imm:$val))]>;
1920
1921 def DeclareRetMemInst : NVPTXInst<(outs),
1922   (ins i32imm:$align, i32imm:$size, i32imm:$num),
1923          ".param .align $align .b8 retval$num[$size];",
1924          [(DeclareRetParam (i32 imm:$align), (i32 imm:$size), (i32 imm:$num))]>;
1925 def DeclareRetScalarInst : NVPTXInst<(outs), (ins i32imm:$size, i32imm:$num),
1926          ".param .b$size retval$num;",
1927          [(DeclareRet (i32 1), (i32 imm:$size), (i32 imm:$num))]>;
1928 def DeclareRetRegInst : NVPTXInst<(outs), (ins i32imm:$size, i32imm:$num),
1929          ".reg .b$size retval$num;",
1930          [(DeclareRet (i32 2), (i32 imm:$size), (i32 imm:$num))]>;
1931
1932 def DeclareParamInst : NVPTXInst<(outs),
1933   (ins i32imm:$align, i32imm:$a, i32imm:$size),
1934          ".param .align $align .b8 param$a[$size];",
1935          [(DeclareParam (i32 imm:$align), (i32 imm:$a), (i32 imm:$size))]>;
1936 def DeclareScalarParamInst : NVPTXInst<(outs), (ins i32imm:$a, i32imm:$size),
1937          ".param .b$size param$a;",
1938          [(DeclareScalarParam (i32 imm:$a), (i32 imm:$size), (i32 0))]>;
1939 def DeclareScalarRegInst : NVPTXInst<(outs), (ins i32imm:$a, i32imm:$size),
1940          ".reg .b$size param$a;",
1941          [(DeclareScalarParam (i32 imm:$a), (i32 imm:$size), (i32 1))]>;
1942
1943 class MoveParamInst<NVPTXRegClass regclass, string asmstr> :
1944       NVPTXInst<(outs regclass:$dst), (ins regclass:$src),
1945                 !strconcat(!strconcat("mov", asmstr), "\t$dst, $src;"),
1946                 [(set regclass:$dst, (MoveParam regclass:$src))]>;
1947
1948 def MoveParamI64 : MoveParamInst<Int64Regs, ".b64">;
1949 def MoveParamI32 : MoveParamInst<Int32Regs, ".b32">;
1950 def MoveParamI16 : NVPTXInst<(outs Int16Regs:$dst), (ins Int16Regs:$src),
1951                    "cvt.u16.u32\t$dst, $src;",
1952                    [(set Int16Regs:$dst, (MoveParam Int16Regs:$src))]>;
1953 def MoveParamF64 : MoveParamInst<Float64Regs, ".f64">;
1954 def MoveParamF32 : MoveParamInst<Float32Regs, ".f32">;
1955
1956 class PseudoUseParamInst<NVPTXRegClass regclass> :
1957       NVPTXInst<(outs), (ins regclass:$src),
1958       "// Pseudo use of $src",
1959       [(PseudoUseParam regclass:$src)]>;
1960
1961 def PseudoUseParamI64 : PseudoUseParamInst<Int64Regs>;
1962 def PseudoUseParamI32 : PseudoUseParamInst<Int32Regs>;
1963 def PseudoUseParamI16 : PseudoUseParamInst<Int16Regs>;
1964 def PseudoUseParamF64 : PseudoUseParamInst<Float64Regs>;
1965 def PseudoUseParamF32 : PseudoUseParamInst<Float32Regs>;
1966
1967
1968 //
1969 // Load / Store Handling
1970 //
1971 multiclass LD<NVPTXRegClass regclass> {
1972   def _avar : NVPTXInst<(outs regclass:$dst),
1973     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
1974       i32imm:$fromWidth, imem:$addr),
1975 !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
1976            "$fromWidth \t$dst, [$addr];"), []>;
1977   def _areg : NVPTXInst<(outs regclass:$dst),
1978     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
1979       i32imm:$fromWidth, Int32Regs:$addr),
1980 !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
1981            "$fromWidth \t$dst, [$addr];"), []>;
1982   def _areg_64 : NVPTXInst<(outs regclass:$dst),
1983     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
1984      i32imm:$fromWidth, Int64Regs:$addr),
1985      !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$fromWidth",
1986                 " \t$dst, [$addr];"), []>;
1987   def _ari : NVPTXInst<(outs regclass:$dst),
1988     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
1989       i32imm:$fromWidth, Int32Regs:$addr, i32imm:$offset),
1990 !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
1991            "$fromWidth \t$dst, [$addr+$offset];"), []>;
1992   def _ari_64 : NVPTXInst<(outs regclass:$dst),
1993     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
1994      i32imm:$fromWidth, Int64Regs:$addr, i32imm:$offset),
1995     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$fromWidth",
1996                " \t$dst, [$addr+$offset];"), []>;
1997   def _asi : NVPTXInst<(outs regclass:$dst),
1998     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
1999       i32imm:$fromWidth, imem:$addr, i32imm:$offset),
2000 !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2001            "$fromWidth \t$dst, [$addr+$offset];"), []>;
2002 }
2003
2004 let mayLoad=1, neverHasSideEffects=1 in {
2005 defm LD_i8  : LD<Int16Regs>;
2006 defm LD_i16 : LD<Int16Regs>;
2007 defm LD_i32 : LD<Int32Regs>;
2008 defm LD_i64 : LD<Int64Regs>;
2009 defm LD_f32 : LD<Float32Regs>;
2010 defm LD_f64 : LD<Float64Regs>;
2011 }
2012
2013 multiclass ST<NVPTXRegClass regclass> {
2014   def _avar : NVPTXInst<(outs),
2015     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2016       LdStCode:$Sign, i32imm:$toWidth, imem:$addr),
2017 !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth",
2018            " \t[$addr], $src;"), []>;
2019   def _areg : NVPTXInst<(outs),
2020     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2021       LdStCode:$Sign, i32imm:$toWidth, Int32Regs:$addr),
2022 !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth",
2023            " \t[$addr], $src;"), []>;
2024   def _areg_64 : NVPTXInst<(outs),
2025     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2026      LdStCode:$Sign, i32imm:$toWidth, Int64Regs:$addr),
2027   !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth ",
2028                "\t[$addr], $src;"), []>;
2029   def _ari : NVPTXInst<(outs),
2030     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2031       LdStCode:$Sign, i32imm:$toWidth, Int32Regs:$addr, i32imm:$offset),
2032 !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth",
2033            " \t[$addr+$offset], $src;"), []>;
2034   def _ari_64 : NVPTXInst<(outs),
2035     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2036      LdStCode:$Sign, i32imm:$toWidth, Int64Regs:$addr, i32imm:$offset),
2037   !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth ",
2038                "\t[$addr+$offset], $src;"), []>;
2039   def _asi : NVPTXInst<(outs),
2040     (ins regclass:$src, LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec,
2041       LdStCode:$Sign, i32imm:$toWidth, imem:$addr, i32imm:$offset),
2042 !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}$toWidth",
2043            " \t[$addr+$offset], $src;"), []>;
2044 }
2045
2046 let mayStore=1, neverHasSideEffects=1 in {
2047 defm ST_i8  : ST<Int16Regs>;
2048 defm ST_i16 : ST<Int16Regs>;
2049 defm ST_i32 : ST<Int32Regs>;
2050 defm ST_i64 : ST<Int64Regs>;
2051 defm ST_f32 : ST<Float32Regs>;
2052 defm ST_f64 : ST<Float64Regs>;
2053 }
2054
2055 // The following is used only in and after vector elementizations.
2056 // Vector elementization happens at the machine instruction level, so the
2057 // following instruction
2058 // never appears in the DAG.
2059 multiclass LD_VEC<NVPTXRegClass regclass> {
2060   def _v2_avar : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2061     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2062       i32imm:$fromWidth, imem:$addr),
2063     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2064                "$fromWidth \t{{$dst1, $dst2}}, [$addr];"), []>;
2065   def _v2_areg : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2066     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2067       i32imm:$fromWidth, Int32Regs:$addr),
2068     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2069                "$fromWidth \t{{$dst1, $dst2}}, [$addr];"), []>;
2070   def _v2_areg_64 : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2071     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2072      i32imm:$fromWidth, Int64Regs:$addr),
2073     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2074                "$fromWidth \t{{$dst1, $dst2}}, [$addr];"), []>;
2075   def _v2_ari : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2076     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2077       i32imm:$fromWidth, Int32Regs:$addr, i32imm:$offset),
2078     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2079                "$fromWidth \t{{$dst1, $dst2}}, [$addr+$offset];"), []>;
2080   def _v2_ari_64 : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2081     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2082      i32imm:$fromWidth, Int64Regs:$addr, i32imm:$offset),
2083     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2084                "$fromWidth \t{{$dst1, $dst2}}, [$addr+$offset];"), []>;
2085   def _v2_asi : NVPTXInst<(outs regclass:$dst1, regclass:$dst2),
2086     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2087       i32imm:$fromWidth, imem:$addr, i32imm:$offset),
2088     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2089                "$fromWidth \t{{$dst1, $dst2}}, [$addr+$offset];"), []>;
2090   def _v4_avar : NVPTXInst<(outs regclass:$dst1, regclass:$dst2,
2091       regclass:$dst3, regclass:$dst4),
2092     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2093       i32imm:$fromWidth, imem:$addr),
2094     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2095                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr];"), []>;
2096   def _v4_areg : NVPTXInst<(outs regclass:$dst1, regclass:$dst2, regclass:$dst3,
2097       regclass:$dst4),
2098     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2099       i32imm:$fromWidth, Int32Regs:$addr),
2100     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2101                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr];"), []>;
2102   def _v4_areg_64 : NVPTXInst<(outs regclass:$dst1, regclass:$dst2,
2103                                regclass:$dst3, regclass:$dst4),
2104     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2105      i32imm:$fromWidth, Int64Regs:$addr),
2106     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2107                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr];"), []>;
2108   def _v4_ari : NVPTXInst<(outs regclass:$dst1, regclass:$dst2, regclass:$dst3,
2109       regclass:$dst4),
2110     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2111       i32imm:$fromWidth, Int32Regs:$addr, i32imm:$offset),
2112     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2113                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr+$offset];"),
2114                 []>;
2115   def _v4_ari_64 : NVPTXInst<(outs regclass:$dst1, regclass:$dst2,
2116                               regclass:$dst3, regclass:$dst4),
2117     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2118      i32imm:$fromWidth, Int64Regs:$addr, i32imm:$offset),
2119     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2120                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr+$offset];"),
2121     []>;
2122   def _v4_asi : NVPTXInst<(outs regclass:$dst1, regclass:$dst2, regclass:$dst3,
2123       regclass:$dst4),
2124     (ins LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2125       i32imm:$fromWidth, imem:$addr, i32imm:$offset),
2126     !strconcat("ld${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2127                "$fromWidth \t{{$dst1, $dst2, $dst3, $dst4}}, [$addr+$offset];"),
2128                 []>;
2129 }
2130 let mayLoad=1, neverHasSideEffects=1 in {
2131 defm LDV_i8  : LD_VEC<Int16Regs>;
2132 defm LDV_i16 : LD_VEC<Int16Regs>;
2133 defm LDV_i32 : LD_VEC<Int32Regs>;
2134 defm LDV_i64 : LD_VEC<Int64Regs>;
2135 defm LDV_f32 : LD_VEC<Float32Regs>;
2136 defm LDV_f64 : LD_VEC<Float64Regs>;
2137 }
2138
2139 multiclass ST_VEC<NVPTXRegClass regclass> {
2140   def _v2_avar : NVPTXInst<(outs),
2141     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2142       LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, imem:$addr),
2143     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2144                "$fromWidth \t[$addr], {{$src1, $src2}};"), []>;
2145   def _v2_areg : NVPTXInst<(outs),
2146     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2147       LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, Int32Regs:$addr),
2148     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2149                "$fromWidth \t[$addr], {{$src1, $src2}};"), []>;
2150   def _v2_areg_64 : NVPTXInst<(outs),
2151     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2152      LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, Int64Regs:$addr),
2153     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2154                "$fromWidth \t[$addr], {{$src1, $src2}};"), []>;
2155   def _v2_ari : NVPTXInst<(outs),
2156     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2157       LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, Int32Regs:$addr,
2158       i32imm:$offset),
2159     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2160                "$fromWidth \t[$addr+$offset], {{$src1, $src2}};"), []>;
2161   def _v2_ari_64 : NVPTXInst<(outs),
2162     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2163      LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, Int64Regs:$addr,
2164      i32imm:$offset),
2165     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2166                "$fromWidth \t[$addr+$offset], {{$src1, $src2}};"), []>;
2167   def _v2_asi : NVPTXInst<(outs),
2168     (ins regclass:$src1, regclass:$src2, LdStCode:$isVol, LdStCode:$addsp,
2169       LdStCode:$Vec, LdStCode:$Sign, i32imm:$fromWidth, imem:$addr,
2170       i32imm:$offset),
2171     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2172                "$fromWidth \t[$addr+$offset], {{$src1, $src2}};"), []>;
2173   def _v4_avar : NVPTXInst<(outs),
2174     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2175       LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2176       i32imm:$fromWidth, imem:$addr),
2177     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2178                "$fromWidth \t[$addr], {{$src1, $src2, $src3, $src4}};"), []>;
2179   def _v4_areg : NVPTXInst<(outs),
2180     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2181       LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2182       i32imm:$fromWidth, Int32Regs:$addr),
2183     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2184                "$fromWidth \t[$addr], {{$src1, $src2, $src3, $src4}};"), []>;
2185   def _v4_areg_64 : NVPTXInst<(outs),
2186     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2187      LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2188      i32imm:$fromWidth, Int64Regs:$addr),
2189     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2190                "$fromWidth \t[$addr], {{$src1, $src2, $src3, $src4}};"), []>;
2191   def _v4_ari : NVPTXInst<(outs),
2192     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2193       LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2194       i32imm:$fromWidth, Int32Regs:$addr, i32imm:$offset),
2195     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2196                "$fromWidth \t[$addr+$offset], {{$src1, $src2, $src3, $src4}};"),
2197     []>;
2198   def _v4_ari_64 : NVPTXInst<(outs),
2199     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2200      LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2201      i32imm:$fromWidth, Int64Regs:$addr, i32imm:$offset),
2202     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2203                "$fromWidth \t[$addr+$offset], {{$src1, $src2, $src3, $src4}};"),
2204      []>;
2205   def _v4_asi : NVPTXInst<(outs),
2206     (ins regclass:$src1, regclass:$src2, regclass:$src3, regclass:$src4,
2207       LdStCode:$isVol, LdStCode:$addsp, LdStCode:$Vec, LdStCode:$Sign,
2208       i32imm:$fromWidth, imem:$addr, i32imm:$offset),
2209     !strconcat("st${isVol:volatile}${addsp:addsp}${Vec:vec}.${Sign:sign}",
2210                "$fromWidth \t[$addr+$offset], {{$src1, $src2, $src3, $src4}};"),
2211     []>;
2212 }
2213 let mayStore=1, neverHasSideEffects=1 in {
2214 defm STV_i8  : ST_VEC<Int16Regs>;
2215 defm STV_i16 : ST_VEC<Int16Regs>;
2216 defm STV_i32 : ST_VEC<Int32Regs>;
2217 defm STV_i64 : ST_VEC<Int64Regs>;
2218 defm STV_f32 : ST_VEC<Float32Regs>;
2219 defm STV_f64 : ST_VEC<Float64Regs>;
2220 }
2221
2222
2223 //---- Conversion ----
2224
2225 class F_BITCONVERT<string SzStr, NVPTXRegClass regclassIn,
2226   NVPTXRegClass regclassOut> :
2227            NVPTXInst<(outs regclassOut:$d), (ins regclassIn:$a),
2228            !strconcat("mov.b", !strconcat(SzStr, " \t $d, $a;")),
2229      [(set regclassOut:$d, (bitconvert regclassIn:$a))]>;
2230
2231 def BITCONVERT_32_I2F : F_BITCONVERT<"32", Int32Regs, Float32Regs>;
2232 def BITCONVERT_32_F2I : F_BITCONVERT<"32", Float32Regs, Int32Regs>;
2233 def BITCONVERT_64_I2F : F_BITCONVERT<"64", Int64Regs, Float64Regs>;
2234 def BITCONVERT_64_F2I : F_BITCONVERT<"64", Float64Regs, Int64Regs>;
2235
2236 // NOTE: pred->fp are currently sub-optimal due to an issue in TableGen where
2237 // we cannot specify floating-point literals in isel patterns.  Therefore, we
2238 // use an integer selp to select either 1 or 0 and then cvt to floating-point.
2239
2240 // sint -> f32
2241 def : Pat<(f32 (sint_to_fp Int1Regs:$a)),
2242           (CVT_f32_s32 (SELP_u32ii 1, 0, Int1Regs:$a), CvtRN)>;
2243 def : Pat<(f32 (sint_to_fp Int16Regs:$a)),
2244           (CVT_f32_s16 Int16Regs:$a, CvtRN)>;
2245 def : Pat<(f32 (sint_to_fp Int32Regs:$a)),
2246           (CVT_f32_s32 Int32Regs:$a, CvtRN)>;
2247 def : Pat<(f32 (sint_to_fp Int64Regs:$a)),
2248           (CVT_f32_s64 Int64Regs:$a, CvtRN)>;
2249
2250 // uint -> f32
2251 def : Pat<(f32 (uint_to_fp Int1Regs:$a)),
2252           (CVT_f32_u32 (SELP_u32ii 1, 0, Int1Regs:$a), CvtRN)>;
2253 def : Pat<(f32 (uint_to_fp Int16Regs:$a)),
2254           (CVT_f32_u16 Int16Regs:$a, CvtRN)>;
2255 def : Pat<(f32 (uint_to_fp Int32Regs:$a)),
2256           (CVT_f32_u32 Int32Regs:$a, CvtRN)>;
2257 def : Pat<(f32 (uint_to_fp Int64Regs:$a)),
2258           (CVT_f32_u64 Int64Regs:$a, CvtRN)>;
2259
2260 // sint -> f64
2261 def : Pat<(f64 (sint_to_fp Int1Regs:$a)),
2262           (CVT_f64_s32 (SELP_u32ii 1, 0, Int1Regs:$a), CvtRN)>;
2263 def : Pat<(f64 (sint_to_fp Int16Regs:$a)),
2264           (CVT_f64_s16 Int16Regs:$a, CvtRN)>;
2265 def : Pat<(f64 (sint_to_fp Int32Regs:$a)),
2266           (CVT_f64_s32 Int32Regs:$a, CvtRN)>;
2267 def : Pat<(f64 (sint_to_fp Int64Regs:$a)),
2268           (CVT_f64_s64 Int64Regs:$a, CvtRN)>;
2269
2270 // uint -> f64
2271 def : Pat<(f64 (uint_to_fp Int1Regs:$a)),
2272           (CVT_f64_u32 (SELP_u32ii 1, 0, Int1Regs:$a), CvtRN)>;
2273 def : Pat<(f64 (uint_to_fp Int16Regs:$a)),
2274           (CVT_f64_u16 Int16Regs:$a, CvtRN)>;
2275 def : Pat<(f64 (uint_to_fp Int32Regs:$a)),
2276           (CVT_f64_u32 Int32Regs:$a, CvtRN)>;
2277 def : Pat<(f64 (uint_to_fp Int64Regs:$a)),
2278           (CVT_f64_u64 Int64Regs:$a, CvtRN)>;
2279
2280
2281 // f32 -> sint
2282 def : Pat<(i1 (fp_to_sint Float32Regs:$a)),
2283           (SETP_b32ri (BITCONVERT_32_F2I Float32Regs:$a), 0, CmpEQ)>;
2284 def : Pat<(i16 (fp_to_sint Float32Regs:$a)),
2285           (CVT_s16_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2286 def : Pat<(i16 (fp_to_sint Float32Regs:$a)),
2287           (CVT_s16_f32 Float32Regs:$a, CvtRZI)>;
2288 def : Pat<(i32 (fp_to_sint Float32Regs:$a)),
2289           (CVT_s32_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2290 def : Pat<(i32 (fp_to_sint Float32Regs:$a)),
2291           (CVT_s32_f32 Float32Regs:$a, CvtRZI)>;
2292 def : Pat<(i64 (fp_to_sint Float32Regs:$a)),
2293           (CVT_s64_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2294 def : Pat<(i64 (fp_to_sint Float32Regs:$a)),
2295           (CVT_s64_f32 Float32Regs:$a, CvtRZI)>;
2296
2297 // f32 -> uint
2298 def : Pat<(i1 (fp_to_uint Float32Regs:$a)),
2299           (SETP_b32ri (BITCONVERT_32_F2I Float32Regs:$a), 0, CmpEQ)>;
2300 def : Pat<(i16 (fp_to_uint Float32Regs:$a)),
2301           (CVT_u16_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2302 def : Pat<(i16 (fp_to_uint Float32Regs:$a)),
2303           (CVT_u16_f32 Float32Regs:$a, CvtRZI)>;
2304 def : Pat<(i32 (fp_to_uint Float32Regs:$a)),
2305           (CVT_u32_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2306 def : Pat<(i32 (fp_to_uint Float32Regs:$a)),
2307           (CVT_u32_f32 Float32Regs:$a, CvtRZI)>;
2308 def : Pat<(i64 (fp_to_uint Float32Regs:$a)),
2309           (CVT_u64_f32 Float32Regs:$a, CvtRZI_FTZ)>, Requires<[doF32FTZ]>;
2310 def : Pat<(i64 (fp_to_uint Float32Regs:$a)),
2311           (CVT_u64_f32 Float32Regs:$a, CvtRZI)>;
2312
2313 // f64 -> sint
2314 def : Pat<(i1 (fp_to_sint Float64Regs:$a)),
2315           (SETP_b64ri (BITCONVERT_64_F2I Float64Regs:$a), 0, CmpEQ)>;
2316 def : Pat<(i16 (fp_to_sint Float64Regs:$a)),
2317           (CVT_s16_f64 Float64Regs:$a, CvtRZI)>;
2318 def : Pat<(i32 (fp_to_sint Float64Regs:$a)),
2319           (CVT_s32_f64 Float64Regs:$a, CvtRZI)>;
2320 def : Pat<(i64 (fp_to_sint Float64Regs:$a)),
2321           (CVT_s64_f64 Float64Regs:$a, CvtRZI)>;
2322
2323 // f64 -> uint
2324 def : Pat<(i1 (fp_to_uint Float64Regs:$a)),
2325           (SETP_b64ri (BITCONVERT_64_F2I Float64Regs:$a), 0, CmpEQ)>;
2326 def : Pat<(i16 (fp_to_uint Float64Regs:$a)),
2327           (CVT_u16_f64 Float64Regs:$a, CvtRZI)>;
2328 def : Pat<(i32 (fp_to_uint Float64Regs:$a)),
2329           (CVT_u32_f64 Float64Regs:$a, CvtRZI)>;
2330 def : Pat<(i64 (fp_to_uint Float64Regs:$a)),
2331           (CVT_u64_f64 Float64Regs:$a, CvtRZI)>;
2332
2333 // sext i1
2334 def : Pat<(i16 (sext Int1Regs:$a)),
2335           (SELP_s16ii -1, 0, Int1Regs:$a)>;
2336 def : Pat<(i32 (sext Int1Regs:$a)),
2337           (SELP_s32ii -1, 0, Int1Regs:$a)>;
2338 def : Pat<(i64 (sext Int1Regs:$a)),
2339           (SELP_s64ii -1, 0, Int1Regs:$a)>;
2340
2341 // zext i1
2342 def : Pat<(i16 (zext Int1Regs:$a)),
2343           (SELP_u16ii 1, 0, Int1Regs:$a)>;
2344 def : Pat<(i32 (zext Int1Regs:$a)),
2345           (SELP_u32ii 1, 0, Int1Regs:$a)>;
2346 def : Pat<(i64 (zext Int1Regs:$a)),
2347           (SELP_u64ii 1, 0, Int1Regs:$a)>;
2348
2349 // anyext i1
2350 def : Pat<(i16 (anyext Int1Regs:$a)),
2351           (SELP_u16ii -1, 0, Int1Regs:$a)>;
2352 def : Pat<(i32 (anyext Int1Regs:$a)),
2353           (SELP_u32ii -1, 0, Int1Regs:$a)>;
2354 def : Pat<(i64 (anyext Int1Regs:$a)),
2355           (SELP_u64ii -1, 0, Int1Regs:$a)>;
2356
2357 // sext i16
2358 def : Pat<(i32 (sext Int16Regs:$a)),
2359           (CVT_s32_s16 Int16Regs:$a, CvtNONE)>;
2360 def : Pat<(i64 (sext Int16Regs:$a)),
2361           (CVT_s64_s16 Int16Regs:$a, CvtNONE)>;
2362
2363 // zext i16
2364 def : Pat<(i32 (zext Int16Regs:$a)),
2365           (CVT_u32_u16 Int16Regs:$a, CvtNONE)>;
2366 def : Pat<(i64 (zext Int16Regs:$a)),
2367           (CVT_u64_u16 Int16Regs:$a, CvtNONE)>;
2368
2369 // anyext i16
2370 def : Pat<(i32 (anyext Int16Regs:$a)),
2371           (CVT_u32_u16 Int16Regs:$a, CvtNONE)>;
2372 def : Pat<(i64 (anyext Int16Regs:$a)),
2373           (CVT_u64_u16 Int16Regs:$a, CvtNONE)>;
2374
2375 // sext i32
2376 def : Pat<(i64 (sext Int32Regs:$a)),
2377           (CVT_s64_s32 Int32Regs:$a, CvtNONE)>;
2378
2379 // zext i32
2380 def : Pat<(i64 (zext Int32Regs:$a)),
2381           (CVT_u64_u32 Int32Regs:$a, CvtNONE)>;
2382
2383 // anyext i32
2384 def : Pat<(i64 (anyext Int32Regs:$a)),
2385           (CVT_u64_u32 Int32Regs:$a, CvtNONE)>;
2386
2387
2388 // truncate i64
2389 def : Pat<(i32 (trunc Int64Regs:$a)),
2390           (CVT_u32_u64 Int64Regs:$a, CvtNONE)>;
2391 def : Pat<(i16 (trunc Int64Regs:$a)),
2392           (CVT_u16_u64 Int64Regs:$a, CvtNONE)>;
2393 def : Pat<(i1 (trunc Int64Regs:$a)),
2394           (SETP_b64ri (ANDb64ri Int64Regs:$a, 1), 1, CmpEQ)>;
2395
2396 // truncate i32
2397 def : Pat<(i16 (trunc Int32Regs:$a)),
2398           (CVT_u16_u32 Int32Regs:$a, CvtNONE)>;
2399 def : Pat<(i1 (trunc Int32Regs:$a)),
2400           (SETP_b32ri (ANDb32ri Int32Regs:$a, 1), 1, CmpEQ)>;
2401
2402 // truncate i16
2403 def : Pat<(i1 (trunc Int16Regs:$a)),
2404           (SETP_b16ri (ANDb16ri Int16Regs:$a, 1), 1, CmpEQ)>;
2405
2406 // sext_inreg
2407 def : Pat<(sext_inreg Int16Regs:$a, i8), (CVT_INREG_s16_s8 Int16Regs:$a)>;
2408 def : Pat<(sext_inreg Int32Regs:$a, i8), (CVT_INREG_s32_s8 Int32Regs:$a)>;
2409 def : Pat<(sext_inreg Int32Regs:$a, i16), (CVT_INREG_s32_s16 Int32Regs:$a)>;
2410 def : Pat<(sext_inreg Int64Regs:$a, i8), (CVT_INREG_s64_s8 Int64Regs:$a)>;
2411 def : Pat<(sext_inreg Int64Regs:$a, i16), (CVT_INREG_s64_s16 Int64Regs:$a)>;
2412 def : Pat<(sext_inreg Int64Regs:$a, i32), (CVT_INREG_s64_s32 Int64Regs:$a)>;
2413
2414
2415 // Select instructions with 32-bit predicates
2416 def : Pat<(select Int32Regs:$pred, Int16Regs:$a, Int16Regs:$b),
2417           (SELP_b16rr Int16Regs:$a, Int16Regs:$b,
2418           (SETP_b32ri (ANDb32ri Int32Regs:$pred, 1), 1, CmpEQ))>;
2419 def : Pat<(select Int32Regs:$pred, Int32Regs:$a, Int32Regs:$b),
2420           (SELP_b32rr Int32Regs:$a, Int32Regs:$b,
2421           (SETP_b32ri (ANDb32ri Int32Regs:$pred, 1), 1, CmpEQ))>;
2422 def : Pat<(select Int32Regs:$pred, Int64Regs:$a, Int64Regs:$b),
2423           (SELP_b64rr Int64Regs:$a, Int64Regs:$b,
2424           (SETP_b32ri (ANDb32ri Int32Regs:$pred, 1), 1, CmpEQ))>;
2425 def : Pat<(select Int32Regs:$pred, Float32Regs:$a, Float32Regs:$b),
2426           (SELP_f32rr Float32Regs:$a, Float32Regs:$b,
2427           (SETP_b32ri (ANDb32ri Int32Regs:$pred, 1), 1, CmpEQ))>;
2428 def : Pat<(select Int32Regs:$pred, Float64Regs:$a, Float64Regs:$b),
2429           (SELP_f64rr Float64Regs:$a, Float64Regs:$b,
2430           (SETP_b32ri (ANDb32ri Int32Regs:$pred, 1), 1, CmpEQ))>;
2431
2432
2433 // pack a set of smaller int registers to a larger int register
2434 def V4I16toI64 : NVPTXInst<(outs Int64Regs:$d),
2435                           (ins Int16Regs:$s1, Int16Regs:$s2,
2436                                Int16Regs:$s3, Int16Regs:$s4),
2437                           "mov.b64\t$d, {{$s1, $s2, $s3, $s4}};",
2438                           []>;
2439 def V2I16toI32 : NVPTXInst<(outs Int32Regs:$d),
2440                           (ins Int16Regs:$s1, Int16Regs:$s2),
2441                           "mov.b32\t$d, {{$s1, $s2}};",
2442                           []>;
2443 def V2I32toI64 : NVPTXInst<(outs Int64Regs:$d),
2444                           (ins Int32Regs:$s1, Int32Regs:$s2),
2445                           "mov.b64\t$d, {{$s1, $s2}};",
2446                           []>;
2447 def V2F32toF64 : NVPTXInst<(outs Float64Regs:$d),
2448                           (ins Float32Regs:$s1, Float32Regs:$s2),
2449                           "mov.b64\t$d, {{$s1, $s2}};",
2450                           []>;
2451
2452 // unpack a larger int register to a set of smaller int registers
2453 def I64toV4I16 : NVPTXInst<(outs Int16Regs:$d1, Int16Regs:$d2,
2454                                  Int16Regs:$d3, Int16Regs:$d4),
2455                            (ins Int64Regs:$s),
2456                            "mov.b64\t{{$d1, $d2, $d3, $d4}}, $s;",
2457                           []>;
2458 def I32toV2I16 : NVPTXInst<(outs Int16Regs:$d1, Int16Regs:$d2),
2459                            (ins Int32Regs:$s),
2460                            "mov.b32\t{{$d1, $d2}}, $s;",
2461                           []>;
2462 def I64toV2I32 : NVPTXInst<(outs Int32Regs:$d1, Int32Regs:$d2),
2463                            (ins Int64Regs:$s),
2464                            "mov.b64\t{{$d1, $d2}}, $s;",
2465                           []>;
2466 def F64toV2F32 : NVPTXInst<(outs Float32Regs:$d1, Float32Regs:$d2),
2467                            (ins Float64Regs:$s),
2468                            "mov.b64\t{{$d1, $d2}}, $s;",
2469                           []>;
2470
2471 // Count leading zeros
2472 def CLZr32 : NVPTXInst<(outs Int32Regs:$d), (ins Int32Regs:$a),
2473                        "clz.b32\t$d, $a;",
2474                        []>;
2475 def CLZr64 : NVPTXInst<(outs Int32Regs:$d), (ins Int64Regs:$a),
2476                        "clz.b64\t$d, $a;",
2477                        []>;
2478
2479 // 32-bit has a direct PTX instruction
2480 def : Pat<(ctlz Int32Regs:$a),
2481           (CLZr32 Int32Regs:$a)>;
2482 def : Pat<(ctlz_zero_undef Int32Regs:$a),
2483           (CLZr32 Int32Regs:$a)>;
2484
2485 // For 64-bit, the result in PTX is actually 32-bit so we zero-extend
2486 // to 64-bit to match the LLVM semantics
2487 def : Pat<(ctlz Int64Regs:$a),
2488           (CVT_u64_u32 (CLZr64 Int64Regs:$a), CvtNONE)>;
2489 def : Pat<(ctlz_zero_undef Int64Regs:$a),
2490           (CVT_u64_u32 (CLZr64 Int64Regs:$a), CvtNONE)>;
2491
2492 // For 16-bit, we zero-extend to 32-bit, then trunc the result back
2493 // to 16-bits (ctlz of a 16-bit value is guaranteed to require less
2494 // than 16 bits to store). We also need to subtract 16 because the
2495 // high-order 16 zeros were counted.
2496 def : Pat<(ctlz Int16Regs:$a),
2497           (SUBi16ri (CVT_u16_u32 (CLZr32
2498             (CVT_u32_u16 Int16Regs:$a, CvtNONE)),
2499            CvtNONE), 16)>;
2500 def : Pat<(ctlz_zero_undef Int16Regs:$a),
2501           (SUBi16ri (CVT_u16_u32 (CLZr32
2502             (CVT_u32_u16 Int16Regs:$a, CvtNONE)),
2503            CvtNONE), 16)>;
2504
2505 // Population count
2506 def POPCr32 : NVPTXInst<(outs Int32Regs:$d), (ins Int32Regs:$a),
2507                         "popc.b32\t$d, $a;",
2508                         []>;
2509 def POPCr64 : NVPTXInst<(outs Int32Regs:$d), (ins Int64Regs:$a),
2510                         "popc.b64\t$d, $a;",
2511                         []>;
2512
2513 // 32-bit has a direct PTX instruction
2514 def : Pat<(ctpop Int32Regs:$a),
2515           (POPCr32 Int32Regs:$a)>;
2516
2517 // For 64-bit, the result in PTX is actually 32-bit so we zero-extend
2518 // to 64-bit to match the LLVM semantics
2519 def : Pat<(ctpop Int64Regs:$a),
2520           (CVT_u64_u32 (POPCr64 Int64Regs:$a), CvtNONE)>;
2521
2522 // For 16-bit, we zero-extend to 32-bit, then trunc the result back
2523 // to 16-bits (ctpop of a 16-bit value is guaranteed to require less
2524 // than 16 bits to store)
2525 def : Pat<(ctpop Int16Regs:$a),
2526           (CVT_u16_u32 (POPCr32 (CVT_u32_u16 Int16Regs:$a, CvtNONE)),
2527            CvtNONE)>;
2528
2529 // fround f64 -> f32
2530 def : Pat<(f32 (fround Float64Regs:$a)),
2531           (CVT_f32_f64 Float64Regs:$a, CvtRN_FTZ)>, Requires<[doF32FTZ]>;
2532 def : Pat<(f32 (fround Float64Regs:$a)),
2533           (CVT_f32_f64 Float64Regs:$a, CvtRN)>;
2534
2535 // fextend f32 -> f64
2536 def : Pat<(f64 (fextend Float32Regs:$a)),
2537           (CVT_f64_f32 Float32Regs:$a, CvtNONE_FTZ)>, Requires<[doF32FTZ]>;
2538 def : Pat<(f64 (fextend Float32Regs:$a)),
2539           (CVT_f64_f32 Float32Regs:$a, CvtNONE)>;
2540
2541 def retflag       : SDNode<"NVPTXISD::RET_FLAG", SDTNone,
2542                            [SDNPHasChain, SDNPOptInGlue]>;
2543
2544 //-----------------------------------
2545 // Control-flow
2546 //-----------------------------------
2547
2548 let isTerminator=1 in {
2549    let isReturn=1, isBarrier=1 in
2550       def Return : NVPTXInst<(outs), (ins), "ret;", [(retflag)]>;
2551
2552    let isBranch=1 in
2553       def CBranch : NVPTXInst<(outs), (ins Int1Regs:$a, brtarget:$target),
2554                           "@$a bra \t$target;",
2555                            [(brcond Int1Regs:$a, bb:$target)]>;
2556    let isBranch=1 in
2557       def CBranchOther : NVPTXInst<(outs), (ins Int1Regs:$a, brtarget:$target),
2558                           "@!$a bra \t$target;",
2559                            []>;
2560
2561    let isBranch=1, isBarrier=1 in
2562       def GOTO : NVPTXInst<(outs), (ins brtarget:$target),
2563                         "bra.uni \t$target;",
2564                   [(br bb:$target)]>;
2565 }
2566
2567 def : Pat<(brcond Int32Regs:$a, bb:$target),
2568           (CBranch (SETP_u32ri Int32Regs:$a, 0, CmpNE), bb:$target)>;
2569
2570 // SelectionDAGBuilder::visitSWitchCase() will invert the condition of a
2571 // conditional branch if
2572 // the target block is the next block so that the code can fall through to the
2573 // target block.
2574 // The invertion is done by 'xor condition, 1', which will be translated to
2575 // (setne condition, -1).
2576 // Since ptx supports '@!pred bra target', we should use it.
2577 def : Pat<(brcond (i1 (setne Int1Regs:$a, -1)), bb:$target),
2578   (CBranchOther Int1Regs:$a, bb:$target)>;
2579
2580 // Call
2581 def SDT_NVPTXCallSeqStart : SDCallSeqStart<[ SDTCisVT<0, i32> ]>;
2582 def SDT_NVPTXCallSeqEnd   : SDCallSeqEnd<[ SDTCisVT<0, i32>,
2583                                         SDTCisVT<1, i32> ]>;
2584
2585 def callseq_start : SDNode<"ISD::CALLSEQ_START", SDT_NVPTXCallSeqStart,
2586                            [SDNPHasChain, SDNPOutGlue, SDNPSideEffect]>;
2587 def callseq_end   : SDNode<"ISD::CALLSEQ_END",   SDT_NVPTXCallSeqEnd,
2588                            [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue,
2589                            SDNPSideEffect]>;
2590
2591 def SDT_NVPTXCall : SDTypeProfile<0, 1, [SDTCisVT<0, i32>]>;
2592 def call          : SDNode<"NVPTXISD::CALL", SDT_NVPTXCall,
2593                            [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
2594 def calltarget : Operand<i32>;
2595 let isCall=1 in {
2596    def CALL : NVPTXInst<(outs), (ins calltarget:$dst),
2597                   "call \t$dst, (1);", []>;
2598 }
2599
2600 def : Pat<(call tglobaladdr:$dst),
2601           (CALL tglobaladdr:$dst)>;
2602 def : Pat<(call texternalsym:$dst),
2603           (CALL texternalsym:$dst)>;
2604
2605 // Pseudo instructions.
2606 class Pseudo<dag outs, dag ins, string asmstr, list<dag> pattern>
2607    : NVPTXInst<outs, ins, asmstr, pattern>;
2608
2609 // @TODO: We use some tricks here to emit curly braces.  Can we clean this up
2610 // a bit without TableGen modifications?
2611 def Callseq_Start : NVPTXInst<(outs), (ins i32imm:$amt),
2612   "// Callseq Start $amt\n\t{{\n\t.reg .b32 temp_param_reg;\n\t// <end>}}",
2613                                [(callseq_start timm:$amt)]>;
2614 def Callseq_End : NVPTXInst<(outs), (ins i32imm:$amt1, i32imm:$amt2),
2615   "\n\t//{{\n\t}}// Callseq End $amt1",
2616                             [(callseq_end timm:$amt1, timm:$amt2)]>;
2617
2618 // trap instruction
2619
2620 def trapinst : NVPTXInst<(outs), (ins),
2621                          "trap;",
2622                          [(trap)]>;
2623
2624 // Call prototype wrapper
2625 def SDTCallPrototype : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
2626 def CallPrototype
2627   : SDNode<"NVPTXISD::CallPrototype", SDTCallPrototype,
2628            [SDNPHasChain, SDNPOutGlue, SDNPInGlue, SDNPSideEffect]>;
2629 def ProtoIdent : Operand<i32> {
2630   let PrintMethod = "printProtoIdent";
2631 }
2632 def CALL_PROTOTYPE
2633   : NVPTXInst<(outs), (ins ProtoIdent:$ident),
2634               "$ident", [(CallPrototype (i32 texternalsym:$ident))]>;
2635
2636
2637
2638 include "NVPTXIntrinsics.td"
2639
2640
2641 //-----------------------------------
2642 // Notes
2643 //-----------------------------------
2644 // BSWAP is currently expanded. The following is a more efficient
2645 // - for < sm_20, use vector scalar mov, as tesla support native 16-bit register
2646 // - for sm_20, use pmpt (use vector scalar mov to get the pack and
2647 //   unpack). sm_20 supports native 32-bit register, but not native 16-bit
2648 // register.