| blob | 2169b39b9dfa05428f48b3837abb48982e33d9fd |
1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
2 ; RUN: llc -disable-peephole -mtriple=x86_64-linux-unknown < %s | FileCheck %s --check-prefixes=CHECK,LINUX,SDAG
3 ; RUN: llc -disable-peephole -mtriple=x86_64-linux-unknown -fast-isel -fast-isel-abort=1 < %s | FileCheck %s --check-prefixes=CHECK,LINUX,FAST
4 ; RUN: llc -disable-peephole -mtriple=x86_64-linux-unknown -mcpu=knl < %s | FileCheck %s --check-prefixes=CHECK,LINUX,SDAG
5 ; RUN: llc -disable-peephole -mtriple=x86_64-pc-win32 < %s | FileCheck %s --check-prefixes=CHECK,WIN64
6 ; RUN: llc -disable-peephole -mtriple=i386-pc-win32 < %s | FileCheck %s --check-prefix=WIN32
8 define {i64, i1} @t1() nounwind {
9 ; CHECK-LABEL: t1:
10 ; CHECK: # %bb.0:
11 ; CHECK-NEXT: movl $72, %eax
12 ; CHECK-NEXT: xorl %edx, %edx
13 ; CHECK-NEXT: retq
14 ;
15 ; WIN32-LABEL: t1:
16 ; WIN32: # %bb.0:
17 ; WIN32-NEXT: movl $72, %eax
18 ; WIN32-NEXT: xorl %edx, %edx
19 ; WIN32-NEXT: xorl %ecx, %ecx
20 ; WIN32-NEXT: retl
21 %1 = call {i64, i1} @llvm.umul.with.overflow.i64(i64 9, i64 8)
22 ret {i64, i1} %1
23 }
25 define {i64, i1} @t2() nounwind {
26 ; CHECK-LABEL: t2:
27 ; CHECK: # %bb.0:
28 ; CHECK-NEXT: xorl %eax, %eax
29 ; CHECK-NEXT: xorl %edx, %edx
30 ; CHECK-NEXT: retq
31 ;
32 ; WIN32-LABEL: t2:
33 ; WIN32: # %bb.0:
34 ; WIN32-NEXT: xorl %eax, %eax
35 ; WIN32-NEXT: xorl %edx, %edx
36 ; WIN32-NEXT: xorl %ecx, %ecx
37 ; WIN32-NEXT: retl
38 %1 = call {i64, i1} @llvm.umul.with.overflow.i64(i64 9, i64 0)
39 ret {i64, i1} %1
40 }
42 define {i64, i1} @t3() nounwind {
43 ; CHECK-LABEL: t3:
44 ; CHECK: # %bb.0:
45 ; CHECK-NEXT: movq $-9, %rax
46 ; CHECK-NEXT: movb $1, %dl
47 ; CHECK-NEXT: retq
48 ;
49 ; WIN32-LABEL: t3:
50 ; WIN32: # %bb.0:
51 ; WIN32-NEXT: movl $-9, %eax
52 ; WIN32-NEXT: movl $-1, %edx
53 ; WIN32-NEXT: movb $1, %cl
54 ; WIN32-NEXT: retl
55 %1 = call {i64, i1} @llvm.umul.with.overflow.i64(i64 9, i64 -1)
56 ret {i64, i1} %1
57 }
59 ; SMULO
60 define zeroext i1 @smuloi8(i8 %v1, i8 %v2, ptr %res) {
61 ; SDAG-LABEL: smuloi8:
62 ; SDAG: # %bb.0:
63 ; SDAG-NEXT: movl %edi, %eax
64 ; SDAG-NEXT: # kill: def $al killed $al killed $eax
65 ; SDAG-NEXT: imulb %sil
66 ; SDAG-NEXT: seto %cl
67 ; SDAG-NEXT: movb %al, (%rdx)
68 ; SDAG-NEXT: movl %ecx, %eax
69 ; SDAG-NEXT: retq
70 ;
71 ; FAST-LABEL: smuloi8:
72 ; FAST: # %bb.0:
73 ; FAST-NEXT: movl %edi, %eax
74 ; FAST-NEXT: # kill: def $al killed $al killed $eax
75 ; FAST-NEXT: imulb %sil
76 ; FAST-NEXT: seto %cl
77 ; FAST-NEXT: movb %al, (%rdx)
78 ; FAST-NEXT: andb $1, %cl
79 ; FAST-NEXT: movl %ecx, %eax
80 ; FAST-NEXT: retq
81 ;
82 ; WIN64-LABEL: smuloi8:
83 ; WIN64: # %bb.0:
84 ; WIN64-NEXT: movl %ecx, %eax
85 ; WIN64-NEXT: imulb %dl
86 ; WIN64-NEXT: seto %cl
87 ; WIN64-NEXT: movb %al, (%r8)
88 ; WIN64-NEXT: movl %ecx, %eax
89 ; WIN64-NEXT: retq
90 ;
91 ; WIN32-LABEL: smuloi8:
92 ; WIN32: # %bb.0:
93 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edx
94 ; WIN32-NEXT: movzbl {{[0-9]+}}(%esp), %eax
95 ; WIN32-NEXT: imulb {{[0-9]+}}(%esp)
96 ; WIN32-NEXT: seto %cl
97 ; WIN32-NEXT: movb %al, (%edx)
98 ; WIN32-NEXT: movl %ecx, %eax
99 ; WIN32-NEXT: retl
100 %t = call {i8, i1} @llvm.smul.with.overflow.i8(i8 %v1, i8 %v2)
101 %val = extractvalue {i8, i1} %t, 0
102 %obit = extractvalue {i8, i1} %t, 1
103 store i8 %val, ptr %res
104 ret i1 %obit
105 }
107 define zeroext i1 @smuloi16(i16 %v1, i16 %v2, ptr %res) {
108 ; SDAG-LABEL: smuloi16:
109 ; SDAG: # %bb.0:
110 ; SDAG-NEXT: imulw %si, %di
111 ; SDAG-NEXT: seto %al
112 ; SDAG-NEXT: movw %di, (%rdx)
113 ; SDAG-NEXT: retq
114 ;
115 ; FAST-LABEL: smuloi16:
116 ; FAST: # %bb.0:
117 ; FAST-NEXT: imulw %si, %di
118 ; FAST-NEXT: seto %al
119 ; FAST-NEXT: movw %di, (%rdx)
120 ; FAST-NEXT: andb $1, %al
121 ; FAST-NEXT: retq
122 ;
123 ; WIN64-LABEL: smuloi16:
124 ; WIN64: # %bb.0:
125 ; WIN64-NEXT: imulw %dx, %cx
126 ; WIN64-NEXT: seto %al
127 ; WIN64-NEXT: movw %cx, (%r8)
128 ; WIN64-NEXT: retq
129 ;
130 ; WIN32-LABEL: smuloi16:
131 ; WIN32: # %bb.0:
132 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
133 ; WIN32-NEXT: movzwl {{[0-9]+}}(%esp), %edx
134 ; WIN32-NEXT: imulw {{[0-9]+}}(%esp), %dx
135 ; WIN32-NEXT: seto %al
136 ; WIN32-NEXT: movw %dx, (%ecx)
137 ; WIN32-NEXT: retl
138 %t = call {i16, i1} @llvm.smul.with.overflow.i16(i16 %v1, i16 %v2)
139 %val = extractvalue {i16, i1} %t, 0
140 %obit = extractvalue {i16, i1} %t, 1
141 store i16 %val, ptr %res
142 ret i1 %obit
143 }
145 define zeroext i1 @smuloi32(i32 %v1, i32 %v2, ptr %res) {
146 ; SDAG-LABEL: smuloi32:
147 ; SDAG: # %bb.0:
148 ; SDAG-NEXT: imull %esi, %edi
149 ; SDAG-NEXT: seto %al
150 ; SDAG-NEXT: movl %edi, (%rdx)
151 ; SDAG-NEXT: retq
152 ;
153 ; FAST-LABEL: smuloi32:
154 ; FAST: # %bb.0:
155 ; FAST-NEXT: imull %esi, %edi
156 ; FAST-NEXT: seto %al
157 ; FAST-NEXT: movl %edi, (%rdx)
158 ; FAST-NEXT: andb $1, %al
159 ; FAST-NEXT: retq
160 ;
161 ; WIN64-LABEL: smuloi32:
162 ; WIN64: # %bb.0:
163 ; WIN64-NEXT: imull %edx, %ecx
164 ; WIN64-NEXT: seto %al
165 ; WIN64-NEXT: movl %ecx, (%r8)
166 ; WIN64-NEXT: retq
167 ;
168 ; WIN32-LABEL: smuloi32:
169 ; WIN32: # %bb.0:
170 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
171 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edx
172 ; WIN32-NEXT: imull {{[0-9]+}}(%esp), %edx
173 ; WIN32-NEXT: seto %al
174 ; WIN32-NEXT: movl %edx, (%ecx)
175 ; WIN32-NEXT: retl
176 %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
177 %val = extractvalue {i32, i1} %t, 0
178 %obit = extractvalue {i32, i1} %t, 1
179 store i32 %val, ptr %res
180 ret i1 %obit
181 }
183 define zeroext i1 @smuloi64(i64 %v1, i64 %v2, ptr %res) {
184 ; SDAG-LABEL: smuloi64:
185 ; SDAG: # %bb.0:
186 ; SDAG-NEXT: imulq %rsi, %rdi
187 ; SDAG-NEXT: seto %al
188 ; SDAG-NEXT: movq %rdi, (%rdx)
189 ; SDAG-NEXT: retq
190 ;
191 ; FAST-LABEL: smuloi64:
192 ; FAST: # %bb.0:
193 ; FAST-NEXT: imulq %rsi, %rdi
194 ; FAST-NEXT: seto %al
195 ; FAST-NEXT: movq %rdi, (%rdx)
196 ; FAST-NEXT: andb $1, %al
197 ; FAST-NEXT: retq
198 ;
199 ; WIN64-LABEL: smuloi64:
200 ; WIN64: # %bb.0:
201 ; WIN64-NEXT: imulq %rdx, %rcx
202 ; WIN64-NEXT: seto %al
203 ; WIN64-NEXT: movq %rcx, (%r8)
204 ; WIN64-NEXT: retq
205 ;
206 ; WIN32-LABEL: smuloi64:
207 ; WIN32: # %bb.0:
208 ; WIN32-NEXT: pushl %ebp
209 ; WIN32-NEXT: pushl %ebx
210 ; WIN32-NEXT: pushl %edi
211 ; WIN32-NEXT: pushl %esi
212 ; WIN32-NEXT: subl $8, %esp
213 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
214 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edi
215 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edx
216 ; WIN32-NEXT: movl %edx, %ecx
217 ; WIN32-NEXT: movl %edx, %ebx
218 ; WIN32-NEXT: sarl $31, %ecx
219 ; WIN32-NEXT: movl %edi, %esi
220 ; WIN32-NEXT: imull %ecx, %esi
221 ; WIN32-NEXT: mull %ecx
222 ; WIN32-NEXT: movl %edx, %ecx
223 ; WIN32-NEXT: movl %eax, %ebp
224 ; WIN32-NEXT: addl %eax, %ecx
225 ; WIN32-NEXT: addl %esi, %ecx
226 ; WIN32-NEXT: movl %edi, %eax
227 ; WIN32-NEXT: sarl $31, %eax
228 ; WIN32-NEXT: movl %eax, %edi
229 ; WIN32-NEXT: imull %ebx, %edi
230 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ebx
231 ; WIN32-NEXT: mull %ebx
232 ; WIN32-NEXT: movl %edx, %esi
233 ; WIN32-NEXT: addl %edi, %esi
234 ; WIN32-NEXT: addl %eax, %esi
235 ; WIN32-NEXT: addl %ebp, %eax
236 ; WIN32-NEXT: movl %eax, (%esp) # 4-byte Spill
237 ; WIN32-NEXT: adcl %ecx, %esi
238 ; WIN32-NEXT: movl %ebx, %eax
239 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
240 ; WIN32-NEXT: mull %ecx
241 ; WIN32-NEXT: movl %edx, %ebp
242 ; WIN32-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
243 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
244 ; WIN32-NEXT: mull %ecx
245 ; WIN32-NEXT: movl %edx, %edi
246 ; WIN32-NEXT: movl %eax, %ecx
247 ; WIN32-NEXT: addl %ebp, %ecx
248 ; WIN32-NEXT: adcl $0, %edi
249 ; WIN32-NEXT: movl %ebx, %eax
250 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
251 ; WIN32-NEXT: movl %edx, %ebx
252 ; WIN32-NEXT: movl %eax, %ebp
253 ; WIN32-NEXT: addl %ecx, %ebp
254 ; WIN32-NEXT: adcl %edi, %ebx
255 ; WIN32-NEXT: setb %cl
256 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
257 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
258 ; WIN32-NEXT: addl %ebx, %eax
259 ; WIN32-NEXT: movzbl %cl, %ecx
260 ; WIN32-NEXT: adcl %ecx, %edx
261 ; WIN32-NEXT: addl (%esp), %eax # 4-byte Folded Reload
262 ; WIN32-NEXT: adcl %esi, %edx
263 ; WIN32-NEXT: movl %ebp, %ecx
264 ; WIN32-NEXT: sarl $31, %ecx
265 ; WIN32-NEXT: xorl %ecx, %edx
266 ; WIN32-NEXT: xorl %eax, %ecx
267 ; WIN32-NEXT: orl %edx, %ecx
268 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
269 ; WIN32-NEXT: movl %ebp, 4(%eax)
270 ; WIN32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 4-byte Reload
271 ; WIN32-NEXT: movl %ecx, (%eax)
272 ; WIN32-NEXT: setne %al
273 ; WIN32-NEXT: addl $8, %esp
274 ; WIN32-NEXT: popl %esi
275 ; WIN32-NEXT: popl %edi
276 ; WIN32-NEXT: popl %ebx
277 ; WIN32-NEXT: popl %ebp
278 ; WIN32-NEXT: retl
279 %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
280 %val = extractvalue {i64, i1} %t, 0
281 %obit = extractvalue {i64, i1} %t, 1
282 store i64 %val, ptr %res
283 ret i1 %obit
284 }
286 ; UMULO
287 define zeroext i1 @umuloi8(i8 %v1, i8 %v2, ptr %res) {
288 ; SDAG-LABEL: umuloi8:
289 ; SDAG: # %bb.0:
290 ; SDAG-NEXT: movl %edi, %eax
291 ; SDAG-NEXT: # kill: def $al killed $al killed $eax
292 ; SDAG-NEXT: mulb %sil
293 ; SDAG-NEXT: seto %cl
294 ; SDAG-NEXT: movb %al, (%rdx)
295 ; SDAG-NEXT: movl %ecx, %eax
296 ; SDAG-NEXT: retq
297 ;
298 ; FAST-LABEL: umuloi8:
299 ; FAST: # %bb.0:
300 ; FAST-NEXT: movl %edi, %eax
301 ; FAST-NEXT: # kill: def $al killed $al killed $eax
302 ; FAST-NEXT: mulb %sil
303 ; FAST-NEXT: seto %cl
304 ; FAST-NEXT: movb %al, (%rdx)
305 ; FAST-NEXT: andb $1, %cl
306 ; FAST-NEXT: movl %ecx, %eax
307 ; FAST-NEXT: retq
308 ;
309 ; WIN64-LABEL: umuloi8:
310 ; WIN64: # %bb.0:
311 ; WIN64-NEXT: movl %ecx, %eax
312 ; WIN64-NEXT: mulb %dl
313 ; WIN64-NEXT: seto %cl
314 ; WIN64-NEXT: movb %al, (%r8)
315 ; WIN64-NEXT: movl %ecx, %eax
316 ; WIN64-NEXT: retq
317 ;
318 ; WIN32-LABEL: umuloi8:
319 ; WIN32: # %bb.0:
320 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edx
321 ; WIN32-NEXT: movzbl {{[0-9]+}}(%esp), %eax
322 ; WIN32-NEXT: mulb {{[0-9]+}}(%esp)
323 ; WIN32-NEXT: seto %cl
324 ; WIN32-NEXT: movb %al, (%edx)
325 ; WIN32-NEXT: movl %ecx, %eax
326 ; WIN32-NEXT: retl
327 %t = call {i8, i1} @llvm.umul.with.overflow.i8(i8 %v1, i8 %v2)
328 %val = extractvalue {i8, i1} %t, 0
329 %obit = extractvalue {i8, i1} %t, 1
330 store i8 %val, ptr %res
331 ret i1 %obit
332 }
334 define zeroext i1 @umuloi16(i16 %v1, i16 %v2, ptr %res) {
335 ; SDAG-LABEL: umuloi16:
336 ; SDAG: # %bb.0:
337 ; SDAG-NEXT: movq %rdx, %rcx
338 ; SDAG-NEXT: movl %edi, %eax
339 ; SDAG-NEXT: # kill: def $ax killed $ax killed $eax
340 ; SDAG-NEXT: mulw %si
341 ; SDAG-NEXT: seto %dl
342 ; SDAG-NEXT: movw %ax, (%rcx)
343 ; SDAG-NEXT: movl %edx, %eax
344 ; SDAG-NEXT: retq
345 ;
346 ; FAST-LABEL: umuloi16:
347 ; FAST: # %bb.0:
348 ; FAST-NEXT: movq %rdx, %rcx
349 ; FAST-NEXT: movl %edi, %eax
350 ; FAST-NEXT: # kill: def $ax killed $ax killed $eax
351 ; FAST-NEXT: mulw %si
352 ; FAST-NEXT: seto %dl
353 ; FAST-NEXT: movw %ax, (%rcx)
354 ; FAST-NEXT: andb $1, %dl
355 ; FAST-NEXT: movl %edx, %eax
356 ; FAST-NEXT: retq
357 ;
358 ; WIN64-LABEL: umuloi16:
359 ; WIN64: # %bb.0:
360 ; WIN64-NEXT: movl %ecx, %eax
361 ; WIN64-NEXT: mulw %dx
362 ; WIN64-NEXT: seto %cl
363 ; WIN64-NEXT: movw %ax, (%r8)
364 ; WIN64-NEXT: movl %ecx, %eax
365 ; WIN64-NEXT: retq
366 ;
367 ; WIN32-LABEL: umuloi16:
368 ; WIN32: # %bb.0:
369 ; WIN32-NEXT: pushl %esi
370 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
371 ; WIN32-NEXT: movzwl {{[0-9]+}}(%esp), %eax
372 ; WIN32-NEXT: mulw {{[0-9]+}}(%esp)
373 ; WIN32-NEXT: seto %cl
374 ; WIN32-NEXT: movw %ax, (%esi)
375 ; WIN32-NEXT: movl %ecx, %eax
376 ; WIN32-NEXT: popl %esi
377 ; WIN32-NEXT: retl
378 %t = call {i16, i1} @llvm.umul.with.overflow.i16(i16 %v1, i16 %v2)
379 %val = extractvalue {i16, i1} %t, 0
380 %obit = extractvalue {i16, i1} %t, 1
381 store i16 %val, ptr %res
382 ret i1 %obit
383 }
385 define zeroext i1 @umuloi32(i32 %v1, i32 %v2, ptr %res) {
386 ; SDAG-LABEL: umuloi32:
387 ; SDAG: # %bb.0:
388 ; SDAG-NEXT: movq %rdx, %rcx
389 ; SDAG-NEXT: movl %edi, %eax
390 ; SDAG-NEXT: mull %esi
391 ; SDAG-NEXT: seto %dl
392 ; SDAG-NEXT: movl %eax, (%rcx)
393 ; SDAG-NEXT: movl %edx, %eax
394 ; SDAG-NEXT: retq
395 ;
396 ; FAST-LABEL: umuloi32:
397 ; FAST: # %bb.0:
398 ; FAST-NEXT: movq %rdx, %rcx
399 ; FAST-NEXT: movl %edi, %eax
400 ; FAST-NEXT: mull %esi
401 ; FAST-NEXT: seto %dl
402 ; FAST-NEXT: movl %eax, (%rcx)
403 ; FAST-NEXT: andb $1, %dl
404 ; FAST-NEXT: movl %edx, %eax
405 ; FAST-NEXT: retq
406 ;
407 ; WIN64-LABEL: umuloi32:
408 ; WIN64: # %bb.0:
409 ; WIN64-NEXT: movl %ecx, %eax
410 ; WIN64-NEXT: mull %edx
411 ; WIN64-NEXT: seto %cl
412 ; WIN64-NEXT: movl %eax, (%r8)
413 ; WIN64-NEXT: movl %ecx, %eax
414 ; WIN64-NEXT: retq
415 ;
416 ; WIN32-LABEL: umuloi32:
417 ; WIN32: # %bb.0:
418 ; WIN32-NEXT: pushl %esi
419 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
420 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
421 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
422 ; WIN32-NEXT: seto %cl
423 ; WIN32-NEXT: movl %eax, (%esi)
424 ; WIN32-NEXT: movl %ecx, %eax
425 ; WIN32-NEXT: popl %esi
426 ; WIN32-NEXT: retl
427 %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
428 %val = extractvalue {i32, i1} %t, 0
429 %obit = extractvalue {i32, i1} %t, 1
430 store i32 %val, ptr %res
431 ret i1 %obit
432 }
434 define zeroext i1 @umuloi64(i64 %v1, i64 %v2, ptr %res) {
435 ; SDAG-LABEL: umuloi64:
436 ; SDAG: # %bb.0:
437 ; SDAG-NEXT: movq %rdx, %rcx
438 ; SDAG-NEXT: movq %rdi, %rax
439 ; SDAG-NEXT: mulq %rsi
440 ; SDAG-NEXT: seto %dl
441 ; SDAG-NEXT: movq %rax, (%rcx)
442 ; SDAG-NEXT: movl %edx, %eax
443 ; SDAG-NEXT: retq
444 ;
445 ; FAST-LABEL: umuloi64:
446 ; FAST: # %bb.0:
447 ; FAST-NEXT: movq %rdx, %rcx
448 ; FAST-NEXT: movq %rdi, %rax
449 ; FAST-NEXT: mulq %rsi
450 ; FAST-NEXT: seto %dl
451 ; FAST-NEXT: movq %rax, (%rcx)
452 ; FAST-NEXT: andb $1, %dl
453 ; FAST-NEXT: movl %edx, %eax
454 ; FAST-NEXT: retq
455 ;
456 ; WIN64-LABEL: umuloi64:
457 ; WIN64: # %bb.0:
458 ; WIN64-NEXT: movq %rcx, %rax
459 ; WIN64-NEXT: mulq %rdx
460 ; WIN64-NEXT: seto %cl
461 ; WIN64-NEXT: movq %rax, (%r8)
462 ; WIN64-NEXT: movl %ecx, %eax
463 ; WIN64-NEXT: retq
464 ;
465 ; WIN32-LABEL: umuloi64:
466 ; WIN32: # %bb.0:
467 ; WIN32-NEXT: pushl %ebp
468 ; WIN32-NEXT: pushl %ebx
469 ; WIN32-NEXT: pushl %edi
470 ; WIN32-NEXT: pushl %esi
471 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ebp
472 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
473 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
474 ; WIN32-NEXT: testl %esi, %esi
475 ; WIN32-NEXT: setne %dl
476 ; WIN32-NEXT: testl %eax, %eax
477 ; WIN32-NEXT: setne %cl
478 ; WIN32-NEXT: andb %dl, %cl
479 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
480 ; WIN32-NEXT: movl %eax, %edi
481 ; WIN32-NEXT: seto %bl
482 ; WIN32-NEXT: movl %esi, %eax
483 ; WIN32-NEXT: mull %ebp
484 ; WIN32-NEXT: seto %ch
485 ; WIN32-NEXT: orb %bl, %ch
486 ; WIN32-NEXT: orb %cl, %ch
487 ; WIN32-NEXT: leal (%edi,%eax), %esi
488 ; WIN32-NEXT: movl %ebp, %eax
489 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
490 ; WIN32-NEXT: addl %esi, %edx
491 ; WIN32-NEXT: setb %cl
492 ; WIN32-NEXT: orb %ch, %cl
493 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
494 ; WIN32-NEXT: movl %eax, (%esi)
495 ; WIN32-NEXT: movl %edx, 4(%esi)
496 ; WIN32-NEXT: movl %ecx, %eax
497 ; WIN32-NEXT: popl %esi
498 ; WIN32-NEXT: popl %edi
499 ; WIN32-NEXT: popl %ebx
500 ; WIN32-NEXT: popl %ebp
501 ; WIN32-NEXT: retl
502 %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
503 %val = extractvalue {i64, i1} %t, 0
504 %obit = extractvalue {i64, i1} %t, 1
505 store i64 %val, ptr %res
506 ret i1 %obit
507 }
509 ;
510 ; Check the use of the overflow bit in combination with a select instruction.
511 ;
512 define i32 @smuloselecti32(i32 %v1, i32 %v2) {
513 ; LINUX-LABEL: smuloselecti32:
514 ; LINUX: # %bb.0:
515 ; LINUX-NEXT: movl %esi, %eax
516 ; LINUX-NEXT: movl %edi, %ecx
517 ; LINUX-NEXT: imull %esi, %ecx
518 ; LINUX-NEXT: cmovol %edi, %eax
519 ; LINUX-NEXT: retq
520 ;
521 ; WIN64-LABEL: smuloselecti32:
522 ; WIN64: # %bb.0:
523 ; WIN64-NEXT: movl %edx, %eax
524 ; WIN64-NEXT: movl %ecx, %edx
525 ; WIN64-NEXT: imull %eax, %edx
526 ; WIN64-NEXT: cmovol %ecx, %eax
527 ; WIN64-NEXT: retq
528 ;
529 ; WIN32-LABEL: smuloselecti32:
530 ; WIN32: # %bb.0:
531 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
532 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
533 ; WIN32-NEXT: movl %eax, %edx
534 ; WIN32-NEXT: imull %ecx, %edx
535 ; WIN32-NEXT: jo LBB11_2
536 ; WIN32-NEXT: # %bb.1:
537 ; WIN32-NEXT: movl %ecx, %eax
538 ; WIN32-NEXT: LBB11_2:
539 ; WIN32-NEXT: retl
540 %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
541 %obit = extractvalue {i32, i1} %t, 1
542 %ret = select i1 %obit, i32 %v1, i32 %v2
543 ret i32 %ret
544 }
546 define i64 @smuloselecti64(i64 %v1, i64 %v2) {
547 ; LINUX-LABEL: smuloselecti64:
548 ; LINUX: # %bb.0:
549 ; LINUX-NEXT: movq %rsi, %rax
550 ; LINUX-NEXT: movq %rdi, %rcx
551 ; LINUX-NEXT: imulq %rsi, %rcx
552 ; LINUX-NEXT: cmovoq %rdi, %rax
553 ; LINUX-NEXT: retq
554 ;
555 ; WIN64-LABEL: smuloselecti64:
556 ; WIN64: # %bb.0:
557 ; WIN64-NEXT: movq %rdx, %rax
558 ; WIN64-NEXT: movq %rcx, %rdx
559 ; WIN64-NEXT: imulq %rax, %rdx
560 ; WIN64-NEXT: cmovoq %rcx, %rax
561 ; WIN64-NEXT: retq
562 ;
563 ; WIN32-LABEL: smuloselecti64:
564 ; WIN32: # %bb.0:
565 ; WIN32-NEXT: pushl %ebp
566 ; WIN32-NEXT: pushl %ebx
567 ; WIN32-NEXT: pushl %edi
568 ; WIN32-NEXT: pushl %esi
569 ; WIN32-NEXT: pushl %eax
570 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ebp
571 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
572 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
573 ; WIN32-NEXT: sarl $31, %ecx
574 ; WIN32-NEXT: movl %eax, %edi
575 ; WIN32-NEXT: movl %eax, %ebx
576 ; WIN32-NEXT: imull %ecx, %edi
577 ; WIN32-NEXT: movl %ebp, %eax
578 ; WIN32-NEXT: mull %ecx
579 ; WIN32-NEXT: movl %edx, %esi
580 ; WIN32-NEXT: movl %eax, %ecx
581 ; WIN32-NEXT: addl %eax, %esi
582 ; WIN32-NEXT: addl %edi, %esi
583 ; WIN32-NEXT: movl %ebx, %eax
584 ; WIN32-NEXT: sarl $31, %eax
585 ; WIN32-NEXT: movl %eax, %edi
586 ; WIN32-NEXT: imull {{[0-9]+}}(%esp), %edi
587 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
588 ; WIN32-NEXT: movl %edx, %ebx
589 ; WIN32-NEXT: addl %edi, %ebx
590 ; WIN32-NEXT: addl %eax, %ebx
591 ; WIN32-NEXT: addl %ecx, %eax
592 ; WIN32-NEXT: movl %eax, (%esp) # 4-byte Spill
593 ; WIN32-NEXT: adcl %esi, %ebx
594 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edi
595 ; WIN32-NEXT: movl %edi, %eax
596 ; WIN32-NEXT: mull %ebp
597 ; WIN32-NEXT: movl %edx, %esi
598 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
599 ; WIN32-NEXT: mull %ebp
600 ; WIN32-NEXT: movl %edx, %ebp
601 ; WIN32-NEXT: movl %eax, %ecx
602 ; WIN32-NEXT: addl %esi, %ecx
603 ; WIN32-NEXT: adcl $0, %ebp
604 ; WIN32-NEXT: movl %edi, %eax
605 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
606 ; WIN32-NEXT: movl %edx, %edi
607 ; WIN32-NEXT: movl %eax, %esi
608 ; WIN32-NEXT: addl %ecx, %esi
609 ; WIN32-NEXT: adcl %ebp, %edi
610 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ebp
611 ; WIN32-NEXT: setb %cl
612 ; WIN32-NEXT: movl %ebp, %eax
613 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
614 ; WIN32-NEXT: addl %edi, %eax
615 ; WIN32-NEXT: movzbl %cl, %ecx
616 ; WIN32-NEXT: adcl %ecx, %edx
617 ; WIN32-NEXT: addl (%esp), %eax # 4-byte Folded Reload
618 ; WIN32-NEXT: adcl %ebx, %edx
619 ; WIN32-NEXT: sarl $31, %esi
620 ; WIN32-NEXT: xorl %esi, %edx
621 ; WIN32-NEXT: xorl %eax, %esi
622 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
623 ; WIN32-NEXT: orl %edx, %esi
624 ; WIN32-NEXT: jne LBB12_2
625 ; WIN32-NEXT: # %bb.1:
626 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
627 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ebp
628 ; WIN32-NEXT: LBB12_2:
629 ; WIN32-NEXT: movl %ebp, %edx
630 ; WIN32-NEXT: addl $4, %esp
631 ; WIN32-NEXT: popl %esi
632 ; WIN32-NEXT: popl %edi
633 ; WIN32-NEXT: popl %ebx
634 ; WIN32-NEXT: popl %ebp
635 ; WIN32-NEXT: retl
636 %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
637 %obit = extractvalue {i64, i1} %t, 1
638 %ret = select i1 %obit, i64 %v1, i64 %v2
639 ret i64 %ret
640 }
642 define i32 @umuloselecti32(i32 %v1, i32 %v2) {
643 ; LINUX-LABEL: umuloselecti32:
644 ; LINUX: # %bb.0:
645 ; LINUX-NEXT: movl %edi, %eax
646 ; LINUX-NEXT: mull %esi
647 ; LINUX-NEXT: cmovol %edi, %esi
648 ; LINUX-NEXT: movl %esi, %eax
649 ; LINUX-NEXT: retq
650 ;
651 ; WIN64-LABEL: umuloselecti32:
652 ; WIN64: # %bb.0:
653 ; WIN64-NEXT: movl %edx, %r8d
654 ; WIN64-NEXT: movl %ecx, %eax
655 ; WIN64-NEXT: mull %edx
656 ; WIN64-NEXT: cmovol %ecx, %r8d
657 ; WIN64-NEXT: movl %r8d, %eax
658 ; WIN64-NEXT: retq
659 ;
660 ; WIN32-LABEL: umuloselecti32:
661 ; WIN32: # %bb.0:
662 ; WIN32-NEXT: pushl %esi
663 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
664 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
665 ; WIN32-NEXT: movl %ecx, %eax
666 ; WIN32-NEXT: mull %esi
667 ; WIN32-NEXT: jo LBB13_2
668 ; WIN32-NEXT: # %bb.1:
669 ; WIN32-NEXT: movl %esi, %ecx
670 ; WIN32-NEXT: LBB13_2:
671 ; WIN32-NEXT: movl %ecx, %eax
672 ; WIN32-NEXT: popl %esi
673 ; WIN32-NEXT: retl
674 %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
675 %obit = extractvalue {i32, i1} %t, 1
676 %ret = select i1 %obit, i32 %v1, i32 %v2
677 ret i32 %ret
678 }
680 define i64 @umuloselecti64(i64 %v1, i64 %v2) {
681 ; LINUX-LABEL: umuloselecti64:
682 ; LINUX: # %bb.0:
683 ; LINUX-NEXT: movq %rdi, %rax
684 ; LINUX-NEXT: mulq %rsi
685 ; LINUX-NEXT: cmovoq %rdi, %rsi
686 ; LINUX-NEXT: movq %rsi, %rax
687 ; LINUX-NEXT: retq
688 ;
689 ; WIN64-LABEL: umuloselecti64:
690 ; WIN64: # %bb.0:
691 ; WIN64-NEXT: movq %rdx, %r8
692 ; WIN64-NEXT: movq %rcx, %rax
693 ; WIN64-NEXT: mulq %rdx
694 ; WIN64-NEXT: cmovoq %rcx, %r8
695 ; WIN64-NEXT: movq %r8, %rax
696 ; WIN64-NEXT: retq
697 ;
698 ; WIN32-LABEL: umuloselecti64:
699 ; WIN32: # %bb.0:
700 ; WIN32-NEXT: pushl %ebp
701 ; WIN32-NEXT: pushl %ebx
702 ; WIN32-NEXT: pushl %edi
703 ; WIN32-NEXT: pushl %esi
704 ; WIN32-NEXT: pushl %eax
705 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
706 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
707 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edi
708 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ebp
709 ; WIN32-NEXT: testl %ebp, %ebp
710 ; WIN32-NEXT: setne %al
711 ; WIN32-NEXT: testl %esi, %esi
712 ; WIN32-NEXT: setne %bl
713 ; WIN32-NEXT: andb %al, %bl
714 ; WIN32-NEXT: movl %esi, %eax
715 ; WIN32-NEXT: mull %edi
716 ; WIN32-NEXT: movl %edi, %edx
717 ; WIN32-NEXT: movl %eax, %edi
718 ; WIN32-NEXT: seto {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
719 ; WIN32-NEXT: movl %ebp, %eax
720 ; WIN32-NEXT: movl %edx, %ebp
721 ; WIN32-NEXT: mull %ecx
722 ; WIN32-NEXT: seto %bh
723 ; WIN32-NEXT: orb {{[-0-9]+}}(%e{{[sb]}}p), %bh # 1-byte Folded Reload
724 ; WIN32-NEXT: orb %bl, %bh
725 ; WIN32-NEXT: addl %eax, %edi
726 ; WIN32-NEXT: movl %ecx, %eax
727 ; WIN32-NEXT: mull %ebp
728 ; WIN32-NEXT: addl %edi, %edx
729 ; WIN32-NEXT: setb %al
730 ; WIN32-NEXT: orb %bh, %al
731 ; WIN32-NEXT: testb %al, %al
732 ; WIN32-NEXT: jne LBB14_2
733 ; WIN32-NEXT: # %bb.1:
734 ; WIN32-NEXT: movl %ebp, %ecx
735 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
736 ; WIN32-NEXT: LBB14_2:
737 ; WIN32-NEXT: movl %ecx, %eax
738 ; WIN32-NEXT: movl %esi, %edx
739 ; WIN32-NEXT: addl $4, %esp
740 ; WIN32-NEXT: popl %esi
741 ; WIN32-NEXT: popl %edi
742 ; WIN32-NEXT: popl %ebx
743 ; WIN32-NEXT: popl %ebp
744 ; WIN32-NEXT: retl
745 %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
746 %obit = extractvalue {i64, i1} %t, 1
747 %ret = select i1 %obit, i64 %v1, i64 %v2
748 ret i64 %ret
749 }
751 ;
752 ; Check the use of the overflow bit in combination with a branch instruction.
753 ;
754 define zeroext i1 @smulobri8(i8 %v1, i8 %v2) {
755 ; SDAG-LABEL: smulobri8:
756 ; SDAG: # %bb.0:
757 ; SDAG-NEXT: movl %edi, %eax
758 ; SDAG-NEXT: # kill: def $al killed $al killed $eax
759 ; SDAG-NEXT: imulb %sil
760 ; SDAG-NEXT: jo .LBB15_1
761 ; SDAG-NEXT: # %bb.2: # %continue
762 ; SDAG-NEXT: movb $1, %al
763 ; SDAG-NEXT: retq
764 ; SDAG-NEXT: .LBB15_1: # %overflow
765 ; SDAG-NEXT: xorl %eax, %eax
766 ; SDAG-NEXT: retq
767 ;
768 ; FAST-LABEL: smulobri8:
769 ; FAST: # %bb.0:
770 ; FAST-NEXT: movl %edi, %eax
771 ; FAST-NEXT: # kill: def $al killed $al killed $eax
772 ; FAST-NEXT: imulb %sil
773 ; FAST-NEXT: seto %al
774 ; FAST-NEXT: testb $1, %al
775 ; FAST-NEXT: jne .LBB15_1
776 ; FAST-NEXT: # %bb.2: # %continue
777 ; FAST-NEXT: movb $1, %al
778 ; FAST-NEXT: andb $1, %al
779 ; FAST-NEXT: retq
780 ; FAST-NEXT: .LBB15_1: # %overflow
781 ; FAST-NEXT: xorl %eax, %eax
782 ; FAST-NEXT: andb $1, %al
783 ; FAST-NEXT: # kill: def $al killed $al killed $eax
784 ; FAST-NEXT: retq
785 ;
786 ; WIN64-LABEL: smulobri8:
787 ; WIN64: # %bb.0:
788 ; WIN64-NEXT: movl %ecx, %eax
789 ; WIN64-NEXT: imulb %dl
790 ; WIN64-NEXT: jo .LBB15_1
791 ; WIN64-NEXT: # %bb.2: # %continue
792 ; WIN64-NEXT: movb $1, %al
793 ; WIN64-NEXT: retq
794 ; WIN64-NEXT: .LBB15_1: # %overflow
795 ; WIN64-NEXT: xorl %eax, %eax
796 ; WIN64-NEXT: retq
797 ;
798 ; WIN32-LABEL: smulobri8:
799 ; WIN32: # %bb.0:
800 ; WIN32-NEXT: movzbl {{[0-9]+}}(%esp), %eax
801 ; WIN32-NEXT: imulb {{[0-9]+}}(%esp)
802 ; WIN32-NEXT: jo LBB15_1
803 ; WIN32-NEXT: # %bb.2: # %continue
804 ; WIN32-NEXT: movb $1, %al
805 ; WIN32-NEXT: retl
806 ; WIN32-NEXT: LBB15_1: # %overflow
807 ; WIN32-NEXT: xorl %eax, %eax
808 ; WIN32-NEXT: retl
809 %t = call {i8, i1} @llvm.smul.with.overflow.i8(i8 %v1, i8 %v2)
810 %val = extractvalue {i8, i1} %t, 0
811 %obit = extractvalue {i8, i1} %t, 1
812 br i1 %obit, label %overflow, label %continue, !prof !0
814 overflow:
815 ret i1 false
817 continue:
818 ret i1 true
819 }
821 define zeroext i1 @smulobri16(i16 %v1, i16 %v2) {
822 ; SDAG-LABEL: smulobri16:
823 ; SDAG: # %bb.0:
824 ; SDAG-NEXT: imulw %si, %di
825 ; SDAG-NEXT: jo .LBB16_1
826 ; SDAG-NEXT: # %bb.2: # %continue
827 ; SDAG-NEXT: movb $1, %al
828 ; SDAG-NEXT: retq
829 ; SDAG-NEXT: .LBB16_1: # %overflow
830 ; SDAG-NEXT: xorl %eax, %eax
831 ; SDAG-NEXT: retq
832 ;
833 ; FAST-LABEL: smulobri16:
834 ; FAST: # %bb.0:
835 ; FAST-NEXT: imulw %si, %di
836 ; FAST-NEXT: seto %al
837 ; FAST-NEXT: testb $1, %al
838 ; FAST-NEXT: jne .LBB16_1
839 ; FAST-NEXT: # %bb.2: # %continue
840 ; FAST-NEXT: movb $1, %al
841 ; FAST-NEXT: andb $1, %al
842 ; FAST-NEXT: retq
843 ; FAST-NEXT: .LBB16_1: # %overflow
844 ; FAST-NEXT: xorl %eax, %eax
845 ; FAST-NEXT: andb $1, %al
846 ; FAST-NEXT: # kill: def $al killed $al killed $eax
847 ; FAST-NEXT: retq
848 ;
849 ; WIN64-LABEL: smulobri16:
850 ; WIN64: # %bb.0:
851 ; WIN64-NEXT: imulw %dx, %cx
852 ; WIN64-NEXT: jo .LBB16_1
853 ; WIN64-NEXT: # %bb.2: # %continue
854 ; WIN64-NEXT: movb $1, %al
855 ; WIN64-NEXT: retq
856 ; WIN64-NEXT: .LBB16_1: # %overflow
857 ; WIN64-NEXT: xorl %eax, %eax
858 ; WIN64-NEXT: retq
859 ;
860 ; WIN32-LABEL: smulobri16:
861 ; WIN32: # %bb.0:
862 ; WIN32-NEXT: movzwl {{[0-9]+}}(%esp), %eax
863 ; WIN32-NEXT: imulw {{[0-9]+}}(%esp), %ax
864 ; WIN32-NEXT: jo LBB16_1
865 ; WIN32-NEXT: # %bb.2: # %continue
866 ; WIN32-NEXT: movb $1, %al
867 ; WIN32-NEXT: retl
868 ; WIN32-NEXT: LBB16_1: # %overflow
869 ; WIN32-NEXT: xorl %eax, %eax
870 ; WIN32-NEXT: retl
871 %t = call {i16, i1} @llvm.smul.with.overflow.i16(i16 %v1, i16 %v2)
872 %val = extractvalue {i16, i1} %t, 0
873 %obit = extractvalue {i16, i1} %t, 1
874 br i1 %obit, label %overflow, label %continue, !prof !0
876 overflow:
877 ret i1 false
879 continue:
880 ret i1 true
881 }
883 define zeroext i1 @smulobri32(i32 %v1, i32 %v2) {
884 ; SDAG-LABEL: smulobri32:
885 ; SDAG: # %bb.0:
886 ; SDAG-NEXT: imull %esi, %edi
887 ; SDAG-NEXT: jo .LBB17_1
888 ; SDAG-NEXT: # %bb.2: # %continue
889 ; SDAG-NEXT: movb $1, %al
890 ; SDAG-NEXT: retq
891 ; SDAG-NEXT: .LBB17_1: # %overflow
892 ; SDAG-NEXT: xorl %eax, %eax
893 ; SDAG-NEXT: retq
894 ;
895 ; FAST-LABEL: smulobri32:
896 ; FAST: # %bb.0:
897 ; FAST-NEXT: imull %esi, %edi
898 ; FAST-NEXT: jo .LBB17_1
899 ; FAST-NEXT: # %bb.2: # %continue
900 ; FAST-NEXT: movb $1, %al
901 ; FAST-NEXT: andb $1, %al
902 ; FAST-NEXT: retq
903 ; FAST-NEXT: .LBB17_1: # %overflow
904 ; FAST-NEXT: xorl %eax, %eax
905 ; FAST-NEXT: andb $1, %al
906 ; FAST-NEXT: # kill: def $al killed $al killed $eax
907 ; FAST-NEXT: retq
908 ;
909 ; WIN64-LABEL: smulobri32:
910 ; WIN64: # %bb.0:
911 ; WIN64-NEXT: imull %edx, %ecx
912 ; WIN64-NEXT: jo .LBB17_1
913 ; WIN64-NEXT: # %bb.2: # %continue
914 ; WIN64-NEXT: movb $1, %al
915 ; WIN64-NEXT: retq
916 ; WIN64-NEXT: .LBB17_1: # %overflow
917 ; WIN64-NEXT: xorl %eax, %eax
918 ; WIN64-NEXT: retq
919 ;
920 ; WIN32-LABEL: smulobri32:
921 ; WIN32: # %bb.0:
922 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
923 ; WIN32-NEXT: imull {{[0-9]+}}(%esp), %eax
924 ; WIN32-NEXT: jo LBB17_1
925 ; WIN32-NEXT: # %bb.2: # %continue
926 ; WIN32-NEXT: movb $1, %al
927 ; WIN32-NEXT: retl
928 ; WIN32-NEXT: LBB17_1: # %overflow
929 ; WIN32-NEXT: xorl %eax, %eax
930 ; WIN32-NEXT: retl
931 %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
932 %val = extractvalue {i32, i1} %t, 0
933 %obit = extractvalue {i32, i1} %t, 1
934 br i1 %obit, label %overflow, label %continue, !prof !0
936 overflow:
937 ret i1 false
939 continue:
940 ret i1 true
941 }
943 define zeroext i1 @smulobri64(i64 %v1, i64 %v2) {
944 ; SDAG-LABEL: smulobri64:
945 ; SDAG: # %bb.0:
946 ; SDAG-NEXT: imulq %rsi, %rdi
947 ; SDAG-NEXT: jo .LBB18_1
948 ; SDAG-NEXT: # %bb.2: # %continue
949 ; SDAG-NEXT: movb $1, %al
950 ; SDAG-NEXT: retq
951 ; SDAG-NEXT: .LBB18_1: # %overflow
952 ; SDAG-NEXT: xorl %eax, %eax
953 ; SDAG-NEXT: retq
954 ;
955 ; FAST-LABEL: smulobri64:
956 ; FAST: # %bb.0:
957 ; FAST-NEXT: imulq %rsi, %rdi
958 ; FAST-NEXT: jo .LBB18_1
959 ; FAST-NEXT: # %bb.2: # %continue
960 ; FAST-NEXT: movb $1, %al
961 ; FAST-NEXT: andb $1, %al
962 ; FAST-NEXT: retq
963 ; FAST-NEXT: .LBB18_1: # %overflow
964 ; FAST-NEXT: xorl %eax, %eax
965 ; FAST-NEXT: andb $1, %al
966 ; FAST-NEXT: # kill: def $al killed $al killed $eax
967 ; FAST-NEXT: retq
968 ;
969 ; WIN64-LABEL: smulobri64:
970 ; WIN64: # %bb.0:
971 ; WIN64-NEXT: imulq %rdx, %rcx
972 ; WIN64-NEXT: jo .LBB18_1
973 ; WIN64-NEXT: # %bb.2: # %continue
974 ; WIN64-NEXT: movb $1, %al
975 ; WIN64-NEXT: retq
976 ; WIN64-NEXT: .LBB18_1: # %overflow
977 ; WIN64-NEXT: xorl %eax, %eax
978 ; WIN64-NEXT: retq
979 ;
980 ; WIN32-LABEL: smulobri64:
981 ; WIN32: # %bb.0:
982 ; WIN32-NEXT: pushl %ebp
983 ; WIN32-NEXT: pushl %ebx
984 ; WIN32-NEXT: pushl %edi
985 ; WIN32-NEXT: pushl %esi
986 ; WIN32-NEXT: pushl %eax
987 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
988 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edi
989 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edx
990 ; WIN32-NEXT: movl %edx, %ecx
991 ; WIN32-NEXT: movl %edx, %ebp
992 ; WIN32-NEXT: sarl $31, %ecx
993 ; WIN32-NEXT: movl %edi, %esi
994 ; WIN32-NEXT: imull %ecx, %esi
995 ; WIN32-NEXT: mull %ecx
996 ; WIN32-NEXT: movl %edx, %ecx
997 ; WIN32-NEXT: movl %eax, %ebx
998 ; WIN32-NEXT: addl %eax, %ecx
999 ; WIN32-NEXT: addl %esi, %ecx
1000 ; WIN32-NEXT: movl %edi, %eax
1001 ; WIN32-NEXT: sarl $31, %eax
1002 ; WIN32-NEXT: movl %eax, %edi
1003 ; WIN32-NEXT: imull %ebp, %edi
1004 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ebp
1005 ; WIN32-NEXT: mull %ebp
1006 ; WIN32-NEXT: movl %edx, %esi
1007 ; WIN32-NEXT: addl %edi, %esi
1008 ; WIN32-NEXT: addl %eax, %esi
1009 ; WIN32-NEXT: addl %ebx, %eax
1010 ; WIN32-NEXT: movl %eax, (%esp) # 4-byte Spill
1011 ; WIN32-NEXT: adcl %ecx, %esi
1012 ; WIN32-NEXT: movl %ebp, %eax
1013 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
1014 ; WIN32-NEXT: mull %ecx
1015 ; WIN32-NEXT: movl %edx, %ebx
1016 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1017 ; WIN32-NEXT: mull %ecx
1018 ; WIN32-NEXT: movl %edx, %edi
1019 ; WIN32-NEXT: movl %eax, %ecx
1020 ; WIN32-NEXT: addl %ebx, %ecx
1021 ; WIN32-NEXT: adcl $0, %edi
1022 ; WIN32-NEXT: movl %ebp, %eax
1023 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
1024 ; WIN32-NEXT: movl %edx, %ebp
1025 ; WIN32-NEXT: movl %eax, %ebx
1026 ; WIN32-NEXT: addl %ecx, %ebx
1027 ; WIN32-NEXT: adcl %edi, %ebp
1028 ; WIN32-NEXT: setb %cl
1029 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1030 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
1031 ; WIN32-NEXT: addl %ebp, %eax
1032 ; WIN32-NEXT: movzbl %cl, %ecx
1033 ; WIN32-NEXT: adcl %ecx, %edx
1034 ; WIN32-NEXT: addl (%esp), %eax # 4-byte Folded Reload
1035 ; WIN32-NEXT: adcl %esi, %edx
1036 ; WIN32-NEXT: sarl $31, %ebx
1037 ; WIN32-NEXT: xorl %ebx, %edx
1038 ; WIN32-NEXT: xorl %eax, %ebx
1039 ; WIN32-NEXT: orl %edx, %ebx
1040 ; WIN32-NEXT: jne LBB18_1
1041 ; WIN32-NEXT: # %bb.3: # %continue
1042 ; WIN32-NEXT: movb $1, %al
1043 ; WIN32-NEXT: LBB18_2: # %overflow
1044 ; WIN32-NEXT: addl $4, %esp
1045 ; WIN32-NEXT: popl %esi
1046 ; WIN32-NEXT: popl %edi
1047 ; WIN32-NEXT: popl %ebx
1048 ; WIN32-NEXT: popl %ebp
1049 ; WIN32-NEXT: retl
1050 ; WIN32-NEXT: LBB18_1: # %overflow
1051 ; WIN32-NEXT: xorl %eax, %eax
1052 ; WIN32-NEXT: jmp LBB18_2
1053 %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
1054 %val = extractvalue {i64, i1} %t, 0
1055 %obit = extractvalue {i64, i1} %t, 1
1056 br i1 %obit, label %overflow, label %continue, !prof !0
1058 overflow:
1059 ret i1 false
1061 continue:
1062 ret i1 true
1063 }
1065 define zeroext i1 @umulobri8(i8 %v1, i8 %v2) {
1066 ; SDAG-LABEL: umulobri8:
1067 ; SDAG: # %bb.0:
1068 ; SDAG-NEXT: movl %edi, %eax
1069 ; SDAG-NEXT: # kill: def $al killed $al killed $eax
1070 ; SDAG-NEXT: mulb %sil
1071 ; SDAG-NEXT: jo .LBB19_1
1072 ; SDAG-NEXT: # %bb.2: # %continue
1073 ; SDAG-NEXT: movb $1, %al
1074 ; SDAG-NEXT: retq
1075 ; SDAG-NEXT: .LBB19_1: # %overflow
1076 ; SDAG-NEXT: xorl %eax, %eax
1077 ; SDAG-NEXT: retq
1078 ;
1079 ; FAST-LABEL: umulobri8:
1080 ; FAST: # %bb.0:
1081 ; FAST-NEXT: movl %edi, %eax
1082 ; FAST-NEXT: # kill: def $al killed $al killed $eax
1083 ; FAST-NEXT: mulb %sil
1084 ; FAST-NEXT: seto %al
1085 ; FAST-NEXT: testb $1, %al
1086 ; FAST-NEXT: jne .LBB19_1
1087 ; FAST-NEXT: # %bb.2: # %continue
1088 ; FAST-NEXT: movb $1, %al
1089 ; FAST-NEXT: andb $1, %al
1090 ; FAST-NEXT: retq
1091 ; FAST-NEXT: .LBB19_1: # %overflow
1092 ; FAST-NEXT: xorl %eax, %eax
1093 ; FAST-NEXT: andb $1, %al
1094 ; FAST-NEXT: # kill: def $al killed $al killed $eax
1095 ; FAST-NEXT: retq
1096 ;
1097 ; WIN64-LABEL: umulobri8:
1098 ; WIN64: # %bb.0:
1099 ; WIN64-NEXT: movl %ecx, %eax
1100 ; WIN64-NEXT: mulb %dl
1101 ; WIN64-NEXT: jo .LBB19_1
1102 ; WIN64-NEXT: # %bb.2: # %continue
1103 ; WIN64-NEXT: movb $1, %al
1104 ; WIN64-NEXT: retq
1105 ; WIN64-NEXT: .LBB19_1: # %overflow
1106 ; WIN64-NEXT: xorl %eax, %eax
1107 ; WIN64-NEXT: retq
1108 ;
1109 ; WIN32-LABEL: umulobri8:
1110 ; WIN32: # %bb.0:
1111 ; WIN32-NEXT: movzbl {{[0-9]+}}(%esp), %eax
1112 ; WIN32-NEXT: mulb {{[0-9]+}}(%esp)
1113 ; WIN32-NEXT: jo LBB19_1
1114 ; WIN32-NEXT: # %bb.2: # %continue
1115 ; WIN32-NEXT: movb $1, %al
1116 ; WIN32-NEXT: retl
1117 ; WIN32-NEXT: LBB19_1: # %overflow
1118 ; WIN32-NEXT: xorl %eax, %eax
1119 ; WIN32-NEXT: retl
1120 %t = call {i8, i1} @llvm.umul.with.overflow.i8(i8 %v1, i8 %v2)
1121 %val = extractvalue {i8, i1} %t, 0
1122 %obit = extractvalue {i8, i1} %t, 1
1123 br i1 %obit, label %overflow, label %continue, !prof !0
1125 overflow:
1126 ret i1 false
1128 continue:
1129 ret i1 true
1130 }
1132 define zeroext i1 @umulobri16(i16 %v1, i16 %v2) {
1133 ; SDAG-LABEL: umulobri16:
1134 ; SDAG: # %bb.0:
1135 ; SDAG-NEXT: movl %edi, %eax
1136 ; SDAG-NEXT: # kill: def $ax killed $ax killed $eax
1137 ; SDAG-NEXT: mulw %si
1138 ; SDAG-NEXT: jo .LBB20_1
1139 ; SDAG-NEXT: # %bb.2: # %continue
1140 ; SDAG-NEXT: movb $1, %al
1141 ; SDAG-NEXT: retq
1142 ; SDAG-NEXT: .LBB20_1: # %overflow
1143 ; SDAG-NEXT: xorl %eax, %eax
1144 ; SDAG-NEXT: retq
1145 ;
1146 ; FAST-LABEL: umulobri16:
1147 ; FAST: # %bb.0:
1148 ; FAST-NEXT: movl %edi, %eax
1149 ; FAST-NEXT: # kill: def $ax killed $ax killed $eax
1150 ; FAST-NEXT: mulw %si
1151 ; FAST-NEXT: seto %al
1152 ; FAST-NEXT: testb $1, %al
1153 ; FAST-NEXT: jne .LBB20_1
1154 ; FAST-NEXT: # %bb.2: # %continue
1155 ; FAST-NEXT: movb $1, %al
1156 ; FAST-NEXT: andb $1, %al
1157 ; FAST-NEXT: retq
1158 ; FAST-NEXT: .LBB20_1: # %overflow
1159 ; FAST-NEXT: xorl %eax, %eax
1160 ; FAST-NEXT: andb $1, %al
1161 ; FAST-NEXT: # kill: def $al killed $al killed $eax
1162 ; FAST-NEXT: retq
1163 ;
1164 ; WIN64-LABEL: umulobri16:
1165 ; WIN64: # %bb.0:
1166 ; WIN64-NEXT: movl %ecx, %eax
1167 ; WIN64-NEXT: mulw %dx
1168 ; WIN64-NEXT: jo .LBB20_1
1169 ; WIN64-NEXT: # %bb.2: # %continue
1170 ; WIN64-NEXT: movb $1, %al
1171 ; WIN64-NEXT: retq
1172 ; WIN64-NEXT: .LBB20_1: # %overflow
1173 ; WIN64-NEXT: xorl %eax, %eax
1174 ; WIN64-NEXT: retq
1175 ;
1176 ; WIN32-LABEL: umulobri16:
1177 ; WIN32: # %bb.0:
1178 ; WIN32-NEXT: movzwl {{[0-9]+}}(%esp), %eax
1179 ; WIN32-NEXT: mulw {{[0-9]+}}(%esp)
1180 ; WIN32-NEXT: jo LBB20_1
1181 ; WIN32-NEXT: # %bb.2: # %continue
1182 ; WIN32-NEXT: movb $1, %al
1183 ; WIN32-NEXT: retl
1184 ; WIN32-NEXT: LBB20_1: # %overflow
1185 ; WIN32-NEXT: xorl %eax, %eax
1186 ; WIN32-NEXT: retl
1187 %t = call {i16, i1} @llvm.umul.with.overflow.i16(i16 %v1, i16 %v2)
1188 %val = extractvalue {i16, i1} %t, 0
1189 %obit = extractvalue {i16, i1} %t, 1
1190 br i1 %obit, label %overflow, label %continue, !prof !0
1192 overflow:
1193 ret i1 false
1195 continue:
1196 ret i1 true
1197 }
1199 define zeroext i1 @umulobri32(i32 %v1, i32 %v2) {
1200 ; SDAG-LABEL: umulobri32:
1201 ; SDAG: # %bb.0:
1202 ; SDAG-NEXT: movl %edi, %eax
1203 ; SDAG-NEXT: mull %esi
1204 ; SDAG-NEXT: jo .LBB21_1
1205 ; SDAG-NEXT: # %bb.2: # %continue
1206 ; SDAG-NEXT: movb $1, %al
1207 ; SDAG-NEXT: retq
1208 ; SDAG-NEXT: .LBB21_1: # %overflow
1209 ; SDAG-NEXT: xorl %eax, %eax
1210 ; SDAG-NEXT: retq
1211 ;
1212 ; FAST-LABEL: umulobri32:
1213 ; FAST: # %bb.0:
1214 ; FAST-NEXT: movl %edi, %eax
1215 ; FAST-NEXT: mull %esi
1216 ; FAST-NEXT: jo .LBB21_1
1217 ; FAST-NEXT: # %bb.2: # %continue
1218 ; FAST-NEXT: movb $1, %al
1219 ; FAST-NEXT: andb $1, %al
1220 ; FAST-NEXT: retq
1221 ; FAST-NEXT: .LBB21_1: # %overflow
1222 ; FAST-NEXT: xorl %eax, %eax
1223 ; FAST-NEXT: andb $1, %al
1224 ; FAST-NEXT: # kill: def $al killed $al killed $eax
1225 ; FAST-NEXT: retq
1226 ;
1227 ; WIN64-LABEL: umulobri32:
1228 ; WIN64: # %bb.0:
1229 ; WIN64-NEXT: movl %ecx, %eax
1230 ; WIN64-NEXT: mull %edx
1231 ; WIN64-NEXT: jo .LBB21_1
1232 ; WIN64-NEXT: # %bb.2: # %continue
1233 ; WIN64-NEXT: movb $1, %al
1234 ; WIN64-NEXT: retq
1235 ; WIN64-NEXT: .LBB21_1: # %overflow
1236 ; WIN64-NEXT: xorl %eax, %eax
1237 ; WIN64-NEXT: retq
1238 ;
1239 ; WIN32-LABEL: umulobri32:
1240 ; WIN32: # %bb.0:
1241 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1242 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
1243 ; WIN32-NEXT: jo LBB21_1
1244 ; WIN32-NEXT: # %bb.2: # %continue
1245 ; WIN32-NEXT: movb $1, %al
1246 ; WIN32-NEXT: retl
1247 ; WIN32-NEXT: LBB21_1: # %overflow
1248 ; WIN32-NEXT: xorl %eax, %eax
1249 ; WIN32-NEXT: retl
1250 %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
1251 %val = extractvalue {i32, i1} %t, 0
1252 %obit = extractvalue {i32, i1} %t, 1
1253 br i1 %obit, label %overflow, label %continue, !prof !0
1255 overflow:
1256 ret i1 false
1258 continue:
1259 ret i1 true
1260 }
1262 define zeroext i1 @umulobri64(i64 %v1, i64 %v2) {
1263 ; SDAG-LABEL: umulobri64:
1264 ; SDAG: # %bb.0:
1265 ; SDAG-NEXT: movq %rdi, %rax
1266 ; SDAG-NEXT: mulq %rsi
1267 ; SDAG-NEXT: jo .LBB22_1
1268 ; SDAG-NEXT: # %bb.2: # %continue
1269 ; SDAG-NEXT: movb $1, %al
1270 ; SDAG-NEXT: retq
1271 ; SDAG-NEXT: .LBB22_1: # %overflow
1272 ; SDAG-NEXT: xorl %eax, %eax
1273 ; SDAG-NEXT: retq
1274 ;
1275 ; FAST-LABEL: umulobri64:
1276 ; FAST: # %bb.0:
1277 ; FAST-NEXT: movq %rdi, %rax
1278 ; FAST-NEXT: mulq %rsi
1279 ; FAST-NEXT: jo .LBB22_1
1280 ; FAST-NEXT: # %bb.2: # %continue
1281 ; FAST-NEXT: movb $1, %al
1282 ; FAST-NEXT: andb $1, %al
1283 ; FAST-NEXT: retq
1284 ; FAST-NEXT: .LBB22_1: # %overflow
1285 ; FAST-NEXT: xorl %eax, %eax
1286 ; FAST-NEXT: andb $1, %al
1287 ; FAST-NEXT: # kill: def $al killed $al killed $eax
1288 ; FAST-NEXT: retq
1289 ;
1290 ; WIN64-LABEL: umulobri64:
1291 ; WIN64: # %bb.0:
1292 ; WIN64-NEXT: movq %rcx, %rax
1293 ; WIN64-NEXT: mulq %rdx
1294 ; WIN64-NEXT: jo .LBB22_1
1295 ; WIN64-NEXT: # %bb.2: # %continue
1296 ; WIN64-NEXT: movb $1, %al
1297 ; WIN64-NEXT: retq
1298 ; WIN64-NEXT: .LBB22_1: # %overflow
1299 ; WIN64-NEXT: xorl %eax, %eax
1300 ; WIN64-NEXT: retq
1301 ;
1302 ; WIN32-LABEL: umulobri64:
1303 ; WIN32: # %bb.0:
1304 ; WIN32-NEXT: pushl %ebp
1305 ; WIN32-NEXT: pushl %ebx
1306 ; WIN32-NEXT: pushl %edi
1307 ; WIN32-NEXT: pushl %esi
1308 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ebp
1309 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1310 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
1311 ; WIN32-NEXT: testl %esi, %esi
1312 ; WIN32-NEXT: setne %dl
1313 ; WIN32-NEXT: testl %eax, %eax
1314 ; WIN32-NEXT: setne %cl
1315 ; WIN32-NEXT: andb %dl, %cl
1316 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
1317 ; WIN32-NEXT: movl %eax, %edi
1318 ; WIN32-NEXT: seto %bl
1319 ; WIN32-NEXT: movl %esi, %eax
1320 ; WIN32-NEXT: mull %ebp
1321 ; WIN32-NEXT: seto %ch
1322 ; WIN32-NEXT: orb %bl, %ch
1323 ; WIN32-NEXT: orb %cl, %ch
1324 ; WIN32-NEXT: leal (%edi,%eax), %esi
1325 ; WIN32-NEXT: movl %ebp, %eax
1326 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
1327 ; WIN32-NEXT: addl %esi, %edx
1328 ; WIN32-NEXT: setb %al
1329 ; WIN32-NEXT: orb %ch, %al
1330 ; WIN32-NEXT: subb $1, %al
1331 ; WIN32-NEXT: je LBB22_1
1332 ; WIN32-NEXT: # %bb.3: # %continue
1333 ; WIN32-NEXT: movb $1, %al
1334 ; WIN32-NEXT: LBB22_2: # %overflow
1335 ; WIN32-NEXT: popl %esi
1336 ; WIN32-NEXT: popl %edi
1337 ; WIN32-NEXT: popl %ebx
1338 ; WIN32-NEXT: popl %ebp
1339 ; WIN32-NEXT: retl
1340 ; WIN32-NEXT: LBB22_1: # %overflow
1341 ; WIN32-NEXT: xorl %eax, %eax
1342 ; WIN32-NEXT: jmp LBB22_2
1343 %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
1344 %val = extractvalue {i64, i1} %t, 0
1345 %obit = extractvalue {i64, i1} %t, 1
1346 br i1 %obit, label %overflow, label %continue, !prof !0
1348 overflow:
1349 ret i1 false
1351 continue:
1352 ret i1 true
1353 }
1355 define i1 @bug27873(i64 %c1, i1 %c2) {
1356 ; LINUX-LABEL: bug27873:
1357 ; LINUX: # %bb.0:
1358 ; LINUX-NEXT: movq %rdi, %rax
1359 ; LINUX-NEXT: movl $160, %ecx
1360 ; LINUX-NEXT: mulq %rcx
1361 ; LINUX-NEXT: seto %al
1362 ; LINUX-NEXT: orb %sil, %al
1363 ; LINUX-NEXT: retq
1364 ;
1365 ; WIN64-LABEL: bug27873:
1366 ; WIN64: # %bb.0:
1367 ; WIN64-NEXT: movl %edx, %r8d
1368 ; WIN64-NEXT: movq %rcx, %rax
1369 ; WIN64-NEXT: movl $160, %ecx
1370 ; WIN64-NEXT: mulq %rcx
1371 ; WIN64-NEXT: seto %al
1372 ; WIN64-NEXT: orb %r8b, %al
1373 ; WIN64-NEXT: retq
1374 ;
1375 ; WIN32-LABEL: bug27873:
1376 ; WIN32: # %bb.0:
1377 ; WIN32-NEXT: pushl %ebx
1378 ; WIN32-NEXT: movl $160, %eax
1379 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
1380 ; WIN32-NEXT: movl %eax, %ecx
1381 ; WIN32-NEXT: seto %bl
1382 ; WIN32-NEXT: movl $160, %eax
1383 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
1384 ; WIN32-NEXT: addl %ecx, %edx
1385 ; WIN32-NEXT: setb %al
1386 ; WIN32-NEXT: orb %bl, %al
1387 ; WIN32-NEXT: orb {{[0-9]+}}(%esp), %al
1388 ; WIN32-NEXT: popl %ebx
1389 ; WIN32-NEXT: retl
1390 %mul = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %c1, i64 160)
1391 %mul.overflow = extractvalue { i64, i1 } %mul, 1
1392 %x1 = or i1 %c2, %mul.overflow
1393 ret i1 %x1
1394 }
1396 define zeroext i1 @smuloi8_load(ptr %ptr1, i8 %v2, ptr %res) {
1397 ; SDAG-LABEL: smuloi8_load:
1398 ; SDAG: # %bb.0:
1399 ; SDAG-NEXT: movl %esi, %eax
1400 ; SDAG-NEXT: # kill: def $al killed $al killed $eax
1401 ; SDAG-NEXT: imulb (%rdi)
1402 ; SDAG-NEXT: seto %cl
1403 ; SDAG-NEXT: movb %al, (%rdx)
1404 ; SDAG-NEXT: movl %ecx, %eax
1405 ; SDAG-NEXT: retq
1406 ;
1407 ; FAST-LABEL: smuloi8_load:
1408 ; FAST: # %bb.0:
1409 ; FAST-NEXT: movzbl (%rdi), %eax
1410 ; FAST-NEXT: imulb %sil
1411 ; FAST-NEXT: seto %cl
1412 ; FAST-NEXT: movb %al, (%rdx)
1413 ; FAST-NEXT: andb $1, %cl
1414 ; FAST-NEXT: movl %ecx, %eax
1415 ; FAST-NEXT: retq
1416 ;
1417 ; WIN64-LABEL: smuloi8_load:
1418 ; WIN64: # %bb.0:
1419 ; WIN64-NEXT: movl %edx, %eax
1420 ; WIN64-NEXT: imulb (%rcx)
1421 ; WIN64-NEXT: seto %cl
1422 ; WIN64-NEXT: movb %al, (%r8)
1423 ; WIN64-NEXT: movl %ecx, %eax
1424 ; WIN64-NEXT: retq
1425 ;
1426 ; WIN32-LABEL: smuloi8_load:
1427 ; WIN32: # %bb.0:
1428 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edx
1429 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1430 ; WIN32-NEXT: movzbl (%eax), %eax
1431 ; WIN32-NEXT: imulb {{[0-9]+}}(%esp)
1432 ; WIN32-NEXT: seto %cl
1433 ; WIN32-NEXT: movb %al, (%edx)
1434 ; WIN32-NEXT: movl %ecx, %eax
1435 ; WIN32-NEXT: retl
1436 %v1 = load i8, ptr %ptr1
1437 %t = call {i8, i1} @llvm.smul.with.overflow.i8(i8 %v1, i8 %v2)
1438 %val = extractvalue {i8, i1} %t, 0
1439 %obit = extractvalue {i8, i1} %t, 1
1440 store i8 %val, ptr %res
1441 ret i1 %obit
1442 }
1444 define zeroext i1 @smuloi8_load2(i8 %v1, ptr %ptr2, ptr %res) {
1445 ; SDAG-LABEL: smuloi8_load2:
1446 ; SDAG: # %bb.0:
1447 ; SDAG-NEXT: movl %edi, %eax
1448 ; SDAG-NEXT: # kill: def $al killed $al killed $eax
1449 ; SDAG-NEXT: imulb (%rsi)
1450 ; SDAG-NEXT: seto %cl
1451 ; SDAG-NEXT: movb %al, (%rdx)
1452 ; SDAG-NEXT: movl %ecx, %eax
1453 ; SDAG-NEXT: retq
1454 ;
1455 ; FAST-LABEL: smuloi8_load2:
1456 ; FAST: # %bb.0:
1457 ; FAST-NEXT: movl %edi, %eax
1458 ; FAST-NEXT: # kill: def $al killed $al killed $eax
1459 ; FAST-NEXT: imulb (%rsi)
1460 ; FAST-NEXT: seto %cl
1461 ; FAST-NEXT: movb %al, (%rdx)
1462 ; FAST-NEXT: andb $1, %cl
1463 ; FAST-NEXT: movl %ecx, %eax
1464 ; FAST-NEXT: retq
1465 ;
1466 ; WIN64-LABEL: smuloi8_load2:
1467 ; WIN64: # %bb.0:
1468 ; WIN64-NEXT: movl %ecx, %eax
1469 ; WIN64-NEXT: imulb (%rdx)
1470 ; WIN64-NEXT: seto %cl
1471 ; WIN64-NEXT: movb %al, (%r8)
1472 ; WIN64-NEXT: movl %ecx, %eax
1473 ; WIN64-NEXT: retq
1474 ;
1475 ; WIN32-LABEL: smuloi8_load2:
1476 ; WIN32: # %bb.0:
1477 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edx
1478 ; WIN32-NEXT: movzbl {{[0-9]+}}(%esp), %eax
1479 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
1480 ; WIN32-NEXT: imulb (%ecx)
1481 ; WIN32-NEXT: seto %cl
1482 ; WIN32-NEXT: movb %al, (%edx)
1483 ; WIN32-NEXT: movl %ecx, %eax
1484 ; WIN32-NEXT: retl
1485 %v2 = load i8, ptr %ptr2
1486 %t = call {i8, i1} @llvm.smul.with.overflow.i8(i8 %v1, i8 %v2)
1487 %val = extractvalue {i8, i1} %t, 0
1488 %obit = extractvalue {i8, i1} %t, 1
1489 store i8 %val, ptr %res
1490 ret i1 %obit
1491 }
1493 define zeroext i1 @smuloi16_load(ptr %ptr1, i16 %v2, ptr %res) {
1494 ; SDAG-LABEL: smuloi16_load:
1495 ; SDAG: # %bb.0:
1496 ; SDAG-NEXT: imulw (%rdi), %si
1497 ; SDAG-NEXT: seto %al
1498 ; SDAG-NEXT: movw %si, (%rdx)
1499 ; SDAG-NEXT: retq
1500 ;
1501 ; FAST-LABEL: smuloi16_load:
1502 ; FAST: # %bb.0:
1503 ; FAST-NEXT: imulw (%rdi), %si
1504 ; FAST-NEXT: seto %al
1505 ; FAST-NEXT: movw %si, (%rdx)
1506 ; FAST-NEXT: andb $1, %al
1507 ; FAST-NEXT: retq
1508 ;
1509 ; WIN64-LABEL: smuloi16_load:
1510 ; WIN64: # %bb.0:
1511 ; WIN64-NEXT: imulw (%rcx), %dx
1512 ; WIN64-NEXT: seto %al
1513 ; WIN64-NEXT: movw %dx, (%r8)
1514 ; WIN64-NEXT: retq
1515 ;
1516 ; WIN32-LABEL: smuloi16_load:
1517 ; WIN32: # %bb.0:
1518 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
1519 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1520 ; WIN32-NEXT: movzwl (%eax), %edx
1521 ; WIN32-NEXT: imulw {{[0-9]+}}(%esp), %dx
1522 ; WIN32-NEXT: seto %al
1523 ; WIN32-NEXT: movw %dx, (%ecx)
1524 ; WIN32-NEXT: retl
1525 %v1 = load i16, ptr %ptr1
1526 %t = call {i16, i1} @llvm.smul.with.overflow.i16(i16 %v1, i16 %v2)
1527 %val = extractvalue {i16, i1} %t, 0
1528 %obit = extractvalue {i16, i1} %t, 1
1529 store i16 %val, ptr %res
1530 ret i1 %obit
1531 }
1533 define zeroext i1 @smuloi16_load2(i16 %v1, ptr %ptr2, ptr %res) {
1534 ; SDAG-LABEL: smuloi16_load2:
1535 ; SDAG: # %bb.0:
1536 ; SDAG-NEXT: imulw (%rsi), %di
1537 ; SDAG-NEXT: seto %al
1538 ; SDAG-NEXT: movw %di, (%rdx)
1539 ; SDAG-NEXT: retq
1540 ;
1541 ; FAST-LABEL: smuloi16_load2:
1542 ; FAST: # %bb.0:
1543 ; FAST-NEXT: imulw (%rsi), %di
1544 ; FAST-NEXT: seto %al
1545 ; FAST-NEXT: movw %di, (%rdx)
1546 ; FAST-NEXT: andb $1, %al
1547 ; FAST-NEXT: retq
1548 ;
1549 ; WIN64-LABEL: smuloi16_load2:
1550 ; WIN64: # %bb.0:
1551 ; WIN64-NEXT: imulw (%rdx), %cx
1552 ; WIN64-NEXT: seto %al
1553 ; WIN64-NEXT: movw %cx, (%r8)
1554 ; WIN64-NEXT: retq
1555 ;
1556 ; WIN32-LABEL: smuloi16_load2:
1557 ; WIN32: # %bb.0:
1558 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
1559 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1560 ; WIN32-NEXT: movzwl {{[0-9]+}}(%esp), %edx
1561 ; WIN32-NEXT: imulw (%eax), %dx
1562 ; WIN32-NEXT: seto %al
1563 ; WIN32-NEXT: movw %dx, (%ecx)
1564 ; WIN32-NEXT: retl
1565 %v2 = load i16, ptr %ptr2
1566 %t = call {i16, i1} @llvm.smul.with.overflow.i16(i16 %v1, i16 %v2)
1567 %val = extractvalue {i16, i1} %t, 0
1568 %obit = extractvalue {i16, i1} %t, 1
1569 store i16 %val, ptr %res
1570 ret i1 %obit
1571 }
1573 define zeroext i1 @smuloi32_load(ptr %ptr1, i32 %v2, ptr %res) {
1574 ; SDAG-LABEL: smuloi32_load:
1575 ; SDAG: # %bb.0:
1576 ; SDAG-NEXT: imull (%rdi), %esi
1577 ; SDAG-NEXT: seto %al
1578 ; SDAG-NEXT: movl %esi, (%rdx)
1579 ; SDAG-NEXT: retq
1580 ;
1581 ; FAST-LABEL: smuloi32_load:
1582 ; FAST: # %bb.0:
1583 ; FAST-NEXT: imull (%rdi), %esi
1584 ; FAST-NEXT: seto %al
1585 ; FAST-NEXT: movl %esi, (%rdx)
1586 ; FAST-NEXT: andb $1, %al
1587 ; FAST-NEXT: retq
1588 ;
1589 ; WIN64-LABEL: smuloi32_load:
1590 ; WIN64: # %bb.0:
1591 ; WIN64-NEXT: imull (%rcx), %edx
1592 ; WIN64-NEXT: seto %al
1593 ; WIN64-NEXT: movl %edx, (%r8)
1594 ; WIN64-NEXT: retq
1595 ;
1596 ; WIN32-LABEL: smuloi32_load:
1597 ; WIN32: # %bb.0:
1598 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
1599 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1600 ; WIN32-NEXT: movl (%eax), %edx
1601 ; WIN32-NEXT: imull {{[0-9]+}}(%esp), %edx
1602 ; WIN32-NEXT: seto %al
1603 ; WIN32-NEXT: movl %edx, (%ecx)
1604 ; WIN32-NEXT: retl
1605 %v1 = load i32, ptr %ptr1
1606 %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
1607 %val = extractvalue {i32, i1} %t, 0
1608 %obit = extractvalue {i32, i1} %t, 1
1609 store i32 %val, ptr %res
1610 ret i1 %obit
1611 }
1613 define zeroext i1 @smuloi32_load2(i32 %v1, ptr %ptr2, ptr %res) {
1614 ; SDAG-LABEL: smuloi32_load2:
1615 ; SDAG: # %bb.0:
1616 ; SDAG-NEXT: imull (%rsi), %edi
1617 ; SDAG-NEXT: seto %al
1618 ; SDAG-NEXT: movl %edi, (%rdx)
1619 ; SDAG-NEXT: retq
1620 ;
1621 ; FAST-LABEL: smuloi32_load2:
1622 ; FAST: # %bb.0:
1623 ; FAST-NEXT: imull (%rsi), %edi
1624 ; FAST-NEXT: seto %al
1625 ; FAST-NEXT: movl %edi, (%rdx)
1626 ; FAST-NEXT: andb $1, %al
1627 ; FAST-NEXT: retq
1628 ;
1629 ; WIN64-LABEL: smuloi32_load2:
1630 ; WIN64: # %bb.0:
1631 ; WIN64-NEXT: imull (%rdx), %ecx
1632 ; WIN64-NEXT: seto %al
1633 ; WIN64-NEXT: movl %ecx, (%r8)
1634 ; WIN64-NEXT: retq
1635 ;
1636 ; WIN32-LABEL: smuloi32_load2:
1637 ; WIN32: # %bb.0:
1638 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
1639 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1640 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edx
1641 ; WIN32-NEXT: imull (%eax), %edx
1642 ; WIN32-NEXT: seto %al
1643 ; WIN32-NEXT: movl %edx, (%ecx)
1644 ; WIN32-NEXT: retl
1645 %v2 = load i32, ptr %ptr2
1646 %t = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %v1, i32 %v2)
1647 %val = extractvalue {i32, i1} %t, 0
1648 %obit = extractvalue {i32, i1} %t, 1
1649 store i32 %val, ptr %res
1650 ret i1 %obit
1651 }
1653 define zeroext i1 @smuloi64_load(ptr %ptr1, i64 %v2, ptr %res) {
1654 ; SDAG-LABEL: smuloi64_load:
1655 ; SDAG: # %bb.0:
1656 ; SDAG-NEXT: imulq (%rdi), %rsi
1657 ; SDAG-NEXT: seto %al
1658 ; SDAG-NEXT: movq %rsi, (%rdx)
1659 ; SDAG-NEXT: retq
1660 ;
1661 ; FAST-LABEL: smuloi64_load:
1662 ; FAST: # %bb.0:
1663 ; FAST-NEXT: imulq (%rdi), %rsi
1664 ; FAST-NEXT: seto %al
1665 ; FAST-NEXT: movq %rsi, (%rdx)
1666 ; FAST-NEXT: andb $1, %al
1667 ; FAST-NEXT: retq
1668 ;
1669 ; WIN64-LABEL: smuloi64_load:
1670 ; WIN64: # %bb.0:
1671 ; WIN64-NEXT: imulq (%rcx), %rdx
1672 ; WIN64-NEXT: seto %al
1673 ; WIN64-NEXT: movq %rdx, (%r8)
1674 ; WIN64-NEXT: retq
1675 ;
1676 ; WIN32-LABEL: smuloi64_load:
1677 ; WIN32: # %bb.0:
1678 ; WIN32-NEXT: pushl %ebp
1679 ; WIN32-NEXT: pushl %ebx
1680 ; WIN32-NEXT: pushl %edi
1681 ; WIN32-NEXT: pushl %esi
1682 ; WIN32-NEXT: subl $20, %esp
1683 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
1684 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1685 ; WIN32-NEXT: movl (%eax), %ebx
1686 ; WIN32-NEXT: movl %ebx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
1687 ; WIN32-NEXT: movl 4(%eax), %ebp
1688 ; WIN32-NEXT: movl %ecx, %eax
1689 ; WIN32-NEXT: movl %ecx, %edi
1690 ; WIN32-NEXT: sarl $31, %eax
1691 ; WIN32-NEXT: movl %eax, %ecx
1692 ; WIN32-NEXT: imull %ebp, %ecx
1693 ; WIN32-NEXT: mull %ebx
1694 ; WIN32-NEXT: movl %eax, (%esp) # 4-byte Spill
1695 ; WIN32-NEXT: movl %edx, %ebx
1696 ; WIN32-NEXT: addl %ecx, %ebx
1697 ; WIN32-NEXT: movl %ebp, %ecx
1698 ; WIN32-NEXT: movl %ebp, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
1699 ; WIN32-NEXT: sarl $31, %ecx
1700 ; WIN32-NEXT: movl %edi, %esi
1701 ; WIN32-NEXT: imull %ecx, %esi
1702 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1703 ; WIN32-NEXT: mull %ecx
1704 ; WIN32-NEXT: movl %edx, %edi
1705 ; WIN32-NEXT: addl %eax, %edi
1706 ; WIN32-NEXT: addl %esi, %edi
1707 ; WIN32-NEXT: movl (%esp), %ecx # 4-byte Reload
1708 ; WIN32-NEXT: addl %ecx, %ebx
1709 ; WIN32-NEXT: addl %eax, %ecx
1710 ; WIN32-NEXT: movl %ecx, (%esp) # 4-byte Spill
1711 ; WIN32-NEXT: adcl %ebx, %edi
1712 ; WIN32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 4-byte Reload
1713 ; WIN32-NEXT: movl %ecx, %eax
1714 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
1715 ; WIN32-NEXT: mull %esi
1716 ; WIN32-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
1717 ; WIN32-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
1718 ; WIN32-NEXT: movl %ebp, %eax
1719 ; WIN32-NEXT: mull %esi
1720 ; WIN32-NEXT: movl %edx, %ebx
1721 ; WIN32-NEXT: movl %eax, %esi
1722 ; WIN32-NEXT: addl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Folded Reload
1723 ; WIN32-NEXT: adcl $0, %ebx
1724 ; WIN32-NEXT: movl %ecx, %eax
1725 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
1726 ; WIN32-NEXT: movl %edx, %ecx
1727 ; WIN32-NEXT: movl %eax, %ebp
1728 ; WIN32-NEXT: addl %esi, %ebp
1729 ; WIN32-NEXT: adcl %ebx, %ecx
1730 ; WIN32-NEXT: setb %bl
1731 ; WIN32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
1732 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
1733 ; WIN32-NEXT: addl %ecx, %eax
1734 ; WIN32-NEXT: movzbl %bl, %ecx
1735 ; WIN32-NEXT: adcl %ecx, %edx
1736 ; WIN32-NEXT: addl (%esp), %eax # 4-byte Folded Reload
1737 ; WIN32-NEXT: adcl %edi, %edx
1738 ; WIN32-NEXT: movl %ebp, %ecx
1739 ; WIN32-NEXT: sarl $31, %ecx
1740 ; WIN32-NEXT: xorl %ecx, %edx
1741 ; WIN32-NEXT: xorl %eax, %ecx
1742 ; WIN32-NEXT: orl %edx, %ecx
1743 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1744 ; WIN32-NEXT: movl %ebp, 4(%eax)
1745 ; WIN32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 4-byte Reload
1746 ; WIN32-NEXT: movl %ecx, (%eax)
1747 ; WIN32-NEXT: setne %al
1748 ; WIN32-NEXT: addl $20, %esp
1749 ; WIN32-NEXT: popl %esi
1750 ; WIN32-NEXT: popl %edi
1751 ; WIN32-NEXT: popl %ebx
1752 ; WIN32-NEXT: popl %ebp
1753 ; WIN32-NEXT: retl
1754 %v1 = load i64, ptr %ptr1
1755 %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
1756 %val = extractvalue {i64, i1} %t, 0
1757 %obit = extractvalue {i64, i1} %t, 1
1758 store i64 %val, ptr %res
1759 ret i1 %obit
1760 }
1762 define zeroext i1 @smuloi64_load2(i64 %v1, ptr %ptr2, ptr %res) {
1763 ; SDAG-LABEL: smuloi64_load2:
1764 ; SDAG: # %bb.0:
1765 ; SDAG-NEXT: imulq (%rsi), %rdi
1766 ; SDAG-NEXT: seto %al
1767 ; SDAG-NEXT: movq %rdi, (%rdx)
1768 ; SDAG-NEXT: retq
1769 ;
1770 ; FAST-LABEL: smuloi64_load2:
1771 ; FAST: # %bb.0:
1772 ; FAST-NEXT: imulq (%rsi), %rdi
1773 ; FAST-NEXT: seto %al
1774 ; FAST-NEXT: movq %rdi, (%rdx)
1775 ; FAST-NEXT: andb $1, %al
1776 ; FAST-NEXT: retq
1777 ;
1778 ; WIN64-LABEL: smuloi64_load2:
1779 ; WIN64: # %bb.0:
1780 ; WIN64-NEXT: imulq (%rdx), %rcx
1781 ; WIN64-NEXT: seto %al
1782 ; WIN64-NEXT: movq %rcx, (%r8)
1783 ; WIN64-NEXT: retq
1784 ;
1785 ; WIN32-LABEL: smuloi64_load2:
1786 ; WIN32: # %bb.0:
1787 ; WIN32-NEXT: pushl %ebp
1788 ; WIN32-NEXT: pushl %ebx
1789 ; WIN32-NEXT: pushl %edi
1790 ; WIN32-NEXT: pushl %esi
1791 ; WIN32-NEXT: subl $12, %esp
1792 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
1793 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1794 ; WIN32-NEXT: movl (%eax), %ebp
1795 ; WIN32-NEXT: movl 4(%eax), %eax
1796 ; WIN32-NEXT: sarl $31, %ecx
1797 ; WIN32-NEXT: movl %eax, %esi
1798 ; WIN32-NEXT: movl %eax, %edi
1799 ; WIN32-NEXT: movl %eax, (%esp) # 4-byte Spill
1800 ; WIN32-NEXT: imull %ecx, %esi
1801 ; WIN32-NEXT: movl %ebp, %eax
1802 ; WIN32-NEXT: mull %ecx
1803 ; WIN32-NEXT: movl %edx, %ecx
1804 ; WIN32-NEXT: movl %eax, %ebx
1805 ; WIN32-NEXT: addl %eax, %ecx
1806 ; WIN32-NEXT: addl %esi, %ecx
1807 ; WIN32-NEXT: movl %edi, %eax
1808 ; WIN32-NEXT: sarl $31, %eax
1809 ; WIN32-NEXT: movl %eax, %edi
1810 ; WIN32-NEXT: imull {{[0-9]+}}(%esp), %edi
1811 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
1812 ; WIN32-NEXT: movl %edx, %esi
1813 ; WIN32-NEXT: addl %edi, %esi
1814 ; WIN32-NEXT: addl %eax, %esi
1815 ; WIN32-NEXT: addl %ebx, %eax
1816 ; WIN32-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
1817 ; WIN32-NEXT: adcl %ecx, %esi
1818 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1819 ; WIN32-NEXT: mull %ebp
1820 ; WIN32-NEXT: movl %edx, %ebx
1821 ; WIN32-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
1822 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1823 ; WIN32-NEXT: mull %ebp
1824 ; WIN32-NEXT: movl %edx, %edi
1825 ; WIN32-NEXT: movl %eax, %ecx
1826 ; WIN32-NEXT: addl %ebx, %ecx
1827 ; WIN32-NEXT: adcl $0, %edi
1828 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1829 ; WIN32-NEXT: mull (%esp) # 4-byte Folded Reload
1830 ; WIN32-NEXT: movl %edx, %ebx
1831 ; WIN32-NEXT: movl %eax, %ebp
1832 ; WIN32-NEXT: addl %ecx, %ebp
1833 ; WIN32-NEXT: adcl %edi, %ebx
1834 ; WIN32-NEXT: setb %cl
1835 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1836 ; WIN32-NEXT: mull (%esp) # 4-byte Folded Reload
1837 ; WIN32-NEXT: addl %ebx, %eax
1838 ; WIN32-NEXT: movzbl %cl, %ecx
1839 ; WIN32-NEXT: adcl %ecx, %edx
1840 ; WIN32-NEXT: addl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Folded Reload
1841 ; WIN32-NEXT: adcl %esi, %edx
1842 ; WIN32-NEXT: movl %ebp, %ecx
1843 ; WIN32-NEXT: sarl $31, %ecx
1844 ; WIN32-NEXT: xorl %ecx, %edx
1845 ; WIN32-NEXT: xorl %eax, %ecx
1846 ; WIN32-NEXT: orl %edx, %ecx
1847 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1848 ; WIN32-NEXT: movl %ebp, 4(%eax)
1849 ; WIN32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 4-byte Reload
1850 ; WIN32-NEXT: movl %ecx, (%eax)
1851 ; WIN32-NEXT: setne %al
1852 ; WIN32-NEXT: addl $12, %esp
1853 ; WIN32-NEXT: popl %esi
1854 ; WIN32-NEXT: popl %edi
1855 ; WIN32-NEXT: popl %ebx
1856 ; WIN32-NEXT: popl %ebp
1857 ; WIN32-NEXT: retl
1858 %v2 = load i64, ptr %ptr2
1859 %t = call {i64, i1} @llvm.smul.with.overflow.i64(i64 %v1, i64 %v2)
1860 %val = extractvalue {i64, i1} %t, 0
1861 %obit = extractvalue {i64, i1} %t, 1
1862 store i64 %val, ptr %res
1863 ret i1 %obit
1864 }
1866 define zeroext i1 @umuloi8_load(ptr %ptr1, i8 %v2, ptr %res) {
1867 ; SDAG-LABEL: umuloi8_load:
1868 ; SDAG: # %bb.0:
1869 ; SDAG-NEXT: movl %esi, %eax
1870 ; SDAG-NEXT: # kill: def $al killed $al killed $eax
1871 ; SDAG-NEXT: mulb (%rdi)
1872 ; SDAG-NEXT: seto %cl
1873 ; SDAG-NEXT: movb %al, (%rdx)
1874 ; SDAG-NEXT: movl %ecx, %eax
1875 ; SDAG-NEXT: retq
1876 ;
1877 ; FAST-LABEL: umuloi8_load:
1878 ; FAST: # %bb.0:
1879 ; FAST-NEXT: movzbl (%rdi), %eax
1880 ; FAST-NEXT: mulb %sil
1881 ; FAST-NEXT: seto %cl
1882 ; FAST-NEXT: movb %al, (%rdx)
1883 ; FAST-NEXT: andb $1, %cl
1884 ; FAST-NEXT: movl %ecx, %eax
1885 ; FAST-NEXT: retq
1886 ;
1887 ; WIN64-LABEL: umuloi8_load:
1888 ; WIN64: # %bb.0:
1889 ; WIN64-NEXT: movl %edx, %eax
1890 ; WIN64-NEXT: mulb (%rcx)
1891 ; WIN64-NEXT: seto %cl
1892 ; WIN64-NEXT: movb %al, (%r8)
1893 ; WIN64-NEXT: movl %ecx, %eax
1894 ; WIN64-NEXT: retq
1895 ;
1896 ; WIN32-LABEL: umuloi8_load:
1897 ; WIN32: # %bb.0:
1898 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edx
1899 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
1900 ; WIN32-NEXT: movzbl (%eax), %eax
1901 ; WIN32-NEXT: mulb {{[0-9]+}}(%esp)
1902 ; WIN32-NEXT: seto %cl
1903 ; WIN32-NEXT: movb %al, (%edx)
1904 ; WIN32-NEXT: movl %ecx, %eax
1905 ; WIN32-NEXT: retl
1906 %v1 = load i8, ptr %ptr1
1907 %t = call {i8, i1} @llvm.umul.with.overflow.i8(i8 %v1, i8 %v2)
1908 %val = extractvalue {i8, i1} %t, 0
1909 %obit = extractvalue {i8, i1} %t, 1
1910 store i8 %val, ptr %res
1911 ret i1 %obit
1912 }
1914 define zeroext i1 @umuloi8_load2(i8 %v1, ptr %ptr2, ptr %res) {
1915 ; SDAG-LABEL: umuloi8_load2:
1916 ; SDAG: # %bb.0:
1917 ; SDAG-NEXT: movl %edi, %eax
1918 ; SDAG-NEXT: # kill: def $al killed $al killed $eax
1919 ; SDAG-NEXT: mulb (%rsi)
1920 ; SDAG-NEXT: seto %cl
1921 ; SDAG-NEXT: movb %al, (%rdx)
1922 ; SDAG-NEXT: movl %ecx, %eax
1923 ; SDAG-NEXT: retq
1924 ;
1925 ; FAST-LABEL: umuloi8_load2:
1926 ; FAST: # %bb.0:
1927 ; FAST-NEXT: movl %edi, %eax
1928 ; FAST-NEXT: # kill: def $al killed $al killed $eax
1929 ; FAST-NEXT: mulb (%rsi)
1930 ; FAST-NEXT: seto %cl
1931 ; FAST-NEXT: movb %al, (%rdx)
1932 ; FAST-NEXT: andb $1, %cl
1933 ; FAST-NEXT: movl %ecx, %eax
1934 ; FAST-NEXT: retq
1935 ;
1936 ; WIN64-LABEL: umuloi8_load2:
1937 ; WIN64: # %bb.0:
1938 ; WIN64-NEXT: movl %ecx, %eax
1939 ; WIN64-NEXT: mulb (%rdx)
1940 ; WIN64-NEXT: seto %cl
1941 ; WIN64-NEXT: movb %al, (%r8)
1942 ; WIN64-NEXT: movl %ecx, %eax
1943 ; WIN64-NEXT: retq
1944 ;
1945 ; WIN32-LABEL: umuloi8_load2:
1946 ; WIN32: # %bb.0:
1947 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %edx
1948 ; WIN32-NEXT: movzbl {{[0-9]+}}(%esp), %eax
1949 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
1950 ; WIN32-NEXT: mulb (%ecx)
1951 ; WIN32-NEXT: seto %cl
1952 ; WIN32-NEXT: movb %al, (%edx)
1953 ; WIN32-NEXT: movl %ecx, %eax
1954 ; WIN32-NEXT: retl
1955 %v2 = load i8, ptr %ptr2
1956 %t = call {i8, i1} @llvm.umul.with.overflow.i8(i8 %v1, i8 %v2)
1957 %val = extractvalue {i8, i1} %t, 0
1958 %obit = extractvalue {i8, i1} %t, 1
1959 store i8 %val, ptr %res
1960 ret i1 %obit
1961 }
1963 define zeroext i1 @umuloi16_load(ptr %ptr1, i16 %v2, ptr %res) {
1964 ; SDAG-LABEL: umuloi16_load:
1965 ; SDAG: # %bb.0:
1966 ; SDAG-NEXT: movq %rdx, %rcx
1967 ; SDAG-NEXT: movl %esi, %eax
1968 ; SDAG-NEXT: # kill: def $ax killed $ax killed $eax
1969 ; SDAG-NEXT: mulw (%rdi)
1970 ; SDAG-NEXT: seto %dl
1971 ; SDAG-NEXT: movw %ax, (%rcx)
1972 ; SDAG-NEXT: movl %edx, %eax
1973 ; SDAG-NEXT: retq
1974 ;
1975 ; FAST-LABEL: umuloi16_load:
1976 ; FAST: # %bb.0:
1977 ; FAST-NEXT: movq %rdx, %rcx
1978 ; FAST-NEXT: movzwl (%rdi), %eax
1979 ; FAST-NEXT: mulw %si
1980 ; FAST-NEXT: seto %dl
1981 ; FAST-NEXT: movw %ax, (%rcx)
1982 ; FAST-NEXT: andb $1, %dl
1983 ; FAST-NEXT: movl %edx, %eax
1984 ; FAST-NEXT: retq
1985 ;
1986 ; WIN64-LABEL: umuloi16_load:
1987 ; WIN64: # %bb.0:
1988 ; WIN64-NEXT: movl %edx, %eax
1989 ; WIN64-NEXT: mulw (%rcx)
1990 ; WIN64-NEXT: seto %cl
1991 ; WIN64-NEXT: movw %ax, (%r8)
1992 ; WIN64-NEXT: movl %ecx, %eax
1993 ; WIN64-NEXT: retq
1994 ;
1995 ; WIN32-LABEL: umuloi16_load:
1996 ; WIN32: # %bb.0:
1997 ; WIN32-NEXT: pushl %esi
1998 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
1999 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
2000 ; WIN32-NEXT: movzwl (%eax), %eax
2001 ; WIN32-NEXT: mulw {{[0-9]+}}(%esp)
2002 ; WIN32-NEXT: seto %cl
2003 ; WIN32-NEXT: movw %ax, (%esi)
2004 ; WIN32-NEXT: movl %ecx, %eax
2005 ; WIN32-NEXT: popl %esi
2006 ; WIN32-NEXT: retl
2007 %v1 = load i16, ptr %ptr1
2008 %t = call {i16, i1} @llvm.umul.with.overflow.i16(i16 %v1, i16 %v2)
2009 %val = extractvalue {i16, i1} %t, 0
2010 %obit = extractvalue {i16, i1} %t, 1
2011 store i16 %val, ptr %res
2012 ret i1 %obit
2013 }
2015 define zeroext i1 @umuloi16_load2(i16 %v1, ptr %ptr2, ptr %res) {
2016 ; SDAG-LABEL: umuloi16_load2:
2017 ; SDAG: # %bb.0:
2018 ; SDAG-NEXT: movq %rdx, %rcx
2019 ; SDAG-NEXT: movl %edi, %eax
2020 ; SDAG-NEXT: # kill: def $ax killed $ax killed $eax
2021 ; SDAG-NEXT: mulw (%rsi)
2022 ; SDAG-NEXT: seto %dl
2023 ; SDAG-NEXT: movw %ax, (%rcx)
2024 ; SDAG-NEXT: movl %edx, %eax
2025 ; SDAG-NEXT: retq
2026 ;
2027 ; FAST-LABEL: umuloi16_load2:
2028 ; FAST: # %bb.0:
2029 ; FAST-NEXT: movq %rdx, %rcx
2030 ; FAST-NEXT: movl %edi, %eax
2031 ; FAST-NEXT: # kill: def $ax killed $ax killed $eax
2032 ; FAST-NEXT: mulw (%rsi)
2033 ; FAST-NEXT: seto %dl
2034 ; FAST-NEXT: movw %ax, (%rcx)
2035 ; FAST-NEXT: andb $1, %dl
2036 ; FAST-NEXT: movl %edx, %eax
2037 ; FAST-NEXT: retq
2038 ;
2039 ; WIN64-LABEL: umuloi16_load2:
2040 ; WIN64: # %bb.0:
2041 ; WIN64-NEXT: movl %ecx, %eax
2042 ; WIN64-NEXT: mulw (%rdx)
2043 ; WIN64-NEXT: seto %cl
2044 ; WIN64-NEXT: movw %ax, (%r8)
2045 ; WIN64-NEXT: movl %ecx, %eax
2046 ; WIN64-NEXT: retq
2047 ;
2048 ; WIN32-LABEL: umuloi16_load2:
2049 ; WIN32: # %bb.0:
2050 ; WIN32-NEXT: pushl %esi
2051 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
2052 ; WIN32-NEXT: movzwl {{[0-9]+}}(%esp), %eax
2053 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
2054 ; WIN32-NEXT: mulw (%ecx)
2055 ; WIN32-NEXT: seto %cl
2056 ; WIN32-NEXT: movw %ax, (%esi)
2057 ; WIN32-NEXT: movl %ecx, %eax
2058 ; WIN32-NEXT: popl %esi
2059 ; WIN32-NEXT: retl
2060 %v2 = load i16, ptr %ptr2
2061 %t = call {i16, i1} @llvm.umul.with.overflow.i16(i16 %v1, i16 %v2)
2062 %val = extractvalue {i16, i1} %t, 0
2063 %obit = extractvalue {i16, i1} %t, 1
2064 store i16 %val, ptr %res
2065 ret i1 %obit
2066 }
2068 define zeroext i1 @umuloi32_load(ptr %ptr1, i32 %v2, ptr %res) {
2069 ; SDAG-LABEL: umuloi32_load:
2070 ; SDAG: # %bb.0:
2071 ; SDAG-NEXT: movq %rdx, %rcx
2072 ; SDAG-NEXT: movl %esi, %eax
2073 ; SDAG-NEXT: mull (%rdi)
2074 ; SDAG-NEXT: seto %dl
2075 ; SDAG-NEXT: movl %eax, (%rcx)
2076 ; SDAG-NEXT: movl %edx, %eax
2077 ; SDAG-NEXT: retq
2078 ;
2079 ; FAST-LABEL: umuloi32_load:
2080 ; FAST: # %bb.0:
2081 ; FAST-NEXT: movq %rdx, %rcx
2082 ; FAST-NEXT: movl (%rdi), %eax
2083 ; FAST-NEXT: mull %esi
2084 ; FAST-NEXT: seto %dl
2085 ; FAST-NEXT: movl %eax, (%rcx)
2086 ; FAST-NEXT: andb $1, %dl
2087 ; FAST-NEXT: movl %edx, %eax
2088 ; FAST-NEXT: retq
2089 ;
2090 ; WIN64-LABEL: umuloi32_load:
2091 ; WIN64: # %bb.0:
2092 ; WIN64-NEXT: movl %edx, %eax
2093 ; WIN64-NEXT: mull (%rcx)
2094 ; WIN64-NEXT: seto %cl
2095 ; WIN64-NEXT: movl %eax, (%r8)
2096 ; WIN64-NEXT: movl %ecx, %eax
2097 ; WIN64-NEXT: retq
2098 ;
2099 ; WIN32-LABEL: umuloi32_load:
2100 ; WIN32: # %bb.0:
2101 ; WIN32-NEXT: pushl %esi
2102 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
2103 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
2104 ; WIN32-NEXT: movl (%eax), %eax
2105 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
2106 ; WIN32-NEXT: seto %cl
2107 ; WIN32-NEXT: movl %eax, (%esi)
2108 ; WIN32-NEXT: movl %ecx, %eax
2109 ; WIN32-NEXT: popl %esi
2110 ; WIN32-NEXT: retl
2111 %v1 = load i32, ptr %ptr1
2112 %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
2113 %val = extractvalue {i32, i1} %t, 0
2114 %obit = extractvalue {i32, i1} %t, 1
2115 store i32 %val, ptr %res
2116 ret i1 %obit
2117 }
2119 define zeroext i1 @umuloi32_load2(i32 %v1, ptr %ptr2, ptr %res) {
2120 ; SDAG-LABEL: umuloi32_load2:
2121 ; SDAG: # %bb.0:
2122 ; SDAG-NEXT: movq %rdx, %rcx
2123 ; SDAG-NEXT: movl %edi, %eax
2124 ; SDAG-NEXT: mull (%rsi)
2125 ; SDAG-NEXT: seto %dl
2126 ; SDAG-NEXT: movl %eax, (%rcx)
2127 ; SDAG-NEXT: movl %edx, %eax
2128 ; SDAG-NEXT: retq
2129 ;
2130 ; FAST-LABEL: umuloi32_load2:
2131 ; FAST: # %bb.0:
2132 ; FAST-NEXT: movq %rdx, %rcx
2133 ; FAST-NEXT: movl %edi, %eax
2134 ; FAST-NEXT: mull (%rsi)
2135 ; FAST-NEXT: seto %dl
2136 ; FAST-NEXT: movl %eax, (%rcx)
2137 ; FAST-NEXT: andb $1, %dl
2138 ; FAST-NEXT: movl %edx, %eax
2139 ; FAST-NEXT: retq
2140 ;
2141 ; WIN64-LABEL: umuloi32_load2:
2142 ; WIN64: # %bb.0:
2143 ; WIN64-NEXT: movl %ecx, %eax
2144 ; WIN64-NEXT: mull (%rdx)
2145 ; WIN64-NEXT: seto %cl
2146 ; WIN64-NEXT: movl %eax, (%r8)
2147 ; WIN64-NEXT: movl %ecx, %eax
2148 ; WIN64-NEXT: retq
2149 ;
2150 ; WIN32-LABEL: umuloi32_load2:
2151 ; WIN32: # %bb.0:
2152 ; WIN32-NEXT: pushl %esi
2153 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
2154 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
2155 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
2156 ; WIN32-NEXT: mull (%ecx)
2157 ; WIN32-NEXT: seto %cl
2158 ; WIN32-NEXT: movl %eax, (%esi)
2159 ; WIN32-NEXT: movl %ecx, %eax
2160 ; WIN32-NEXT: popl %esi
2161 ; WIN32-NEXT: retl
2162 %v2 = load i32, ptr %ptr2
2163 %t = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %v1, i32 %v2)
2164 %val = extractvalue {i32, i1} %t, 0
2165 %obit = extractvalue {i32, i1} %t, 1
2166 store i32 %val, ptr %res
2167 ret i1 %obit
2168 }
2170 define zeroext i1 @umuloi64_load(ptr %ptr1, i64 %v2, ptr %res) {
2171 ; SDAG-LABEL: umuloi64_load:
2172 ; SDAG: # %bb.0:
2173 ; SDAG-NEXT: movq %rdx, %rcx
2174 ; SDAG-NEXT: movq %rsi, %rax
2175 ; SDAG-NEXT: mulq (%rdi)
2176 ; SDAG-NEXT: seto %dl
2177 ; SDAG-NEXT: movq %rax, (%rcx)
2178 ; SDAG-NEXT: movl %edx, %eax
2179 ; SDAG-NEXT: retq
2180 ;
2181 ; FAST-LABEL: umuloi64_load:
2182 ; FAST: # %bb.0:
2183 ; FAST-NEXT: movq %rdx, %rcx
2184 ; FAST-NEXT: movq (%rdi), %rax
2185 ; FAST-NEXT: mulq %rsi
2186 ; FAST-NEXT: seto %dl
2187 ; FAST-NEXT: movq %rax, (%rcx)
2188 ; FAST-NEXT: andb $1, %dl
2189 ; FAST-NEXT: movl %edx, %eax
2190 ; FAST-NEXT: retq
2191 ;
2192 ; WIN64-LABEL: umuloi64_load:
2193 ; WIN64: # %bb.0:
2194 ; WIN64-NEXT: movq %rdx, %rax
2195 ; WIN64-NEXT: mulq (%rcx)
2196 ; WIN64-NEXT: seto %cl
2197 ; WIN64-NEXT: movq %rax, (%r8)
2198 ; WIN64-NEXT: movl %ecx, %eax
2199 ; WIN64-NEXT: retq
2200 ;
2201 ; WIN32-LABEL: umuloi64_load:
2202 ; WIN32: # %bb.0:
2203 ; WIN32-NEXT: pushl %ebp
2204 ; WIN32-NEXT: pushl %ebx
2205 ; WIN32-NEXT: pushl %edi
2206 ; WIN32-NEXT: pushl %esi
2207 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
2208 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
2209 ; WIN32-NEXT: movl (%eax), %ebp
2210 ; WIN32-NEXT: movl 4(%eax), %eax
2211 ; WIN32-NEXT: testl %esi, %esi
2212 ; WIN32-NEXT: setne %dl
2213 ; WIN32-NEXT: testl %eax, %eax
2214 ; WIN32-NEXT: setne %cl
2215 ; WIN32-NEXT: andb %dl, %cl
2216 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
2217 ; WIN32-NEXT: movl %eax, %edi
2218 ; WIN32-NEXT: seto %bl
2219 ; WIN32-NEXT: movl %esi, %eax
2220 ; WIN32-NEXT: mull %ebp
2221 ; WIN32-NEXT: seto %ch
2222 ; WIN32-NEXT: orb %bl, %ch
2223 ; WIN32-NEXT: orb %cl, %ch
2224 ; WIN32-NEXT: leal (%edi,%eax), %esi
2225 ; WIN32-NEXT: movl %ebp, %eax
2226 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
2227 ; WIN32-NEXT: addl %esi, %edx
2228 ; WIN32-NEXT: setb %cl
2229 ; WIN32-NEXT: orb %ch, %cl
2230 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
2231 ; WIN32-NEXT: movl %eax, (%esi)
2232 ; WIN32-NEXT: movl %edx, 4(%esi)
2233 ; WIN32-NEXT: movl %ecx, %eax
2234 ; WIN32-NEXT: popl %esi
2235 ; WIN32-NEXT: popl %edi
2236 ; WIN32-NEXT: popl %ebx
2237 ; WIN32-NEXT: popl %ebp
2238 ; WIN32-NEXT: retl
2239 %v1 = load i64, ptr %ptr1
2240 %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
2241 %val = extractvalue {i64, i1} %t, 0
2242 %obit = extractvalue {i64, i1} %t, 1
2243 store i64 %val, ptr %res
2244 ret i1 %obit
2245 }
2247 define zeroext i1 @umuloi64_load2(i64 %v1, ptr %ptr2, ptr %res) {
2248 ; SDAG-LABEL: umuloi64_load2:
2249 ; SDAG: # %bb.0:
2250 ; SDAG-NEXT: movq %rdx, %rcx
2251 ; SDAG-NEXT: movq %rdi, %rax
2252 ; SDAG-NEXT: mulq (%rsi)
2253 ; SDAG-NEXT: seto %dl
2254 ; SDAG-NEXT: movq %rax, (%rcx)
2255 ; SDAG-NEXT: movl %edx, %eax
2256 ; SDAG-NEXT: retq
2257 ;
2258 ; FAST-LABEL: umuloi64_load2:
2259 ; FAST: # %bb.0:
2260 ; FAST-NEXT: movq %rdx, %rcx
2261 ; FAST-NEXT: movq %rdi, %rax
2262 ; FAST-NEXT: mulq (%rsi)
2263 ; FAST-NEXT: seto %dl
2264 ; FAST-NEXT: movq %rax, (%rcx)
2265 ; FAST-NEXT: andb $1, %dl
2266 ; FAST-NEXT: movl %edx, %eax
2267 ; FAST-NEXT: retq
2268 ;
2269 ; WIN64-LABEL: umuloi64_load2:
2270 ; WIN64: # %bb.0:
2271 ; WIN64-NEXT: movq %rcx, %rax
2272 ; WIN64-NEXT: mulq (%rdx)
2273 ; WIN64-NEXT: seto %cl
2274 ; WIN64-NEXT: movq %rax, (%r8)
2275 ; WIN64-NEXT: movl %ecx, %eax
2276 ; WIN64-NEXT: retq
2277 ;
2278 ; WIN32-LABEL: umuloi64_load2:
2279 ; WIN32: # %bb.0:
2280 ; WIN32-NEXT: pushl %ebp
2281 ; WIN32-NEXT: pushl %ebx
2282 ; WIN32-NEXT: pushl %edi
2283 ; WIN32-NEXT: pushl %esi
2284 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
2285 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %ecx
2286 ; WIN32-NEXT: movl (%ecx), %ebp
2287 ; WIN32-NEXT: movl 4(%ecx), %esi
2288 ; WIN32-NEXT: testl %eax, %eax
2289 ; WIN32-NEXT: setne %dl
2290 ; WIN32-NEXT: testl %esi, %esi
2291 ; WIN32-NEXT: setne %cl
2292 ; WIN32-NEXT: andb %dl, %cl
2293 ; WIN32-NEXT: mull %ebp
2294 ; WIN32-NEXT: movl %eax, %edi
2295 ; WIN32-NEXT: seto %bl
2296 ; WIN32-NEXT: movl %esi, %eax
2297 ; WIN32-NEXT: mull {{[0-9]+}}(%esp)
2298 ; WIN32-NEXT: seto %ch
2299 ; WIN32-NEXT: orb %bl, %ch
2300 ; WIN32-NEXT: orb %cl, %ch
2301 ; WIN32-NEXT: leal (%edi,%eax), %esi
2302 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %eax
2303 ; WIN32-NEXT: mull %ebp
2304 ; WIN32-NEXT: addl %esi, %edx
2305 ; WIN32-NEXT: setb %cl
2306 ; WIN32-NEXT: orb %ch, %cl
2307 ; WIN32-NEXT: movl {{[0-9]+}}(%esp), %esi
2308 ; WIN32-NEXT: movl %eax, (%esi)
2309 ; WIN32-NEXT: movl %edx, 4(%esi)
2310 ; WIN32-NEXT: movl %ecx, %eax
2311 ; WIN32-NEXT: popl %esi
2312 ; WIN32-NEXT: popl %edi
2313 ; WIN32-NEXT: popl %ebx
2314 ; WIN32-NEXT: popl %ebp
2315 ; WIN32-NEXT: retl
2316 %v2 = load i64, ptr %ptr2
2317 %t = call {i64, i1} @llvm.umul.with.overflow.i64(i64 %v1, i64 %v2)
2318 %val = extractvalue {i64, i1} %t, 0
2319 %obit = extractvalue {i64, i1} %t, 1
2320 store i64 %val, ptr %res
2321 ret i1 %obit
2322 }
2324 declare {i8, i1} @llvm.smul.with.overflow.i8 (i8, i8 ) nounwind readnone
2325 declare {i16, i1} @llvm.smul.with.overflow.i16(i16, i16) nounwind readnone
2326 declare {i32, i1} @llvm.smul.with.overflow.i32(i32, i32) nounwind readnone
2327 declare {i64, i1} @llvm.smul.with.overflow.i64(i64, i64) nounwind readnone
2328 declare {i8, i1} @llvm.umul.with.overflow.i8 (i8, i8 ) nounwind readnone
2329 declare {i16, i1} @llvm.umul.with.overflow.i16(i16, i16) nounwind readnone
2330 declare {i32, i1} @llvm.umul.with.overflow.i32(i32, i32) nounwind readnone
2331 declare {i64, i1} @llvm.umul.with.overflow.i64(i64, i64) nounwind readnone
2333 !0 = !{!"branch_weights", i32 0, i32 2147483647}