1 ; RUN: llc < %s -O2 -mtriple=x86_64-linux-android -mattr=+mmx | FileCheck %s
2 ; RUN: llc < %s -O2 -mtriple=x86_64-linux-gnu -mattr=+mmx | FileCheck %s
4 ; Check soft floating point conversion function calls.
6 @vi32 = common global i32 0, align 4
7 @vi64 = common global i64 0, align 8
8 @vu32 = common global i32 0, align 4
9 @vu64 = common global i64 0, align 8
10 @vf32 = common global float 0.000000e+00, align 4
11 @vf64 = common global double 0.000000e+00, align 8
12 @vf128 = common global fp128 0xL00000000000000000000000000000000, align 16
14 define void @TestFPExtF32_F128() {
16 %0 = load float, float* @vf32, align 4
17 %conv = fpext float %0 to fp128
18 store fp128 %conv, fp128* @vf128, align 16
20 ; CHECK-LABEL: TestFPExtF32_F128:
21 ; CHECK: movss vf32(%rip), %xmm0
22 ; CHECK-NEXT: callq __extendsftf2
23 ; CHECK-NEXT: movaps %xmm0, vf128(%rip)
27 define void @TestFPExtF64_F128() {
29 %0 = load double, double* @vf64, align 8
30 %conv = fpext double %0 to fp128
31 store fp128 %conv, fp128* @vf128, align 16
33 ; CHECK-LABEL: TestFPExtF64_F128:
34 ; CHECK: movsd vf64(%rip), %xmm0
35 ; CHECK-NEXT: callq __extenddftf2
36 ; CHECK-NEXT: movapd %xmm0, vf128(%rip)
40 define void @TestFPToSIF128_I32() {
42 %0 = load fp128, fp128* @vf128, align 16
43 %conv = fptosi fp128 %0 to i32
44 store i32 %conv, i32* @vi32, align 4
46 ; CHECK-LABEL: TestFPToSIF128_I32:
47 ; CHECK: movaps vf128(%rip), %xmm0
48 ; CHECK-NEXT: callq __fixtfsi
49 ; CHECK-NEXT: movl %eax, vi32(%rip)
53 define void @TestFPToUIF128_U32() {
55 %0 = load fp128, fp128* @vf128, align 16
56 %conv = fptoui fp128 %0 to i32
57 store i32 %conv, i32* @vu32, align 4
59 ; CHECK-LABEL: TestFPToUIF128_U32:
60 ; CHECK: movaps vf128(%rip), %xmm0
61 ; CHECK-NEXT: callq __fixunstfsi
62 ; CHECK-NEXT: movl %eax, vu32(%rip)
66 define void @TestFPToSIF128_I64() {
68 %0 = load fp128, fp128* @vf128, align 16
69 %conv = fptosi fp128 %0 to i32
70 %conv1 = sext i32 %conv to i64
71 store i64 %conv1, i64* @vi64, align 8
73 ; CHECK-LABEL: TestFPToSIF128_I64:
74 ; CHECK: movaps vf128(%rip), %xmm0
75 ; CHECK-NEXT: callq __fixtfsi
77 ; CHECK-NEXT: movq %rax, vi64(%rip)
81 define void @TestFPToUIF128_U64() {
83 %0 = load fp128, fp128* @vf128, align 16
84 %conv = fptoui fp128 %0 to i32
85 %conv1 = zext i32 %conv to i64
86 store i64 %conv1, i64* @vu64, align 8
88 ; CHECK-LABEL: TestFPToUIF128_U64:
89 ; CHECK: movaps vf128(%rip), %xmm0
90 ; CHECK-NEXT: callq __fixunstfsi
91 ; CHECK-NEXT: movl %eax, %eax
92 ; CHECK-NEXT: movq %rax, vu64(%rip)
96 define void @TestFPTruncF128_F32() {
98 %0 = load fp128, fp128* @vf128, align 16
99 %conv = fptrunc fp128 %0 to float
100 store float %conv, float* @vf32, align 4
102 ; CHECK-LABEL: TestFPTruncF128_F32:
103 ; CHECK: movaps vf128(%rip), %xmm0
104 ; CHECK-NEXT: callq __trunctfsf2
105 ; CHECK-NEXT: movss %xmm0, vf32(%rip)
109 define void @TestFPTruncF128_F64() {
111 %0 = load fp128, fp128* @vf128, align 16
112 %conv = fptrunc fp128 %0 to double
113 store double %conv, double* @vf64, align 8
115 ; CHECK-LABEL: TestFPTruncF128_F64:
116 ; CHECK: movapd vf128(%rip), %xmm0
117 ; CHECK-NEXT: callq __trunctfdf2
118 ; CHECK-NEXT: movsd %xmm0, vf64(%rip)
122 define void @TestSIToFPI32_F128() {
124 %0 = load i32, i32* @vi32, align 4
125 %conv = sitofp i32 %0 to fp128
126 store fp128 %conv, fp128* @vf128, align 16
128 ; CHECK-LABEL: TestSIToFPI32_F128:
129 ; CHECK: movl vi32(%rip), %edi
130 ; CHECK-NEXT: callq __floatsitf
131 ; CHECK-NEXT: movaps %xmm0, vf128(%rip)
135 define void @TestUIToFPU32_F128() #2 {
137 %0 = load i32, i32* @vu32, align 4
138 %conv = uitofp i32 %0 to fp128
139 store fp128 %conv, fp128* @vf128, align 16
141 ; CHECK-LABEL: TestUIToFPU32_F128:
142 ; CHECK: movl vu32(%rip), %edi
143 ; CHECK-NEXT: callq __floatunsitf
144 ; CHECK-NEXT: movaps %xmm0, vf128(%rip)
148 define void @TestSIToFPI64_F128(){
150 %0 = load i64, i64* @vi64, align 8
151 %conv = sitofp i64 %0 to fp128
152 store fp128 %conv, fp128* @vf128, align 16
154 ; CHECK-LABEL: TestSIToFPI64_F128:
155 ; CHECK: movq vi64(%rip), %rdi
156 ; CHECK-NEXT: callq __floatditf
157 ; CHECK-NEXT: movaps %xmm0, vf128(%rip)
161 define void @TestUIToFPU64_F128() #2 {
163 %0 = load i64, i64* @vu64, align 8
164 %conv = uitofp i64 %0 to fp128
165 store fp128 %conv, fp128* @vf128, align 16
167 ; CHECK-LABEL: TestUIToFPU64_F128:
168 ; CHECK: movq vu64(%rip), %rdi
169 ; CHECK-NEXT: callq __floatunditf
170 ; CHECK-NEXT: movaps %xmm0, vf128(%rip)
174 define i32 @TestConst128(fp128 %v) {
176 %cmp = fcmp ogt fp128 %v, 0xL00000000000000003FFF000000000000
177 %conv = zext i1 %cmp to i32
179 ; CHECK-LABEL: TestConst128:
180 ; CHECK: movaps {{.*}}, %xmm1
181 ; CHECK-NEXT: callq __gttf2
187 ; struct TestBits_ieee_ext {
191 ; union TestBits_LDU {
193 ; struct TestBits_ieee_ext bits;
195 ; int TestBits128(FP128 ld) {
196 ; union TestBits_LDU u;
198 ; return ((u.bits.v1 | u.bits.v2) == 0);
200 define i32 @TestBits128(fp128 %ld) {
202 %mul = fmul fp128 %ld, %ld
203 %0 = bitcast fp128 %mul to i128
204 %shift = lshr i128 %0, 32
205 %or5 = or i128 %shift, %0
206 %or = trunc i128 %or5 to i32
207 %cmp = icmp eq i32 %or, 0
208 %conv = zext i1 %cmp to i32
210 ; CHECK-LABEL: TestBits128:
211 ; CHECK: movaps %xmm0, %xmm1
212 ; CHECK-NEXT: callq __multf3
213 ; CHECK-NEXT: movaps %xmm0, (%rsp)
214 ; CHECK-NEXT: movq (%rsp),
216 ; CHECK-NEXT: shrq $32,
218 ; CHECK-NEXT: sete %al
219 ; CHECK-NEXT: movzbl %al, %eax
222 ; If TestBits128 fails due to any llvm or clang change,
223 ; please make sure the original simplified C code will
224 ; be compiled into correct IL and assembly code, not
225 ; just this TestBits128 test case. Better yet, try to
226 ; test the whole libm and its test cases.
229 ; C code: (compiled with -target x86_64-linux-android)
230 ; typedef long double __float128;
231 ; __float128 TestPair128(unsigned long a, unsigned long b) {
232 ; unsigned __int128 n;
233 ; unsigned __int128 v1 = ((unsigned __int128)a << 64);
234 ; unsigned __int128 v2 = (unsigned __int128)b;
236 ; return *(__float128*)&n;
238 define fp128 @TestPair128(i64 %a, i64 %b) {
240 %conv = zext i64 %a to i128
241 %shl = shl nuw i128 %conv, 64
242 %conv1 = zext i64 %b to i128
243 %or = or i128 %shl, %conv1
244 %add = add i128 %or, 3
245 %0 = bitcast i128 %add to fp128
247 ; CHECK-LABEL: TestPair128:
248 ; CHECK: addq $3, %rsi
249 ; CHECK: movq %rsi, -24(%rsp)
250 ; CHECK: movq %rdi, -16(%rsp)
251 ; CHECK: movaps -24(%rsp), %xmm0
255 define fp128 @TestTruncCopysign(fp128 %x, i32 %n) {
257 %cmp = icmp sgt i32 %n, 50000
258 br i1 %cmp, label %if.then, label %cleanup
260 if.then: ; preds = %entry
261 %conv = fptrunc fp128 %x to double
262 %call = tail call double @copysign(double 0x7FF0000000000000, double %conv) #2
263 %conv1 = fpext double %call to fp128
266 cleanup: ; preds = %entry, %if.then
267 %retval.0 = phi fp128 [ %conv1, %if.then ], [ %x, %entry ]
269 ; CHECK-LABEL: TestTruncCopysign:
270 ; CHECK: callq __trunctfdf2
271 ; CHECK-NEXT: andpd {{.*}}, %xmm0
272 ; CHECK-NEXT: orpd {{.*}}, %xmm0
273 ; CHECK-NEXT: callq __extenddftf2
277 declare double @copysign(double, double) #1
279 attributes #2 = { nounwind readnone }