1 ; RUN: llc -mtriple=mips64el-unknown-unknown -mcpu=mips4 -soft-float -O1 \
2 ; RUN: -disable-mips-delay-filler < %s | FileCheck %s
3 ; RUN: llc -mtriple=mips64el-unknown-unknown -mcpu=mips64 -soft-float -O1 \
4 ; RUN: -disable-mips-delay-filler < %s | FileCheck %s
6 @gld0 = external global fp128
7 @gld1 = external global fp128
8 @gld2 = external global fp128
9 @gf1 = external global float
10 @gd1 = external global double
13 ; CHECK: ld $25, %call16(__addtf3)
15 define fp128 @addLD() {
17 %0 = load fp128* @gld0, align 16
18 %1 = load fp128* @gld1, align 16
19 %add = fadd fp128 %0, %1
24 ; CHECK: ld $25, %call16(__subtf3)
26 define fp128 @subLD() {
28 %0 = load fp128* @gld0, align 16
29 %1 = load fp128* @gld1, align 16
30 %sub = fsub fp128 %0, %1
35 ; CHECK: ld $25, %call16(__multf3)
37 define fp128 @mulLD() {
39 %0 = load fp128* @gld0, align 16
40 %1 = load fp128* @gld1, align 16
41 %mul = fmul fp128 %0, %1
46 ; CHECK: ld $25, %call16(__divtf3)
48 define fp128 @divLD() {
50 %0 = load fp128* @gld0, align 16
51 %1 = load fp128* @gld1, align 16
52 %div = fdiv fp128 %0, %1
56 ; CHECK-LABEL: conv_LD_char:
57 ; CHECK: ld $25, %call16(__floatsitf)
59 define fp128 @conv_LD_char(i8 signext %a) {
61 %conv = sitofp i8 %a to fp128
65 ; CHECK-LABEL: conv_LD_short:
66 ; CHECK: ld $25, %call16(__floatsitf)
68 define fp128 @conv_LD_short(i16 signext %a) {
70 %conv = sitofp i16 %a to fp128
74 ; CHECK-LABEL: conv_LD_int:
75 ; CHECK: ld $25, %call16(__floatsitf)
77 define fp128 @conv_LD_int(i32 %a) {
79 %conv = sitofp i32 %a to fp128
83 ; CHECK-LABEL: conv_LD_LL:
84 ; CHECK: ld $25, %call16(__floatditf)
86 define fp128 @conv_LD_LL(i64 %a) {
88 %conv = sitofp i64 %a to fp128
92 ; CHECK-LABEL: conv_LD_UChar:
93 ; CHECK: ld $25, %call16(__floatunsitf)
95 define fp128 @conv_LD_UChar(i8 zeroext %a) {
97 %conv = uitofp i8 %a to fp128
101 ; CHECK-LABEL: conv_LD_UShort:
102 ; CHECK: ld $25, %call16(__floatunsitf)
104 define fp128 @conv_LD_UShort(i16 zeroext %a) {
106 %conv = uitofp i16 %a to fp128
110 ; CHECK-LABEL: conv_LD_UInt:
111 ; CHECK: ld $25, %call16(__floatunsitf)
113 define fp128 @conv_LD_UInt(i32 %a) {
115 %conv = uitofp i32 %a to fp128
119 ; CHECK-LABEL: conv_LD_ULL:
120 ; CHECK: ld $25, %call16(__floatunditf)
122 define fp128 @conv_LD_ULL(i64 %a) {
124 %conv = uitofp i64 %a to fp128
128 ; CHECK-LABEL: conv_char_LD:
129 ; CHECK: ld $25, %call16(__fixtfsi)
131 define signext i8 @conv_char_LD(fp128 %a) {
133 %conv = fptosi fp128 %a to i8
137 ; CHECK-LABEL: conv_short_LD:
138 ; CHECK: ld $25, %call16(__fixtfsi)
140 define signext i16 @conv_short_LD(fp128 %a) {
142 %conv = fptosi fp128 %a to i16
146 ; CHECK-LABEL: conv_int_LD:
147 ; CHECK: ld $25, %call16(__fixtfsi)
149 define i32 @conv_int_LD(fp128 %a) {
151 %conv = fptosi fp128 %a to i32
155 ; CHECK-LABEL: conv_LL_LD:
156 ; CHECK: ld $25, %call16(__fixtfdi)
158 define i64 @conv_LL_LD(fp128 %a) {
160 %conv = fptosi fp128 %a to i64
164 ; CHECK-LABEL: conv_UChar_LD:
165 ; CHECK: ld $25, %call16(__fixtfsi)
167 define zeroext i8 @conv_UChar_LD(fp128 %a) {
169 %conv = fptoui fp128 %a to i8
173 ; CHECK-LABEL: conv_UShort_LD:
174 ; CHECK: ld $25, %call16(__fixtfsi)
176 define zeroext i16 @conv_UShort_LD(fp128 %a) {
178 %conv = fptoui fp128 %a to i16
182 ; CHECK-LABEL: conv_UInt_LD:
183 ; CHECK: ld $25, %call16(__fixunstfsi)
185 define i32 @conv_UInt_LD(fp128 %a) {
187 %conv = fptoui fp128 %a to i32
191 ; CHECK-LABEL: conv_ULL_LD:
192 ; CHECK: ld $25, %call16(__fixunstfdi)
194 define i64 @conv_ULL_LD(fp128 %a) {
196 %conv = fptoui fp128 %a to i64
200 ; CHECK-LABEL: conv_LD_float:
201 ; CHECK: ld $25, %call16(__extendsftf2)
203 define fp128 @conv_LD_float(float %a) {
205 %conv = fpext float %a to fp128
209 ; CHECK-LABEL: conv_LD_double:
210 ; CHECK: ld $25, %call16(__extenddftf2)
212 define fp128 @conv_LD_double(double %a) {
214 %conv = fpext double %a to fp128
218 ; CHECK-LABEL: conv_float_LD:
219 ; CHECK: ld $25, %call16(__trunctfsf2)
221 define float @conv_float_LD(fp128 %a) {
223 %conv = fptrunc fp128 %a to float
227 ; CHECK-LABEL: conv_double_LD:
228 ; CHECK: ld $25, %call16(__trunctfdf2)
230 define double @conv_double_LD(fp128 %a) {
232 %conv = fptrunc fp128 %a to double
236 ; CHECK-LABEL: libcall1_fabsl:
237 ; CHECK-DAG: ld $[[R0:[0-9]+]], 8($[[R4:[0-9]+]])
238 ; CHECK-DAG: daddiu $[[R1:[0-9]+]], $zero, 1
239 ; CHECK-DAG: dsll $[[R2:[0-9]+]], $[[R1]], 63
240 ; CHECK-DAG: daddiu $[[R3:[0-9]+]], $[[R2]], -1
241 ; CHECK-DAG: and $4, $[[R0]], $[[R3]]
242 ; CHECK-DAG: ld $2, 0($[[R4]])
244 define fp128 @libcall1_fabsl() {
246 %0 = load fp128* @gld0, align 16
247 %call = tail call fp128 @fabsl(fp128 %0) nounwind readnone
251 declare fp128 @fabsl(fp128) #1
253 ; CHECK-LABEL: libcall1_ceill:
254 ; CHECK: ld $25, %call16(ceill)
256 define fp128 @libcall1_ceill() {
258 %0 = load fp128* @gld0, align 16
259 %call = tail call fp128 @ceill(fp128 %0) nounwind readnone
263 declare fp128 @ceill(fp128) #1
265 ; CHECK-LABEL: libcall1_sinl:
266 ; CHECK: ld $25, %call16(sinl)
268 define fp128 @libcall1_sinl() {
270 %0 = load fp128* @gld0, align 16
271 %call = tail call fp128 @sinl(fp128 %0) nounwind
275 declare fp128 @sinl(fp128) #2
277 ; CHECK-LABEL: libcall1_cosl:
278 ; CHECK: ld $25, %call16(cosl)
280 define fp128 @libcall1_cosl() {
282 %0 = load fp128* @gld0, align 16
283 %call = tail call fp128 @cosl(fp128 %0) nounwind
287 declare fp128 @cosl(fp128) #2
289 ; CHECK-LABEL: libcall1_expl:
290 ; CHECK: ld $25, %call16(expl)
292 define fp128 @libcall1_expl() {
294 %0 = load fp128* @gld0, align 16
295 %call = tail call fp128 @expl(fp128 %0) nounwind
299 declare fp128 @expl(fp128) #2
301 ; CHECK-LABEL: libcall1_exp2l:
302 ; CHECK: ld $25, %call16(exp2l)
304 define fp128 @libcall1_exp2l() {
306 %0 = load fp128* @gld0, align 16
307 %call = tail call fp128 @exp2l(fp128 %0) nounwind
311 declare fp128 @exp2l(fp128) #2
313 ; CHECK-LABEL: libcall1_logl:
314 ; CHECK: ld $25, %call16(logl)
316 define fp128 @libcall1_logl() {
318 %0 = load fp128* @gld0, align 16
319 %call = tail call fp128 @logl(fp128 %0) nounwind
323 declare fp128 @logl(fp128) #2
325 ; CHECK-LABEL: libcall1_log2l:
326 ; CHECK: ld $25, %call16(log2l)
328 define fp128 @libcall1_log2l() {
330 %0 = load fp128* @gld0, align 16
331 %call = tail call fp128 @log2l(fp128 %0) nounwind
335 declare fp128 @log2l(fp128) #2
337 ; CHECK-LABEL: libcall1_log10l:
338 ; CHECK: ld $25, %call16(log10l)
340 define fp128 @libcall1_log10l() {
342 %0 = load fp128* @gld0, align 16
343 %call = tail call fp128 @log10l(fp128 %0) nounwind
347 declare fp128 @log10l(fp128) #2
349 ; CHECK-LABEL: libcall1_nearbyintl:
350 ; CHECK: ld $25, %call16(nearbyintl)
352 define fp128 @libcall1_nearbyintl() {
354 %0 = load fp128* @gld0, align 16
355 %call = tail call fp128 @nearbyintl(fp128 %0) nounwind readnone
359 declare fp128 @nearbyintl(fp128) #1
361 ; CHECK-LABEL: libcall1_floorl:
362 ; CHECK: ld $25, %call16(floorl)
364 define fp128 @libcall1_floorl() {
366 %0 = load fp128* @gld0, align 16
367 %call = tail call fp128 @floorl(fp128 %0) nounwind readnone
371 declare fp128 @floorl(fp128) #1
373 ; CHECK-LABEL: libcall1_sqrtl:
374 ; CHECK: ld $25, %call16(sqrtl)
376 define fp128 @libcall1_sqrtl() {
378 %0 = load fp128* @gld0, align 16
379 %call = tail call fp128 @sqrtl(fp128 %0) nounwind
383 declare fp128 @sqrtl(fp128) #2
385 ; CHECK-LABEL: libcall1_rintl:
386 ; CHECK: ld $25, %call16(rintl)
388 define fp128 @libcall1_rintl() {
390 %0 = load fp128* @gld0, align 16
391 %call = tail call fp128 @rintl(fp128 %0) nounwind readnone
395 declare fp128 @rintl(fp128) #1
397 ; CHECK-LABEL: libcall_powil:
398 ; CHECK: ld $25, %call16(__powitf2)
400 define fp128 @libcall_powil(fp128 %a, i32 %b) {
402 %0 = tail call fp128 @llvm.powi.f128(fp128 %a, i32 %b)
406 declare fp128 @llvm.powi.f128(fp128, i32) #3
408 ; CHECK-LABEL: libcall2_copysignl:
409 ; CHECK-DAG: daddiu $[[R2:[0-9]+]], $zero, 1
410 ; CHECK-DAG: dsll $[[R3:[0-9]+]], $[[R2]], 63
411 ; CHECK-DAG: ld $[[R0:[0-9]+]], %got_disp(gld1)
412 ; CHECK-DAG: ld $[[R1:[0-9]+]], 8($[[R0]])
413 ; CHECK-DAG: and $[[R4:[0-9]+]], $[[R1]], $[[R3]]
414 ; CHECK-DAG: ld $[[R5:[0-9]+]], %got_disp(gld0)
415 ; CHECK-DAG: ld $[[R6:[0-9]+]], 8($[[R5]])
416 ; CHECK-DAG: daddiu $[[R7:[0-9]+]], $[[R3]], -1
417 ; CHECK-DAG: and $[[R8:[0-9]+]], $[[R6]], $[[R7]]
418 ; CHECK-DAG: or $4, $[[R8]], $[[R4]]
419 ; CHECK-DAG: ld $2, 0($[[R5]])
421 define fp128 @libcall2_copysignl() {
423 %0 = load fp128* @gld0, align 16
424 %1 = load fp128* @gld1, align 16
425 %call = tail call fp128 @copysignl(fp128 %0, fp128 %1) nounwind readnone
429 declare fp128 @copysignl(fp128, fp128) #1
431 ; CHECK-LABEL: libcall2_powl:
432 ; CHECK: ld $25, %call16(powl)
434 define fp128 @libcall2_powl() {
436 %0 = load fp128* @gld0, align 16
437 %1 = load fp128* @gld1, align 16
438 %call = tail call fp128 @powl(fp128 %0, fp128 %1) nounwind
442 declare fp128 @powl(fp128, fp128) #2
444 ; CHECK-LABEL: libcall2_fmodl:
445 ; CHECK: ld $25, %call16(fmodl)
447 define fp128 @libcall2_fmodl() {
449 %0 = load fp128* @gld0, align 16
450 %1 = load fp128* @gld1, align 16
451 %call = tail call fp128 @fmodl(fp128 %0, fp128 %1) nounwind
455 declare fp128 @fmodl(fp128, fp128) #2
457 ; CHECK-LABEL: libcall3_fmal:
458 ; CHECK: ld $25, %call16(fmal)
460 define fp128 @libcall3_fmal() {
462 %0 = load fp128* @gld0, align 16
463 %1 = load fp128* @gld2, align 16
464 %2 = load fp128* @gld1, align 16
465 %3 = tail call fp128 @llvm.fma.f128(fp128 %0, fp128 %2, fp128 %1)
469 declare fp128 @llvm.fma.f128(fp128, fp128, fp128) #4
471 ; CHECK-LABEL: cmp_lt:
472 ; CHECK: ld $25, %call16(__lttf2)
474 define i32 @cmp_lt(fp128 %a, fp128 %b) {
476 %cmp = fcmp olt fp128 %a, %b
477 %conv = zext i1 %cmp to i32
481 ; CHECK-LABEL: cmp_le:
482 ; CHECK: ld $25, %call16(__letf2)
484 define i32 @cmp_le(fp128 %a, fp128 %b) {
486 %cmp = fcmp ole fp128 %a, %b
487 %conv = zext i1 %cmp to i32
491 ; CHECK-LABEL: cmp_gt:
492 ; CHECK: ld $25, %call16(__gttf2)
494 define i32 @cmp_gt(fp128 %a, fp128 %b) {
496 %cmp = fcmp ogt fp128 %a, %b
497 %conv = zext i1 %cmp to i32
501 ; CHECK-LABEL: cmp_ge:
502 ; CHECK: ld $25, %call16(__getf2)
504 define i32 @cmp_ge(fp128 %a, fp128 %b) {
506 %cmp = fcmp oge fp128 %a, %b
507 %conv = zext i1 %cmp to i32
511 ; CHECK-LABEL: cmp_eq:
512 ; CHECK: ld $25, %call16(__eqtf2)
514 define i32 @cmp_eq(fp128 %a, fp128 %b) {
516 %cmp = fcmp oeq fp128 %a, %b
517 %conv = zext i1 %cmp to i32
521 ; CHECK-LABEL: cmp_ne:
522 ; CHECK: ld $25, %call16(__netf2)
524 define i32 @cmp_ne(fp128 %a, fp128 %b) {
526 %cmp = fcmp une fp128 %a, %b
527 %conv = zext i1 %cmp to i32
531 ; CHECK-LABEL: load_LD_LD:
532 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gld1)
533 ; CHECK: ld $2, 0($[[R0]])
534 ; CHECK: ld $4, 8($[[R0]])
536 define fp128 @load_LD_LD() {
538 %0 = load fp128* @gld1, align 16
542 ; CHECK-LABEL: load_LD_float:
543 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gf1)
544 ; CHECK: lw $4, 0($[[R0]])
545 ; CHECK: ld $25, %call16(__extendsftf2)
548 define fp128 @load_LD_float() {
550 %0 = load float* @gf1, align 4
551 %conv = fpext float %0 to fp128
555 ; CHECK-LABEL: load_LD_double:
556 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gd1)
557 ; CHECK: ld $4, 0($[[R0]])
558 ; CHECK: ld $25, %call16(__extenddftf2)
561 define fp128 @load_LD_double() {
563 %0 = load double* @gd1, align 8
564 %conv = fpext double %0 to fp128
568 ; CHECK-LABEL: store_LD_LD:
569 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gld1)
570 ; CHECK: ld $[[R1:[0-9]+]], 0($[[R0]])
571 ; CHECK: ld $[[R2:[0-9]+]], 8($[[R0]])
572 ; CHECK: ld $[[R3:[0-9]+]], %got_disp(gld0)
573 ; CHECK: sd $[[R2]], 8($[[R3]])
574 ; CHECK: sd $[[R1]], 0($[[R3]])
576 define void @store_LD_LD() {
578 %0 = load fp128* @gld1, align 16
579 store fp128 %0, fp128* @gld0, align 16
583 ; CHECK-LABEL: store_LD_float:
584 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gld1)
585 ; CHECK: ld $4, 0($[[R0]])
586 ; CHECK: ld $5, 8($[[R0]])
587 ; CHECK: ld $25, %call16(__trunctfsf2)
589 ; CHECK: ld $[[R1:[0-9]+]], %got_disp(gf1)
590 ; CHECK: sw $2, 0($[[R1]])
592 define void @store_LD_float() {
594 %0 = load fp128* @gld1, align 16
595 %conv = fptrunc fp128 %0 to float
596 store float %conv, float* @gf1, align 4
600 ; CHECK-LABEL: store_LD_double:
601 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gld1)
602 ; CHECK: ld $4, 0($[[R0]])
603 ; CHECK: ld $5, 8($[[R0]])
604 ; CHECK: ld $25, %call16(__trunctfdf2)
606 ; CHECK: ld $[[R1:[0-9]+]], %got_disp(gd1)
607 ; CHECK: sd $2, 0($[[R1]])
609 define void @store_LD_double() {
611 %0 = load fp128* @gld1, align 16
612 %conv = fptrunc fp128 %0 to double
613 store double %conv, double* @gd1, align 8
617 ; CHECK-LABEL: select_LD:
618 ; CHECK: movn $8, $6, $4
619 ; CHECK: movn $9, $7, $4
623 define fp128 @select_LD(i32 %a, i64, fp128 %b, fp128 %c) {
625 %tobool = icmp ne i32 %a, 0
626 %cond = select i1 %tobool, fp128 %b, fp128 %c
630 ; CHECK-LABEL: selectCC_LD:
631 ; CHECK: move $[[R0:[0-9]+]], $11
632 ; CHECK: move $[[R1:[0-9]+]], $10
633 ; CHECK: move $[[R2:[0-9]+]], $9
634 ; CHECK: move $[[R3:[0-9]+]], $8
635 ; CHECK: ld $25, %call16(__gttf2)($gp)
637 ; CHECK: slti $1, $2, 1
638 ; CHECK: movz $[[R1]], $[[R3]], $1
639 ; CHECK: movz $[[R0]], $[[R2]], $1
640 ; CHECK: move $2, $[[R1]]
641 ; CHECK: move $4, $[[R0]]
643 define fp128 @selectCC_LD(fp128 %a, fp128 %b, fp128 %c, fp128 %d) {
645 %cmp = fcmp ogt fp128 %a, %b
646 %cond = select i1 %cmp, fp128 %c, fp128 %d