Skip to content

Commit b29e5cd

Browse files
topperctopperc
committed
[X86] Add test cases for most of the constrained fp libcalls with fp128.
Add explicit setOperation actions for some to match their none strict counterparts. This isn't required, but makes the code self documenting that we didn't forget about strict fp. I've used LibCall instead of Expand since that's more explicitly what we want. Only lrint/llrint/lround/llround are missing now.
1 parent fc4020d commit b29e5cd

File tree

2 files changed

+255
-4
lines changed

2 files changed

+255
-4
lines changed

‎llvm/lib/Target/X86/X86ISelLowering.cpp

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -681,10 +681,14 @@ X86TargetLowering::X86TargetLowering(const X86TargetMachine &TM,
681681
setOperationAction(ISD::FNEG, MVT::f128, Custom);
682682
setOperationAction(ISD::FCOPYSIGN, MVT::f128, Custom);
683683

684-
setOperationAction(ISD::FSIN, MVT::f128, Expand);
685-
setOperationAction(ISD::FCOS, MVT::f128, Expand);
686-
setOperationAction(ISD::FSINCOS, MVT::f128, Expand);
687-
setOperationAction(ISD::FSQRT, MVT::f128, Expand);
684+
setOperationAction(ISD::FSIN, MVT::f128, LibCall);
685+
setOperationAction(ISD::STRICT_FSIN, MVT::f128, LibCall);
686+
setOperationAction(ISD::FCOS, MVT::f128, LibCall);
687+
setOperationAction(ISD::STRICT_FCOS, MVT::f128, LibCall);
688+
setOperationAction(ISD::FSINCOS, MVT::f128, LibCall);
689+
// No STRICT_FSINCOS
690+
setOperationAction(ISD::FSQRT, MVT::f128, LibCall);
691+
setOperationAction(ISD::STRICT_FSQRT, MVT::f128, LibCall);
688692

689693
setOperationAction(ISD::FP_EXTEND, MVT::f128, Custom);
690694
// We need to custom handle any FP_ROUND with an f128 input, but

‎llvm/test/CodeGen/X86/fp128-libcalls-strict.ll

Lines changed: 247 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -66,10 +66,257 @@ entry:
6666
ret fp128 %fma
6767
}
6868

