1 ; RUN: llc -mtriple=mips64el-unknown-unknown -mcpu=mips64 -soft-float -O1 \
2 ; RUN: -disable-mips-delay-filler < %s | FileCheck %s
4 @gld0 = external global fp128
5 @gld1 = external global fp128
6 @gld2 = external global fp128
7 @gf1 = external global float
8 @gd1 = external global double
11 ; CHECK: ld $25, %call16(__addtf3)
13 define fp128 @addLD() {
15 %0 = load fp128* @gld0, align 16
16 %1 = load fp128* @gld1, align 16
17 %add = fadd fp128 %0, %1
22 ; CHECK: ld $25, %call16(__subtf3)
24 define fp128 @subLD() {
26 %0 = load fp128* @gld0, align 16
27 %1 = load fp128* @gld1, align 16
28 %sub = fsub fp128 %0, %1
33 ; CHECK: ld $25, %call16(__multf3)
35 define fp128 @mulLD() {
37 %0 = load fp128* @gld0, align 16
38 %1 = load fp128* @gld1, align 16
39 %mul = fmul fp128 %0, %1
44 ; CHECK: ld $25, %call16(__divtf3)
46 define fp128 @divLD() {
48 %0 = load fp128* @gld0, align 16
49 %1 = load fp128* @gld1, align 16
50 %div = fdiv fp128 %0, %1
54 ; CHECK-LABEL: conv_LD_char:
55 ; CHECK: ld $25, %call16(__floatsitf)
57 define fp128 @conv_LD_char(i8 signext %a) {
59 %conv = sitofp i8 %a to fp128
63 ; CHECK-LABEL: conv_LD_short:
64 ; CHECK: ld $25, %call16(__floatsitf)
66 define fp128 @conv_LD_short(i16 signext %a) {
68 %conv = sitofp i16 %a to fp128
72 ; CHECK-LABEL: conv_LD_int:
73 ; CHECK: ld $25, %call16(__floatsitf)
75 define fp128 @conv_LD_int(i32 %a) {
77 %conv = sitofp i32 %a to fp128
81 ; CHECK-LABEL: conv_LD_LL:
82 ; CHECK: ld $25, %call16(__floatditf)
84 define fp128 @conv_LD_LL(i64 %a) {
86 %conv = sitofp i64 %a to fp128
90 ; CHECK-LABEL: conv_LD_UChar:
91 ; CHECK: ld $25, %call16(__floatunsitf)
93 define fp128 @conv_LD_UChar(i8 zeroext %a) {
95 %conv = uitofp i8 %a to fp128
99 ; CHECK-LABEL: conv_LD_UShort:
100 ; CHECK: ld $25, %call16(__floatunsitf)
102 define fp128 @conv_LD_UShort(i16 zeroext %a) {
104 %conv = uitofp i16 %a to fp128
108 ; CHECK-LABEL: conv_LD_UInt:
109 ; CHECK: ld $25, %call16(__floatunsitf)
111 define fp128 @conv_LD_UInt(i32 %a) {
113 %conv = uitofp i32 %a to fp128
117 ; CHECK-LABEL: conv_LD_ULL:
118 ; CHECK: ld $25, %call16(__floatunditf)
120 define fp128 @conv_LD_ULL(i64 %a) {
122 %conv = uitofp i64 %a to fp128
126 ; CHECK-LABEL: conv_char_LD:
127 ; CHECK: ld $25, %call16(__fixtfsi)
129 define signext i8 @conv_char_LD(fp128 %a) {
131 %conv = fptosi fp128 %a to i8
135 ; CHECK-LABEL: conv_short_LD:
136 ; CHECK: ld $25, %call16(__fixtfsi)
138 define signext i16 @conv_short_LD(fp128 %a) {
140 %conv = fptosi fp128 %a to i16
144 ; CHECK-LABEL: conv_int_LD:
145 ; CHECK: ld $25, %call16(__fixtfsi)
147 define i32 @conv_int_LD(fp128 %a) {
149 %conv = fptosi fp128 %a to i32
153 ; CHECK-LABEL: conv_LL_LD:
154 ; CHECK: ld $25, %call16(__fixtfdi)
156 define i64 @conv_LL_LD(fp128 %a) {
158 %conv = fptosi fp128 %a to i64
162 ; CHECK-LABEL: conv_UChar_LD:
163 ; CHECK: ld $25, %call16(__fixtfsi)
165 define zeroext i8 @conv_UChar_LD(fp128 %a) {
167 %conv = fptoui fp128 %a to i8
171 ; CHECK-LABEL: conv_UShort_LD:
172 ; CHECK: ld $25, %call16(__fixtfsi)
174 define zeroext i16 @conv_UShort_LD(fp128 %a) {
176 %conv = fptoui fp128 %a to i16
180 ; CHECK-LABEL: conv_UInt_LD:
181 ; CHECK: ld $25, %call16(__fixunstfsi)
183 define i32 @conv_UInt_LD(fp128 %a) {
185 %conv = fptoui fp128 %a to i32
189 ; CHECK-LABEL: conv_ULL_LD:
190 ; CHECK: ld $25, %call16(__fixunstfdi)
192 define i64 @conv_ULL_LD(fp128 %a) {
194 %conv = fptoui fp128 %a to i64
198 ; CHECK-LABEL: conv_LD_float:
199 ; CHECK: ld $25, %call16(__extendsftf2)
201 define fp128 @conv_LD_float(float %a) {
203 %conv = fpext float %a to fp128
207 ; CHECK-LABEL: conv_LD_double:
208 ; CHECK: ld $25, %call16(__extenddftf2)
210 define fp128 @conv_LD_double(double %a) {
212 %conv = fpext double %a to fp128
216 ; CHECK-LABEL: conv_float_LD:
217 ; CHECK: ld $25, %call16(__trunctfsf2)
219 define float @conv_float_LD(fp128 %a) {
221 %conv = fptrunc fp128 %a to float
225 ; CHECK-LABEL: conv_double_LD:
226 ; CHECK: ld $25, %call16(__trunctfdf2)
228 define double @conv_double_LD(fp128 %a) {
230 %conv = fptrunc fp128 %a to double
234 ; CHECK-LABEL: libcall1_fabsl:
235 ; CHECK-DAG: ld $[[R0:[0-9]+]], 8($[[R4:[0-9]+]])
236 ; CHECK-DAG: daddiu $[[R1:[0-9]+]], $zero, 1
237 ; CHECK-DAG: dsll $[[R2:[0-9]+]], $[[R1]], 63
238 ; CHECK-DAG: daddiu $[[R3:[0-9]+]], $[[R2]], -1
239 ; CHECK-DAG: and $4, $[[R0]], $[[R3]]
240 ; CHECK-DAG: ld $2, 0($[[R4]])
242 define fp128 @libcall1_fabsl() {
244 %0 = load fp128* @gld0, align 16
245 %call = tail call fp128 @fabsl(fp128 %0) nounwind readnone
249 declare fp128 @fabsl(fp128) #1
251 ; CHECK-LABEL: libcall1_ceill:
252 ; CHECK: ld $25, %call16(ceill)
254 define fp128 @libcall1_ceill() {
256 %0 = load fp128* @gld0, align 16
257 %call = tail call fp128 @ceill(fp128 %0) nounwind readnone
261 declare fp128 @ceill(fp128) #1
263 ; CHECK-LABEL: libcall1_sinl:
264 ; CHECK: ld $25, %call16(sinl)
266 define fp128 @libcall1_sinl() {
268 %0 = load fp128* @gld0, align 16
269 %call = tail call fp128 @sinl(fp128 %0) nounwind
273 declare fp128 @sinl(fp128) #2
275 ; CHECK-LABEL: libcall1_cosl:
276 ; CHECK: ld $25, %call16(cosl)
278 define fp128 @libcall1_cosl() {
280 %0 = load fp128* @gld0, align 16
281 %call = tail call fp128 @cosl(fp128 %0) nounwind
285 declare fp128 @cosl(fp128) #2
287 ; CHECK-LABEL: libcall1_expl:
288 ; CHECK: ld $25, %call16(expl)
290 define fp128 @libcall1_expl() {
292 %0 = load fp128* @gld0, align 16
293 %call = tail call fp128 @expl(fp128 %0) nounwind
297 declare fp128 @expl(fp128) #2
299 ; CHECK-LABEL: libcall1_exp2l:
300 ; CHECK: ld $25, %call16(exp2l)
302 define fp128 @libcall1_exp2l() {
304 %0 = load fp128* @gld0, align 16
305 %call = tail call fp128 @exp2l(fp128 %0) nounwind
309 declare fp128 @exp2l(fp128) #2
311 ; CHECK-LABEL: libcall1_logl:
312 ; CHECK: ld $25, %call16(logl)
314 define fp128 @libcall1_logl() {
316 %0 = load fp128* @gld0, align 16
317 %call = tail call fp128 @logl(fp128 %0) nounwind
321 declare fp128 @logl(fp128) #2
323 ; CHECK-LABEL: libcall1_log2l:
324 ; CHECK: ld $25, %call16(log2l)
326 define fp128 @libcall1_log2l() {
328 %0 = load fp128* @gld0, align 16
329 %call = tail call fp128 @log2l(fp128 %0) nounwind
333 declare fp128 @log2l(fp128) #2
335 ; CHECK-LABEL: libcall1_log10l:
336 ; CHECK: ld $25, %call16(log10l)
338 define fp128 @libcall1_log10l() {
340 %0 = load fp128* @gld0, align 16
341 %call = tail call fp128 @log10l(fp128 %0) nounwind
345 declare fp128 @log10l(fp128) #2
347 ; CHECK-LABEL: libcall1_nearbyintl:
348 ; CHECK: ld $25, %call16(nearbyintl)
350 define fp128 @libcall1_nearbyintl() {
352 %0 = load fp128* @gld0, align 16
353 %call = tail call fp128 @nearbyintl(fp128 %0) nounwind readnone
357 declare fp128 @nearbyintl(fp128) #1
359 ; CHECK-LABEL: libcall1_floorl:
360 ; CHECK: ld $25, %call16(floorl)
362 define fp128 @libcall1_floorl() {
364 %0 = load fp128* @gld0, align 16
365 %call = tail call fp128 @floorl(fp128 %0) nounwind readnone
369 declare fp128 @floorl(fp128) #1
371 ; CHECK-LABEL: libcall1_sqrtl:
372 ; CHECK: ld $25, %call16(sqrtl)
374 define fp128 @libcall1_sqrtl() {
376 %0 = load fp128* @gld0, align 16
377 %call = tail call fp128 @sqrtl(fp128 %0) nounwind
381 declare fp128 @sqrtl(fp128) #2
383 ; CHECK-LABEL: libcall1_rintl:
384 ; CHECK: ld $25, %call16(rintl)
386 define fp128 @libcall1_rintl() {
388 %0 = load fp128* @gld0, align 16
389 %call = tail call fp128 @rintl(fp128 %0) nounwind readnone
393 declare fp128 @rintl(fp128) #1
395 ; CHECK-LABEL: libcall_powil:
396 ; CHECK: ld $25, %call16(__powitf2)
398 define fp128 @libcall_powil(fp128 %a, i32 %b) {
400 %0 = tail call fp128 @llvm.powi.f128(fp128 %a, i32 %b)
404 declare fp128 @llvm.powi.f128(fp128, i32) #3
406 ; CHECK-LABEL: libcall2_copysignl:
407 ; CHECK-DAG: daddiu $[[R2:[0-9]+]], $zero, 1
408 ; CHECK-DAG: dsll $[[R3:[0-9]+]], $[[R2]], 63
409 ; CHECK-DAG: ld $[[R0:[0-9]+]], %got_disp(gld1)
410 ; CHECK-DAG: ld $[[R1:[0-9]+]], 8($[[R0]])
411 ; CHECK-DAG: and $[[R4:[0-9]+]], $[[R1]], $[[R3]]
412 ; CHECK-DAG: ld $[[R5:[0-9]+]], %got_disp(gld0)
413 ; CHECK-DAG: ld $[[R6:[0-9]+]], 8($[[R5]])
414 ; CHECK-DAG: daddiu $[[R7:[0-9]+]], $[[R3]], -1
415 ; CHECK-DAG: and $[[R8:[0-9]+]], $[[R6]], $[[R7]]
416 ; CHECK-DAG: or $4, $[[R8]], $[[R4]]
417 ; CHECK-DAG: ld $2, 0($[[R5]])
419 define fp128 @libcall2_copysignl() {
421 %0 = load fp128* @gld0, align 16
422 %1 = load fp128* @gld1, align 16
423 %call = tail call fp128 @copysignl(fp128 %0, fp128 %1) nounwind readnone
427 declare fp128 @copysignl(fp128, fp128) #1
429 ; CHECK-LABEL: libcall2_powl:
430 ; CHECK: ld $25, %call16(powl)
432 define fp128 @libcall2_powl() {
434 %0 = load fp128* @gld0, align 16
435 %1 = load fp128* @gld1, align 16
436 %call = tail call fp128 @powl(fp128 %0, fp128 %1) nounwind
440 declare fp128 @powl(fp128, fp128) #2
442 ; CHECK-LABEL: libcall2_fmodl:
443 ; CHECK: ld $25, %call16(fmodl)
445 define fp128 @libcall2_fmodl() {
447 %0 = load fp128* @gld0, align 16
448 %1 = load fp128* @gld1, align 16
449 %call = tail call fp128 @fmodl(fp128 %0, fp128 %1) nounwind
453 declare fp128 @fmodl(fp128, fp128) #2
455 ; CHECK-LABEL: libcall3_fmal:
456 ; CHECK: ld $25, %call16(fmal)
458 define fp128 @libcall3_fmal() {
460 %0 = load fp128* @gld0, align 16
461 %1 = load fp128* @gld2, align 16
462 %2 = load fp128* @gld1, align 16
463 %3 = tail call fp128 @llvm.fma.f128(fp128 %0, fp128 %2, fp128 %1)
467 declare fp128 @llvm.fma.f128(fp128, fp128, fp128) #4
469 ; CHECK-LABEL: cmp_lt:
470 ; CHECK: ld $25, %call16(__lttf2)
472 define i32 @cmp_lt(fp128 %a, fp128 %b) {
474 %cmp = fcmp olt fp128 %a, %b
475 %conv = zext i1 %cmp to i32
479 ; CHECK-LABEL: cmp_le:
480 ; CHECK: ld $25, %call16(__letf2)
482 define i32 @cmp_le(fp128 %a, fp128 %b) {
484 %cmp = fcmp ole fp128 %a, %b
485 %conv = zext i1 %cmp to i32
489 ; CHECK-LABEL: cmp_gt:
490 ; CHECK: ld $25, %call16(__gttf2)
492 define i32 @cmp_gt(fp128 %a, fp128 %b) {
494 %cmp = fcmp ogt fp128 %a, %b
495 %conv = zext i1 %cmp to i32
499 ; CHECK-LABEL: cmp_ge:
500 ; CHECK: ld $25, %call16(__getf2)
502 define i32 @cmp_ge(fp128 %a, fp128 %b) {
504 %cmp = fcmp oge fp128 %a, %b
505 %conv = zext i1 %cmp to i32
509 ; CHECK-LABEL: cmp_eq:
510 ; CHECK: ld $25, %call16(__eqtf2)
512 define i32 @cmp_eq(fp128 %a, fp128 %b) {
514 %cmp = fcmp oeq fp128 %a, %b
515 %conv = zext i1 %cmp to i32
519 ; CHECK-LABEL: cmp_ne:
520 ; CHECK: ld $25, %call16(__netf2)
522 define i32 @cmp_ne(fp128 %a, fp128 %b) {
524 %cmp = fcmp une fp128 %a, %b
525 %conv = zext i1 %cmp to i32
529 ; CHECK-LABEL: load_LD_LD:
530 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gld1)
531 ; CHECK: ld $2, 0($[[R0]])
532 ; CHECK: ld $4, 8($[[R0]])
534 define fp128 @load_LD_LD() {
536 %0 = load fp128* @gld1, align 16
540 ; CHECK-LABEL: load_LD_float:
541 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gf1)
542 ; CHECK: lw $4, 0($[[R0]])
543 ; CHECK: ld $25, %call16(__extendsftf2)
546 define fp128 @load_LD_float() {
548 %0 = load float* @gf1, align 4
549 %conv = fpext float %0 to fp128
553 ; CHECK-LABEL: load_LD_double:
554 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gd1)
555 ; CHECK: ld $4, 0($[[R0]])
556 ; CHECK: ld $25, %call16(__extenddftf2)
559 define fp128 @load_LD_double() {
561 %0 = load double* @gd1, align 8
562 %conv = fpext double %0 to fp128
566 ; CHECK-LABEL: store_LD_LD:
567 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gld1)
568 ; CHECK: ld $[[R1:[0-9]+]], 0($[[R0]])
569 ; CHECK: ld $[[R2:[0-9]+]], 8($[[R0]])
570 ; CHECK: ld $[[R3:[0-9]+]], %got_disp(gld0)
571 ; CHECK: sd $[[R2]], 8($[[R3]])
572 ; CHECK: sd $[[R1]], 0($[[R3]])
574 define void @store_LD_LD() {
576 %0 = load fp128* @gld1, align 16
577 store fp128 %0, fp128* @gld0, align 16
581 ; CHECK-LABEL: store_LD_float:
582 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gld1)
583 ; CHECK: ld $4, 0($[[R0]])
584 ; CHECK: ld $5, 8($[[R0]])
585 ; CHECK: ld $25, %call16(__trunctfsf2)
587 ; CHECK: ld $[[R1:[0-9]+]], %got_disp(gf1)
588 ; CHECK: sw $2, 0($[[R1]])
590 define void @store_LD_float() {
592 %0 = load fp128* @gld1, align 16
593 %conv = fptrunc fp128 %0 to float
594 store float %conv, float* @gf1, align 4
598 ; CHECK-LABEL: store_LD_double:
599 ; CHECK: ld $[[R0:[0-9]+]], %got_disp(gld1)
600 ; CHECK: ld $4, 0($[[R0]])
601 ; CHECK: ld $5, 8($[[R0]])
602 ; CHECK: ld $25, %call16(__trunctfdf2)
604 ; CHECK: ld $[[R1:[0-9]+]], %got_disp(gd1)
605 ; CHECK: sd $2, 0($[[R1]])
607 define void @store_LD_double() {
609 %0 = load fp128* @gld1, align 16
610 %conv = fptrunc fp128 %0 to double
611 store double %conv, double* @gd1, align 8
615 ; CHECK-LABEL: select_LD:
616 ; CHECK: movn $8, $6, $4
617 ; CHECK: movn $9, $7, $4
621 define fp128 @select_LD(i32 %a, i64, fp128 %b, fp128 %c) {
623 %tobool = icmp ne i32 %a, 0
624 %cond = select i1 %tobool, fp128 %b, fp128 %c
628 ; CHECK-LABEL: selectCC_LD:
629 ; CHECK: move $[[R0:[0-9]+]], $11
630 ; CHECK: move $[[R1:[0-9]+]], $10
631 ; CHECK: move $[[R2:[0-9]+]], $9
632 ; CHECK: move $[[R3:[0-9]+]], $8
633 ; CHECK: ld $25, %call16(__gttf2)($gp)
635 ; CHECK: slti $1, $2, 1
636 ; CHECK: movz $[[R1]], $[[R3]], $1
637 ; CHECK: movz $[[R0]], $[[R2]], $1
638 ; CHECK: move $2, $[[R1]]
639 ; CHECK: move $4, $[[R0]]
641 define fp128 @selectCC_LD(fp128 %a, fp128 %b, fp128 %c, fp128 %d) {
643 %cmp = fcmp ogt fp128 %a, %b
644 %cond = select i1 %cmp, fp128 %c, fp128 %d