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