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