test/CodeGen/NVPTX/arithmetic-int.ll

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