xref: /llvm-project/llvm/test/CodeGen/X86/fp128-libcalls.ll (revision 21630efb5a8f411cdf39b15f21a104888145b03f) 
1; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
2; RUN: llc < %s -O2 -mtriple=x86_64-linux-android \
3; RUN:     -enable-legalize-types-checking | FileCheck %s --check-prefix=ANDROID
4; RUN: llc < %s -O2 -mtriple=x86_64-linux-gnu \
5; RUN:     -enable-legalize-types-checking | FileCheck %s --check-prefix=GNU
6; RUN: llc < %s -O2 -mtriple=i686-linux-gnu -mattr=sse2 \
7; RUN:     -enable-legalize-types-checking | FileCheck %s --check-prefix=X86
8
9; Check all soft floating point library function calls.
10
11@vf64 = common dso_local global double 0.000000e+00, align 8
12@vf128 = common dso_local global fp128 0xL00000000000000000000000000000000, align 16
13
14define dso_local void @Test128Add(fp128 %d1, fp128 %d2) nounwind {
15; CHECK-LABEL: Test128Add:
16; CHECK:       # %bb.0: # %entry
17; CHECK-NEXT:    pushq %rax
18; CHECK-NEXT:    callq __addtf3@PLT
19; CHECK-NEXT:    movaps %xmm0, vf128(%rip)
20; CHECK-NEXT:    popq %rax
21; CHECK-NEXT:    retq
22;
23; ANDROID-LABEL: Test128Add:
24; ANDROID:       # %bb.0: # %entry
25; ANDROID-NEXT:    pushq %rax
26; ANDROID-NEXT:    callq __addtf3@PLT
27; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
28; ANDROID-NEXT:    popq %rax
29; ANDROID-NEXT:    retq
30;
31; GNU-LABEL: Test128Add:
32; GNU:       # %bb.0: # %entry
33; GNU-NEXT:    pushq %rax
34; GNU-NEXT:    callq __addtf3@PLT
35; GNU-NEXT:    movaps %xmm0, vf128(%rip)
36; GNU-NEXT:    popq %rax
37; GNU-NEXT:    retq
38;
39; X86-LABEL: Test128Add:
40; X86:       # %bb.0: # %entry
41; X86-NEXT:    subl $40, %esp
42; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
43; X86-NEXT:    pushl {{[0-9]+}}(%esp)
44; X86-NEXT:    pushl {{[0-9]+}}(%esp)
45; X86-NEXT:    pushl {{[0-9]+}}(%esp)
46; X86-NEXT:    pushl {{[0-9]+}}(%esp)
47; X86-NEXT:    pushl {{[0-9]+}}(%esp)
48; X86-NEXT:    pushl {{[0-9]+}}(%esp)
49; X86-NEXT:    pushl {{[0-9]+}}(%esp)
50; X86-NEXT:    pushl {{[0-9]+}}(%esp)
51; X86-NEXT:    pushl %eax
52; X86-NEXT:    calll __addtf3
53; X86-NEXT:    addl $44, %esp
54; X86-NEXT:    movaps (%esp), %xmm0
55; X86-NEXT:    movaps %xmm0, vf128
56; X86-NEXT:    addl $28, %esp
57; X86-NEXT:    retl
58entry:
59  %add = fadd fp128 %d1, %d2
60  store fp128 %add, ptr @vf128, align 16
61  ret void
62}
63
64define dso_local void @Test128_1Add(fp128 %d1) nounwind {
65; CHECK-LABEL: Test128_1Add:
66; CHECK:       # %bb.0: # %entry
67; CHECK-NEXT:    pushq %rax
68; CHECK-NEXT:    movaps %xmm0, %xmm1
69; CHECK-NEXT:    movaps vf128(%rip), %xmm0
70; CHECK-NEXT:    callq __addtf3@PLT
71; CHECK-NEXT:    movaps %xmm0, vf128(%rip)
72; CHECK-NEXT:    popq %rax
73; CHECK-NEXT:    retq
74;
75; ANDROID-LABEL: Test128_1Add:
76; ANDROID:       # %bb.0: # %entry
77; ANDROID-NEXT:    pushq %rax
78; ANDROID-NEXT:    movaps %xmm0, %xmm1
79; ANDROID-NEXT:    movaps vf128(%rip), %xmm0
80; ANDROID-NEXT:    callq __addtf3@PLT
81; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
82; ANDROID-NEXT:    popq %rax
83; ANDROID-NEXT:    retq
84;
85; GNU-LABEL: Test128_1Add:
86; GNU:       # %bb.0: # %entry
87; GNU-NEXT:    pushq %rax
88; GNU-NEXT:    movaps %xmm0, %xmm1
89; GNU-NEXT:    movaps vf128(%rip), %xmm0
90; GNU-NEXT:    callq __addtf3@PLT
91; GNU-NEXT:    movaps %xmm0, vf128(%rip)
92; GNU-NEXT:    popq %rax
93; GNU-NEXT:    retq
94;
95; X86-LABEL: Test128_1Add:
96; X86:       # %bb.0: # %entry
97; X86-NEXT:    subl $40, %esp
98; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
99; X86-NEXT:    pushl {{[0-9]+}}(%esp)
100; X86-NEXT:    pushl {{[0-9]+}}(%esp)
101; X86-NEXT:    pushl {{[0-9]+}}(%esp)
102; X86-NEXT:    pushl {{[0-9]+}}(%esp)
103; X86-NEXT:    pushl vf128+12
104; X86-NEXT:    pushl vf128+8
105; X86-NEXT:    pushl vf128+4
106; X86-NEXT:    pushl vf128
107; X86-NEXT:    pushl %eax
108; X86-NEXT:    calll __addtf3
109; X86-NEXT:    addl $44, %esp
110; X86-NEXT:    movaps (%esp), %xmm0
111; X86-NEXT:    movaps %xmm0, vf128
112; X86-NEXT:    addl $28, %esp
113; X86-NEXT:    retl
114entry:
115  %0 = load fp128, ptr @vf128, align 16
116  %add = fadd fp128 %0, %d1
117  store fp128 %add, ptr @vf128, align 16
118  ret void
119}
120
121define dso_local void @Test128Sub(fp128 %d1, fp128 %d2) nounwind {
122; CHECK-LABEL: Test128Sub:
123; CHECK:       # %bb.0: # %entry
124; CHECK-NEXT:    pushq %rax
125; CHECK-NEXT:    callq __subtf3@PLT
126; CHECK-NEXT:    movaps %xmm0, vf128(%rip)
127; CHECK-NEXT:    popq %rax
128; CHECK-NEXT:    retq
129;
130; ANDROID-LABEL: Test128Sub:
131; ANDROID:       # %bb.0: # %entry
132; ANDROID-NEXT:    pushq %rax
133; ANDROID-NEXT:    callq __subtf3@PLT
134; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
135; ANDROID-NEXT:    popq %rax
136; ANDROID-NEXT:    retq
137;
138; GNU-LABEL: Test128Sub:
139; GNU:       # %bb.0: # %entry
140; GNU-NEXT:    pushq %rax
141; GNU-NEXT:    callq __subtf3@PLT
142; GNU-NEXT:    movaps %xmm0, vf128(%rip)
143; GNU-NEXT:    popq %rax
144; GNU-NEXT:    retq
145;
146; X86-LABEL: Test128Sub:
147; X86:       # %bb.0: # %entry
148; X86-NEXT:    subl $40, %esp
149; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
150; X86-NEXT:    pushl {{[0-9]+}}(%esp)
151; X86-NEXT:    pushl {{[0-9]+}}(%esp)
152; X86-NEXT:    pushl {{[0-9]+}}(%esp)
153; X86-NEXT:    pushl {{[0-9]+}}(%esp)
154; X86-NEXT:    pushl {{[0-9]+}}(%esp)
155; X86-NEXT:    pushl {{[0-9]+}}(%esp)
156; X86-NEXT:    pushl {{[0-9]+}}(%esp)
157; X86-NEXT:    pushl {{[0-9]+}}(%esp)
158; X86-NEXT:    pushl %eax
159; X86-NEXT:    calll __subtf3
160; X86-NEXT:    addl $44, %esp
161; X86-NEXT:    movaps (%esp), %xmm0
162; X86-NEXT:    movaps %xmm0, vf128
163; X86-NEXT:    addl $28, %esp
164; X86-NEXT:    retl
165entry:
166  %sub = fsub fp128 %d1, %d2
167  store fp128 %sub, ptr @vf128, align 16
168  ret void
169}
170
171define dso_local void @Test128_1Sub(fp128 %d1) nounwind {
172; CHECK-LABEL: Test128_1Sub:
173; CHECK:       # %bb.0: # %entry
174; CHECK-NEXT:    pushq %rax
175; CHECK-NEXT:    movaps %xmm0, %xmm1
176; CHECK-NEXT:    movaps vf128(%rip), %xmm0
177; CHECK-NEXT:    callq __subtf3@PLT
178; CHECK-NEXT:    movaps %xmm0, vf128(%rip)
179; CHECK-NEXT:    popq %rax
180; CHECK-NEXT:    retq
181;
182; ANDROID-LABEL: Test128_1Sub:
183; ANDROID:       # %bb.0: # %entry
184; ANDROID-NEXT:    pushq %rax
185; ANDROID-NEXT:    movaps %xmm0, %xmm1
186; ANDROID-NEXT:    movaps vf128(%rip), %xmm0
187; ANDROID-NEXT:    callq __subtf3@PLT
188; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
189; ANDROID-NEXT:    popq %rax
190; ANDROID-NEXT:    retq
191;
192; GNU-LABEL: Test128_1Sub:
193; GNU:       # %bb.0: # %entry
194; GNU-NEXT:    pushq %rax
195; GNU-NEXT:    movaps %xmm0, %xmm1
196; GNU-NEXT:    movaps vf128(%rip), %xmm0
197; GNU-NEXT:    callq __subtf3@PLT
198; GNU-NEXT:    movaps %xmm0, vf128(%rip)
199; GNU-NEXT:    popq %rax
200; GNU-NEXT:    retq
201;
202; X86-LABEL: Test128_1Sub:
203; X86:       # %bb.0: # %entry
204; X86-NEXT:    subl $40, %esp
205; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
206; X86-NEXT:    pushl {{[0-9]+}}(%esp)
207; X86-NEXT:    pushl {{[0-9]+}}(%esp)
208; X86-NEXT:    pushl {{[0-9]+}}(%esp)
209; X86-NEXT:    pushl {{[0-9]+}}(%esp)
210; X86-NEXT:    pushl vf128+12
211; X86-NEXT:    pushl vf128+8
212; X86-NEXT:    pushl vf128+4
213; X86-NEXT:    pushl vf128
214; X86-NEXT:    pushl %eax
215; X86-NEXT:    calll __subtf3
216; X86-NEXT:    addl $44, %esp
217; X86-NEXT:    movaps (%esp), %xmm0
218; X86-NEXT:    movaps %xmm0, vf128
219; X86-NEXT:    addl $28, %esp
220; X86-NEXT:    retl
221entry:
222  %0 = load fp128, ptr @vf128, align 16
223  %sub = fsub fp128 %0, %d1
224  store fp128 %sub, ptr @vf128, align 16
225  ret void
226}
227
228define dso_local void @Test128Mul(fp128 %d1, fp128 %d2) nounwind {
229; CHECK-LABEL: Test128Mul:
230; CHECK:       # %bb.0: # %entry
231; CHECK-NEXT:    pushq %rax
232; CHECK-NEXT:    callq __multf3@PLT
233; CHECK-NEXT:    movaps %xmm0, vf128(%rip)
234; CHECK-NEXT:    popq %rax
235; CHECK-NEXT:    retq
236;
237; ANDROID-LABEL: Test128Mul:
238; ANDROID:       # %bb.0: # %entry
239; ANDROID-NEXT:    pushq %rax
240; ANDROID-NEXT:    callq __multf3@PLT
241; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
242; ANDROID-NEXT:    popq %rax
243; ANDROID-NEXT:    retq
244;
245; GNU-LABEL: Test128Mul:
246; GNU:       # %bb.0: # %entry
247; GNU-NEXT:    pushq %rax
248; GNU-NEXT:    callq __multf3@PLT
249; GNU-NEXT:    movaps %xmm0, vf128(%rip)
250; GNU-NEXT:    popq %rax
251; GNU-NEXT:    retq
252;
253; X86-LABEL: Test128Mul:
254; X86:       # %bb.0: # %entry
255; X86-NEXT:    subl $40, %esp
256; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
257; X86-NEXT:    pushl {{[0-9]+}}(%esp)
258; X86-NEXT:    pushl {{[0-9]+}}(%esp)
259; X86-NEXT:    pushl {{[0-9]+}}(%esp)
260; X86-NEXT:    pushl {{[0-9]+}}(%esp)
261; X86-NEXT:    pushl {{[0-9]+}}(%esp)
262; X86-NEXT:    pushl {{[0-9]+}}(%esp)
263; X86-NEXT:    pushl {{[0-9]+}}(%esp)
264; X86-NEXT:    pushl {{[0-9]+}}(%esp)
265; X86-NEXT:    pushl %eax
266; X86-NEXT:    calll __multf3
267; X86-NEXT:    addl $44, %esp
268; X86-NEXT:    movaps (%esp), %xmm0
269; X86-NEXT:    movaps %xmm0, vf128
270; X86-NEXT:    addl $28, %esp
271; X86-NEXT:    retl
272entry:
273  %mul = fmul fp128 %d1, %d2
274  store fp128 %mul, ptr @vf128, align 16
275  ret void
276}
277
278define dso_local void @Test128_1Mul(fp128 %d1) nounwind {
279; CHECK-LABEL: Test128_1Mul:
280; CHECK:       # %bb.0: # %entry
281; CHECK-NEXT:    pushq %rax
282; CHECK-NEXT:    movaps %xmm0, %xmm1
283; CHECK-NEXT:    movaps vf128(%rip), %xmm0
284; CHECK-NEXT:    callq __multf3@PLT
285; CHECK-NEXT:    movaps %xmm0, vf128(%rip)
286; CHECK-NEXT:    popq %rax
287; CHECK-NEXT:    retq
288;
289; ANDROID-LABEL: Test128_1Mul:
290; ANDROID:       # %bb.0: # %entry
291; ANDROID-NEXT:    pushq %rax
292; ANDROID-NEXT:    movaps %xmm0, %xmm1
293; ANDROID-NEXT:    movaps vf128(%rip), %xmm0
294; ANDROID-NEXT:    callq __multf3@PLT
295; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
296; ANDROID-NEXT:    popq %rax
297; ANDROID-NEXT:    retq
298;
299; GNU-LABEL: Test128_1Mul:
300; GNU:       # %bb.0: # %entry
301; GNU-NEXT:    pushq %rax
302; GNU-NEXT:    movaps %xmm0, %xmm1
303; GNU-NEXT:    movaps vf128(%rip), %xmm0
304; GNU-NEXT:    callq __multf3@PLT
305; GNU-NEXT:    movaps %xmm0, vf128(%rip)
306; GNU-NEXT:    popq %rax
307; GNU-NEXT:    retq
308;
309; X86-LABEL: Test128_1Mul:
310; X86:       # %bb.0: # %entry
311; X86-NEXT:    subl $40, %esp
312; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
313; X86-NEXT:    pushl {{[0-9]+}}(%esp)
314; X86-NEXT:    pushl {{[0-9]+}}(%esp)
315; X86-NEXT:    pushl {{[0-9]+}}(%esp)
316; X86-NEXT:    pushl {{[0-9]+}}(%esp)
317; X86-NEXT:    pushl vf128+12
318; X86-NEXT:    pushl vf128+8
319; X86-NEXT:    pushl vf128+4
320; X86-NEXT:    pushl vf128
321; X86-NEXT:    pushl %eax
322; X86-NEXT:    calll __multf3
323; X86-NEXT:    addl $44, %esp
324; X86-NEXT:    movaps (%esp), %xmm0
325; X86-NEXT:    movaps %xmm0, vf128
326; X86-NEXT:    addl $28, %esp
327; X86-NEXT:    retl
328entry:
329  %0 = load fp128, ptr @vf128, align 16
330  %mul = fmul fp128 %0, %d1
331  store fp128 %mul, ptr @vf128, align 16
332  ret void
333}
334
335define dso_local void @Test128Div(fp128 %d1, fp128 %d2) nounwind {
336; CHECK-LABEL: Test128Div:
337; CHECK:       # %bb.0: # %entry
338; CHECK-NEXT:    pushq %rax
339; CHECK-NEXT:    callq __divtf3@PLT
340; CHECK-NEXT:    movaps %xmm0, vf128(%rip)
341; CHECK-NEXT:    popq %rax
342; CHECK-NEXT:    retq
343;
344; ANDROID-LABEL: Test128Div:
345; ANDROID:       # %bb.0: # %entry
346; ANDROID-NEXT:    pushq %rax
347; ANDROID-NEXT:    callq __divtf3@PLT
348; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
349; ANDROID-NEXT:    popq %rax
350; ANDROID-NEXT:    retq
351;
352; GNU-LABEL: Test128Div:
353; GNU:       # %bb.0: # %entry
354; GNU-NEXT:    pushq %rax
355; GNU-NEXT:    callq __divtf3@PLT
356; GNU-NEXT:    movaps %xmm0, vf128(%rip)
357; GNU-NEXT:    popq %rax
358; GNU-NEXT:    retq
359;
360; X86-LABEL: Test128Div:
361; X86:       # %bb.0: # %entry
362; X86-NEXT:    subl $40, %esp
363; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
364; X86-NEXT:    pushl {{[0-9]+}}(%esp)
365; X86-NEXT:    pushl {{[0-9]+}}(%esp)
366; X86-NEXT:    pushl {{[0-9]+}}(%esp)
367; X86-NEXT:    pushl {{[0-9]+}}(%esp)
368; X86-NEXT:    pushl {{[0-9]+}}(%esp)
369; X86-NEXT:    pushl {{[0-9]+}}(%esp)
370; X86-NEXT:    pushl {{[0-9]+}}(%esp)
371; X86-NEXT:    pushl {{[0-9]+}}(%esp)
372; X86-NEXT:    pushl %eax
373; X86-NEXT:    calll __divtf3
374; X86-NEXT:    addl $44, %esp
375; X86-NEXT:    movaps (%esp), %xmm0
376; X86-NEXT:    movaps %xmm0, vf128
377; X86-NEXT:    addl $28, %esp
378; X86-NEXT:    retl
379entry:
380  %div = fdiv fp128 %d1, %d2
381  store fp128 %div, ptr @vf128, align 16
382  ret void
383}
384
385define dso_local void @Test128_1Div(fp128 %d1) nounwind {
386; CHECK-LABEL: Test128_1Div:
387; CHECK:       # %bb.0: # %entry
388; CHECK-NEXT:    pushq %rax
389; CHECK-NEXT:    movaps %xmm0, %xmm1
390; CHECK-NEXT:    movaps vf128(%rip), %xmm0
391; CHECK-NEXT:    callq __divtf3@PLT
392; CHECK-NEXT:    movaps %xmm0, vf128(%rip)
393; CHECK-NEXT:    popq %rax
394; CHECK-NEXT:    retq
395;
396; ANDROID-LABEL: Test128_1Div:
397; ANDROID:       # %bb.0: # %entry
398; ANDROID-NEXT:    pushq %rax
399; ANDROID-NEXT:    movaps %xmm0, %xmm1
400; ANDROID-NEXT:    movaps vf128(%rip), %xmm0
401; ANDROID-NEXT:    callq __divtf3@PLT
402; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
403; ANDROID-NEXT:    popq %rax
404; ANDROID-NEXT:    retq
405;
406; GNU-LABEL: Test128_1Div:
407; GNU:       # %bb.0: # %entry
408; GNU-NEXT:    pushq %rax
409; GNU-NEXT:    movaps %xmm0, %xmm1
410; GNU-NEXT:    movaps vf128(%rip), %xmm0
411; GNU-NEXT:    callq __divtf3@PLT
412; GNU-NEXT:    movaps %xmm0, vf128(%rip)
413; GNU-NEXT:    popq %rax
414; GNU-NEXT:    retq
415;
416; X86-LABEL: Test128_1Div:
417; X86:       # %bb.0: # %entry
418; X86-NEXT:    subl $40, %esp
419; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
420; X86-NEXT:    pushl {{[0-9]+}}(%esp)
421; X86-NEXT:    pushl {{[0-9]+}}(%esp)
422; X86-NEXT:    pushl {{[0-9]+}}(%esp)
423; X86-NEXT:    pushl {{[0-9]+}}(%esp)
424; X86-NEXT:    pushl vf128+12
425; X86-NEXT:    pushl vf128+8
426; X86-NEXT:    pushl vf128+4
427; X86-NEXT:    pushl vf128
428; X86-NEXT:    pushl %eax
429; X86-NEXT:    calll __divtf3
430; X86-NEXT:    addl $44, %esp
431; X86-NEXT:    movaps (%esp), %xmm0
432; X86-NEXT:    movaps %xmm0, vf128
433; X86-NEXT:    addl $28, %esp
434; X86-NEXT:    retl
435entry:
436  %0 = load fp128, ptr @vf128, align 16
437  %div = fdiv fp128 %0, %d1
438  store fp128 %div, ptr @vf128, align 16
439  ret void
440}
441
442define dso_local void @Test128Rem(fp128 %d1, fp128 %d2) nounwind {
443; ANDROID-LABEL: Test128Rem:
444; ANDROID:       # %bb.0: # %entry
445; ANDROID-NEXT:    pushq %rax
446; ANDROID-NEXT:    callq fmodl@PLT
447; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
448; ANDROID-NEXT:    popq %rax
449; ANDROID-NEXT:    retq
450;
451; GNU-LABEL: Test128Rem:
452; GNU:       # %bb.0: # %entry
453; GNU-NEXT:    pushq %rax
454; GNU-NEXT:    callq fmodf128@PLT
455; GNU-NEXT:    movaps %xmm0, vf128(%rip)
456; GNU-NEXT:    popq %rax
457; GNU-NEXT:    retq
458;
459; X86-LABEL: Test128Rem:
460; X86:       # %bb.0: # %entry
461; X86-NEXT:    subl $40, %esp
462; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
463; X86-NEXT:    pushl {{[0-9]+}}(%esp)
464; X86-NEXT:    pushl {{[0-9]+}}(%esp)
465; X86-NEXT:    pushl {{[0-9]+}}(%esp)
466; X86-NEXT:    pushl {{[0-9]+}}(%esp)
467; X86-NEXT:    pushl {{[0-9]+}}(%esp)
468; X86-NEXT:    pushl {{[0-9]+}}(%esp)
469; X86-NEXT:    pushl {{[0-9]+}}(%esp)
470; X86-NEXT:    pushl {{[0-9]+}}(%esp)
471; X86-NEXT:    pushl %eax
472; X86-NEXT:    calll fmodl
473; X86-NEXT:    addl $44, %esp
474; X86-NEXT:    movaps (%esp), %xmm0
475; X86-NEXT:    movaps %xmm0, vf128
476; X86-NEXT:    addl $28, %esp
477; X86-NEXT:    retl
478entry:
479  %div = frem fp128 %d1, %d2
480  store fp128 %div, ptr @vf128, align 16
481  ret void
482}
483
484define dso_local void @Test128_1Rem(fp128 %d1) nounwind {
485; ANDROID-LABEL: Test128_1Rem:
486; ANDROID:       # %bb.0: # %entry
487; ANDROID-NEXT:    pushq %rax
488; ANDROID-NEXT:    movaps %xmm0, %xmm1
489; ANDROID-NEXT:    movaps vf128(%rip), %xmm0
490; ANDROID-NEXT:    callq fmodl@PLT
491; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
492; ANDROID-NEXT:    popq %rax
493; ANDROID-NEXT:    retq
494;
495; GNU-LABEL: Test128_1Rem:
496; GNU:       # %bb.0: # %entry
497; GNU-NEXT:    pushq %rax
498; GNU-NEXT:    movaps %xmm0, %xmm1
499; GNU-NEXT:    movaps vf128(%rip), %xmm0
500; GNU-NEXT:    callq fmodf128@PLT
501; GNU-NEXT:    movaps %xmm0, vf128(%rip)
502; GNU-NEXT:    popq %rax
503; GNU-NEXT:    retq
504;
505; X86-LABEL: Test128_1Rem:
506; X86:       # %bb.0: # %entry
507; X86-NEXT:    subl $40, %esp
508; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
509; X86-NEXT:    pushl {{[0-9]+}}(%esp)
510; X86-NEXT:    pushl {{[0-9]+}}(%esp)
511; X86-NEXT:    pushl {{[0-9]+}}(%esp)
512; X86-NEXT:    pushl {{[0-9]+}}(%esp)
513; X86-NEXT:    pushl vf128+12
514; X86-NEXT:    pushl vf128+8
515; X86-NEXT:    pushl vf128+4
516; X86-NEXT:    pushl vf128
517; X86-NEXT:    pushl %eax
518; X86-NEXT:    calll fmodl
519; X86-NEXT:    addl $44, %esp
520; X86-NEXT:    movaps (%esp), %xmm0
521; X86-NEXT:    movaps %xmm0, vf128
522; X86-NEXT:    addl $28, %esp
523; X86-NEXT:    retl
524entry:
525  %0 = load fp128, ptr @vf128, align 16
526  %div = frem fp128 %0, %d1
527  store fp128 %div, ptr @vf128, align 16
528  ret void
529}
530
531define dso_local void @Test128Sqrt(fp128 %d1) nounwind {
532; ANDROID-LABEL: Test128Sqrt:
533; ANDROID:       # %bb.0: # %entry
534; ANDROID-NEXT:    pushq %rax
535; ANDROID-NEXT:    callq sqrtl@PLT
536; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
537; ANDROID-NEXT:    popq %rax
538; ANDROID-NEXT:    retq
539;
540; GNU-LABEL: Test128Sqrt:
541; GNU:       # %bb.0: # %entry
542; GNU-NEXT:    pushq %rax
543; GNU-NEXT:    callq sqrtf128@PLT
544; GNU-NEXT:    movaps %xmm0, vf128(%rip)
545; GNU-NEXT:    popq %rax
546; GNU-NEXT:    retq
547;
548; X86-LABEL: Test128Sqrt:
549; X86:       # %bb.0: # %entry
550; X86-NEXT:    subl $40, %esp
551; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
552; X86-NEXT:    pushl {{[0-9]+}}(%esp)
553; X86-NEXT:    pushl {{[0-9]+}}(%esp)
554; X86-NEXT:    pushl {{[0-9]+}}(%esp)
555; X86-NEXT:    pushl {{[0-9]+}}(%esp)
556; X86-NEXT:    pushl %eax
557; X86-NEXT:    calll sqrtl
558; X86-NEXT:    addl $28, %esp
559; X86-NEXT:    movaps (%esp), %xmm0
560; X86-NEXT:    movaps %xmm0, vf128
561; X86-NEXT:    addl $28, %esp
562; X86-NEXT:    retl
563entry:
564  %sqrt = call fp128 @llvm.sqrt.f128(fp128 %d1)
565  store fp128 %sqrt, ptr @vf128, align 16
566  ret void
567}
568declare fp128 @llvm.sqrt.f128(fp128)
569
570define dso_local void @Test128Sin(fp128 %d1) nounwind {
571; ANDROID-LABEL: Test128Sin:
572; ANDROID:       # %bb.0: # %entry
573; ANDROID-NEXT:    pushq %rax
574; ANDROID-NEXT:    callq sinl@PLT
575; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
576; ANDROID-NEXT:    popq %rax
577; ANDROID-NEXT:    retq
578;
579; GNU-LABEL: Test128Sin:
580; GNU:       # %bb.0: # %entry
581; GNU-NEXT:    pushq %rax
582; GNU-NEXT:    callq sinf128@PLT
583; GNU-NEXT:    movaps %xmm0, vf128(%rip)
584; GNU-NEXT:    popq %rax
585; GNU-NEXT:    retq
586;
587; X86-LABEL: Test128Sin:
588; X86:       # %bb.0: # %entry
589; X86-NEXT:    subl $40, %esp
590; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
591; X86-NEXT:    pushl {{[0-9]+}}(%esp)
592; X86-NEXT:    pushl {{[0-9]+}}(%esp)
593; X86-NEXT:    pushl {{[0-9]+}}(%esp)
594; X86-NEXT:    pushl {{[0-9]+}}(%esp)
595; X86-NEXT:    pushl %eax
596; X86-NEXT:    calll sinl
597; X86-NEXT:    addl $28, %esp
598; X86-NEXT:    movaps (%esp), %xmm0
599; X86-NEXT:    movaps %xmm0, vf128
600; X86-NEXT:    addl $28, %esp
601; X86-NEXT:    retl
602entry:
603  %sqrt = call fp128 @llvm.sin.f128(fp128 %d1)
604  store fp128 %sqrt, ptr @vf128, align 16
605  ret void
606}
607declare fp128 @llvm.sin.f128(fp128)
608
609define dso_local void @Test128Cos(fp128 %d1) nounwind {
610; ANDROID-LABEL: Test128Cos:
611; ANDROID:       # %bb.0: # %entry
612; ANDROID-NEXT:    pushq %rax
613; ANDROID-NEXT:    callq cosl@PLT
614; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
615; ANDROID-NEXT:    popq %rax
616; ANDROID-NEXT:    retq
617;
618; GNU-LABEL: Test128Cos:
619; GNU:       # %bb.0: # %entry
620; GNU-NEXT:    pushq %rax
621; GNU-NEXT:    callq cosf128@PLT
622; GNU-NEXT:    movaps %xmm0, vf128(%rip)
623; GNU-NEXT:    popq %rax
624; GNU-NEXT:    retq
625;
626; X86-LABEL: Test128Cos:
627; X86:       # %bb.0: # %entry
628; X86-NEXT:    subl $40, %esp
629; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
630; X86-NEXT:    pushl {{[0-9]+}}(%esp)
631; X86-NEXT:    pushl {{[0-9]+}}(%esp)
632; X86-NEXT:    pushl {{[0-9]+}}(%esp)
633; X86-NEXT:    pushl {{[0-9]+}}(%esp)
634; X86-NEXT:    pushl %eax
635; X86-NEXT:    calll cosl
636; X86-NEXT:    addl $28, %esp
637; X86-NEXT:    movaps (%esp), %xmm0
638; X86-NEXT:    movaps %xmm0, vf128
639; X86-NEXT:    addl $28, %esp
640; X86-NEXT:    retl
641entry:
642  %sqrt = call fp128 @llvm.cos.f128(fp128 %d1)
643  store fp128 %sqrt, ptr @vf128, align 16
644  ret void
645}
646declare fp128 @llvm.cos.f128(fp128)
647
648define dso_local void @Test128Ceil(fp128 %d1) nounwind {
649; ANDROID-LABEL: Test128Ceil:
650; ANDROID:       # %bb.0: # %entry
651; ANDROID-NEXT:    pushq %rax
652; ANDROID-NEXT:    callq ceill@PLT
653; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
654; ANDROID-NEXT:    popq %rax
655; ANDROID-NEXT:    retq
656;
657; GNU-LABEL: Test128Ceil:
658; GNU:       # %bb.0: # %entry
659; GNU-NEXT:    pushq %rax
660; GNU-NEXT:    callq ceilf128@PLT
661; GNU-NEXT:    movaps %xmm0, vf128(%rip)
662; GNU-NEXT:    popq %rax
663; GNU-NEXT:    retq
664;
665; X86-LABEL: Test128Ceil:
666; X86:       # %bb.0: # %entry
667; X86-NEXT:    subl $40, %esp
668; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
669; X86-NEXT:    pushl {{[0-9]+}}(%esp)
670; X86-NEXT:    pushl {{[0-9]+}}(%esp)
671; X86-NEXT:    pushl {{[0-9]+}}(%esp)
672; X86-NEXT:    pushl {{[0-9]+}}(%esp)
673; X86-NEXT:    pushl %eax
674; X86-NEXT:    calll ceill
675; X86-NEXT:    addl $28, %esp
676; X86-NEXT:    movaps (%esp), %xmm0
677; X86-NEXT:    movaps %xmm0, vf128
678; X86-NEXT:    addl $28, %esp
679; X86-NEXT:    retl
680entry:
681  %sqrt = call fp128 @llvm.ceil.f128(fp128 %d1)
682  store fp128 %sqrt, ptr @vf128, align 16
683  ret void
684}
685declare fp128 @llvm.ceil.f128(fp128)
686
687define dso_local void @Test128Floor(fp128 %d1) nounwind {
688; ANDROID-LABEL: Test128Floor:
689; ANDROID:       # %bb.0: # %entry
690; ANDROID-NEXT:    pushq %rax
691; ANDROID-NEXT:    callq floorl@PLT
692; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
693; ANDROID-NEXT:    popq %rax
694; ANDROID-NEXT:    retq
695;
696; GNU-LABEL: Test128Floor:
697; GNU:       # %bb.0: # %entry
698; GNU-NEXT:    pushq %rax
699; GNU-NEXT:    callq floorf128@PLT
700; GNU-NEXT:    movaps %xmm0, vf128(%rip)
701; GNU-NEXT:    popq %rax
702; GNU-NEXT:    retq
703;
704; X86-LABEL: Test128Floor:
705; X86:       # %bb.0: # %entry
706; X86-NEXT:    subl $40, %esp
707; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
708; X86-NEXT:    pushl {{[0-9]+}}(%esp)
709; X86-NEXT:    pushl {{[0-9]+}}(%esp)
710; X86-NEXT:    pushl {{[0-9]+}}(%esp)
711; X86-NEXT:    pushl {{[0-9]+}}(%esp)
712; X86-NEXT:    pushl %eax
713; X86-NEXT:    calll floorl
714; X86-NEXT:    addl $28, %esp
715; X86-NEXT:    movaps (%esp), %xmm0
716; X86-NEXT:    movaps %xmm0, vf128
717; X86-NEXT:    addl $28, %esp
718; X86-NEXT:    retl
719entry:
720  %sqrt = call fp128 @llvm.floor.f128(fp128 %d1)
721  store fp128 %sqrt, ptr @vf128, align 16
722  ret void
723}
724declare fp128 @llvm.floor.f128(fp128)
725
726define dso_local void @Test128Trunc(fp128 %d1) nounwind {
727; ANDROID-LABEL: Test128Trunc:
728; ANDROID:       # %bb.0: # %entry
729; ANDROID-NEXT:    pushq %rax
730; ANDROID-NEXT:    callq truncl@PLT
731; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
732; ANDROID-NEXT:    popq %rax
733; ANDROID-NEXT:    retq
734;
735; GNU-LABEL: Test128Trunc:
736; GNU:       # %bb.0: # %entry
737; GNU-NEXT:    pushq %rax
738; GNU-NEXT:    callq truncf128@PLT
739; GNU-NEXT:    movaps %xmm0, vf128(%rip)
740; GNU-NEXT:    popq %rax
741; GNU-NEXT:    retq
742;
743; X86-LABEL: Test128Trunc:
744; X86:       # %bb.0: # %entry
745; X86-NEXT:    subl $40, %esp
746; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
747; X86-NEXT:    pushl {{[0-9]+}}(%esp)
748; X86-NEXT:    pushl {{[0-9]+}}(%esp)
749; X86-NEXT:    pushl {{[0-9]+}}(%esp)
750; X86-NEXT:    pushl {{[0-9]+}}(%esp)
751; X86-NEXT:    pushl %eax
752; X86-NEXT:    calll truncl
753; X86-NEXT:    addl $28, %esp
754; X86-NEXT:    movaps (%esp), %xmm0
755; X86-NEXT:    movaps %xmm0, vf128
756; X86-NEXT:    addl $28, %esp
757; X86-NEXT:    retl
758entry:
759  %sqrt = call fp128 @llvm.trunc.f128(fp128 %d1)
760  store fp128 %sqrt, ptr @vf128, align 16
761  ret void
762}
763declare fp128 @llvm.trunc.f128(fp128)
764
765define dso_local void @Test128Nearbyint(fp128 %d1) nounwind {
766; ANDROID-LABEL: Test128Nearbyint:
767; ANDROID:       # %bb.0: # %entry
768; ANDROID-NEXT:    pushq %rax
769; ANDROID-NEXT:    callq nearbyintl@PLT
770; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
771; ANDROID-NEXT:    popq %rax
772; ANDROID-NEXT:    retq
773;
774; GNU-LABEL: Test128Nearbyint:
775; GNU:       # %bb.0: # %entry
776; GNU-NEXT:    pushq %rax
777; GNU-NEXT:    callq nearbyintf128@PLT
778; GNU-NEXT:    movaps %xmm0, vf128(%rip)
779; GNU-NEXT:    popq %rax
780; GNU-NEXT:    retq
781;
782; X86-LABEL: Test128Nearbyint:
783; X86:       # %bb.0: # %entry
784; X86-NEXT:    subl $40, %esp
785; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
786; X86-NEXT:    pushl {{[0-9]+}}(%esp)
787; X86-NEXT:    pushl {{[0-9]+}}(%esp)
788; X86-NEXT:    pushl {{[0-9]+}}(%esp)
789; X86-NEXT:    pushl {{[0-9]+}}(%esp)
790; X86-NEXT:    pushl %eax
791; X86-NEXT:    calll nearbyintl
792; X86-NEXT:    addl $28, %esp
793; X86-NEXT:    movaps (%esp), %xmm0
794; X86-NEXT:    movaps %xmm0, vf128
795; X86-NEXT:    addl $28, %esp
796; X86-NEXT:    retl
797entry:
798  %sqrt = call fp128 @llvm.nearbyint.f128(fp128 %d1)
799  store fp128 %sqrt, ptr @vf128, align 16
800  ret void
801}
802declare fp128 @llvm.nearbyint.f128(fp128)
803
804define dso_local void @Test128Rint(fp128 %d1) nounwind {
805; ANDROID-LABEL: Test128Rint:
806; ANDROID:       # %bb.0: # %entry
807; ANDROID-NEXT:    pushq %rax
808; ANDROID-NEXT:    callq rintl@PLT
809; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
810; ANDROID-NEXT:    popq %rax
811; ANDROID-NEXT:    retq
812;
813; GNU-LABEL: Test128Rint:
814; GNU:       # %bb.0: # %entry
815; GNU-NEXT:    pushq %rax
816; GNU-NEXT:    callq rintf128@PLT
817; GNU-NEXT:    movaps %xmm0, vf128(%rip)
818; GNU-NEXT:    popq %rax
819; GNU-NEXT:    retq
820;
821; X86-LABEL: Test128Rint:
822; X86:       # %bb.0: # %entry
823; X86-NEXT:    subl $40, %esp
824; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
825; X86-NEXT:    pushl {{[0-9]+}}(%esp)
826; X86-NEXT:    pushl {{[0-9]+}}(%esp)
827; X86-NEXT:    pushl {{[0-9]+}}(%esp)
828; X86-NEXT:    pushl {{[0-9]+}}(%esp)
829; X86-NEXT:    pushl %eax
830; X86-NEXT:    calll rintl
831; X86-NEXT:    addl $28, %esp
832; X86-NEXT:    movaps (%esp), %xmm0
833; X86-NEXT:    movaps %xmm0, vf128
834; X86-NEXT:    addl $28, %esp
835; X86-NEXT:    retl
836entry:
837  %sqrt = call fp128 @llvm.rint.f128(fp128 %d1)
838  store fp128 %sqrt, ptr @vf128, align 16
839  ret void
840}
841declare fp128 @llvm.rint.f128(fp128)
842
843define dso_local void @Test128Round(fp128 %d1) nounwind {
844; ANDROID-LABEL: Test128Round:
845; ANDROID:       # %bb.0: # %entry
846; ANDROID-NEXT:    pushq %rax
847; ANDROID-NEXT:    callq roundl@PLT
848; ANDROID-NEXT:    movaps %xmm0, vf128(%rip)
849; ANDROID-NEXT:    popq %rax
850; ANDROID-NEXT:    retq
851;
852; GNU-LABEL: Test128Round:
853; GNU:       # %bb.0: # %entry
854; GNU-NEXT:    pushq %rax
855; GNU-NEXT:    callq roundf128@PLT
856; GNU-NEXT:    movaps %xmm0, vf128(%rip)
857; GNU-NEXT:    popq %rax
858; GNU-NEXT:    retq
859;
860; X86-LABEL: Test128Round:
861; X86:       # %bb.0: # %entry
862; X86-NEXT:    subl $40, %esp
863; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
864; X86-NEXT:    pushl {{[0-9]+}}(%esp)
865; X86-NEXT:    pushl {{[0-9]+}}(%esp)
866; X86-NEXT:    pushl {{[0-9]+}}(%esp)
867; X86-NEXT:    pushl {{[0-9]+}}(%esp)
868; X86-NEXT:    pushl %eax
869; X86-NEXT:    calll roundl
870; X86-NEXT:    addl $28, %esp
871; X86-NEXT:    movaps (%esp), %xmm0
872; X86-NEXT:    movaps %xmm0, vf128
873; X86-NEXT:    addl $28, %esp
874; X86-NEXT:    retl
875entry:
876  %sqrt = call fp128 @llvm.round.f128(fp128 %d1)
877  store fp128 %sqrt, ptr @vf128, align 16
878  ret void
879}
880declare fp128 @llvm.round.f128(fp128)
881
882define fp128 @Test128FMA(fp128 %a, fp128 %b, fp128 %c) nounwind {
883; ANDROID-LABEL: Test128FMA:
884; ANDROID:       # %bb.0: # %entry
885; ANDROID-NEXT:    jmp fmal@PLT # TAILCALL
886;
887; GNU-LABEL: Test128FMA:
888; GNU:       # %bb.0: # %entry
889; GNU-NEXT:    jmp fmaf128@PLT # TAILCALL
890;
891; X86-LABEL: Test128FMA:
892; X86:       # %bb.0: # %entry
893; X86-NEXT:    pushl %esi
894; X86-NEXT:    subl $24, %esp
895; X86-NEXT:    movl {{[0-9]+}}(%esp), %esi
896; X86-NEXT:    subl $12, %esp
897; X86-NEXT:    leal {{[0-9]+}}(%esp), %eax
898; X86-NEXT:    pushl {{[0-9]+}}(%esp)
899; X86-NEXT:    pushl {{[0-9]+}}(%esp)
900; X86-NEXT:    pushl {{[0-9]+}}(%esp)
901; X86-NEXT:    pushl {{[0-9]+}}(%esp)
902; X86-NEXT:    pushl {{[0-9]+}}(%esp)
903; X86-NEXT:    pushl {{[0-9]+}}(%esp)
904; X86-NEXT:    pushl {{[0-9]+}}(%esp)
905; X86-NEXT:    pushl {{[0-9]+}}(%esp)
906; X86-NEXT:    pushl {{[0-9]+}}(%esp)
907; X86-NEXT:    pushl {{[0-9]+}}(%esp)
908; X86-NEXT:    pushl {{[0-9]+}}(%esp)
909; X86-NEXT:    pushl {{[0-9]+}}(%esp)
910; X86-NEXT:    pushl %eax
911; X86-NEXT:    calll fmal
912; X86-NEXT:    addl $60, %esp
913; X86-NEXT:    movaps (%esp), %xmm0
914; X86-NEXT:    movaps %xmm0, (%esi)
915; X86-NEXT:    movl %esi, %eax
916; X86-NEXT:    addl $24, %esp
917; X86-NEXT:    popl %esi
918; X86-NEXT:    retl $4
919entry:
920  %call = call fp128 @llvm.fma.f128(fp128 %a, fp128 %b, fp128 %c)
921  ret fp128 %call
922}
923declare fp128 @llvm.fma.f128(fp128, fp128, fp128)
924