[AArch64,ELF] Restrict MOVZ/MOVK to non-PIC large code model (#70178)
[llvm-project.git] / llvm / test / CodeGen / VE / Scalar / pow.ll
blob5b6cab6df71497e140f824453be6d761be1caef9
1 ; RUN: llc < %s -mtriple=ve | FileCheck %s
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.
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
40 ; Function Attrs: mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn
41 declare float @llvm.pow.f32(float, float)
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
56 ; Function Attrs: mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn
57 declare double @llvm.pow.f64(double, double)
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
72 ; Function Attrs: mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn
73 declare fp128 @llvm.pow.f128(fp128, fp128)
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
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
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
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
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
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
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
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
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
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
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
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
249 ; Function Attrs: nocallback nofree nosync nounwind readnone speculatable willreturn
250 declare float @llvm.powi.f32.i32(float, i32)
252 ; Function Attrs: nocallback nofree nosync nounwind readnone speculatable willreturn
253 declare double @llvm.powi.f64.i32(double, i32)
255 ; Function Attrs: nocallback nofree nosync nounwind readnone speculatable willreturn
256 declare fp128 @llvm.powi.f128.i32(fp128, i32)