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 } 318
