test/CodeGen/NVPTX/arithmetic-int.ll

   1 ; RUN: llc < %s -march=nvptx -mcpu=sm_20 | FileCheck %s
   2 ; RUN: llc < %s -march=nvptx64 -mcpu=sm_20 | FileCheck %s
   3
   4 ;; These tests should run for all targets
   5
   6 ;;===-- Basic instruction selection tests ---------------------------------===;;
   7
   8
   9 ;;; i64
  10
  11 define i64 @add_i64(i64 %a, i64 %b) {
  12 ; CHECK: add.s64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %rd{{[0-9]+}}
  13 ; CHECK: ret
  14   %ret = add i64 %a, %b
  15   ret i64 %ret
  16 }
  17
  18 define i64 @sub_i64(i64 %a, i64 %b) {
  19 ; CHECK: sub.s64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %rd{{[0-9]+}}
  20 ; CHECK: ret
  21   %ret = sub i64 %a, %b
  22   ret i64 %ret
  23 }
  24
  25 define i64 @mul_i64(i64 %a, i64 %b) {
  26 ; CHECK: mul.lo.s64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %rd{{[0-9]+}}
  27 ; CHECK: ret
  28   %ret = mul i64 %a, %b
  29   ret i64 %ret
  30 }
  31
  32 define i64 @sdiv_i64(i64 %a, i64 %b) {
  33 ; CHECK: div.s64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %rd{{[0-9]+}}
  34 ; CHECK: ret
  35   %ret = sdiv i64 %a, %b
  36   ret i64 %ret
  37 }
  38
  39 define i64 @udiv_i64(i64 %a, i64 %b) {
  40 ; CHECK: div.u64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %rd{{[0-9]+}}
  41 ; CHECK: ret
  42   %ret = udiv i64 %a, %b
  43   ret i64 %ret
  44 }
  45
  46 define i64 @srem_i64(i64 %a, i64 %b) {
  47 ; CHECK: rem.s64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %rd{{[0-9]+}}
  48 ; CHECK: ret
  49   %ret = srem i64 %a, %b
  50   ret i64 %ret
  51 }
  52
  53 define i64 @urem_i64(i64 %a, i64 %b) {
  54 ; CHECK: rem.u64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %rd{{[0-9]+}}
  55 ; CHECK: ret
  56   %ret = urem i64 %a, %b
  57   ret i64 %ret
  58 }
  59
  60 define i64 @and_i64(i64 %a, i64 %b) {
  61 ; CHECK: and.b64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %rd{{[0-9]+}}
  62 ; CHECK: ret
  63   %ret = and i64 %a, %b
  64   ret i64 %ret
  65 }
  66
  67 define i64 @or_i64(i64 %a, i64 %b) {
  68 ; CHECK: or.b64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %rd{{[0-9]+}}
  69 ; CHECK: ret
  70   %ret = or i64 %a, %b
  71   ret i64 %ret
  72 }
  73
  74 define i64 @xor_i64(i64 %a, i64 %b) {
  75 ; CHECK: xor.b64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %rd{{[0-9]+}}
  76 ; CHECK: ret
  77   %ret = xor i64 %a, %b
  78   ret i64 %ret
  79 }
  80
  81 define i64 @shl_i64(i64 %a, i64 %b) {
  82 ; PTX requires 32-bit shift amount
  83 ; CHECK: shl.b64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %r{{[0-9]+}}
  84 ; CHECK: ret
  85   %ret = shl i64 %a, %b
  86   ret i64 %ret
  87 }
  88
  89 define i64 @ashr_i64(i64 %a, i64 %b) {
  90 ; PTX requires 32-bit shift amount
  91 ; CHECK: shr.s64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %r{{[0-9]+}}
  92 ; CHECK: ret
  93   %ret = ashr i64 %a, %b
  94   ret i64 %ret
  95 }
  96
  97 define i64 @lshr_i64(i64 %a, i64 %b) {
  98 ; PTX requires 32-bit shift amount
  99 ; CHECK: shr.u64 %rd{{[0-9]+}}, %rd{{[0-9]+}}, %r{{[0-9]+}}
 100 ; CHECK: ret
 101   %ret = lshr i64 %a, %b
 102   ret i64 %ret
 103 }
 104
 105
 106 ;;; i32
 107
 108 define i32 @add_i32(i32 %a, i32 %b) {
 109 ; CHECK: add.s32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 110 ; CHECK: ret
 111   %ret = add i32 %a, %b
 112   ret i32 %ret
 113 }
 114
 115 define i32 @sub_i32(i32 %a, i32 %b) {
 116 ; CHECK: sub.s32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 117 ; CHECK: ret
 118   %ret = sub i32 %a, %b
 119   ret i32 %ret
 120 }
 121
 122 define i32 @mul_i32(i32 %a, i32 %b) {
 123 ; CHECK: mul.lo.s32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 124 ; CHECK: ret
 125   %ret = mul i32 %a, %b
 126   ret i32 %ret
 127 }
 128
 129 define i32 @sdiv_i32(i32 %a, i32 %b) {
 130 ; CHECK: div.s32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 131 ; CHECK: ret
 132   %ret = sdiv i32 %a, %b
 133   ret i32 %ret
 134 }
 135
 136 define i32 @udiv_i32(i32 %a, i32 %b) {
 137 ; CHECK: div.u32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 138 ; CHECK: ret
 139   %ret = udiv i32 %a, %b
 140   ret i32 %ret
 141 }
 142
 143 define i32 @srem_i32(i32 %a, i32 %b) {
 144 ; CHECK: rem.s32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 145 ; CHECK: ret
 146   %ret = srem i32 %a, %b
 147   ret i32 %ret
 148 }
 149
 150 define i32 @urem_i32(i32 %a, i32 %b) {
 151 ; CHECK: rem.u32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 152 ; CHECK: ret
 153   %ret = urem i32 %a, %b
 154   ret i32 %ret
 155 }
 156
 157 define i32 @and_i32(i32 %a, i32 %b) {
 158 ; CHECK: and.b32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 159 ; CHECK: ret
 160   %ret = and i32 %a, %b
 161   ret i32 %ret
 162 }
 163
 164 define i32 @or_i32(i32 %a, i32 %b) {
 165 ; CHECK: or.b32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 166 ; CHECK: ret
 167   %ret = or i32 %a, %b
 168   ret i32 %ret
 169 }
 170
 171 define i32 @xor_i32(i32 %a, i32 %b) {
 172 ; CHECK: xor.b32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 173 ; CHECK: ret
 174   %ret = xor i32 %a, %b
 175   ret i32 %ret
 176 }
 177
 178 define i32 @shl_i32(i32 %a, i32 %b) {
 179 ; CHECK: shl.b32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 180 ; CHECK: ret
 181   %ret = shl i32 %a, %b
 182   ret i32 %ret
 183 }
 184
 185 define i32 @ashr_i32(i32 %a, i32 %b) {
 186 ; CHECK: shr.s32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 187 ; CHECK: ret
 188   %ret = ashr i32 %a, %b
 189   ret i32 %ret
 190 }
 191
 192 define i32 @lshr_i32(i32 %a, i32 %b) {
 193 ; CHECK: shr.u32 %r{{[0-9]+}}, %r{{[0-9]+}}, %r{{[0-9]+}}
 194 ; CHECK: ret
 195   %ret = lshr i32 %a, %b
 196   ret i32 %ret
 197 }
 198
 199 ;;; i16
 200
 201 define i16 @add_i16(i16 %a, i16 %b) {
 202 ; CHECK: add.s16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %rs{{[0-9]+}}
 203 ; CHECK: ret
 204   %ret = add i16 %a, %b
 205   ret i16 %ret
 206 }
 207
 208 define i16 @sub_i16(i16 %a, i16 %b) {
 209 ; CHECK: sub.s16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %rs{{[0-9]+}}
 210 ; CHECK: ret
 211   %ret = sub i16 %a, %b
 212   ret i16 %ret
 213 }
 214
 215 define i16 @mul_i16(i16 %a, i16 %b) {
 216 ; CHECK: mul.lo.s16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %rs{{[0-9]+}}
 217 ; CHECK: ret
 218   %ret = mul i16 %a, %b
 219   ret i16 %ret
 220 }
 221
 222 define i16 @sdiv_i16(i16 %a, i16 %b) {
 223 ; CHECK: div.s16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %rs{{[0-9]+}}
 224 ; CHECK: ret
 225   %ret = sdiv i16 %a, %b
 226   ret i16 %ret
 227 }
 228
 229 define i16 @udiv_i16(i16 %a, i16 %b) {
 230 ; CHECK: div.u16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %rs{{[0-9]+}}
 231 ; CHECK: ret
 232   %ret = udiv i16 %a, %b
 233   ret i16 %ret
 234 }
 235
 236 define i16 @srem_i16(i16 %a, i16 %b) {
 237 ; CHECK: rem.s16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %rs{{[0-9]+}}
 238 ; CHECK: ret
 239   %ret = srem i16 %a, %b
 240   ret i16 %ret
 241 }
 242
 243 define i16 @urem_i16(i16 %a, i16 %b) {
 244 ; CHECK: rem.u16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %rs{{[0-9]+}}
 245 ; CHECK: ret
 246   %ret = urem i16 %a, %b
 247   ret i16 %ret
 248 }
 249
 250 define i16 @and_i16(i16 %a, i16 %b) {
 251 ; CHECK: and.b16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %rs{{[0-9]+}}
 252 ; CHECK: ret
 253   %ret = and i16 %a, %b
 254   ret i16 %ret
 255 }
 256
 257 define i16 @or_i16(i16 %a, i16 %b) {
 258 ; CHECK: or.b16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %rs{{[0-9]+}}
 259 ; CHECK: ret
 260   %ret = or i16 %a, %b
 261   ret i16 %ret
 262 }
 263
 264 define i16 @xor_i16(i16 %a, i16 %b) {
 265 ; CHECK: xor.b16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %rs{{[0-9]+}}
 266 ; CHECK: ret
 267   %ret = xor i16 %a, %b
 268   ret i16 %ret
 269 }
 270
 271 define i16 @shl_i16(i16 %a, i16 %b) {
 272 ; PTX requires 32-bit shift amount
 273 ; CHECK: shl.b16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %r{{[0-9]+}}
 274 ; CHECK: ret
 275   %ret = shl i16 %a, %b
 276   ret i16 %ret
 277 }
 278
 279 define i16 @ashr_i16(i16 %a, i16 %b) {
 280 ; PTX requires 32-bit shift amount
 281 ; CHECK: shr.s16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %r{{[0-9]+}}
 282 ; CHECK: ret
 283   %ret = ashr i16 %a, %b
 284   ret i16 %ret
 285 }
 286
 287 define i16 @lshr_i16(i16 %a, i16 %b) {
 288 ; PTX requires 32-bit shift amount
 289 ; CHECK: shr.u16 %rs{{[0-9]+}}, %rs{{[0-9]+}}, %r{{[0-9]+}}
 290 ; CHECK: ret
 291   %ret = lshr i16 %a, %b
 292   ret i16 %ret
 293 }