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