[Sparc] Expand FP_TO_UINT, UINT_TO_FP for fp128.
[oota-llvm.git] / test / CodeGen / SPARC / fp128.ll
1 ; RUN: llc < %s -march=sparc -mattr=hard-quad-float | FileCheck %s --check-prefix=HARD
2 ; RUN: llc < %s -march=sparc -mattr=-hard-quad-float | FileCheck %s --check-prefix=SOFT
3
4
5 ; HARD-LABEL: f128_ops
6 ; HARD:       ldd
7 ; HARD:       ldd
8 ; HARD:       ldd
9 ; HARD:       ldd
10 ; HARD:       faddq [[R0:.+]],  [[R1:.+]],  [[R2:.+]]
11 ; HARD:       fsubq [[R2]], [[R3:.+]], [[R4:.+]]
12 ; HARD:       fmulq [[R4]], [[R5:.+]], [[R6:.+]]
13 ; HARD:       fdivq [[R6]], [[R2]]
14 ; HARD:       std
15 ; HARD:       std
16
17 ; SOFT-LABEL: f128_ops
18 ; SOFT:       ldd
19 ; SOFT:       ldd
20 ; SOFT:       ldd
21 ; SOFT:       ldd
22 ; SOFT:       call _Q_add
23 ; SOFT:       call _Q_sub
24 ; SOFT:       call _Q_mul
25 ; SOFT:       call _Q_div
26 ; SOFT:       std
27 ; SOFT:       std
28
29 define void @f128_ops(fp128* noalias sret %scalar.result, fp128* byval %a, fp128* byval %b, fp128* byval %c, fp128* byval %d) {
30 entry:
31   %0 = load fp128* %a, align 8
32   %1 = load fp128* %b, align 8
33   %2 = load fp128* %c, align 8
34   %3 = load fp128* %d, align 8
35   %4 = fadd fp128 %0, %1
36   %5 = fsub fp128 %4, %2
37   %6 = fmul fp128 %5, %3
38   %7 = fdiv fp128 %6, %4
39   store fp128 %7, fp128* %scalar.result, align 8
40   ret void
41 }
42
43 ; HARD-LABEL: f128_spill
44 ; HARD:       std %f{{.+}}, [%[[S0:.+]]]
45 ; HARD:       std %f{{.+}}, [%[[S1:.+]]]
46 ; HARD-DAG:   ldd [%[[S0]]], %f{{.+}}
47 ; HARD-DAG:   ldd [%[[S1]]], %f{{.+}}
48 ; HARD:       jmp
49
50 ; SOFT-LABEL: f128_spill
51 ; SOFT:       std %f{{.+}}, [%[[S0:.+]]]
52 ; SOFT:       std %f{{.+}}, [%[[S1:.+]]]
53 ; SOFT-DAG:   ldd [%[[S0]]], %f{{.+}}
54 ; SOFT-DAG:   ldd [%[[S1]]], %f{{.+}}
55 ; SOFT:       jmp
56
57 define void @f128_spill(fp128* noalias sret %scalar.result, fp128* byval %a) {
58 entry:
59   %0 = load fp128* %a, align 8
60   call void asm sideeffect "", "~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f8},~{f9},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f18},~{f19},~{f20},~{f21},~{f22},~{f23},~{f24},~{f25},~{f26},~{f27},~{f28},~{f29},~{f30},~{f31}"()
61   store fp128 %0, fp128* %scalar.result, align 8
62   ret void
63 }
64
65 ; HARD-LABEL: f128_compare
66 ; HARD:       fcmpq
67 ; HARD-NEXT:  nop
68
69 ; SOFT-LABEL: f128_compare
70 ; SOFT:       _Q_cmp
71
72 define i32 @f128_compare(fp128* byval %f0, fp128* byval %f1, i32 %a, i32 %b) {
73 entry:
74    %0 = load fp128* %f0, align 8
75    %1 = load fp128* %f1, align 8
76    %cond = fcmp ult fp128 %0, %1
77    %ret = select i1 %cond, i32 %a, i32 %b
78    ret i32 %ret
79 }
80
81 ; HARD-LABEL: f128_compare2
82 ; HARD:       fcmpq
83 ; HARD:       fb{{ule|g}}
84
85 ; SOFT-LABEL: f128_compare2
86 ; SOFT:       _Q_cmp
87 ; SOFT:       cmp
88
89 define i32 @f128_compare2() {
90 entry:
91   %0 = fcmp ogt fp128 undef, 0xL00000000000000000000000000000000
92   br i1 %0, label %"5", label %"7"
93
94 "5":                                              ; preds = %entry
95   ret i32 0
96
97 "7":                                              ; preds = %entry
98   ret i32 1
99 }
100
101
102 ; HARD-LABEL: f128_abs
103 ; HARD:       fabss
104
105 ; SOFT-LABEL: f128_abs
106 ; SOFT:       fabss
107
108 define void @f128_abs(fp128* noalias sret %scalar.result, fp128* byval %a) {
109 entry:
110   %0 = load fp128* %a, align 8
111   %1 = tail call fp128 @llvm.fabs.f128(fp128 %0)
112   store fp128 %1, fp128* %scalar.result, align 8
113   ret void
114 }
115
116 declare fp128 @llvm.fabs.f128(fp128) nounwind readonly
117
118 ; HARD-LABEL: int_to_f128
119 ; HARD:       fitoq
120
121 ; SOFT-LABEL: int_to_f128
122 ; SOFT:       _Q_itoq
123
124 define void @int_to_f128(fp128* noalias sret %scalar.result, i32 %i) {
125 entry:
126   %0 = sitofp i32 %i to fp128
127   store fp128 %0, fp128* %scalar.result, align 8
128   ret void
129 }
130
131 ; HARD-LABEL: fp128_unaligned
132 ; HARD:       ldub
133 ; HARD:       faddq
134 ; HARD:       stb
135 ; HARD:       jmp
136
137 ; SOFT-LABEL: fp128_unaligned
138 ; SOFT:       ldub
139 ; SOFT:       call _Q_add
140 ; SOFT:       stb
141 ; SOFT:       jmp
142
143 define void @fp128_unaligned(fp128* %a, fp128* %b, fp128* %c) {
144 entry:
145   %0 = load fp128* %a, align 1
146   %1 = load fp128* %b, align 1
147   %2 = fadd fp128 %0, %1
148   store fp128 %2, fp128* %c, align 1
149   ret void
150 }
151
152 ; HARD-LABEL: uint_to_f128
153 ; HARD:       fdtoq
154
155 ; SOFT-LABEL: uint_to_f128
156 ; SOFT:       _Q_utoq
157
158 define void @uint_to_f128(fp128* noalias sret %scalar.result, i32 %i) {
159 entry:
160   %0 = uitofp i32 %i to fp128
161   store fp128 %0, fp128* %scalar.result, align 8
162   ret void
163 }
164
165 ; HARD-LABEL: f128_to_i32
166 ; HARD:       fqtoi
167 ; HARD:       fqtoi
168
169 ; SOFT-LABEL: f128_to_i32
170 ; SOFT:       call _Q_qtou
171 ; SOFT:       call _Q_qtoi
172
173
174 define i32 @f128_to_i32(fp128* %a, fp128* %b) {
175 entry:
176   %0 = load fp128* %a, align 8
177   %1 = load fp128* %b, align 8
178   %2 = fptoui fp128 %0 to i32
179   %3 = fptosi fp128 %1 to i32
180   %4 = add i32 %2, %3
181   ret i32 %4
182 }