69+
define fp128 @frem(fp128 %x, fp128 %y) nounwind strictfp {
70+
; CHECK-LABEL: frem:
71+
; CHECK: # %bb.0: # %entry
72+
; CHECK-NEXT: pushq %rax
73+
; CHECK-NEXT: callq fmodl
74+
; CHECK-NEXT: popq %rax
75+
; CHECK-NEXT: retq
76+
entry:
77+
%div = call fp128 @llvm.experimental.constrained.frem.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
78+
ret fp128 %div
79+
}
80+
81+
define fp128 @ceil(fp128 %x) nounwind strictfp {
82+
; CHECK-LABEL: ceil:
83+
; CHECK: # %bb.0: # %entry
84+
; CHECK-NEXT: pushq %rax
85+
; CHECK-NEXT: callq ceill
86+
; CHECK-NEXT: popq %rax
87+
; CHECK-NEXT: retq
88+
entry:
89+
%ceil = call fp128 @llvm.experimental.constrained.ceil.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
90+
ret fp128 %ceil
91+
}
92+
93+
define fp128 @cos(fp128 %x) nounwind strictfp {
94+
; CHECK-LABEL: cos:
95+
; CHECK: # %bb.0: # %entry
96+
; CHECK-NEXT: pushq %rax
97+
; CHECK-NEXT: callq cosl
98+
; CHECK-NEXT: popq %rax
99+
; CHECK-NEXT: retq
100+
entry:
101+
%cos = call fp128 @llvm.experimental.constrained.cos.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
102+
ret fp128 %cos
103+
}
104+
105+
define fp128 @exp(fp128 %x) nounwind strictfp {
106+
; CHECK-LABEL: exp:
107+
; CHECK: # %bb.0: # %entry
108+
; CHECK-NEXT: pushq %rax
109+
; CHECK-NEXT: callq expl
110+
; CHECK-NEXT: popq %rax
111+
; CHECK-NEXT: retq
112+
entry:
113+
%exp = call fp128 @llvm.experimental.constrained.exp.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
114+
ret fp128 %exp
115+
}
116+
117+
define fp128 @exp2(fp128 %x) nounwind strictfp {
118+
; CHECK-LABEL: exp2:
119+
; CHECK: # %bb.0: # %entry
120+
; CHECK-NEXT: pushq %rax
121+
; CHECK-NEXT: callq exp2l
122+
; CHECK-NEXT: popq %rax
123+
; CHECK-NEXT: retq
124+
entry:
125+
%exp2 = call fp128 @llvm.experimental.constrained.exp2.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
126+
ret fp128 %exp2
127+
}
128+
129+
define fp128 @floor(fp128 %x) nounwind strictfp {
130+
; CHECK-LABEL: floor:
131+
; CHECK: # %bb.0: # %entry
132+
; CHECK-NEXT: pushq %rax
133+
; CHECK-NEXT: callq floorl
134+
; CHECK-NEXT: popq %rax
135+
; CHECK-NEXT: retq
136+
entry:
137+
%floor = call fp128 @llvm.experimental.constrained.floor.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
138+
ret fp128 %floor
139+
}
140+
141+
define fp128 @log(fp128 %x) nounwind strictfp {
142+
; CHECK-LABEL: log:
143+
; CHECK: # %bb.0: # %entry
144+
; CHECK-NEXT: pushq %rax
145+
; CHECK-NEXT: callq logl
146+
; CHECK-NEXT: popq %rax
147+
; CHECK-NEXT: retq
148+
entry:
149+
%log = call fp128 @llvm.experimental.constrained.log.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
150+
ret fp128 %log
151+
}
152+
153+
define fp128 @log10(fp128 %x) nounwind strictfp {
154+
; CHECK-LABEL: log10:
155+
; CHECK: # %bb.0: # %entry
156+
; CHECK-NEXT: pushq %rax
157+
; CHECK-NEXT: callq log10l
158+
; CHECK-NEXT: popq %rax
159+
; CHECK-NEXT: retq
160+
entry:
161+
%log10 = call fp128 @llvm.experimental.constrained.log10.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
162+
ret fp128 %log10
163+
}
164+
165+
define fp128 @log2(fp128 %x) nounwind strictfp {
166+
; CHECK-LABEL: log2:
167+
; CHECK: # %bb.0: # %entry
168+
; CHECK-NEXT: pushq %rax
169+
; CHECK-NEXT: callq log2l
170+
; CHECK-NEXT: popq %rax
171+
; CHECK-NEXT: retq
172+
entry:
173+
%log2 = call fp128 @llvm.experimental.constrained.log2.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
174+
ret fp128 %log2
175+
}
176+
177+
define fp128 @maxnum(fp128 %x, fp128 %y) nounwind strictfp {
178+
; CHECK-LABEL: maxnum:
179+
; CHECK: # %bb.0: # %entry
180+
; CHECK-NEXT: pushq %rax
181+
; CHECK-NEXT: callq fmaxl
182+
; CHECK-NEXT: popq %rax
183+
; CHECK-NEXT: retq
184+
entry:
185+
%maxnum = call fp128 @llvm.experimental.constrained.maxnum.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
186+
ret fp128 %maxnum
187+
}
188+
189+
define fp128 @minnum(fp128 %x, fp128 %y) nounwind strictfp {
190+
; CHECK-LABEL: minnum:
191+
; CHECK: # %bb.0: # %entry
192+
; CHECK-NEXT: pushq %rax
193+
; CHECK-NEXT: callq fminl
194+
; CHECK-NEXT: popq %rax
195+
; CHECK-NEXT: retq
196+
entry:
197+
%minnum = call fp128 @llvm.experimental.constrained.minnum.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
198+
ret fp128 %minnum
199+
}
200+
201+
define fp128 @nearbyint(fp128 %x) nounwind strictfp {
202+
; CHECK-LABEL: nearbyint:
203+
; CHECK: # %bb.0: # %entry
204+
; CHECK-NEXT: pushq %rax
205+
; CHECK-NEXT: callq nearbyintl
206+
; CHECK-NEXT: popq %rax
207+
; CHECK-NEXT: retq
208+
entry:
209+
%nearbyint = call fp128 @llvm.experimental.constrained.nearbyint.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
210+
ret fp128 %nearbyint
211+
}
212+
213+
define fp128 @pow(fp128 %x, fp128 %y) nounwind strictfp {
214+
; CHECK-LABEL: pow:
215+
; CHECK: # %bb.0: # %entry
216+
; CHECK-NEXT: pushq %rax
217+
; CHECK-NEXT: callq powl
218+
; CHECK-NEXT: popq %rax
219+
; CHECK-NEXT: retq
220+
entry:
221+
%pow = call fp128 @llvm.experimental.constrained.pow.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
222+
ret fp128 %pow
223+
}
224+
225+
define fp128 @powi(fp128 %x, i32 %y) nounwind strictfp {
226+
; CHECK-LABEL: powi:
227+
; CHECK: # %bb.0: # %entry
228+
; CHECK-NEXT: pushq %rax
229+
; CHECK-NEXT: callq __powitf2
230+
; CHECK-NEXT: popq %rax
231+
; CHECK-NEXT: retq
232+
entry:
233+
%powi = call fp128 @llvm.experimental.constrained.powi.f128(fp128 %x, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
234+
ret fp128 %powi
235+
}
236+
237+
define fp128 @rint(fp128 %x) nounwind strictfp {
238+
; CHECK-LABEL: rint:
239+
; CHECK: # %bb.0: # %entry
240+
; CHECK-NEXT: pushq %rax
241+
; CHECK-NEXT: callq rintl
242+
; CHECK-NEXT: popq %rax
243+
; CHECK-NEXT: retq
244+
entry:
245+
%rint = call fp128 @llvm.experimental.constrained.rint.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
246+
ret fp128 %rint
247+
}
248+
249+
define fp128 @round(fp128 %x) nounwind strictfp {
250+
; CHECK-LABEL: round:
251+
; CHECK: # %bb.0: # %entry
252+
; CHECK-NEXT: pushq %rax
253+
; CHECK-NEXT: callq roundl
254+
; CHECK-NEXT: popq %rax
255+
; CHECK-NEXT: retq
256+
entry:
257+
%round = call fp128 @llvm.experimental.constrained.round.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
258+
ret fp128 %round
259+
}
260+
261+
define fp128 @sin(fp128 %x) nounwind strictfp {
262+
; CHECK-LABEL: sin:
263+
; CHECK: # %bb.0: # %entry
264+
; CHECK-NEXT: pushq %rax
265+
; CHECK-NEXT: callq sinl
266+
; CHECK-NEXT: popq %rax
267+
; CHECK-NEXT: retq
268+
entry:
269+
%sin = call fp128 @llvm.experimental.constrained.sin.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
270+
ret fp128 %sin
271+
}
272+
273+
define fp128 @sqrt(fp128 %x) nounwind strictfp {
274+
; CHECK-LABEL: sqrt:
275+
; CHECK: # %bb.0: # %entry
276+
; CHECK-NEXT: pushq %rax
277+
; CHECK-NEXT: callq sqrtl
278+
; CHECK-NEXT: popq %rax
279+
; CHECK-NEXT: retq
280+
entry:
281+
%sqrt = call fp128 @llvm.experimental.constrained.sqrt.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
282+
ret fp128 %sqrt
283+
}
284+
285+
define fp128 @trunc(fp128 %x) nounwind strictfp {
286+
; CHECK-LABEL: trunc:
287+
; CHECK: # %bb.0: # %entry
288+
; CHECK-NEXT: pushq %rax
289+
; CHECK-NEXT: callq truncl
290+
; CHECK-NEXT: popq %rax
291+
; CHECK-NEXT: retq
292+
entry:
293+
%trunc = call fp128 @llvm.experimental.constrained.trunc.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
294+
ret fp128 %trunc
295+
}
296+
69297
attributes #0 = { strictfp }
70298

71299
declare fp128 @llvm.experimental.constrained.fadd.f128(fp128, fp128, metadata, metadata)
72300
declare fp128 @llvm.experimental.constrained.fsub.f128(fp128, fp128, metadata, metadata)
73301
declare fp128 @llvm.experimental.constrained.fmul.f128(fp128, fp128, metadata, metadata)
74302
declare fp128 @llvm.experimental.constrained.fdiv.f128(fp128, fp128, metadata, metadata)
75303
declare fp128 @llvm.experimental.constrained.fma.f128(fp128, fp128, fp128, metadata, metadata)
304+
declare fp128 @llvm.experimental.constrained.frem.f128(fp128, fp128, metadata, metadata)
305+
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
306+
declare fp128 @llvm.experimental.constrained.cos.f128(fp128, metadata, metadata)
307+
declare fp128 @llvm.experimental.constrained.exp.f128(fp128, metadata, metadata)
308+
declare fp128 @llvm.experimental.constrained.exp2.f128(fp128, metadata, metadata)
309+
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
310+
declare fp128 @llvm.experimental.constrained.log.f128(fp128, metadata, metadata)
311+
declare fp128 @llvm.experimental.constrained.log10.f128(fp128, metadata, metadata)
312+
declare fp128 @llvm.experimental.constrained.log2.f128(fp128, metadata, metadata)
313+
declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata, metadata)
314+
declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata, metadata)
315+
declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)
316+
declare fp128 @llvm.experimental.constrained.pow.f128(fp128, fp128, metadata, metadata)
317+
declare fp128 @llvm.experimental.constrained.powi.f128(fp128, i32, metadata, metadata)
318+
declare fp128 @llvm.experimental.constrained.rint.f128(fp128, metadata, metadata)
319+
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
320+
declare fp128 @llvm.experimental.constrained.sin.f128(fp128, metadata, metadata)
321+
declare fp128 @llvm.experimental.constrained.sqrt.f128(fp128, metadata, metadata)
322+
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)

0 commit comments

Comments
 (0)