Skip to content

Commit de80132

Browse files
kaz7kaz7
committed
[VE] Change to expand FPOW
VE doesn't have FPOW instruction, so this patch makes llvm expand it. Reviewed By: efocht Differential Revision: https://reviews.llvm.org/D134695
1 parent c2a44b5 commit de80132

File tree

2 files changed

+257
-0
lines changed

2 files changed

+257
-0
lines changed

‎llvm/lib/Target/VE/VEISelLowering.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -249,6 +249,7 @@ void VETargetLowering::initSPUActions() {
249249
setOperationAction(ISD::FCOPYSIGN, VT, Expand);
250250
setOperationAction(ISD::FCOS, VT, Expand);
251251
setOperationAction(ISD::FMA, VT, Expand);
252+
setOperationAction(ISD::FPOW, VT, Expand);
252253
setOperationAction(ISD::FSIN, VT, Expand);
253254
setOperationAction(ISD::FSQRT, VT, Expand);
254255
}

‎llvm/test/CodeGen/VE/Scalar/pow.ll

Lines changed: 256 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,256 @@
1+
; RUN: llc < %s -mtriple=ve | FileCheck %s
2+
3+
;;; Test ‘llvm.pow.*’ intrinsic
4+
;;;
5+
;;; Syntax:
6+
;;; This is an overloaded intrinsic. You can use llvm.pow on any
7+
;;; floating-point or vector of floating-point type. Not all targets
8+
;;; support all types however.
9+
;;;
10+
;;; declare float @llvm.pow.f32(float %Val, float %Power)
11+
;;; declare double @llvm.pow.f64(double %Val, double %Power)
12+
;;; declare x86_fp80 @llvm.pow.f80(x86_fp80 %Val, x86_fp80 %Power)
13+
;;; declare fp128 @llvm.pow.f128(fp128 %Val, fp128 %Power)
14+
;;; declare ppc_fp128 @llvm.pow.ppcf128(ppc_fp128 %Val, ppc_fp128 Power)
15+
;;;
16+
;;; Overview:
17+
;;; The ‘llvm.pow.*’ intrinsics return the first operand raised to
18+
;;; the specified (positive or negative) power.
19+
;;;
20+
;;; Arguments:
21+
;;; The arguments and return value are floating-point numbers of
22+
;;; the same type.
23+
;;;
24+
;;; Note:
25+
;;; We test only float/double/fp128.
26+
27+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
28+
define float @func_fp_pow_var_float(float noundef %0, float noundef %1) {
29+
; CHECK-LABEL: func_fp_pow_var_float:
30+
; CHECK: .LBB{{[0-9]+}}_2:
31+
; CHECK-NEXT: lea %s2, powf@lo
32+
; CHECK-NEXT: and %s2, %s2, (32)0
33+
; CHECK-NEXT: lea.sl %s12, powf@hi(, %s2)
34+
; CHECK-NEXT: bsic %s10, (, %s12)
35+
; CHECK-NEXT: or %s11, 0, %s9
36+
%3 = tail call fast float @llvm.pow.f32(float %0, float %1)
37+
ret float %3
38+
}
39+
40+
; Function Attrs: mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn
41+
declare float @llvm.pow.f32(float, float)
42+
43+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
44+
define double @func_fp_pow_var_double(double noundef %0, double noundef %1) {
45+
; CHECK-LABEL: func_fp_pow_var_double:
46+
; CHECK: .LBB{{[0-9]+}}_2:
47+
; CHECK-NEXT: lea %s2, pow@lo
48+
; CHECK-NEXT: and %s2, %s2, (32)0
49+
; CHECK-NEXT: lea.sl %s12, pow@hi(, %s2)
50+
; CHECK-NEXT: bsic %s10, (, %s12)
51+
; CHECK-NEXT: or %s11, 0, %s9
52+
%3 = tail call fast double @llvm.pow.f64(double %0, double %1)
53+
ret double %3
54+
}
55+
56+
; Function Attrs: mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn
57+
declare double @llvm.pow.f64(double, double)
58+
59+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
60+
define fp128 @func_fp_pow_var_quad(fp128 noundef %0, fp128 noundef %1) {
61+
; CHECK-LABEL: func_fp_pow_var_quad:
62+
; CHECK: .LBB{{[0-9]+}}_2:
63+
; CHECK-NEXT: lea %s4, powl@lo
64+
; CHECK-NEXT: and %s4, %s4, (32)0
65+
; CHECK-NEXT: lea.sl %s12, powl@hi(, %s4)
66+
; CHECK-NEXT: bsic %s10, (, %s12)
67+
; CHECK-NEXT: or %s11, 0, %s9
68+
%3 = tail call fast fp128 @llvm.pow.f128(fp128 %0, fp128 %1)
69+
ret fp128 %3
70+
}
71+
72+
; Function Attrs: mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn
73+
declare fp128 @llvm.pow.f128(fp128, fp128)
74+
75+
; Function Attrs: mustprogress nofree norecurse nosync nounwind readnone willreturn
76+
define float @func_fp_pow_zero_back_float(float noundef %0) {
77+
; CHECK-LABEL: func_fp_pow_zero_back_float:
78+
; CHECK: # %bb.0:
79+
; CHECK-NEXT: lea.sl %s0, 1065353216
80+
; CHECK-NEXT: b.l.t (, %s10)
81+
ret float 1.000000e+00
82+
}
83+
84+
; Function Attrs: mustprogress nofree norecurse nosync nounwind readnone willreturn
85+
define double @func_fp_pow_zero_back_double(double noundef %0) {
86+
; CHECK-LABEL: func_fp_pow_zero_back_double:
87+
; CHECK: # %bb.0:
88+
; CHECK-NEXT: lea.sl %s0, 1072693248
89+
; CHECK-NEXT: b.l.t (, %s10)
90+
ret double 1.000000e+00
91+
}
92+
93+
; Function Attrs: mustprogress nofree norecurse nosync nounwind readnone willreturn
94+
define fp128 @func_fp_pow_zero_back_quad(fp128 noundef %0) {
95+
; CHECK-LABEL: func_fp_pow_zero_back_quad:
96+
; CHECK: # %bb.0:
97+
; CHECK-NEXT: lea %s0, .LCPI{{[0-9]+}}_0@lo
98+
; CHECK-NEXT: and %s0, %s0, (32)0
99+
; CHECK-NEXT: lea.sl %s2, .LCPI{{[0-9]+}}_0@hi(, %s0)
100+
; CHECK-NEXT: ld %s0, 8(, %s2)
101+
; CHECK-NEXT: ld %s1, (, %s2)
102+
; CHECK-NEXT: b.l.t (, %s10)
103+
ret fp128 0xL00000000000000003FFF000000000000
104+
}
105+
106+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
107+
define float @func_fp_pow_zero_fore_float(float noundef %0) {
108+
; CHECK-LABEL: func_fp_pow_zero_fore_float:
109+
; CHECK: .LBB{{[0-9]+}}_2:
110+
; CHECK-NEXT: or %s1, 0, %s0
111+
; CHECK-NEXT: lea %s0, powf@lo
112+
; CHECK-NEXT: and %s0, %s0, (32)0
113+
; CHECK-NEXT: lea.sl %s12, powf@hi(, %s0)
114+
; CHECK-NEXT: lea.sl %s0, 0
115+
; CHECK-NEXT: bsic %s10, (, %s12)
116+
; CHECK-NEXT: or %s11, 0, %s9
117+
%2 = tail call fast float @llvm.pow.f32(float 0.000000e+00, float %0)
118+
ret float %2
119+
}
120+
121+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
122+
define double @func_fp_pow_zero_fore_double(double noundef %0) {
123+
; CHECK-LABEL: func_fp_pow_zero_fore_double:
124+
; CHECK: .LBB{{[0-9]+}}_2:
125+
; CHECK-NEXT: or %s1, 0, %s0
126+
; CHECK-NEXT: lea %s0, pow@lo
127+
; CHECK-NEXT: and %s0, %s0, (32)0
128+
; CHECK-NEXT: lea.sl %s12, pow@hi(, %s0)
129+
; CHECK-NEXT: lea.sl %s0, 0
130+
; CHECK-NEXT: bsic %s10, (, %s12)
131+
; CHECK-NEXT: or %s11, 0, %s9
132+
%2 = tail call fast double @llvm.pow.f64(double 0.000000e+00, double %0)
133+
ret double %2
134+
}
135+
136+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
137+
define fp128 @func_fp_pow_zero_fore_quad(fp128 noundef %0) {
138+
; CHECK-LABEL: func_fp_pow_zero_fore_quad:
139+
; CHECK: .LBB{{[0-9]+}}_2:
140+
; CHECK-NEXT: or %s2, 0, %s0
141+
; CHECK-NEXT: or %s3, 0, %s1
142+
; CHECK-NEXT: lea %s0, .LCPI{{[0-9]+}}_0@lo
143+
; CHECK-NEXT: and %s0, %s0, (32)0
144+
; CHECK-NEXT: lea.sl %s4, .LCPI{{[0-9]+}}_0@hi(, %s0)
145+
; CHECK-NEXT: ld %s0, 8(, %s4)
146+
; CHECK-NEXT: ld %s1, (, %s4)
147+
; CHECK-NEXT: lea %s4, powl@lo
148+
; CHECK-NEXT: and %s4, %s4, (32)0
149+
; CHECK-NEXT: lea.sl %s12, powl@hi(, %s4)
150+
; CHECK-NEXT: bsic %s10, (, %s12)
151+
; CHECK-NEXT: or %s11, 0, %s9
152+
%2 = tail call fast fp128 @llvm.pow.f128(fp128 0xL00000000000000000000000000000000, fp128 %0)
153+
ret fp128 %2
154+
}
155+
156+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
157+
define float @func_fp_pow_const_back_float(float noundef %0) {
158+
; CHECK-LABEL: func_fp_pow_const_back_float:
159+
; CHECK: # %bb.0:
160+
; CHECK-NEXT: fmul.s %s0, %s0, %s0
161+
; CHECK-NEXT: lea.sl %s1, 1065353216
162+
; CHECK-NEXT: fdiv.s %s0, %s1, %s0
163+
; CHECK-NEXT: b.l.t (, %s10)
164+
%2 = tail call fast float @llvm.powi.f32.i32(float %0, i32 -2)
165+
ret float %2
166+
}
167+
168+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
169+
define double @func_fp_pow_const_back_double(double noundef %0) {
170+
; CHECK-LABEL: func_fp_pow_const_back_double:
171+
; CHECK: # %bb.0:
172+
; CHECK-NEXT: fmul.d %s0, %s0, %s0
173+
; CHECK-NEXT: lea.sl %s1, 1072693248
174+
; CHECK-NEXT: fdiv.d %s0, %s1, %s0
175+
; CHECK-NEXT: b.l.t (, %s10)
176+
%2 = tail call fast double @llvm.powi.f64.i32(double %0, i32 -2)
177+
ret double %2
178+
}
179+
180+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
181+
define fp128 @func_fp_pow_const_back_quad(fp128 noundef %0) {
182+
; CHECK-LABEL: func_fp_pow_const_back_quad:
183+
; CHECK: .LBB{{[0-9]+}}_2:
184+
; CHECK-NEXT: fmul.q %s2, %s0, %s0
185+
; CHECK-NEXT: lea %s0, .LCPI{{[0-9]+}}_0@lo
186+
; CHECK-NEXT: and %s0, %s0, (32)0
187+
; CHECK-NEXT: lea.sl %s4, .LCPI{{[0-9]+}}_0@hi(, %s0)
188+
; CHECK-NEXT: ld %s0, 8(, %s4)
189+
; CHECK-NEXT: ld %s1, (, %s4)
190+
; CHECK-NEXT: lea %s4, __divtf3@lo
191+
; CHECK-NEXT: and %s4, %s4, (32)0
192+
; CHECK-NEXT: lea.sl %s12, __divtf3@hi(, %s4)
193+
; CHECK-NEXT: bsic %s10, (, %s12)
194+
; CHECK-NEXT: or %s11, 0, %s9
195+
%2 = tail call fast fp128 @llvm.powi.f128.i32(fp128 %0, i32 -2)
196+
ret fp128 %2
197+
}
198+
199+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
200+
define float @func_fp_pow_const_fore_float(float noundef %0) {
201+
; CHECK-LABEL: func_fp_pow_const_fore_float:
202+
; CHECK: .LBB{{[0-9]+}}_2:
203+
; CHECK-NEXT: or %s1, 0, %s0
204+
; CHECK-NEXT: lea %s0, powf@lo
205+
; CHECK-NEXT: and %s0, %s0, (32)0
206+
; CHECK-NEXT: lea.sl %s12, powf@hi(, %s0)
207+
; CHECK-NEXT: lea.sl %s0, -1073741824
208+
; CHECK-NEXT: bsic %s10, (, %s12)
209+
; CHECK-NEXT: or %s11, 0, %s9
210+
%2 = tail call fast float @llvm.pow.f32(float -2.000000e+00, float %0)
211+
ret float %2
212+
}
213+
214+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
215+
define double @func_fp_pow_const_fore_double(double noundef %0) {
216+
; CHECK-LABEL: func_fp_pow_const_fore_double:
217+
; CHECK: .LBB{{[0-9]+}}_2:
218+
; CHECK-NEXT: or %s1, 0, %s0
219+
; CHECK-NEXT: lea %s0, pow@lo
220+
; CHECK-NEXT: and %s0, %s0, (32)0
221+
; CHECK-NEXT: lea.sl %s12, pow@hi(, %s0)
222+
; CHECK-NEXT: lea.sl %s0, -1073741824
223+
; CHECK-NEXT: bsic %s10, (, %s12)
224+
; CHECK-NEXT: or %s11, 0, %s9
225+
%2 = tail call fast double @llvm.pow.f64(double -2.000000e+00, double %0)
226+
ret double %2
227+
}
228+
229+
; Function Attrs: mustprogress nofree nosync nounwind readnone willreturn
230+
define fp128 @func_fp_pow_const_fore_quad(fp128 noundef %0) {
231+
; CHECK-LABEL: func_fp_pow_const_fore_quad:
232+
; CHECK: .LBB{{[0-9]+}}_2:
233+
; CHECK-NEXT: or %s2, 0, %s0
234+
; CHECK-NEXT: or %s3, 0, %s1
235+
; CHECK-NEXT: lea %s0, .LCPI{{[0-9]+}}_0@lo
236+
; CHECK-NEXT: and %s0, %s0, (32)0
237+
; CHECK-NEXT: lea.sl %s4, .LCPI{{[0-9]+}}_0@hi(, %s0)
238+
; CHECK-NEXT: ld %s0, 8(, %s4)
239+
; CHECK-NEXT: ld %s1, (, %s4)
240+
; CHECK-NEXT: lea %s4, powl@lo
241+
; CHECK-NEXT: and %s4, %s4, (32)0
242+
; CHECK-NEXT: lea.sl %s12, powl@hi(, %s4)
243+
; CHECK-NEXT: bsic %s10, (, %s12)
244+
; CHECK-NEXT: or %s11, 0, %s9
245+
%2 = tail call fast fp128 @llvm.pow.f128(fp128 0xL0000000000000000C000000000000000, fp128 %0)
246+
ret fp128 %2
247+
}
248+
249+
; Function Attrs: nocallback nofree nosync nounwind readnone speculatable willreturn
250+
declare float @llvm.powi.f32.i32(float, i32)
251+
252+
; Function Attrs: nocallback nofree nosync nounwind readnone speculatable willreturn
253+
declare double @llvm.powi.f64.i32(double, i32)
254+
255+
; Function Attrs: nocallback nofree nosync nounwind readnone speculatable willreturn
256+
declare fp128 @llvm.powi.f128.i32(fp128, i32)

0 commit comments

Comments
 (0)