1; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
2; RUN: llc -mtriple=i686-unknown-linux-gnu < %s | FileCheck %s --check-prefixes=CHECK,X86
3; RUN: llc -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s --check-prefixes=CHECK,X64
4
5;------------------------------------------------------------------------------;
6; Odd divisors
7;------------------------------------------------------------------------------;
8
9define i32 @test_urem_odd(i32 %X) nounwind {
10; X86-LABEL: test_urem_odd:
11; X86:       # %bb.0:
12; X86-NEXT:    imull $-858993459, {{[0-9]+}}(%esp), %ecx # imm = 0xCCCCCCCD
13; X86-NEXT:    xorl %eax, %eax
14; X86-NEXT:    cmpl $858993460, %ecx # imm = 0x33333334
15; X86-NEXT:    setb %al
16; X86-NEXT:    retl
17;
18; X64-LABEL: test_urem_odd:
19; X64:       # %bb.0:
20; X64-NEXT:    imull $-858993459, %edi, %ecx # imm = 0xCCCCCCCD
21; X64-NEXT:    xorl %eax, %eax
22; X64-NEXT:    cmpl $858993460, %ecx # imm = 0x33333334
23; X64-NEXT:    setb %al
24; X64-NEXT:    retq
25  %urem = urem i32 %X, 5
26  %cmp = icmp eq i32 %urem, 0
27  %ret = zext i1 %cmp to i32
28  ret i32 %ret
29}
30
31define i32 @test_urem_odd_25(i32 %X) nounwind {
32; X86-LABEL: test_urem_odd_25:
33; X86:       # %bb.0:
34; X86-NEXT:    imull $-1030792151, {{[0-9]+}}(%esp), %ecx # imm = 0xC28F5C29
35; X86-NEXT:    xorl %eax, %eax
36; X86-NEXT:    cmpl $171798692, %ecx # imm = 0xA3D70A4
37; X86-NEXT:    setb %al
38; X86-NEXT:    retl
39;
40; X64-LABEL: test_urem_odd_25:
41; X64:       # %bb.0:
42; X64-NEXT:    imull $-1030792151, %edi, %ecx # imm = 0xC28F5C29
43; X64-NEXT:    xorl %eax, %eax
44; X64-NEXT:    cmpl $171798692, %ecx # imm = 0xA3D70A4
45; X64-NEXT:    setb %al
46; X64-NEXT:    retq
47  %urem = urem i32 %X, 25
48  %cmp = icmp eq i32 %urem, 0
49  %ret = zext i1 %cmp to i32
50  ret i32 %ret
51}
52
53; This is like test_urem_odd, except the divisor has bit 30 set.
54define i32 @test_urem_odd_bit30(i32 %X) nounwind {
55; X86-LABEL: test_urem_odd_bit30:
56; X86:       # %bb.0:
57; X86-NEXT:    imull $1789569707, {{[0-9]+}}(%esp), %ecx # imm = 0x6AAAAAAB
58; X86-NEXT:    xorl %eax, %eax
59; X86-NEXT:    cmpl $4, %ecx
60; X86-NEXT:    setb %al
61; X86-NEXT:    retl
62;
63; X64-LABEL: test_urem_odd_bit30:
64; X64:       # %bb.0:
65; X64-NEXT:    imull $1789569707, %edi, %ecx # imm = 0x6AAAAAAB
66; X64-NEXT:    xorl %eax, %eax
67; X64-NEXT:    cmpl $4, %ecx
68; X64-NEXT:    setb %al
69; X64-NEXT:    retq
70  %urem = urem i32 %X, 1073741827
71  %cmp = icmp eq i32 %urem, 0
72  %ret = zext i1 %cmp to i32
73  ret i32 %ret
74}
75
76; This is like test_urem_odd, except the divisor has bit 31 set.
77define i32 @test_urem_odd_bit31(i32 %X) nounwind {
78; X86-LABEL: test_urem_odd_bit31:
79; X86:       # %bb.0:
80; X86-NEXT:    imull $715827883, {{[0-9]+}}(%esp), %ecx # imm = 0x2AAAAAAB
81; X86-NEXT:    xorl %eax, %eax
82; X86-NEXT:    cmpl $2, %ecx
83; X86-NEXT:    setb %al
84; X86-NEXT:    retl
85;
86; X64-LABEL: test_urem_odd_bit31:
87; X64:       # %bb.0:
88; X64-NEXT:    imull $715827883, %edi, %ecx # imm = 0x2AAAAAAB
89; X64-NEXT:    xorl %eax, %eax
90; X64-NEXT:    cmpl $2, %ecx
91; X64-NEXT:    setb %al
92; X64-NEXT:    retq
93  %urem = urem i32 %X, 2147483651
94  %cmp = icmp eq i32 %urem, 0
95  %ret = zext i1 %cmp to i32
96  ret i32 %ret
97}
98
99;------------------------------------------------------------------------------;
100; Even divisors
101;------------------------------------------------------------------------------;
102
103define i16 @test_urem_even(i16 %X) nounwind {
104; X86-LABEL: test_urem_even:
105; X86:       # %bb.0:
106; X86-NEXT:    imull $28087, {{[0-9]+}}(%esp), %eax # imm = 0x6DB7
107; X86-NEXT:    rorw %ax
108; X86-NEXT:    movzwl %ax, %ecx
109; X86-NEXT:    xorl %eax, %eax
110; X86-NEXT:    cmpl $4682, %ecx # imm = 0x124A
111; X86-NEXT:    setae %al
112; X86-NEXT:    # kill: def $ax killed $ax killed $eax
113; X86-NEXT:    retl
114;
115; X64-LABEL: test_urem_even:
116; X64:       # %bb.0:
117; X64-NEXT:    imull $28087, %edi, %eax # imm = 0x6DB7
118; X64-NEXT:    rorw %ax
119; X64-NEXT:    movzwl %ax, %ecx
120; X64-NEXT:    xorl %eax, %eax
121; X64-NEXT:    cmpl $4682, %ecx # imm = 0x124A
122; X64-NEXT:    setae %al
123; X64-NEXT:    # kill: def $ax killed $ax killed $eax
124; X64-NEXT:    retq
125  %urem = urem i16 %X, 14
126  %cmp = icmp ne i16 %urem, 0
127  %ret = zext i1 %cmp to i16
128  ret i16 %ret
129}
130
131define i32 @test_urem_even_100(i32 %X) nounwind {
132; X86-LABEL: test_urem_even_100:
133; X86:       # %bb.0:
134; X86-NEXT:    imull $-1030792151, {{[0-9]+}}(%esp), %ecx # imm = 0xC28F5C29
135; X86-NEXT:    rorl $2, %ecx
136; X86-NEXT:    xorl %eax, %eax
137; X86-NEXT:    cmpl $42949673, %ecx # imm = 0x28F5C29
138; X86-NEXT:    setb %al
139; X86-NEXT:    retl
140;
141; X64-LABEL: test_urem_even_100:
142; X64:       # %bb.0:
143; X64-NEXT:    imull $-1030792151, %edi, %ecx # imm = 0xC28F5C29
144; X64-NEXT:    rorl $2, %ecx
145; X64-NEXT:    xorl %eax, %eax
146; X64-NEXT:    cmpl $42949673, %ecx # imm = 0x28F5C29
147; X64-NEXT:    setb %al
148; X64-NEXT:    retq
149  %urem = urem i32 %X, 100
150  %cmp = icmp eq i32 %urem, 0
151  %ret = zext i1 %cmp to i32
152  ret i32 %ret
153}
154
155; This is like test_urem_even, except the divisor has bit 30 set.
156define i32 @test_urem_even_bit30(i32 %X) nounwind {
157; X86-LABEL: test_urem_even_bit30:
158; X86:       # %bb.0:
159; X86-NEXT:    imull $-51622203, {{[0-9]+}}(%esp), %ecx # imm = 0xFCEC4EC5
160; X86-NEXT:    rorl $3, %ecx
161; X86-NEXT:    xorl %eax, %eax
162; X86-NEXT:    cmpl $4, %ecx
163; X86-NEXT:    setb %al
164; X86-NEXT:    retl
165;
166; X64-LABEL: test_urem_even_bit30:
167; X64:       # %bb.0:
168; X64-NEXT:    imull $-51622203, %edi, %ecx # imm = 0xFCEC4EC5
169; X64-NEXT:    rorl $3, %ecx
170; X64-NEXT:    xorl %eax, %eax
171; X64-NEXT:    cmpl $4, %ecx
172; X64-NEXT:    setb %al
173; X64-NEXT:    retq
174  %urem = urem i32 %X, 1073741928
175  %cmp = icmp eq i32 %urem, 0
176  %ret = zext i1 %cmp to i32
177  ret i32 %ret
178}
179
180; This is like test_urem_odd, except the divisor has bit 31 set.
181define i32 @test_urem_even_bit31(i32 %X) nounwind {
182; X86-LABEL: test_urem_even_bit31:
183; X86:       # %bb.0:
184; X86-NEXT:    imull $-1157956869, {{[0-9]+}}(%esp), %ecx # imm = 0xBAFAFAFB
185; X86-NEXT:    rorl %ecx
186; X86-NEXT:    xorl %eax, %eax
187; X86-NEXT:    cmpl $2, %ecx
188; X86-NEXT:    setb %al
189; X86-NEXT:    retl
190;
191; X64-LABEL: test_urem_even_bit31:
192; X64:       # %bb.0:
193; X64-NEXT:    imull $-1157956869, %edi, %ecx # imm = 0xBAFAFAFB
194; X64-NEXT:    rorl %ecx
195; X64-NEXT:    xorl %eax, %eax
196; X64-NEXT:    cmpl $2, %ecx
197; X64-NEXT:    setb %al
198; X64-NEXT:    retq
199  %urem = urem i32 %X, 2147483750
200  %cmp = icmp eq i32 %urem, 0
201  %ret = zext i1 %cmp to i32
202  ret i32 %ret
203}
204
205;------------------------------------------------------------------------------;
206; Special case
207;------------------------------------------------------------------------------;
208
209; 'NE' predicate is fine too.
210define i32 @test_urem_odd_setne(i32 %X) nounwind {
211; X86-LABEL: test_urem_odd_setne:
212; X86:       # %bb.0:
213; X86-NEXT:    imull $-858993459, {{[0-9]+}}(%esp), %ecx # imm = 0xCCCCCCCD
214; X86-NEXT:    xorl %eax, %eax
215; X86-NEXT:    cmpl $858993460, %ecx # imm = 0x33333334
216; X86-NEXT:    setae %al
217; X86-NEXT:    retl
218;
219; X64-LABEL: test_urem_odd_setne:
220; X64:       # %bb.0:
221; X64-NEXT:    imull $-858993459, %edi, %ecx # imm = 0xCCCCCCCD
222; X64-NEXT:    xorl %eax, %eax
223; X64-NEXT:    cmpl $858993460, %ecx # imm = 0x33333334
224; X64-NEXT:    setae %al
225; X64-NEXT:    retq
226  %urem = urem i32 %X, 5
227  %cmp = icmp ne i32 %urem, 0
228  %ret = zext i1 %cmp to i32
229  ret i32 %ret
230}
231
232; The fold is only valid for positive divisors, negative-ones should be negated.
233define i32 @test_urem_negative_odd(i32 %X) nounwind {
234; X86-LABEL: test_urem_negative_odd:
235; X86:       # %bb.0:
236; X86-NEXT:    imull $858993459, {{[0-9]+}}(%esp), %ecx # imm = 0x33333333
237; X86-NEXT:    xorl %eax, %eax
238; X86-NEXT:    cmpl $2, %ecx
239; X86-NEXT:    setae %al
240; X86-NEXT:    retl
241;
242; X64-LABEL: test_urem_negative_odd:
243; X64:       # %bb.0:
244; X64-NEXT:    imull $858993459, %edi, %ecx # imm = 0x33333333
245; X64-NEXT:    xorl %eax, %eax
246; X64-NEXT:    cmpl $2, %ecx
247; X64-NEXT:    setae %al
248; X64-NEXT:    retq
249  %urem = urem i32 %X, -5
250  %cmp = icmp ne i32 %urem, 0
251  %ret = zext i1 %cmp to i32
252  ret i32 %ret
253}
254define i32 @test_urem_negative_even(i32 %X) nounwind {
255; X86-LABEL: test_urem_negative_even:
256; X86:       # %bb.0:
257; X86-NEXT:    imull $-920350135, {{[0-9]+}}(%esp), %ecx # imm = 0xC9249249
258; X86-NEXT:    rorl %ecx
259; X86-NEXT:    xorl %eax, %eax
260; X86-NEXT:    cmpl $2, %ecx
261; X86-NEXT:    setae %al
262; X86-NEXT:    retl
263;
264; X64-LABEL: test_urem_negative_even:
265; X64:       # %bb.0:
266; X64-NEXT:    imull $-920350135, %edi, %ecx # imm = 0xC9249249
267; X64-NEXT:    rorl %ecx
268; X64-NEXT:    xorl %eax, %eax
269; X64-NEXT:    cmpl $2, %ecx
270; X64-NEXT:    setae %al
271; X64-NEXT:    retq
272  %urem = urem i32 %X, -14
273  %cmp = icmp ne i32 %urem, 0
274  %ret = zext i1 %cmp to i32
275  ret i32 %ret
276}
277
278;------------------------------------------------------------------------------;
279; Negative tests
280;------------------------------------------------------------------------------;
281
282; We can lower remainder of division by one much better elsewhere.
283define i32 @test_urem_one(i32 %X) nounwind {
284; CHECK-LABEL: test_urem_one:
285; CHECK:       # %bb.0:
286; CHECK-NEXT:    movl $1, %eax
287; CHECK-NEXT:    ret{{[l|q]}}
288  %urem = urem i32 %X, 1
289  %cmp = icmp eq i32 %urem, 0
290  %ret = zext i1 %cmp to i32
291  ret i32 %ret
292}
293
294; We can lower remainder of division by powers of two much better elsewhere.
295define i32 @test_urem_pow2(i32 %X) nounwind {
296; X86-LABEL: test_urem_pow2:
297; X86:       # %bb.0:
298; X86-NEXT:    xorl %eax, %eax
299; X86-NEXT:    testb $15, {{[0-9]+}}(%esp)
300; X86-NEXT:    sete %al
301; X86-NEXT:    retl
302;
303; X64-LABEL: test_urem_pow2:
304; X64:       # %bb.0:
305; X64-NEXT:    xorl %eax, %eax
306; X64-NEXT:    testb $15, %dil
307; X64-NEXT:    sete %al
308; X64-NEXT:    retq
309  %urem = urem i32 %X, 16
310  %cmp = icmp eq i32 %urem, 0
311  %ret = zext i1 %cmp to i32
312  ret i32 %ret
313}
314
315; The fold is only valid for positive divisors, and we can't negate INT_MIN.
316define i32 @test_urem_int_min(i32 %X) nounwind {
317; X86-LABEL: test_urem_int_min:
318; X86:       # %bb.0:
319; X86-NEXT:    xorl %eax, %eax
320; X86-NEXT:    testl $2147483647, {{[0-9]+}}(%esp) # imm = 0x7FFFFFFF
321; X86-NEXT:    sete %al
322; X86-NEXT:    retl
323;
324; X64-LABEL: test_urem_int_min:
325; X64:       # %bb.0:
326; X64-NEXT:    xorl %eax, %eax
327; X64-NEXT:    testl $2147483647, %edi # imm = 0x7FFFFFFF
328; X64-NEXT:    sete %al
329; X64-NEXT:    retq
330  %urem = urem i32 %X, 2147483648
331  %cmp = icmp eq i32 %urem, 0
332  %ret = zext i1 %cmp to i32
333  ret i32 %ret
334}
335
336; We can lower remainder of division by all-ones much better elsewhere.
337define i32 @test_urem_allones(i32 %X) nounwind {
338; X86-LABEL: test_urem_allones:
339; X86:       # %bb.0:
340; X86-NEXT:    xorl %ecx, %ecx
341; X86-NEXT:    subl {{[0-9]+}}(%esp), %ecx
342; X86-NEXT:    xorl %eax, %eax
343; X86-NEXT:    cmpl $2, %ecx
344; X86-NEXT:    setb %al
345; X86-NEXT:    retl
346;
347; X64-LABEL: test_urem_allones:
348; X64:       # %bb.0:
349; X64-NEXT:    negl %edi
350; X64-NEXT:    xorl %eax, %eax
351; X64-NEXT:    cmpl $2, %edi
352; X64-NEXT:    setb %al
353; X64-NEXT:    retq
354  %urem = urem i32 %X, 4294967295
355  %cmp = icmp eq i32 %urem, 0
356  %ret = zext i1 %cmp to i32
357  ret i32 %ret
358}
359
360; Check illegal types.
361
362; https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=34366
363define void @ossfuzz34366() {
364; X86-LABEL: ossfuzz34366:
365; X86:       # %bb.0:
366; X86-NEXT:    movl (%eax), %eax
367; X86-NEXT:    movl %eax, %ecx
368; X86-NEXT:    andl $2147483647, %ecx # imm = 0x7FFFFFFF
369; X86-NEXT:    orl %eax, %ecx
370; X86-NEXT:    orl %eax, %ecx
371; X86-NEXT:    orl %eax, %ecx
372; X86-NEXT:    orl %eax, %ecx
373; X86-NEXT:    sete (%eax)
374; X86-NEXT:    retl
375;
376; X64-LABEL: ossfuzz34366:
377; X64:       # %bb.0:
378; X64-NEXT:    movq (%rax), %rax
379; X64-NEXT:    movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF
380; X64-NEXT:    andq %rax, %rcx
381; X64-NEXT:    orq %rax, %rcx
382; X64-NEXT:    orq %rax, %rcx
383; X64-NEXT:    orq %rax, %rcx
384; X64-NEXT:    sete (%rax)
385; X64-NEXT:    retq
386  %L10 = load i448, i448* undef, align 4
387  %B18 = urem i448 %L10, -363419362147803445274661903944002267176820680343659030140745099590319644056698961663095525356881782780381260803133088966767300814307328
388  %C13 = icmp ule i448 %B18, 0
389  store i1 %C13, i1* undef, align 1
390  ret void
391}
392