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

   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)