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 13define 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 20define 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 27define 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 34define 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 41define 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 48define 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 55define 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 62define 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 69define 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 76define 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 83define 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 91define 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 99define 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 110define 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 117define 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 124define 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 131define 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 138define 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 145define 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 152define 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 159define 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 166define 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 173define 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 180define 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 187define 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 194define 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 203define 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 210define 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 217define 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 224define 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 231define 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 238define 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 245define 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 252define 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 259define 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 266define 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 273define 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 281define 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 289define 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} 296