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 11define 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 18define 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 25define 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 32define i64 @umul_lohi_i64(i64 %a) { 33; CHECK-LABEL: umul_lohi_i64( 34entry: 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 44define i64 @smul_lohi_i64(i64 %a) { 45; CHECK-LABEL: smul_lohi_i64( 46entry: 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 56define 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 63define 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 70define 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 77define 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 84define 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 91define 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 98define 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 105define 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 113define 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 121define 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 132define 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 139define 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 146define 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 153define 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 160define 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 167define 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 174define 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 181define 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 188define 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 195define 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 202define 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 209define 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 216define 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 225define 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 232define 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 239define 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 246define 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 253define 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 260define 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 267define 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 274define 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 281define 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 288define 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 295define 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 303define 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 311define 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