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