1; RUN: llc -mtriple=arm64-linux-gnu -verify-machineinstrs -mcpu=cyclone -aarch64-atomic-cfg-tidy=0 < %s | FileCheck %s
2
3@lhs = global fp128 zeroinitializer, align 16
4@rhs = global fp128 zeroinitializer, align 16
5
6define fp128 @test_add() {
7; CHECK-LABEL: test_add:
8
9  %lhs = load fp128* @lhs, align 16
10  %rhs = load fp128* @rhs, align 16
11; CHECK: ldr q0, [{{x[0-9]+}}, :lo12:lhs]
12; CHECK: ldr q1, [{{x[0-9]+}}, :lo12:rhs]
13
14  %val = fadd fp128 %lhs, %rhs
15; CHECK: bl __addtf3
16  ret fp128 %val
17}
18
19define fp128 @test_sub() {
20; CHECK-LABEL: test_sub:
21
22  %lhs = load fp128* @lhs, align 16
23  %rhs = load fp128* @rhs, align 16
24; CHECK: ldr q0, [{{x[0-9]+}}, :lo12:lhs]
25; CHECK: ldr q1, [{{x[0-9]+}}, :lo12:rhs]
26
27  %val = fsub fp128 %lhs, %rhs
28; CHECK: bl __subtf3
29  ret fp128 %val
30}
31
32define fp128 @test_mul() {
33; CHECK-LABEL: test_mul:
34
35  %lhs = load fp128* @lhs, align 16
36  %rhs = load fp128* @rhs, align 16
37; CHECK: ldr q0, [{{x[0-9]+}}, :lo12:lhs]
38; CHECK: ldr q1, [{{x[0-9]+}}, :lo12:rhs]
39
40  %val = fmul fp128 %lhs, %rhs
41; CHECK: bl __multf3
42  ret fp128 %val
43}
44
45define fp128 @test_div() {
46; CHECK-LABEL: test_div:
47
48  %lhs = load fp128* @lhs, align 16
49  %rhs = load fp128* @rhs, align 16
50; CHECK: ldr q0, [{{x[0-9]+}}, :lo12:lhs]
51; CHECK: ldr q1, [{{x[0-9]+}}, :lo12:rhs]
52
53  %val = fdiv fp128 %lhs, %rhs
54; CHECK: bl __divtf3
55  ret fp128 %val
56}
57
58@var32 = global i32 0
59@var64 = global i64 0
60
61define void @test_fptosi() {
62; CHECK-LABEL: test_fptosi:
63  %val = load fp128* @lhs, align 16
64
65  %val32 = fptosi fp128 %val to i32
66  store i32 %val32, i32* @var32
67; CHECK: bl __fixtfsi
68
69  %val64 = fptosi fp128 %val to i64
70  store i64 %val64, i64* @var64
71; CHECK: bl __fixtfdi
72
73  ret void
74}
75
76define void @test_fptoui() {
77; CHECK-LABEL: test_fptoui:
78  %val = load fp128* @lhs, align 16
79
80  %val32 = fptoui fp128 %val to i32
81  store i32 %val32, i32* @var32
82; CHECK: bl __fixunstfsi
83
84  %val64 = fptoui fp128 %val to i64
85  store i64 %val64, i64* @var64
86; CHECK: bl __fixunstfdi
87
88  ret void
89}
90
91define void @test_sitofp() {
92; CHECK-LABEL: test_sitofp:
93
94  %src32 = load i32* @var32
95  %val32 = sitofp i32 %src32 to fp128
96  store volatile fp128 %val32, fp128* @lhs
97; CHECK: bl __floatsitf
98
99  %src64 = load i64* @var64
100  %val64 = sitofp i64 %src64 to fp128
101  store volatile fp128 %val64, fp128* @lhs
102; CHECK: bl __floatditf
103
104  ret void
105}
106
107define void @test_uitofp() {
108; CHECK-LABEL: test_uitofp:
109
110  %src32 = load i32* @var32
111  %val32 = uitofp i32 %src32 to fp128
112  store volatile fp128 %val32, fp128* @lhs
113; CHECK: bl __floatunsitf
114
115  %src64 = load i64* @var64
116  %val64 = uitofp i64 %src64 to fp128
117  store volatile fp128 %val64, fp128* @lhs
118; CHECK: bl __floatunditf
119
120  ret void
121}
122
123define i1 @test_setcc1() {
124; CHECK-LABEL: test_setcc1:
125
126  %lhs = load fp128* @lhs, align 16
127  %rhs = load fp128* @rhs, align 16
128; CHECK: ldr q0, [{{x[0-9]+}}, :lo12:lhs]
129; CHECK: ldr q1, [{{x[0-9]+}}, :lo12:rhs]
130
131; Technically, everything after the call to __letf2 is redundant, but we'll let
132; LLVM have its fun for now.
133  %val = fcmp ole fp128 %lhs, %rhs
134; CHECK: bl __letf2
135; CHECK: cmp w0, #0
136; CHECK: cset w0, le
137
138  ret i1 %val
139; CHECK: ret
140}
141
142define i1 @test_setcc2() {
143; CHECK-LABEL: test_setcc2:
144
145  %lhs = load fp128* @lhs, align 16
146  %rhs = load fp128* @rhs, align 16
147; CHECK: ldr q0, [{{x[0-9]+}}, :lo12:lhs]
148; CHECK: ldr q1, [{{x[0-9]+}}, :lo12:rhs]
149
150  %val = fcmp ugt fp128 %lhs, %rhs
151; CHECK: bl      __gttf2
152; CHECK: cmp     w0, #0
153; CHECK: cset   [[GT:w[0-9]+]], gt
154
155; CHECK: bl      __unordtf2
156; CHECK: cmp     w0, #0
157; CHECK: cset   [[UNORDERED:w[0-9]+]], ne
158; CHECK: orr     w0, [[UNORDERED]], [[GT]]
159
160  ret i1 %val
161; CHECK: ret
162}
163
164define i32 @test_br_cc() {
165; CHECK-LABEL: test_br_cc:
166
167  %lhs = load fp128* @lhs, align 16
168  %rhs = load fp128* @rhs, align 16
169; CHECK: ldr q0, [{{x[0-9]+}}, :lo12:lhs]
170; CHECK: ldr q1, [{{x[0-9]+}}, :lo12:rhs]
171
172  ; olt == !uge, which LLVM unfortunately "optimizes" this to.
173  %cond = fcmp olt fp128 %lhs, %rhs
174; CHECK: bl      __getf2
175; CHECK: cmp     w0, #0
176; CHECK: cset   [[OGE:w[0-9]+]], ge
177
178; CHECK: bl      __unordtf2
179; CHECK: cmp     w0, #0
180; CHECK: cset   [[UNORDERED:w[0-9]+]], ne
181
182; CHECK: orr     [[UGE:w[0-9]+]], [[UNORDERED]], [[OGE]]
183; CHECK: cbnz [[UGE]], [[RET29:.LBB[0-9]+_[0-9]+]]
184  br i1 %cond, label %iftrue, label %iffalse
185
186iftrue:
187  ret i32 42
188; CHECK-NEXT: BB#
189; CHECK-NEXT: movz w0, #0x2a
190; CHECK-NEXT: b [[REALRET:.LBB[0-9]+_[0-9]+]]
191
192iffalse:
193  ret i32 29
194; CHECK: [[RET29]]:
195; CHECK-NEXT: movz w0, #0x1d
196; CHECK-NEXT: [[REALRET]]:
197; CHECK: ret
198}
199
200define void @test_select(i1 %cond, fp128 %lhs, fp128 %rhs) {
201; CHECK-LABEL: test_select:
202
203  %val = select i1 %cond, fp128 %lhs, fp128 %rhs
204  store fp128 %val, fp128* @lhs, align 16
205; CHECK: tst w0, #0x1
206; CHECK-NEXT: b.eq [[IFFALSE:.LBB[0-9]+_[0-9]+]]
207; CHECK-NEXT: BB#
208; CHECK-NEXT: mov v[[VAL:[0-9]+]].16b, v0.16b
209; CHECK-NEXT: [[IFFALSE]]:
210; CHECK: str q[[VAL]], [{{x[0-9]+}}, :lo12:lhs]
211  ret void
212; CHECK: ret
213}
214
215@varfloat = global float 0.0, align 4
216@vardouble = global double 0.0, align 8
217
218define void @test_round() {
219; CHECK-LABEL: test_round:
220
221  %val = load fp128* @lhs, align 16
222
223  %float = fptrunc fp128 %val to float
224  store float %float, float* @varfloat, align 4
225; CHECK: bl __trunctfsf2
226; CHECK: str s0, [{{x[0-9]+}}, :lo12:varfloat]
227
228  %double = fptrunc fp128 %val to double
229  store double %double, double* @vardouble, align 8
230; CHECK: bl __trunctfdf2
231; CHECK: str d0, [{{x[0-9]+}}, :lo12:vardouble]
232
233  ret void
234}
235
236define void @test_extend() {
237; CHECK-LABEL: test_extend:
238
239  %val = load fp128* @lhs, align 16
240
241  %float = load float* @varfloat
242  %fromfloat = fpext float %float to fp128
243  store volatile fp128 %fromfloat, fp128* @lhs, align 16
244; CHECK: bl __extendsftf2
245; CHECK: str q0, [{{x[0-9]+}}, :lo12:lhs]
246
247  %double = load double* @vardouble
248  %fromdouble = fpext double %double to fp128
249  store volatile fp128 %fromdouble, fp128* @lhs, align 16
250; CHECK: bl __extenddftf2
251; CHECK: str q0, [{{x[0-9]+}}, :lo12:lhs]
252
253  ret void
254; CHECK: ret
255}
256
257define fp128 @test_neg(fp128 %in) {
258; CHECK: [[MINUS0:.LCPI[0-9]+_0]]:
259; Make sure the weird hex constant below *is* -0.0
260; CHECK-NEXT: fp128 -0
261
262; CHECK-LABEL: test_neg:
263
264  ; Could in principle be optimized to fneg which we can't select, this makes
265  ; sure that doesn't happen.
266  %ret = fsub fp128 0xL00000000000000008000000000000000, %in
267; CHECK: mov v1.16b, v0.16b
268; CHECK: ldr q0, [{{x[0-9]+}}, :lo12:[[MINUS0]]]
269; CHECK: bl __subtf3
270
271  ret fp128 %ret
272; CHECK: ret
273}
274