Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 14 | pmbaty | 1 | //===-- VecFuncs.def - Library information -------------*- C++ -*-----------===// |
| 2 | // |
||
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
||
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
||
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
||
| 6 | // |
||
| 7 | //===----------------------------------------------------------------------===// |
||
| 8 | |||
| 9 | // This .def file will create mappings from scalar math functions to vector |
||
| 10 | // functions along with their vectorization factor. The current support includes |
||
| 11 | // such mappings for Accelerate framework, MASS vector library, and SVML library. |
||
| 12 | // This .def file also allows creating an array of vector functions supported in |
||
| 13 | // the specified framework or library. |
||
| 14 | |||
| 15 | #if defined(TLI_DEFINE_MASSV_VECFUNCS_NAMES) |
||
| 16 | #define TLI_DEFINE_MASSV_VECFUNCS |
||
| 17 | #define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) VEC, |
||
| 18 | #endif |
||
| 19 | |||
| 20 | #define FIXED(NL) ElementCount::getFixed(NL) |
||
| 21 | #define SCALABLE(NL) ElementCount::getScalable(NL) |
||
| 22 | |||
| 23 | #if !(defined(TLI_DEFINE_VECFUNC)) |
||
| 24 | #define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) {SCAL, VEC, VF}, |
||
| 25 | #endif |
||
| 26 | |||
| 27 | #if defined(TLI_DEFINE_ACCELERATE_VECFUNCS) |
||
| 28 | // Accelerate framework's Vector Functions |
||
| 29 | |||
| 30 | // Floating-Point Arithmetic and Auxiliary Functions |
||
| 31 | TLI_DEFINE_VECFUNC("ceilf", "vceilf", FIXED(4)) |
||
| 32 | TLI_DEFINE_VECFUNC("fabsf", "vfabsf", FIXED(4)) |
||
| 33 | TLI_DEFINE_VECFUNC("llvm.fabs.f32", "vfabsf", FIXED(4)) |
||
| 34 | TLI_DEFINE_VECFUNC("floorf", "vfloorf", FIXED(4)) |
||
| 35 | TLI_DEFINE_VECFUNC("sqrtf", "vsqrtf", FIXED(4)) |
||
| 36 | TLI_DEFINE_VECFUNC("llvm.sqrt.f32", "vsqrtf", FIXED(4)) |
||
| 37 | |||
| 38 | // Exponential and Logarithmic Functions |
||
| 39 | TLI_DEFINE_VECFUNC("expf", "vexpf", FIXED(4)) |
||
| 40 | TLI_DEFINE_VECFUNC("llvm.exp.f32", "vexpf", FIXED(4)) |
||
| 41 | TLI_DEFINE_VECFUNC("expm1f", "vexpm1f", FIXED(4)) |
||
| 42 | TLI_DEFINE_VECFUNC("logf", "vlogf", FIXED(4)) |
||
| 43 | TLI_DEFINE_VECFUNC("llvm.log.f32", "vlogf", FIXED(4)) |
||
| 44 | TLI_DEFINE_VECFUNC("log1pf", "vlog1pf", FIXED(4)) |
||
| 45 | TLI_DEFINE_VECFUNC("log10f", "vlog10f", FIXED(4)) |
||
| 46 | TLI_DEFINE_VECFUNC("llvm.log10.f32", "vlog10f", FIXED(4)) |
||
| 47 | TLI_DEFINE_VECFUNC("logbf", "vlogbf", FIXED(4)) |
||
| 48 | |||
| 49 | // Trigonometric Functions |
||
| 50 | TLI_DEFINE_VECFUNC("sinf", "vsinf", FIXED(4)) |
||
| 51 | TLI_DEFINE_VECFUNC("llvm.sin.f32", "vsinf", FIXED(4)) |
||
| 52 | TLI_DEFINE_VECFUNC("cosf", "vcosf", FIXED(4)) |
||
| 53 | TLI_DEFINE_VECFUNC("llvm.cos.f32", "vcosf", FIXED(4)) |
||
| 54 | TLI_DEFINE_VECFUNC("tanf", "vtanf", FIXED(4)) |
||
| 55 | TLI_DEFINE_VECFUNC("asinf", "vasinf", FIXED(4)) |
||
| 56 | TLI_DEFINE_VECFUNC("acosf", "vacosf", FIXED(4)) |
||
| 57 | TLI_DEFINE_VECFUNC("atanf", "vatanf", FIXED(4)) |
||
| 58 | |||
| 59 | // Hyperbolic Functions |
||
| 60 | TLI_DEFINE_VECFUNC("sinhf", "vsinhf", FIXED(4)) |
||
| 61 | TLI_DEFINE_VECFUNC("coshf", "vcoshf", FIXED(4)) |
||
| 62 | TLI_DEFINE_VECFUNC("tanhf", "vtanhf", FIXED(4)) |
||
| 63 | TLI_DEFINE_VECFUNC("asinhf", "vasinhf", FIXED(4)) |
||
| 64 | TLI_DEFINE_VECFUNC("acoshf", "vacoshf", FIXED(4)) |
||
| 65 | TLI_DEFINE_VECFUNC("atanhf", "vatanhf", FIXED(4)) |
||
| 66 | |||
| 67 | #elif defined(TLI_DEFINE_DARWIN_LIBSYSTEM_M_VECFUNCS) |
||
| 68 | // Darwin libsystem_m vector functions. |
||
| 69 | |||
| 70 | // Exponential and Logarithmic Functions |
||
| 71 | TLI_DEFINE_VECFUNC("exp", "_simd_exp_d2", FIXED(2)) |
||
| 72 | TLI_DEFINE_VECFUNC("llvm.exp.f64", "_simd_exp_d2", FIXED(2)) |
||
| 73 | TLI_DEFINE_VECFUNC("expf", "_simd_exp_f4", FIXED(4)) |
||
| 74 | TLI_DEFINE_VECFUNC("llvm.exp.f32", "_simd_exp_f4", FIXED(4)) |
||
| 75 | |||
| 76 | // Trigonometric Functions |
||
| 77 | TLI_DEFINE_VECFUNC("acos", "_simd_acos_d2", FIXED(2)) |
||
| 78 | TLI_DEFINE_VECFUNC("acosf", "_simd_acos_f4", FIXED(4)) |
||
| 79 | TLI_DEFINE_VECFUNC("asin", "_simd_asin_d2", FIXED(2)) |
||
| 80 | TLI_DEFINE_VECFUNC("asinf", "_simd_asin_f4", FIXED(4)) |
||
| 81 | |||
| 82 | TLI_DEFINE_VECFUNC("atan", "_simd_atan_d2", FIXED(2)) |
||
| 83 | TLI_DEFINE_VECFUNC("atanf", "_simd_atan_f4", FIXED(4)) |
||
| 84 | TLI_DEFINE_VECFUNC("atan2", "_simd_atan2_d2", FIXED(2)) |
||
| 85 | TLI_DEFINE_VECFUNC("atan2f", "_simd_atan2_f4", FIXED(4)) |
||
| 86 | |||
| 87 | TLI_DEFINE_VECFUNC("cos", "_simd_cos_d2", FIXED(2)) |
||
| 88 | TLI_DEFINE_VECFUNC("llvm.cos.f64", "_simd_cos_d2", FIXED(2)) |
||
| 89 | TLI_DEFINE_VECFUNC("cosf", "_simd_cos_f4", FIXED(4)) |
||
| 90 | TLI_DEFINE_VECFUNC("llvm.cos.f32", "_simd_cos_f4", FIXED(4)) |
||
| 91 | |||
| 92 | TLI_DEFINE_VECFUNC("sin", "_simd_sin_d2", FIXED(2)) |
||
| 93 | TLI_DEFINE_VECFUNC("llvm.sin.f64", "_simd_sin_d2", FIXED(2)) |
||
| 94 | TLI_DEFINE_VECFUNC("sinf", "_simd_sin_f4", FIXED(4)) |
||
| 95 | TLI_DEFINE_VECFUNC("llvm.sin.f32", "_simd_sin_f4", FIXED(4)) |
||
| 96 | |||
| 97 | // Floating-Point Arithmetic and Auxiliary Functions |
||
| 98 | TLI_DEFINE_VECFUNC("cbrt", "_simd_cbrt_d2", FIXED(2)) |
||
| 99 | TLI_DEFINE_VECFUNC("cbrtf", "_simd_cbrt_f4", FIXED(4)) |
||
| 100 | TLI_DEFINE_VECFUNC("erf", "_simd_erf_d2", FIXED(2)) |
||
| 101 | TLI_DEFINE_VECFUNC("erff", "_simd_erf_f4", FIXED(4)) |
||
| 102 | TLI_DEFINE_VECFUNC("pow", "_simd_pow_d2", FIXED(2)) |
||
| 103 | TLI_DEFINE_VECFUNC("llvm.pow.f64", "_simd_pow_d2", FIXED(2)) |
||
| 104 | TLI_DEFINE_VECFUNC("powf", "_simd_pow_f4", FIXED(4)) |
||
| 105 | TLI_DEFINE_VECFUNC("llvm.pow.f32", "_simd_pow_f4", FIXED(4)) |
||
| 106 | |||
| 107 | // Hyperbolic Functions |
||
| 108 | TLI_DEFINE_VECFUNC("sinh", "_simd_sinh_d2", FIXED(2)) |
||
| 109 | TLI_DEFINE_VECFUNC("sinhf", "_simd_sinh_f4", FIXED(4)) |
||
| 110 | TLI_DEFINE_VECFUNC("cosh", "_simd_cosh_d2", FIXED(2)) |
||
| 111 | TLI_DEFINE_VECFUNC("coshf", "_simd_cosh_f4", FIXED(4)) |
||
| 112 | TLI_DEFINE_VECFUNC("tanh", "_simd_tanh_d2", FIXED(2)) |
||
| 113 | TLI_DEFINE_VECFUNC("tanhf", "_simd_tanh_f4", FIXED(4)) |
||
| 114 | TLI_DEFINE_VECFUNC("asinh", "_simd_asinh_d2", FIXED(2)) |
||
| 115 | TLI_DEFINE_VECFUNC("asinhf", "_simd_asinh_f4", FIXED(4)) |
||
| 116 | TLI_DEFINE_VECFUNC("acosh", "_simd_acosh_d2", FIXED(2)) |
||
| 117 | TLI_DEFINE_VECFUNC("acoshf", "_simd_acosh_f4", FIXED(4)) |
||
| 118 | TLI_DEFINE_VECFUNC("atanh", "_simd_atanh_d2", FIXED(2)) |
||
| 119 | TLI_DEFINE_VECFUNC("atanhf", "_simd_atanh_f4", FIXED(4)) |
||
| 120 | |||
| 121 | #elif defined(TLI_DEFINE_LIBMVEC_X86_VECFUNCS) |
||
| 122 | // GLIBC Vector math Functions |
||
| 123 | |||
| 124 | TLI_DEFINE_VECFUNC("sin", "_ZGVbN2v_sin", FIXED(2)) |
||
| 125 | TLI_DEFINE_VECFUNC("sin", "_ZGVdN4v_sin", FIXED(4)) |
||
| 126 | |||
| 127 | TLI_DEFINE_VECFUNC("sinf", "_ZGVbN4v_sinf", FIXED(4)) |
||
| 128 | TLI_DEFINE_VECFUNC("sinf", "_ZGVdN8v_sinf", FIXED(8)) |
||
| 129 | |||
| 130 | TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVbN2v_sin", FIXED(2)) |
||
| 131 | TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVdN4v_sin", FIXED(4)) |
||
| 132 | |||
| 133 | TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVbN4v_sinf", FIXED(4)) |
||
| 134 | TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVdN8v_sinf", FIXED(8)) |
||
| 135 | |||
| 136 | TLI_DEFINE_VECFUNC("cos", "_ZGVbN2v_cos", FIXED(2)) |
||
| 137 | TLI_DEFINE_VECFUNC("cos", "_ZGVdN4v_cos", FIXED(4)) |
||
| 138 | |||
| 139 | TLI_DEFINE_VECFUNC("cosf", "_ZGVbN4v_cosf", FIXED(4)) |
||
| 140 | TLI_DEFINE_VECFUNC("cosf", "_ZGVdN8v_cosf", FIXED(8)) |
||
| 141 | |||
| 142 | TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVbN2v_cos", FIXED(2)) |
||
| 143 | TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVdN4v_cos", FIXED(4)) |
||
| 144 | |||
| 145 | TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVbN4v_cosf", FIXED(4)) |
||
| 146 | TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVdN8v_cosf", FIXED(8)) |
||
| 147 | |||
| 148 | TLI_DEFINE_VECFUNC("pow", "_ZGVbN2vv_pow", FIXED(2)) |
||
| 149 | TLI_DEFINE_VECFUNC("pow", "_ZGVdN4vv_pow", FIXED(4)) |
||
| 150 | |||
| 151 | TLI_DEFINE_VECFUNC("powf", "_ZGVbN4vv_powf", FIXED(4)) |
||
| 152 | TLI_DEFINE_VECFUNC("powf", "_ZGVdN8vv_powf", FIXED(8)) |
||
| 153 | |||
| 154 | TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVbN2vv___pow_finite", FIXED(2)) |
||
| 155 | TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVdN4vv___pow_finite", FIXED(4)) |
||
| 156 | |||
| 157 | TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVbN4vv___powf_finite", FIXED(4)) |
||
| 158 | TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVdN8vv___powf_finite", FIXED(8)) |
||
| 159 | |||
| 160 | TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVbN2vv_pow", FIXED(2)) |
||
| 161 | TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVdN4vv_pow", FIXED(4)) |
||
| 162 | |||
| 163 | TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVbN4vv_powf", FIXED(4)) |
||
| 164 | TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVdN8vv_powf", FIXED(8)) |
||
| 165 | |||
| 166 | TLI_DEFINE_VECFUNC("exp", "_ZGVbN2v_exp", FIXED(2)) |
||
| 167 | TLI_DEFINE_VECFUNC("exp", "_ZGVdN4v_exp", FIXED(4)) |
||
| 168 | |||
| 169 | TLI_DEFINE_VECFUNC("expf", "_ZGVbN4v_expf", FIXED(4)) |
||
| 170 | TLI_DEFINE_VECFUNC("expf", "_ZGVdN8v_expf", FIXED(8)) |
||
| 171 | |||
| 172 | TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVbN2v___exp_finite", FIXED(2)) |
||
| 173 | TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVdN4v___exp_finite", FIXED(4)) |
||
| 174 | |||
| 175 | TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVbN4v___expf_finite", FIXED(4)) |
||
| 176 | TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVdN8v___expf_finite", FIXED(8)) |
||
| 177 | |||
| 178 | TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVbN2v_exp", FIXED(2)) |
||
| 179 | TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVdN4v_exp", FIXED(4)) |
||
| 180 | |||
| 181 | TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVbN4v_expf", FIXED(4)) |
||
| 182 | TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVdN8v_expf", FIXED(8)) |
||
| 183 | |||
| 184 | TLI_DEFINE_VECFUNC("log", "_ZGVbN2v_log", FIXED(2)) |
||
| 185 | TLI_DEFINE_VECFUNC("log", "_ZGVdN4v_log", FIXED(4)) |
||
| 186 | |||
| 187 | TLI_DEFINE_VECFUNC("logf", "_ZGVbN4v_logf", FIXED(4)) |
||
| 188 | TLI_DEFINE_VECFUNC("logf", "_ZGVdN8v_logf", FIXED(8)) |
||
| 189 | |||
| 190 | TLI_DEFINE_VECFUNC("__log_finite", "_ZGVbN2v___log_finite", FIXED(2)) |
||
| 191 | TLI_DEFINE_VECFUNC("__log_finite", "_ZGVdN4v___log_finite", FIXED(4)) |
||
| 192 | |||
| 193 | TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVbN4v___logf_finite", FIXED(4)) |
||
| 194 | TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVdN8v___logf_finite", FIXED(8)) |
||
| 195 | |||
| 196 | TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVbN2v_log", FIXED(2)) |
||
| 197 | TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVdN4v_log", FIXED(4)) |
||
| 198 | |||
| 199 | TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVbN4v_logf", FIXED(4)) |
||
| 200 | TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVdN8v_logf", FIXED(8)) |
||
| 201 | |||
| 202 | #elif defined(TLI_DEFINE_MASSV_VECFUNCS) |
||
| 203 | // IBM MASS library's vector Functions |
||
| 204 | |||
| 205 | // Floating-Point Arithmetic and Auxiliary Functions |
||
| 206 | TLI_DEFINE_VECFUNC("cbrt", "__cbrtd2", FIXED(2)) |
||
| 207 | TLI_DEFINE_VECFUNC("cbrtf", "__cbrtf4", FIXED(4)) |
||
| 208 | TLI_DEFINE_VECFUNC("pow", "__powd2", FIXED(2)) |
||
| 209 | TLI_DEFINE_VECFUNC("llvm.pow.f64", "__powd2", FIXED(2)) |
||
| 210 | TLI_DEFINE_VECFUNC("powf", "__powf4", FIXED(4)) |
||
| 211 | TLI_DEFINE_VECFUNC("llvm.pow.f32", "__powf4", FIXED(4)) |
||
| 212 | |||
| 213 | // Exponential and Logarithmic Functions |
||
| 214 | TLI_DEFINE_VECFUNC("exp", "__expd2", FIXED(2)) |
||
| 215 | TLI_DEFINE_VECFUNC("llvm.exp.f64", "__expd2", FIXED(2)) |
||
| 216 | TLI_DEFINE_VECFUNC("expf", "__expf4", FIXED(4)) |
||
| 217 | TLI_DEFINE_VECFUNC("llvm.exp.f32", "__expf4", FIXED(4)) |
||
| 218 | TLI_DEFINE_VECFUNC("exp2", "__exp2d2", FIXED(2)) |
||
| 219 | TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__exp2d2", FIXED(2)) |
||
| 220 | TLI_DEFINE_VECFUNC("exp2f", "__exp2f4", FIXED(4)) |
||
| 221 | TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__exp2f4", FIXED(4)) |
||
| 222 | TLI_DEFINE_VECFUNC("expm1", "__expm1d2", FIXED(2)) |
||
| 223 | TLI_DEFINE_VECFUNC("expm1f", "__expm1f4", FIXED(4)) |
||
| 224 | TLI_DEFINE_VECFUNC("log", "__logd2", FIXED(2)) |
||
| 225 | TLI_DEFINE_VECFUNC("llvm.log.f64", "__logd2", FIXED(2)) |
||
| 226 | TLI_DEFINE_VECFUNC("logf", "__logf4", FIXED(4)) |
||
| 227 | TLI_DEFINE_VECFUNC("llvm.log.f32", "__logf4", FIXED(4)) |
||
| 228 | TLI_DEFINE_VECFUNC("log1p", "__log1pd2", FIXED(2)) |
||
| 229 | TLI_DEFINE_VECFUNC("log1pf", "__log1pf4", FIXED(4)) |
||
| 230 | TLI_DEFINE_VECFUNC("log10", "__log10d2", FIXED(2)) |
||
| 231 | TLI_DEFINE_VECFUNC("llvm.log10.f64", "__log10d2", FIXED(2)) |
||
| 232 | TLI_DEFINE_VECFUNC("log10f", "__log10f4", FIXED(4)) |
||
| 233 | TLI_DEFINE_VECFUNC("llvm.log10.f32", "__log10f4", FIXED(4)) |
||
| 234 | TLI_DEFINE_VECFUNC("log2", "__log2d2", FIXED(2)) |
||
| 235 | TLI_DEFINE_VECFUNC("llvm.log2.f64", "__log2d2", FIXED(2)) |
||
| 236 | TLI_DEFINE_VECFUNC("log2f", "__log2f4", FIXED(4)) |
||
| 237 | TLI_DEFINE_VECFUNC("llvm.log2.f32", "__log2f4", FIXED(4)) |
||
| 238 | |||
| 239 | // Trigonometric Functions |
||
| 240 | TLI_DEFINE_VECFUNC("sin", "__sind2", FIXED(2)) |
||
| 241 | TLI_DEFINE_VECFUNC("llvm.sin.f64", "__sind2", FIXED(2)) |
||
| 242 | TLI_DEFINE_VECFUNC("sinf", "__sinf4", FIXED(4)) |
||
| 243 | TLI_DEFINE_VECFUNC("llvm.sin.f32", "__sinf4", FIXED(4)) |
||
| 244 | TLI_DEFINE_VECFUNC("cos", "__cosd2", FIXED(2)) |
||
| 245 | TLI_DEFINE_VECFUNC("llvm.cos.f64", "__cosd2", FIXED(2)) |
||
| 246 | TLI_DEFINE_VECFUNC("cosf", "__cosf4", FIXED(4)) |
||
| 247 | TLI_DEFINE_VECFUNC("llvm.cos.f32", "__cosf4", FIXED(4)) |
||
| 248 | TLI_DEFINE_VECFUNC("tan", "__tand2", FIXED(2)) |
||
| 249 | TLI_DEFINE_VECFUNC("tanf", "__tanf4", FIXED(4)) |
||
| 250 | TLI_DEFINE_VECFUNC("asin", "__asind2", FIXED(2)) |
||
| 251 | TLI_DEFINE_VECFUNC("asinf", "__asinf4", FIXED(4)) |
||
| 252 | TLI_DEFINE_VECFUNC("acos", "__acosd2", FIXED(2)) |
||
| 253 | TLI_DEFINE_VECFUNC("acosf", "__acosf4", FIXED(4)) |
||
| 254 | TLI_DEFINE_VECFUNC("atan", "__atand2", FIXED(2)) |
||
| 255 | TLI_DEFINE_VECFUNC("atanf", "__atanf4", FIXED(4)) |
||
| 256 | TLI_DEFINE_VECFUNC("atan2", "__atan2d2", FIXED(2)) |
||
| 257 | TLI_DEFINE_VECFUNC("atan2f", "__atan2f4", FIXED(4)) |
||
| 258 | |||
| 259 | // Hyperbolic Functions |
||
| 260 | TLI_DEFINE_VECFUNC("sinh", "__sinhd2", FIXED(2)) |
||
| 261 | TLI_DEFINE_VECFUNC("sinhf", "__sinhf4", FIXED(4)) |
||
| 262 | TLI_DEFINE_VECFUNC("cosh", "__coshd2", FIXED(2)) |
||
| 263 | TLI_DEFINE_VECFUNC("coshf", "__coshf4", FIXED(4)) |
||
| 264 | TLI_DEFINE_VECFUNC("tanh", "__tanhd2", FIXED(2)) |
||
| 265 | TLI_DEFINE_VECFUNC("tanhf", "__tanhf4", FIXED(4)) |
||
| 266 | TLI_DEFINE_VECFUNC("asinh", "__asinhd2", FIXED(2)) |
||
| 267 | TLI_DEFINE_VECFUNC("asinhf", "__asinhf4", FIXED(4)) |
||
| 268 | TLI_DEFINE_VECFUNC("acosh", "__acoshd2", FIXED(2)) |
||
| 269 | TLI_DEFINE_VECFUNC("acoshf", "__acoshf4", FIXED(4)) |
||
| 270 | TLI_DEFINE_VECFUNC("atanh", "__atanhd2", FIXED(2)) |
||
| 271 | TLI_DEFINE_VECFUNC("atanhf", "__atanhf4", FIXED(4)) |
||
| 272 | |||
| 273 | |||
| 274 | #elif defined(TLI_DEFINE_SVML_VECFUNCS) |
||
| 275 | // Intel SVM library's Vector Functions |
||
| 276 | |||
| 277 | TLI_DEFINE_VECFUNC("sin", "__svml_sin2", FIXED(2)) |
||
| 278 | TLI_DEFINE_VECFUNC("sin", "__svml_sin4", FIXED(4)) |
||
| 279 | TLI_DEFINE_VECFUNC("sin", "__svml_sin8", FIXED(8)) |
||
| 280 | |||
| 281 | TLI_DEFINE_VECFUNC("sinf", "__svml_sinf4", FIXED(4)) |
||
| 282 | TLI_DEFINE_VECFUNC("sinf", "__svml_sinf8", FIXED(8)) |
||
| 283 | TLI_DEFINE_VECFUNC("sinf", "__svml_sinf16", FIXED(16)) |
||
| 284 | |||
| 285 | TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin2", FIXED(2)) |
||
| 286 | TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin4", FIXED(4)) |
||
| 287 | TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin8", FIXED(8)) |
||
| 288 | |||
| 289 | TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf4", FIXED(4)) |
||
| 290 | TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf8", FIXED(8)) |
||
| 291 | TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf16", FIXED(16)) |
||
| 292 | |||
| 293 | TLI_DEFINE_VECFUNC("cos", "__svml_cos2", FIXED(2)) |
||
| 294 | TLI_DEFINE_VECFUNC("cos", "__svml_cos4", FIXED(4)) |
||
| 295 | TLI_DEFINE_VECFUNC("cos", "__svml_cos8", FIXED(8)) |
||
| 296 | |||
| 297 | TLI_DEFINE_VECFUNC("cosf", "__svml_cosf4", FIXED(4)) |
||
| 298 | TLI_DEFINE_VECFUNC("cosf", "__svml_cosf8", FIXED(8)) |
||
| 299 | TLI_DEFINE_VECFUNC("cosf", "__svml_cosf16", FIXED(16)) |
||
| 300 | |||
| 301 | TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos2", FIXED(2)) |
||
| 302 | TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos4", FIXED(4)) |
||
| 303 | TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos8", FIXED(8)) |
||
| 304 | |||
| 305 | TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf4", FIXED(4)) |
||
| 306 | TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf8", FIXED(8)) |
||
| 307 | TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf16", FIXED(16)) |
||
| 308 | |||
| 309 | TLI_DEFINE_VECFUNC("pow", "__svml_pow2", FIXED(2)) |
||
| 310 | TLI_DEFINE_VECFUNC("pow", "__svml_pow4", FIXED(4)) |
||
| 311 | TLI_DEFINE_VECFUNC("pow", "__svml_pow8", FIXED(8)) |
||
| 312 | |||
| 313 | TLI_DEFINE_VECFUNC("powf", "__svml_powf4", FIXED(4)) |
||
| 314 | TLI_DEFINE_VECFUNC("powf", "__svml_powf8", FIXED(8)) |
||
| 315 | TLI_DEFINE_VECFUNC("powf", "__svml_powf16", FIXED(16)) |
||
| 316 | |||
| 317 | TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow2", FIXED(2)) |
||
| 318 | TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow4", FIXED(4)) |
||
| 319 | TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow8", FIXED(8)) |
||
| 320 | |||
| 321 | TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf4", FIXED(4)) |
||
| 322 | TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf8", FIXED(8)) |
||
| 323 | TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf16", FIXED(16)) |
||
| 324 | |||
| 325 | TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow2", FIXED(2)) |
||
| 326 | TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow4", FIXED(4)) |
||
| 327 | TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow8", FIXED(8)) |
||
| 328 | |||
| 329 | TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf4", FIXED(4)) |
||
| 330 | TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf8", FIXED(8)) |
||
| 331 | TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf16", FIXED(16)) |
||
| 332 | |||
| 333 | TLI_DEFINE_VECFUNC("exp", "__svml_exp2", FIXED(2)) |
||
| 334 | TLI_DEFINE_VECFUNC("exp", "__svml_exp4", FIXED(4)) |
||
| 335 | TLI_DEFINE_VECFUNC("exp", "__svml_exp8", FIXED(8)) |
||
| 336 | |||
| 337 | TLI_DEFINE_VECFUNC("expf", "__svml_expf4", FIXED(4)) |
||
| 338 | TLI_DEFINE_VECFUNC("expf", "__svml_expf8", FIXED(8)) |
||
| 339 | TLI_DEFINE_VECFUNC("expf", "__svml_expf16", FIXED(16)) |
||
| 340 | |||
| 341 | TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp2", FIXED(2)) |
||
| 342 | TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp4", FIXED(4)) |
||
| 343 | TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp8", FIXED(8)) |
||
| 344 | |||
| 345 | TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf4", FIXED(4)) |
||
| 346 | TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf8", FIXED(8)) |
||
| 347 | TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf16", FIXED(16)) |
||
| 348 | |||
| 349 | TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp2", FIXED(2)) |
||
| 350 | TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp4", FIXED(4)) |
||
| 351 | TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp8", FIXED(8)) |
||
| 352 | |||
| 353 | TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf4", FIXED(4)) |
||
| 354 | TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf8", FIXED(8)) |
||
| 355 | TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf16", FIXED(16)) |
||
| 356 | |||
| 357 | TLI_DEFINE_VECFUNC("log", "__svml_log2", FIXED(2)) |
||
| 358 | TLI_DEFINE_VECFUNC("log", "__svml_log4", FIXED(4)) |
||
| 359 | TLI_DEFINE_VECFUNC("log", "__svml_log8", FIXED(8)) |
||
| 360 | |||
| 361 | TLI_DEFINE_VECFUNC("logf", "__svml_logf4", FIXED(4)) |
||
| 362 | TLI_DEFINE_VECFUNC("logf", "__svml_logf8", FIXED(8)) |
||
| 363 | TLI_DEFINE_VECFUNC("logf", "__svml_logf16", FIXED(16)) |
||
| 364 | |||
| 365 | TLI_DEFINE_VECFUNC("__log_finite", "__svml_log2", FIXED(2)) |
||
| 366 | TLI_DEFINE_VECFUNC("__log_finite", "__svml_log4", FIXED(4)) |
||
| 367 | TLI_DEFINE_VECFUNC("__log_finite", "__svml_log8", FIXED(8)) |
||
| 368 | |||
| 369 | TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf4", FIXED(4)) |
||
| 370 | TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf8", FIXED(8)) |
||
| 371 | TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf16", FIXED(16)) |
||
| 372 | |||
| 373 | TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log2", FIXED(2)) |
||
| 374 | TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log4", FIXED(4)) |
||
| 375 | TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log8", FIXED(8)) |
||
| 376 | |||
| 377 | TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf4", FIXED(4)) |
||
| 378 | TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf8", FIXED(8)) |
||
| 379 | TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf16", FIXED(16)) |
||
| 380 | |||
| 381 | TLI_DEFINE_VECFUNC("log2", "__svml_log22", FIXED(2)) |
||
| 382 | TLI_DEFINE_VECFUNC("log2", "__svml_log24", FIXED(4)) |
||
| 383 | TLI_DEFINE_VECFUNC("log2", "__svml_log28", FIXED(8)) |
||
| 384 | |||
| 385 | TLI_DEFINE_VECFUNC("log2f", "__svml_log2f4", FIXED(4)) |
||
| 386 | TLI_DEFINE_VECFUNC("log2f", "__svml_log2f8", FIXED(8)) |
||
| 387 | TLI_DEFINE_VECFUNC("log2f", "__svml_log2f16", FIXED(16)) |
||
| 388 | |||
| 389 | TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log22", FIXED(2)) |
||
| 390 | TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log24", FIXED(4)) |
||
| 391 | TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log28", FIXED(8)) |
||
| 392 | |||
| 393 | TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f4", FIXED(4)) |
||
| 394 | TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f8", FIXED(8)) |
||
| 395 | TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f16", FIXED(16)) |
||
| 396 | |||
| 397 | TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log22", FIXED(2)) |
||
| 398 | TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log24", FIXED(4)) |
||
| 399 | TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log28", FIXED(8)) |
||
| 400 | |||
| 401 | TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f4", FIXED(4)) |
||
| 402 | TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f8", FIXED(8)) |
||
| 403 | TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f16", FIXED(16)) |
||
| 404 | |||
| 405 | TLI_DEFINE_VECFUNC("log10", "__svml_log102", FIXED(2)) |
||
| 406 | TLI_DEFINE_VECFUNC("log10", "__svml_log104", FIXED(4)) |
||
| 407 | TLI_DEFINE_VECFUNC("log10", "__svml_log108", FIXED(8)) |
||
| 408 | |||
| 409 | TLI_DEFINE_VECFUNC("log10f", "__svml_log10f4", FIXED(4)) |
||
| 410 | TLI_DEFINE_VECFUNC("log10f", "__svml_log10f8", FIXED(8)) |
||
| 411 | TLI_DEFINE_VECFUNC("log10f", "__svml_log10f16", FIXED(16)) |
||
| 412 | |||
| 413 | TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log102", FIXED(2)) |
||
| 414 | TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log104", FIXED(4)) |
||
| 415 | TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log108", FIXED(8)) |
||
| 416 | |||
| 417 | TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f4", FIXED(4)) |
||
| 418 | TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f8", FIXED(8)) |
||
| 419 | TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f16", FIXED(16)) |
||
| 420 | |||
| 421 | TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log102", FIXED(2)) |
||
| 422 | TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log104", FIXED(4)) |
||
| 423 | TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log108", FIXED(8)) |
||
| 424 | |||
| 425 | TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f4", FIXED(4)) |
||
| 426 | TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f8", FIXED(8)) |
||
| 427 | TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f16", FIXED(16)) |
||
| 428 | |||
| 429 | TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt2", FIXED(2)) |
||
| 430 | TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt4", FIXED(4)) |
||
| 431 | TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt8", FIXED(8)) |
||
| 432 | |||
| 433 | TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf4", FIXED(4)) |
||
| 434 | TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf8", FIXED(8)) |
||
| 435 | TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf16", FIXED(16)) |
||
| 436 | |||
| 437 | TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt2", FIXED(2)) |
||
| 438 | TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt4", FIXED(4)) |
||
| 439 | TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt8", FIXED(8)) |
||
| 440 | |||
| 441 | TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf4", FIXED(4)) |
||
| 442 | TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf8", FIXED(8)) |
||
| 443 | TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf16", FIXED(16)) |
||
| 444 | |||
| 445 | TLI_DEFINE_VECFUNC("exp2", "__svml_exp22", FIXED(2)) |
||
| 446 | TLI_DEFINE_VECFUNC("exp2", "__svml_exp24", FIXED(4)) |
||
| 447 | TLI_DEFINE_VECFUNC("exp2", "__svml_exp28", FIXED(8)) |
||
| 448 | |||
| 449 | TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f4", FIXED(4)) |
||
| 450 | TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f8", FIXED(8)) |
||
| 451 | TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f16", FIXED(16)) |
||
| 452 | |||
| 453 | TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp22", FIXED(2)) |
||
| 454 | TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp24", FIXED(4)) |
||
| 455 | TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp28", FIXED(8)) |
||
| 456 | |||
| 457 | TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f4", FIXED(4)) |
||
| 458 | TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f8", FIXED(8)) |
||
| 459 | TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f16", FIXED(16)) |
||
| 460 | |||
| 461 | TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp22", FIXED(2)) |
||
| 462 | TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp24", FIXED(4)) |
||
| 463 | TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp28", FIXED(8)) |
||
| 464 | |||
| 465 | TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f4", FIXED(4)) |
||
| 466 | TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f8", FIXED(8)) |
||
| 467 | TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f16", FIXED(16)) |
||
| 468 | |||
| 469 | #elif defined(TLI_DEFINE_SLEEFGNUABI_VF2_VECFUNCS) |
||
| 470 | |||
| 471 | TLI_DEFINE_VECFUNC( "acos", "_ZGVnN2v_acos", FIXED(2)) |
||
| 472 | TLI_DEFINE_VECFUNC( "llvm.acos.f64", "_ZGVnN2v_acos", FIXED(2)) |
||
| 473 | |||
| 474 | TLI_DEFINE_VECFUNC( "asin", "_ZGVnN2v_asin", FIXED(2)) |
||
| 475 | TLI_DEFINE_VECFUNC( "llvm.asin.f64", "_ZGVnN2v_asin", FIXED(2)) |
||
| 476 | |||
| 477 | TLI_DEFINE_VECFUNC( "atan", "_ZGVnN2v_atan", FIXED(2)) |
||
| 478 | TLI_DEFINE_VECFUNC( "llvm.atan.f64", "_ZGVnN2v_atan", FIXED(2)) |
||
| 479 | |||
| 480 | TLI_DEFINE_VECFUNC( "atan2", "_ZGVnN2vv_atan2", FIXED(2)) |
||
| 481 | TLI_DEFINE_VECFUNC( "llvm.atan2.f64", "_ZGVnN2vv_atan2", FIXED(2)) |
||
| 482 | TLI_DEFINE_VECFUNC( "llvm.atan2.v2f64", "_ZGVnN2vv_atan2", FIXED(2)) |
||
| 483 | |||
| 484 | TLI_DEFINE_VECFUNC( "atanh", "_ZGVnN2v_atanh", FIXED(2)) |
||
| 485 | TLI_DEFINE_VECFUNC( "llvm.atanh.f64", "_ZGVnN2v_atanh", FIXED(2)) |
||
| 486 | |||
| 487 | TLI_DEFINE_VECFUNC( "cos", "_ZGVnN2v_cos", FIXED(2)) |
||
| 488 | TLI_DEFINE_VECFUNC( "llvm.cos.f64", "_ZGVnN2v_cos", FIXED(2)) |
||
| 489 | |||
| 490 | TLI_DEFINE_VECFUNC( "cosh", "_ZGVnN2v_cosh", FIXED(2)) |
||
| 491 | TLI_DEFINE_VECFUNC( "llvm.cosh.f64", "_ZGVnN2v_cosh", FIXED(2)) |
||
| 492 | |||
| 493 | TLI_DEFINE_VECFUNC( "exp", "_ZGVnN2v_exp", FIXED(2)) |
||
| 494 | TLI_DEFINE_VECFUNC( "llvm.exp.f64", "_ZGVnN2v_exp", FIXED(2)) |
||
| 495 | TLI_DEFINE_VECFUNC( "llvm.exp.v2f64", "_ZGVnN2v_exp", FIXED(2)) |
||
| 496 | |||
| 497 | TLI_DEFINE_VECFUNC( "exp2", "_ZGVnN2v_exp2", FIXED(2)) |
||
| 498 | TLI_DEFINE_VECFUNC( "llvm.exp2.f64", "_ZGVnN2v_exp2", FIXED(2)) |
||
| 499 | TLI_DEFINE_VECFUNC( "llvm.exp2.v2f64", "_ZGVnN2v_exp2", FIXED(2)) |
||
| 500 | |||
| 501 | TLI_DEFINE_VECFUNC( "exp10", "_ZGVnN2v_exp10", FIXED(2)) |
||
| 502 | TLI_DEFINE_VECFUNC( "llvm.exp10.f64", "_ZGVnN2v_exp10", FIXED(2)) |
||
| 503 | TLI_DEFINE_VECFUNC( "llvm.exp10.v2f64", "_ZGVnN2v_exp10", FIXED(2)) |
||
| 504 | |||
| 505 | TLI_DEFINE_VECFUNC( "lgamma", "_ZGVnN2v_lgamma", FIXED(2)) |
||
| 506 | TLI_DEFINE_VECFUNC( "llvm.lgamma.f64", "_ZGVnN2v_lgamma", FIXED(2)) |
||
| 507 | |||
| 508 | TLI_DEFINE_VECFUNC( "log", "_ZGVnN2v_log", FIXED(2)) |
||
| 509 | TLI_DEFINE_VECFUNC( "llvm.log.f64", "_ZGVnN2v_log", FIXED(2)) |
||
| 510 | |||
| 511 | TLI_DEFINE_VECFUNC( "log2", "_ZGVnN2v_log2", FIXED(2)) |
||
| 512 | TLI_DEFINE_VECFUNC( "llvm.log2.f64", "_ZGVnN2v_log2", FIXED(2)) |
||
| 513 | |||
| 514 | TLI_DEFINE_VECFUNC( "log10", "_ZGVnN2v_log10", FIXED(2)) |
||
| 515 | TLI_DEFINE_VECFUNC( "llvm.log10.f64", "_ZGVnN2v_log10", FIXED(2)) |
||
| 516 | |||
| 517 | TLI_DEFINE_VECFUNC( "pow", "_ZGVnN2vv_pow", FIXED(2)) |
||
| 518 | TLI_DEFINE_VECFUNC( "llvm.pow.f64", "_ZGVnN2vv_pow", FIXED(2)) |
||
| 519 | TLI_DEFINE_VECFUNC( "llvm.pow.v2f64", "_ZGVnN2vv_pow", FIXED(2)) |
||
| 520 | |||
| 521 | TLI_DEFINE_VECFUNC( "sin", "_ZGVnN2v_sin", FIXED(2)) |
||
| 522 | TLI_DEFINE_VECFUNC( "llvm.sin.f64", "_ZGVnN2v_sin", FIXED(2)) |
||
| 523 | |||
| 524 | TLI_DEFINE_VECFUNC( "sinh", "_ZGVnN2v_sinh", FIXED(2)) |
||
| 525 | TLI_DEFINE_VECFUNC( "llvm.sinh.f64", "_ZGVnN2v_sinh", FIXED(2)) |
||
| 526 | |||
| 527 | TLI_DEFINE_VECFUNC( "sqrt", "_ZGVnN2v_sqrt", FIXED(2)) |
||
| 528 | TLI_DEFINE_VECFUNC( "llvm.sqrt.f64", "_ZGVnN2v_sqrt", FIXED(2)) |
||
| 529 | |||
| 530 | TLI_DEFINE_VECFUNC( "tan", "_ZGVnN2v_tan", FIXED(2)) |
||
| 531 | TLI_DEFINE_VECFUNC( "llvm.tan.f64", "_ZGVnN2v_tan", FIXED(2)) |
||
| 532 | |||
| 533 | TLI_DEFINE_VECFUNC( "tanh", "_ZGVnN2v_tanh", FIXED(2)) |
||
| 534 | TLI_DEFINE_VECFUNC( "llvm.tanh.f64", "_ZGVnN2v_tanh", FIXED(2)) |
||
| 535 | |||
| 536 | TLI_DEFINE_VECFUNC( "tgamma", "_ZGVnN2v_tgamma", FIXED(2)) |
||
| 537 | TLI_DEFINE_VECFUNC( "llvm.tgamma.f64", "_ZGVnN2v_tgamma", FIXED(2)) |
||
| 538 | |||
| 539 | #elif defined(TLI_DEFINE_SLEEFGNUABI_VF4_VECFUNCS) |
||
| 540 | |||
| 541 | TLI_DEFINE_VECFUNC( "acosf", "_ZGVnN4v_acosf", FIXED(4)) |
||
| 542 | TLI_DEFINE_VECFUNC( "llvm.acos.f32", "_ZGVnN4v_acosf", FIXED(4)) |
||
| 543 | |||
| 544 | TLI_DEFINE_VECFUNC( "asinf", "_ZGVnN4v_asinf", FIXED(4)) |
||
| 545 | TLI_DEFINE_VECFUNC( "llvm.asin.f32", "_ZGVnN4v_asinf", FIXED(4)) |
||
| 546 | |||
| 547 | TLI_DEFINE_VECFUNC( "atanf", "_ZGVnN4v_atanf", FIXED(4)) |
||
| 548 | TLI_DEFINE_VECFUNC( "llvm.atan.f32", "_ZGVnN4v_atanf", FIXED(4)) |
||
| 549 | |||
| 550 | TLI_DEFINE_VECFUNC( "atan2f", "_ZGVnN4vv_atan2f", FIXED(4)) |
||
| 551 | TLI_DEFINE_VECFUNC( "llvm.atan2.f32", "_ZGVnN4vv_atan2f", FIXED(4)) |
||
| 552 | TLI_DEFINE_VECFUNC( "llvm.atan2.v4f32", "_ZGVnN4vv_atan2f", FIXED(4)) |
||
| 553 | |||
| 554 | TLI_DEFINE_VECFUNC( "atanhf", "_ZGVnN4v_atanhf", FIXED(4)) |
||
| 555 | TLI_DEFINE_VECFUNC( "llvm.atanh.f32", "_ZGVnN4v_atanhf", FIXED(4)) |
||
| 556 | |||
| 557 | TLI_DEFINE_VECFUNC( "cosf", "_ZGVnN4v_cosf", FIXED(4)) |
||
| 558 | TLI_DEFINE_VECFUNC( "llvm.cos.f32", "_ZGVnN4v_cosf", FIXED(4)) |
||
| 559 | |||
| 560 | TLI_DEFINE_VECFUNC( "coshf", "_ZGVnN4v_coshf", FIXED(4)) |
||
| 561 | TLI_DEFINE_VECFUNC( "llvm.cosh.f32", "_ZGVnN4v_coshf", FIXED(4)) |
||
| 562 | |||
| 563 | TLI_DEFINE_VECFUNC( "expf", "_ZGVnN4v_expf", FIXED(4)) |
||
| 564 | TLI_DEFINE_VECFUNC( "llvm.exp.f32", "_ZGVnN4v_expf", FIXED(4)) |
||
| 565 | TLI_DEFINE_VECFUNC( "llvm.exp.v4f32", "_ZGVnN4v_expf", FIXED(4)) |
||
| 566 | |||
| 567 | TLI_DEFINE_VECFUNC( "exp2f", "_ZGVnN4v_exp2f", FIXED(4)) |
||
| 568 | TLI_DEFINE_VECFUNC( "llvm.exp2.f32", "_ZGVnN4v_exp2f", FIXED(4)) |
||
| 569 | TLI_DEFINE_VECFUNC( "llvm.exp2.v4f32", "_ZGVnN4v_exp2f", FIXED(4)) |
||
| 570 | |||
| 571 | TLI_DEFINE_VECFUNC( "exp10f", "_ZGVnN4v_exp10f", FIXED(4)) |
||
| 572 | TLI_DEFINE_VECFUNC( "llvm.exp10.f32", "_ZGVnN4v_exp10f", FIXED(4)) |
||
| 573 | TLI_DEFINE_VECFUNC( "llvm.exp10.v4f32", "_ZGVnN4v_exp10f", FIXED(4)) |
||
| 574 | |||
| 575 | TLI_DEFINE_VECFUNC( "lgammaf", "_ZGVnN4v_lgammaf", FIXED(4)) |
||
| 576 | TLI_DEFINE_VECFUNC( "llvm.lgamma.f32", "_ZGVnN4v_lgammaf", FIXED(4)) |
||
| 577 | |||
| 578 | TLI_DEFINE_VECFUNC( "logf", "_ZGVnN4v_logf", FIXED(4)) |
||
| 579 | TLI_DEFINE_VECFUNC( "llvm.log.f32", "_ZGVnN4v_logf", FIXED(4)) |
||
| 580 | |||
| 581 | TLI_DEFINE_VECFUNC( "log2f", "_ZGVnN4v_log2f", FIXED(4)) |
||
| 582 | TLI_DEFINE_VECFUNC( "llvm.log2.f32", "_ZGVnN4v_log2f", FIXED(4)) |
||
| 583 | |||
| 584 | TLI_DEFINE_VECFUNC( "log10f", "_ZGVnN4v_log10f", FIXED(4)) |
||
| 585 | TLI_DEFINE_VECFUNC( "llvm.log10.f32", "_ZGVnN4v_log10f", FIXED(4)) |
||
| 586 | |||
| 587 | TLI_DEFINE_VECFUNC( "powf", "_ZGVnN4vv_powf", FIXED(4)) |
||
| 588 | TLI_DEFINE_VECFUNC( "llvm.pow.f32", "_ZGVnN4vv_powf", FIXED(4)) |
||
| 589 | TLI_DEFINE_VECFUNC( "llvm.pow.v4f32", "_ZGVnN4vv_powf", FIXED(4)) |
||
| 590 | |||
| 591 | TLI_DEFINE_VECFUNC( "sinf", "_ZGVnN4v_sinf", FIXED(4)) |
||
| 592 | TLI_DEFINE_VECFUNC( "llvm.sin.f32", "_ZGVnN4v_sinf", FIXED(4)) |
||
| 593 | |||
| 594 | TLI_DEFINE_VECFUNC( "sinhf", "_ZGVnN4v_sinhf", FIXED(4)) |
||
| 595 | TLI_DEFINE_VECFUNC( "llvm.sinh.f32", "_ZGVnN4v_sinhf", FIXED(4)) |
||
| 596 | |||
| 597 | TLI_DEFINE_VECFUNC( "sqrtf", "_ZGVnN4v_sqrtf", FIXED(4)) |
||
| 598 | TLI_DEFINE_VECFUNC( "llvm.sqrt.f32", "_ZGVnN4v_sqrtf", FIXED(4)) |
||
| 599 | |||
| 600 | TLI_DEFINE_VECFUNC( "tanf", "_ZGVnN4v_tanf", FIXED(4)) |
||
| 601 | TLI_DEFINE_VECFUNC( "llvm.tan.f32", "_ZGVnN4v_tanf", FIXED(4)) |
||
| 602 | |||
| 603 | TLI_DEFINE_VECFUNC( "tanhf", "_ZGVnN4v_tanhf", FIXED(4)) |
||
| 604 | TLI_DEFINE_VECFUNC( "llvm.tanh.f32", "_ZGVnN4v_tanhf", FIXED(4)) |
||
| 605 | |||
| 606 | TLI_DEFINE_VECFUNC( "tgammaf", "_ZGVnN4v_tgammaf", FIXED(4)) |
||
| 607 | TLI_DEFINE_VECFUNC( "llvm.tgamma.f32", "_ZGVnN4v_tgammaf", FIXED(4)) |
||
| 608 | |||
| 609 | #else |
||
| 610 | #error "Must choose which vector library functions are to be defined." |
||
| 611 | #endif |
||
| 612 | |||
| 613 | #undef TLI_DEFINE_VECFUNC |
||
| 614 | #undef TLI_DEFINE_ACCELERATE_VECFUNCS |
||
| 615 | #undef TLI_DEFINE_DARWIN_LIBSYSTEM_M_VECFUNCS |
||
| 616 | #undef TLI_DEFINE_LIBMVEC_X86_VECFUNCS |
||
| 617 | #undef TLI_DEFINE_MASSV_VECFUNCS |
||
| 618 | #undef TLI_DEFINE_SVML_VECFUNCS |
||
| 619 | #undef TLI_DEFINE_SLEEFGNUABI_VF2_VECFUNCS |
||
| 620 | #undef TLI_DEFINE_SLEEFGNUABI_VF4_VECFUNCS |
||
| 621 | #undef TLI_DEFINE_MASSV_VECFUNCS_NAMES |