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#define NOMASK false 23#define MASKED true 24 25#if !(defined(TLI_DEFINE_VECFUNC)) 26#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) {SCAL, VEC, VF, NOMASK}, 27#endif 28 29#if defined(TLI_DEFINE_ACCELERATE_VECFUNCS) 30// Accelerate framework's Vector Functions 31 32// Floating-Point Arithmetic and Auxiliary Functions 33TLI_DEFINE_VECFUNC("ceilf", "vceilf", FIXED(4)) 34TLI_DEFINE_VECFUNC("fabsf", "vfabsf", FIXED(4)) 35TLI_DEFINE_VECFUNC("llvm.fabs.f32", "vfabsf", FIXED(4)) 36TLI_DEFINE_VECFUNC("floorf", "vfloorf", FIXED(4)) 37TLI_DEFINE_VECFUNC("sqrtf", "vsqrtf", FIXED(4)) 38TLI_DEFINE_VECFUNC("llvm.sqrt.f32", "vsqrtf", FIXED(4)) 39 40// Exponential and Logarithmic Functions 41TLI_DEFINE_VECFUNC("expf", "vexpf", FIXED(4)) 42TLI_DEFINE_VECFUNC("llvm.exp.f32", "vexpf", FIXED(4)) 43TLI_DEFINE_VECFUNC("expm1f", "vexpm1f", FIXED(4)) 44TLI_DEFINE_VECFUNC("logf", "vlogf", FIXED(4)) 45TLI_DEFINE_VECFUNC("llvm.log.f32", "vlogf", FIXED(4)) 46TLI_DEFINE_VECFUNC("log1pf", "vlog1pf", FIXED(4)) 47TLI_DEFINE_VECFUNC("log10f", "vlog10f", FIXED(4)) 48TLI_DEFINE_VECFUNC("llvm.log10.f32", "vlog10f", FIXED(4)) 49TLI_DEFINE_VECFUNC("logbf", "vlogbf", FIXED(4)) 50 51// Trigonometric Functions 52TLI_DEFINE_VECFUNC("sinf", "vsinf", FIXED(4)) 53TLI_DEFINE_VECFUNC("llvm.sin.f32", "vsinf", FIXED(4)) 54TLI_DEFINE_VECFUNC("cosf", "vcosf", FIXED(4)) 55TLI_DEFINE_VECFUNC("llvm.cos.f32", "vcosf", FIXED(4)) 56TLI_DEFINE_VECFUNC("tanf", "vtanf", FIXED(4)) 57TLI_DEFINE_VECFUNC("asinf", "vasinf", FIXED(4)) 58TLI_DEFINE_VECFUNC("acosf", "vacosf", FIXED(4)) 59TLI_DEFINE_VECFUNC("atanf", "vatanf", FIXED(4)) 60 61// Hyperbolic Functions 62TLI_DEFINE_VECFUNC("sinhf", "vsinhf", FIXED(4)) 63TLI_DEFINE_VECFUNC("coshf", "vcoshf", FIXED(4)) 64TLI_DEFINE_VECFUNC("tanhf", "vtanhf", FIXED(4)) 65TLI_DEFINE_VECFUNC("asinhf", "vasinhf", FIXED(4)) 66TLI_DEFINE_VECFUNC("acoshf", "vacoshf", FIXED(4)) 67TLI_DEFINE_VECFUNC("atanhf", "vatanhf", FIXED(4)) 68 69#elif defined(TLI_DEFINE_DARWIN_LIBSYSTEM_M_VECFUNCS) 70// Darwin libsystem_m vector functions. 71 72// Exponential and Logarithmic Functions 73TLI_DEFINE_VECFUNC("exp", "_simd_exp_d2", FIXED(2)) 74TLI_DEFINE_VECFUNC("llvm.exp.f64", "_simd_exp_d2", FIXED(2)) 75TLI_DEFINE_VECFUNC("expf", "_simd_exp_f4", FIXED(4)) 76TLI_DEFINE_VECFUNC("llvm.exp.f32", "_simd_exp_f4", FIXED(4)) 77 78// Trigonometric Functions 79TLI_DEFINE_VECFUNC("acos", "_simd_acos_d2", FIXED(2)) 80TLI_DEFINE_VECFUNC("acosf", "_simd_acos_f4", FIXED(4)) 81TLI_DEFINE_VECFUNC("asin", "_simd_asin_d2", FIXED(2)) 82TLI_DEFINE_VECFUNC("asinf", "_simd_asin_f4", FIXED(4)) 83 84TLI_DEFINE_VECFUNC("atan", "_simd_atan_d2", FIXED(2)) 85TLI_DEFINE_VECFUNC("atanf", "_simd_atan_f4", FIXED(4)) 86TLI_DEFINE_VECFUNC("atan2", "_simd_atan2_d2", FIXED(2)) 87TLI_DEFINE_VECFUNC("atan2f", "_simd_atan2_f4", FIXED(4)) 88 89TLI_DEFINE_VECFUNC("cos", "_simd_cos_d2", FIXED(2)) 90TLI_DEFINE_VECFUNC("llvm.cos.f64", "_simd_cos_d2", FIXED(2)) 91TLI_DEFINE_VECFUNC("cosf", "_simd_cos_f4", FIXED(4)) 92TLI_DEFINE_VECFUNC("llvm.cos.f32", "_simd_cos_f4", FIXED(4)) 93 94TLI_DEFINE_VECFUNC("sin", "_simd_sin_d2", FIXED(2)) 95TLI_DEFINE_VECFUNC("llvm.sin.f64", "_simd_sin_d2", FIXED(2)) 96TLI_DEFINE_VECFUNC("sinf", "_simd_sin_f4", FIXED(4)) 97TLI_DEFINE_VECFUNC("llvm.sin.f32", "_simd_sin_f4", FIXED(4)) 98 99// Floating-Point Arithmetic and Auxiliary Functions 100TLI_DEFINE_VECFUNC("cbrt", "_simd_cbrt_d2", FIXED(2)) 101TLI_DEFINE_VECFUNC("cbrtf", "_simd_cbrt_f4", FIXED(4)) 102TLI_DEFINE_VECFUNC("erf", "_simd_erf_d2", FIXED(2)) 103TLI_DEFINE_VECFUNC("erff", "_simd_erf_f4", FIXED(4)) 104TLI_DEFINE_VECFUNC("pow", "_simd_pow_d2", FIXED(2)) 105TLI_DEFINE_VECFUNC("llvm.pow.f64", "_simd_pow_d2", FIXED(2)) 106TLI_DEFINE_VECFUNC("powf", "_simd_pow_f4", FIXED(4)) 107TLI_DEFINE_VECFUNC("llvm.pow.f32", "_simd_pow_f4", FIXED(4)) 108 109// Hyperbolic Functions 110TLI_DEFINE_VECFUNC("sinh", "_simd_sinh_d2", FIXED(2)) 111TLI_DEFINE_VECFUNC("sinhf", "_simd_sinh_f4", FIXED(4)) 112TLI_DEFINE_VECFUNC("cosh", "_simd_cosh_d2", FIXED(2)) 113TLI_DEFINE_VECFUNC("coshf", "_simd_cosh_f4", FIXED(4)) 114TLI_DEFINE_VECFUNC("tanh", "_simd_tanh_d2", FIXED(2)) 115TLI_DEFINE_VECFUNC("tanhf", "_simd_tanh_f4", FIXED(4)) 116TLI_DEFINE_VECFUNC("asinh", "_simd_asinh_d2", FIXED(2)) 117TLI_DEFINE_VECFUNC("asinhf", "_simd_asinh_f4", FIXED(4)) 118TLI_DEFINE_VECFUNC("acosh", "_simd_acosh_d2", FIXED(2)) 119TLI_DEFINE_VECFUNC("acoshf", "_simd_acosh_f4", FIXED(4)) 120TLI_DEFINE_VECFUNC("atanh", "_simd_atanh_d2", FIXED(2)) 121TLI_DEFINE_VECFUNC("atanhf", "_simd_atanh_f4", FIXED(4)) 122 123#elif defined(TLI_DEFINE_LIBMVEC_X86_VECFUNCS) 124// GLIBC Vector math Functions 125 126TLI_DEFINE_VECFUNC("sin", "_ZGVbN2v_sin", FIXED(2)) 127TLI_DEFINE_VECFUNC("sin", "_ZGVdN4v_sin", FIXED(4)) 128 129TLI_DEFINE_VECFUNC("sinf", "_ZGVbN4v_sinf", FIXED(4)) 130TLI_DEFINE_VECFUNC("sinf", "_ZGVdN8v_sinf", FIXED(8)) 131 132TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVbN2v_sin", FIXED(2)) 133TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVdN4v_sin", FIXED(4)) 134 135TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVbN4v_sinf", FIXED(4)) 136TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVdN8v_sinf", FIXED(8)) 137 138TLI_DEFINE_VECFUNC("cos", "_ZGVbN2v_cos", FIXED(2)) 139TLI_DEFINE_VECFUNC("cos", "_ZGVdN4v_cos", FIXED(4)) 140 141TLI_DEFINE_VECFUNC("cosf", "_ZGVbN4v_cosf", FIXED(4)) 142TLI_DEFINE_VECFUNC("cosf", "_ZGVdN8v_cosf", FIXED(8)) 143 144TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVbN2v_cos", FIXED(2)) 145TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVdN4v_cos", FIXED(4)) 146 147TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVbN4v_cosf", FIXED(4)) 148TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVdN8v_cosf", FIXED(8)) 149 150TLI_DEFINE_VECFUNC("pow", "_ZGVbN2vv_pow", FIXED(2)) 151TLI_DEFINE_VECFUNC("pow", "_ZGVdN4vv_pow", FIXED(4)) 152 153TLI_DEFINE_VECFUNC("powf", "_ZGVbN4vv_powf", FIXED(4)) 154TLI_DEFINE_VECFUNC("powf", "_ZGVdN8vv_powf", FIXED(8)) 155 156TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVbN2vv___pow_finite", FIXED(2)) 157TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVdN4vv___pow_finite", FIXED(4)) 158 159TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVbN4vv___powf_finite", FIXED(4)) 160TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVdN8vv___powf_finite", FIXED(8)) 161 162TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVbN2vv_pow", FIXED(2)) 163TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVdN4vv_pow", FIXED(4)) 164 165TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVbN4vv_powf", FIXED(4)) 166TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVdN8vv_powf", FIXED(8)) 167 168TLI_DEFINE_VECFUNC("exp", "_ZGVbN2v_exp", FIXED(2)) 169TLI_DEFINE_VECFUNC("exp", "_ZGVdN4v_exp", FIXED(4)) 170 171TLI_DEFINE_VECFUNC("expf", "_ZGVbN4v_expf", FIXED(4)) 172TLI_DEFINE_VECFUNC("expf", "_ZGVdN8v_expf", FIXED(8)) 173 174TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVbN2v___exp_finite", FIXED(2)) 175TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVdN4v___exp_finite", FIXED(4)) 176 177TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVbN4v___expf_finite", FIXED(4)) 178TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVdN8v___expf_finite", FIXED(8)) 179 180TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVbN2v_exp", FIXED(2)) 181TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVdN4v_exp", FIXED(4)) 182 183TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVbN4v_expf", FIXED(4)) 184TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVdN8v_expf", FIXED(8)) 185 186TLI_DEFINE_VECFUNC("log", "_ZGVbN2v_log", FIXED(2)) 187TLI_DEFINE_VECFUNC("log", "_ZGVdN4v_log", FIXED(4)) 188 189TLI_DEFINE_VECFUNC("logf", "_ZGVbN4v_logf", FIXED(4)) 190TLI_DEFINE_VECFUNC("logf", "_ZGVdN8v_logf", FIXED(8)) 191 192TLI_DEFINE_VECFUNC("__log_finite", "_ZGVbN2v___log_finite", FIXED(2)) 193TLI_DEFINE_VECFUNC("__log_finite", "_ZGVdN4v___log_finite", FIXED(4)) 194 195TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVbN4v___logf_finite", FIXED(4)) 196TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVdN8v___logf_finite", FIXED(8)) 197 198TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVbN2v_log", FIXED(2)) 199TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVdN4v_log", FIXED(4)) 200 201TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVbN4v_logf", FIXED(4)) 202TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVdN8v_logf", FIXED(8)) 203 204#elif defined(TLI_DEFINE_MASSV_VECFUNCS) 205// IBM MASS library's vector Functions 206 207// Floating-Point Arithmetic and Auxiliary Functions 208TLI_DEFINE_VECFUNC("cbrt", "__cbrtd2", FIXED(2)) 209TLI_DEFINE_VECFUNC("cbrtf", "__cbrtf4", FIXED(4)) 210TLI_DEFINE_VECFUNC("pow", "__powd2", FIXED(2)) 211TLI_DEFINE_VECFUNC("llvm.pow.f64", "__powd2", FIXED(2)) 212TLI_DEFINE_VECFUNC("powf", "__powf4", FIXED(4)) 213TLI_DEFINE_VECFUNC("llvm.pow.f32", "__powf4", FIXED(4)) 214 215// Exponential and Logarithmic Functions 216TLI_DEFINE_VECFUNC("exp", "__expd2", FIXED(2)) 217TLI_DEFINE_VECFUNC("llvm.exp.f64", "__expd2", FIXED(2)) 218TLI_DEFINE_VECFUNC("expf", "__expf4", FIXED(4)) 219TLI_DEFINE_VECFUNC("llvm.exp.f32", "__expf4", FIXED(4)) 220TLI_DEFINE_VECFUNC("exp2", "__exp2d2", FIXED(2)) 221TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__exp2d2", FIXED(2)) 222TLI_DEFINE_VECFUNC("exp2f", "__exp2f4", FIXED(4)) 223TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__exp2f4", FIXED(4)) 224TLI_DEFINE_VECFUNC("expm1", "__expm1d2", FIXED(2)) 225TLI_DEFINE_VECFUNC("expm1f", "__expm1f4", FIXED(4)) 226TLI_DEFINE_VECFUNC("log", "__logd2", FIXED(2)) 227TLI_DEFINE_VECFUNC("llvm.log.f64", "__logd2", FIXED(2)) 228TLI_DEFINE_VECFUNC("logf", "__logf4", FIXED(4)) 229TLI_DEFINE_VECFUNC("llvm.log.f32", "__logf4", FIXED(4)) 230TLI_DEFINE_VECFUNC("log1p", "__log1pd2", FIXED(2)) 231TLI_DEFINE_VECFUNC("log1pf", "__log1pf4", FIXED(4)) 232TLI_DEFINE_VECFUNC("log10", "__log10d2", FIXED(2)) 233TLI_DEFINE_VECFUNC("llvm.log10.f64", "__log10d2", FIXED(2)) 234TLI_DEFINE_VECFUNC("log10f", "__log10f4", FIXED(4)) 235TLI_DEFINE_VECFUNC("llvm.log10.f32", "__log10f4", FIXED(4)) 236TLI_DEFINE_VECFUNC("log2", "__log2d2", FIXED(2)) 237TLI_DEFINE_VECFUNC("llvm.log2.f64", "__log2d2", FIXED(2)) 238TLI_DEFINE_VECFUNC("log2f", "__log2f4", FIXED(4)) 239TLI_DEFINE_VECFUNC("llvm.log2.f32", "__log2f4", FIXED(4)) 240 241// Trigonometric Functions 242TLI_DEFINE_VECFUNC("sin", "__sind2", FIXED(2)) 243TLI_DEFINE_VECFUNC("llvm.sin.f64", "__sind2", FIXED(2)) 244TLI_DEFINE_VECFUNC("sinf", "__sinf4", FIXED(4)) 245TLI_DEFINE_VECFUNC("llvm.sin.f32", "__sinf4", FIXED(4)) 246TLI_DEFINE_VECFUNC("cos", "__cosd2", FIXED(2)) 247TLI_DEFINE_VECFUNC("llvm.cos.f64", "__cosd2", FIXED(2)) 248TLI_DEFINE_VECFUNC("cosf", "__cosf4", FIXED(4)) 249TLI_DEFINE_VECFUNC("llvm.cos.f32", "__cosf4", FIXED(4)) 250TLI_DEFINE_VECFUNC("tan", "__tand2", FIXED(2)) 251TLI_DEFINE_VECFUNC("tanf", "__tanf4", FIXED(4)) 252TLI_DEFINE_VECFUNC("asin", "__asind2", FIXED(2)) 253TLI_DEFINE_VECFUNC("asinf", "__asinf4", FIXED(4)) 254TLI_DEFINE_VECFUNC("acos", "__acosd2", FIXED(2)) 255TLI_DEFINE_VECFUNC("acosf", "__acosf4", FIXED(4)) 256TLI_DEFINE_VECFUNC("atan", "__atand2", FIXED(2)) 257TLI_DEFINE_VECFUNC("atanf", "__atanf4", FIXED(4)) 258TLI_DEFINE_VECFUNC("atan2", "__atan2d2", FIXED(2)) 259TLI_DEFINE_VECFUNC("atan2f", "__atan2f4", FIXED(4)) 260 261// Hyperbolic Functions 262TLI_DEFINE_VECFUNC("sinh", "__sinhd2", FIXED(2)) 263TLI_DEFINE_VECFUNC("sinhf", "__sinhf4", FIXED(4)) 264TLI_DEFINE_VECFUNC("cosh", "__coshd2", FIXED(2)) 265TLI_DEFINE_VECFUNC("coshf", "__coshf4", FIXED(4)) 266TLI_DEFINE_VECFUNC("tanh", "__tanhd2", FIXED(2)) 267TLI_DEFINE_VECFUNC("tanhf", "__tanhf4", FIXED(4)) 268TLI_DEFINE_VECFUNC("asinh", "__asinhd2", FIXED(2)) 269TLI_DEFINE_VECFUNC("asinhf", "__asinhf4", FIXED(4)) 270TLI_DEFINE_VECFUNC("acosh", "__acoshd2", FIXED(2)) 271TLI_DEFINE_VECFUNC("acoshf", "__acoshf4", FIXED(4)) 272TLI_DEFINE_VECFUNC("atanh", "__atanhd2", FIXED(2)) 273TLI_DEFINE_VECFUNC("atanhf", "__atanhf4", FIXED(4)) 274 275 276#elif defined(TLI_DEFINE_SVML_VECFUNCS) 277// Intel SVM library's Vector Functions 278 279TLI_DEFINE_VECFUNC("sin", "__svml_sin2", FIXED(2)) 280TLI_DEFINE_VECFUNC("sin", "__svml_sin4", FIXED(4)) 281TLI_DEFINE_VECFUNC("sin", "__svml_sin8", FIXED(8)) 282 283TLI_DEFINE_VECFUNC("sinf", "__svml_sinf4", FIXED(4)) 284TLI_DEFINE_VECFUNC("sinf", "__svml_sinf8", FIXED(8)) 285TLI_DEFINE_VECFUNC("sinf", "__svml_sinf16", FIXED(16)) 286 287TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin2", FIXED(2)) 288TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin4", FIXED(4)) 289TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin8", FIXED(8)) 290 291TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf4", FIXED(4)) 292TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf8", FIXED(8)) 293TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf16", FIXED(16)) 294 295TLI_DEFINE_VECFUNC("cos", "__svml_cos2", FIXED(2)) 296TLI_DEFINE_VECFUNC("cos", "__svml_cos4", FIXED(4)) 297TLI_DEFINE_VECFUNC("cos", "__svml_cos8", FIXED(8)) 298 299TLI_DEFINE_VECFUNC("cosf", "__svml_cosf4", FIXED(4)) 300TLI_DEFINE_VECFUNC("cosf", "__svml_cosf8", FIXED(8)) 301TLI_DEFINE_VECFUNC("cosf", "__svml_cosf16", FIXED(16)) 302 303TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos2", FIXED(2)) 304TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos4", FIXED(4)) 305TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos8", FIXED(8)) 306 307TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf4", FIXED(4)) 308TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf8", FIXED(8)) 309TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf16", FIXED(16)) 310 311TLI_DEFINE_VECFUNC("pow", "__svml_pow2", FIXED(2)) 312TLI_DEFINE_VECFUNC("pow", "__svml_pow4", FIXED(4)) 313TLI_DEFINE_VECFUNC("pow", "__svml_pow8", FIXED(8)) 314 315TLI_DEFINE_VECFUNC("powf", "__svml_powf4", FIXED(4)) 316TLI_DEFINE_VECFUNC("powf", "__svml_powf8", FIXED(8)) 317TLI_DEFINE_VECFUNC("powf", "__svml_powf16", FIXED(16)) 318 319TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow2", FIXED(2)) 320TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow4", FIXED(4)) 321TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow8", FIXED(8)) 322 323TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf4", FIXED(4)) 324TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf8", FIXED(8)) 325TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf16", FIXED(16)) 326 327TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow2", FIXED(2)) 328TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow4", FIXED(4)) 329TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow8", FIXED(8)) 330 331TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf4", FIXED(4)) 332TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf8", FIXED(8)) 333TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf16", FIXED(16)) 334 335TLI_DEFINE_VECFUNC("exp", "__svml_exp2", FIXED(2)) 336TLI_DEFINE_VECFUNC("exp", "__svml_exp4", FIXED(4)) 337TLI_DEFINE_VECFUNC("exp", "__svml_exp8", FIXED(8)) 338 339TLI_DEFINE_VECFUNC("expf", "__svml_expf4", FIXED(4)) 340TLI_DEFINE_VECFUNC("expf", "__svml_expf8", FIXED(8)) 341TLI_DEFINE_VECFUNC("expf", "__svml_expf16", FIXED(16)) 342 343TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp2", FIXED(2)) 344TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp4", FIXED(4)) 345TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp8", FIXED(8)) 346 347TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf4", FIXED(4)) 348TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf8", FIXED(8)) 349TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf16", FIXED(16)) 350 351TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp2", FIXED(2)) 352TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp4", FIXED(4)) 353TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp8", FIXED(8)) 354 355TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf4", FIXED(4)) 356TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf8", FIXED(8)) 357TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf16", FIXED(16)) 358 359TLI_DEFINE_VECFUNC("log", "__svml_log2", FIXED(2)) 360TLI_DEFINE_VECFUNC("log", "__svml_log4", FIXED(4)) 361TLI_DEFINE_VECFUNC("log", "__svml_log8", FIXED(8)) 362 363TLI_DEFINE_VECFUNC("logf", "__svml_logf4", FIXED(4)) 364TLI_DEFINE_VECFUNC("logf", "__svml_logf8", FIXED(8)) 365TLI_DEFINE_VECFUNC("logf", "__svml_logf16", FIXED(16)) 366 367TLI_DEFINE_VECFUNC("__log_finite", "__svml_log2", FIXED(2)) 368TLI_DEFINE_VECFUNC("__log_finite", "__svml_log4", FIXED(4)) 369TLI_DEFINE_VECFUNC("__log_finite", "__svml_log8", FIXED(8)) 370 371TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf4", FIXED(4)) 372TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf8", FIXED(8)) 373TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf16", FIXED(16)) 374 375TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log2", FIXED(2)) 376TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log4", FIXED(4)) 377TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log8", FIXED(8)) 378 379TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf4", FIXED(4)) 380TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf8", FIXED(8)) 381TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf16", FIXED(16)) 382 383TLI_DEFINE_VECFUNC("log2", "__svml_log22", FIXED(2)) 384TLI_DEFINE_VECFUNC("log2", "__svml_log24", FIXED(4)) 385TLI_DEFINE_VECFUNC("log2", "__svml_log28", FIXED(8)) 386 387TLI_DEFINE_VECFUNC("log2f", "__svml_log2f4", FIXED(4)) 388TLI_DEFINE_VECFUNC("log2f", "__svml_log2f8", FIXED(8)) 389TLI_DEFINE_VECFUNC("log2f", "__svml_log2f16", FIXED(16)) 390 391TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log22", FIXED(2)) 392TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log24", FIXED(4)) 393TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log28", FIXED(8)) 394 395TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f4", FIXED(4)) 396TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f8", FIXED(8)) 397TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f16", FIXED(16)) 398 399TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log22", FIXED(2)) 400TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log24", FIXED(4)) 401TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log28", FIXED(8)) 402 403TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f4", FIXED(4)) 404TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f8", FIXED(8)) 405TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f16", FIXED(16)) 406 407TLI_DEFINE_VECFUNC("log10", "__svml_log102", FIXED(2)) 408TLI_DEFINE_VECFUNC("log10", "__svml_log104", FIXED(4)) 409TLI_DEFINE_VECFUNC("log10", "__svml_log108", FIXED(8)) 410 411TLI_DEFINE_VECFUNC("log10f", "__svml_log10f4", FIXED(4)) 412TLI_DEFINE_VECFUNC("log10f", "__svml_log10f8", FIXED(8)) 413TLI_DEFINE_VECFUNC("log10f", "__svml_log10f16", FIXED(16)) 414 415TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log102", FIXED(2)) 416TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log104", FIXED(4)) 417TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log108", FIXED(8)) 418 419TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f4", FIXED(4)) 420TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f8", FIXED(8)) 421TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f16", FIXED(16)) 422 423TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log102", FIXED(2)) 424TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log104", FIXED(4)) 425TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log108", FIXED(8)) 426 427TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f4", FIXED(4)) 428TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f8", FIXED(8)) 429TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f16", FIXED(16)) 430 431TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt2", FIXED(2)) 432TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt4", FIXED(4)) 433TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt8", FIXED(8)) 434 435TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf4", FIXED(4)) 436TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf8", FIXED(8)) 437TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf16", FIXED(16)) 438 439TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt2", FIXED(2)) 440TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt4", FIXED(4)) 441TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt8", FIXED(8)) 442 443TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf4", FIXED(4)) 444TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf8", FIXED(8)) 445TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf16", FIXED(16)) 446 447TLI_DEFINE_VECFUNC("exp2", "__svml_exp22", FIXED(2)) 448TLI_DEFINE_VECFUNC("exp2", "__svml_exp24", FIXED(4)) 449TLI_DEFINE_VECFUNC("exp2", "__svml_exp28", FIXED(8)) 450 451TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f4", FIXED(4)) 452TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f8", FIXED(8)) 453TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f16", FIXED(16)) 454 455TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp22", FIXED(2)) 456TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp24", FIXED(4)) 457TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp28", FIXED(8)) 458 459TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f4", FIXED(4)) 460TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f8", FIXED(8)) 461TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f16", FIXED(16)) 462 463TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp22", FIXED(2)) 464TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp24", FIXED(4)) 465TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp28", FIXED(8)) 466 467TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f4", FIXED(4)) 468TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f8", FIXED(8)) 469TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f16", FIXED(16)) 470 471#elif defined(TLI_DEFINE_SLEEFGNUABI_VF2_VECFUNCS) 472 473TLI_DEFINE_VECFUNC( "acos", "_ZGVnN2v_acos", FIXED(2)) 474TLI_DEFINE_VECFUNC( "llvm.acos.f64", "_ZGVnN2v_acos", FIXED(2)) 475 476TLI_DEFINE_VECFUNC( "asin", "_ZGVnN2v_asin", FIXED(2)) 477TLI_DEFINE_VECFUNC( "llvm.asin.f64", "_ZGVnN2v_asin", FIXED(2)) 478 479TLI_DEFINE_VECFUNC( "atan", "_ZGVnN2v_atan", FIXED(2)) 480TLI_DEFINE_VECFUNC( "llvm.atan.f64", "_ZGVnN2v_atan", FIXED(2)) 481 482TLI_DEFINE_VECFUNC( "atan2", "_ZGVnN2vv_atan2", FIXED(2)) 483TLI_DEFINE_VECFUNC( "llvm.atan2.f64", "_ZGVnN2vv_atan2", FIXED(2)) 484TLI_DEFINE_VECFUNC( "llvm.atan2.v2f64", "_ZGVnN2vv_atan2", FIXED(2)) 485 486TLI_DEFINE_VECFUNC( "atanh", "_ZGVnN2v_atanh", FIXED(2)) 487TLI_DEFINE_VECFUNC( "llvm.atanh.f64", "_ZGVnN2v_atanh", FIXED(2)) 488 489TLI_DEFINE_VECFUNC( "cos", "_ZGVnN2v_cos", FIXED(2)) 490TLI_DEFINE_VECFUNC( "llvm.cos.f64", "_ZGVnN2v_cos", FIXED(2)) 491 492TLI_DEFINE_VECFUNC( "cosh", "_ZGVnN2v_cosh", FIXED(2)) 493TLI_DEFINE_VECFUNC( "llvm.cosh.f64", "_ZGVnN2v_cosh", FIXED(2)) 494 495TLI_DEFINE_VECFUNC( "exp", "_ZGVnN2v_exp", FIXED(2)) 496TLI_DEFINE_VECFUNC( "llvm.exp.f64", "_ZGVnN2v_exp", FIXED(2)) 497TLI_DEFINE_VECFUNC( "llvm.exp.v2f64", "_ZGVnN2v_exp", FIXED(2)) 498 499TLI_DEFINE_VECFUNC( "exp2", "_ZGVnN2v_exp2", FIXED(2)) 500TLI_DEFINE_VECFUNC( "llvm.exp2.f64", "_ZGVnN2v_exp2", FIXED(2)) 501TLI_DEFINE_VECFUNC( "llvm.exp2.v2f64", "_ZGVnN2v_exp2", FIXED(2)) 502 503TLI_DEFINE_VECFUNC( "exp10", "_ZGVnN2v_exp10", FIXED(2)) 504TLI_DEFINE_VECFUNC( "llvm.exp10.f64", "_ZGVnN2v_exp10", FIXED(2)) 505TLI_DEFINE_VECFUNC( "llvm.exp10.v2f64", "_ZGVnN2v_exp10", FIXED(2)) 506 507TLI_DEFINE_VECFUNC( "lgamma", "_ZGVnN2v_lgamma", FIXED(2)) 508TLI_DEFINE_VECFUNC( "llvm.lgamma.f64", "_ZGVnN2v_lgamma", FIXED(2)) 509 510TLI_DEFINE_VECFUNC( "log", "_ZGVnN2v_log", FIXED(2)) 511TLI_DEFINE_VECFUNC( "llvm.log.f64", "_ZGVnN2v_log", FIXED(2)) 512 513TLI_DEFINE_VECFUNC( "log2", "_ZGVnN2v_log2", FIXED(2)) 514TLI_DEFINE_VECFUNC( "llvm.log2.f64", "_ZGVnN2v_log2", FIXED(2)) 515 516TLI_DEFINE_VECFUNC( "log10", "_ZGVnN2v_log10", FIXED(2)) 517TLI_DEFINE_VECFUNC( "llvm.log10.f64", "_ZGVnN2v_log10", FIXED(2)) 518 519TLI_DEFINE_VECFUNC( "pow", "_ZGVnN2vv_pow", FIXED(2)) 520TLI_DEFINE_VECFUNC( "llvm.pow.f64", "_ZGVnN2vv_pow", FIXED(2)) 521TLI_DEFINE_VECFUNC( "llvm.pow.v2f64", "_ZGVnN2vv_pow", FIXED(2)) 522 523TLI_DEFINE_VECFUNC( "sin", "_ZGVnN2v_sin", FIXED(2)) 524TLI_DEFINE_VECFUNC( "llvm.sin.f64", "_ZGVnN2v_sin", FIXED(2)) 525 526TLI_DEFINE_VECFUNC( "sinh", "_ZGVnN2v_sinh", FIXED(2)) 527TLI_DEFINE_VECFUNC( "llvm.sinh.f64", "_ZGVnN2v_sinh", FIXED(2)) 528 529TLI_DEFINE_VECFUNC( "sqrt", "_ZGVnN2v_sqrt", FIXED(2)) 530 531TLI_DEFINE_VECFUNC( "tan", "_ZGVnN2v_tan", FIXED(2)) 532TLI_DEFINE_VECFUNC( "llvm.tan.f64", "_ZGVnN2v_tan", FIXED(2)) 533 534TLI_DEFINE_VECFUNC( "tanh", "_ZGVnN2v_tanh", FIXED(2)) 535TLI_DEFINE_VECFUNC( "llvm.tanh.f64", "_ZGVnN2v_tanh", FIXED(2)) 536 537TLI_DEFINE_VECFUNC( "tgamma", "_ZGVnN2v_tgamma", FIXED(2)) 538TLI_DEFINE_VECFUNC( "llvm.tgamma.f64", "_ZGVnN2v_tgamma", FIXED(2)) 539 540#elif defined(TLI_DEFINE_SLEEFGNUABI_VF4_VECFUNCS) 541 542TLI_DEFINE_VECFUNC( "acosf", "_ZGVnN4v_acosf", FIXED(4)) 543TLI_DEFINE_VECFUNC( "llvm.acos.f32", "_ZGVnN4v_acosf", FIXED(4)) 544 545TLI_DEFINE_VECFUNC( "asinf", "_ZGVnN4v_asinf", FIXED(4)) 546TLI_DEFINE_VECFUNC( "llvm.asin.f32", "_ZGVnN4v_asinf", FIXED(4)) 547 548TLI_DEFINE_VECFUNC( "atanf", "_ZGVnN4v_atanf", FIXED(4)) 549TLI_DEFINE_VECFUNC( "llvm.atan.f32", "_ZGVnN4v_atanf", FIXED(4)) 550 551TLI_DEFINE_VECFUNC( "atan2f", "_ZGVnN4vv_atan2f", FIXED(4)) 552TLI_DEFINE_VECFUNC( "llvm.atan2.f32", "_ZGVnN4vv_atan2f", FIXED(4)) 553TLI_DEFINE_VECFUNC( "llvm.atan2.v4f32", "_ZGVnN4vv_atan2f", FIXED(4)) 554 555TLI_DEFINE_VECFUNC( "atanhf", "_ZGVnN4v_atanhf", FIXED(4)) 556TLI_DEFINE_VECFUNC( "llvm.atanh.f32", "_ZGVnN4v_atanhf", FIXED(4)) 557 558TLI_DEFINE_VECFUNC( "cosf", "_ZGVnN4v_cosf", FIXED(4)) 559TLI_DEFINE_VECFUNC( "llvm.cos.f32", "_ZGVnN4v_cosf", FIXED(4)) 560 561TLI_DEFINE_VECFUNC( "coshf", "_ZGVnN4v_coshf", FIXED(4)) 562TLI_DEFINE_VECFUNC( "llvm.cosh.f32", "_ZGVnN4v_coshf", FIXED(4)) 563 564TLI_DEFINE_VECFUNC( "expf", "_ZGVnN4v_expf", FIXED(4)) 565TLI_DEFINE_VECFUNC( "llvm.exp.f32", "_ZGVnN4v_expf", FIXED(4)) 566TLI_DEFINE_VECFUNC( "llvm.exp.v4f32", "_ZGVnN4v_expf", FIXED(4)) 567 568TLI_DEFINE_VECFUNC( "exp2f", "_ZGVnN4v_exp2f", FIXED(4)) 569TLI_DEFINE_VECFUNC( "llvm.exp2.f32", "_ZGVnN4v_exp2f", FIXED(4)) 570TLI_DEFINE_VECFUNC( "llvm.exp2.v4f32", "_ZGVnN4v_exp2f", FIXED(4)) 571 572TLI_DEFINE_VECFUNC( "exp10f", "_ZGVnN4v_exp10f", FIXED(4)) 573TLI_DEFINE_VECFUNC( "llvm.exp10.f32", "_ZGVnN4v_exp10f", FIXED(4)) 574TLI_DEFINE_VECFUNC( "llvm.exp10.v4f32", "_ZGVnN4v_exp10f", FIXED(4)) 575 576TLI_DEFINE_VECFUNC( "lgammaf", "_ZGVnN4v_lgammaf", FIXED(4)) 577TLI_DEFINE_VECFUNC( "llvm.lgamma.f32", "_ZGVnN4v_lgammaf", FIXED(4)) 578 579TLI_DEFINE_VECFUNC( "logf", "_ZGVnN4v_logf", FIXED(4)) 580TLI_DEFINE_VECFUNC( "llvm.log.f32", "_ZGVnN4v_logf", FIXED(4)) 581 582TLI_DEFINE_VECFUNC( "log2f", "_ZGVnN4v_log2f", FIXED(4)) 583TLI_DEFINE_VECFUNC( "llvm.log2.f32", "_ZGVnN4v_log2f", FIXED(4)) 584 585TLI_DEFINE_VECFUNC( "log10f", "_ZGVnN4v_log10f", FIXED(4)) 586TLI_DEFINE_VECFUNC( "llvm.log10.f32", "_ZGVnN4v_log10f", FIXED(4)) 587 588TLI_DEFINE_VECFUNC( "powf", "_ZGVnN4vv_powf", FIXED(4)) 589TLI_DEFINE_VECFUNC( "llvm.pow.f32", "_ZGVnN4vv_powf", FIXED(4)) 590TLI_DEFINE_VECFUNC( "llvm.pow.v4f32", "_ZGVnN4vv_powf", FIXED(4)) 591 592TLI_DEFINE_VECFUNC( "sinf", "_ZGVnN4v_sinf", FIXED(4)) 593TLI_DEFINE_VECFUNC( "llvm.sin.f32", "_ZGVnN4v_sinf", FIXED(4)) 594 595TLI_DEFINE_VECFUNC( "sinhf", "_ZGVnN4v_sinhf", FIXED(4)) 596TLI_DEFINE_VECFUNC( "llvm.sinh.f32", "_ZGVnN4v_sinhf", FIXED(4)) 597 598TLI_DEFINE_VECFUNC( "sqrtf", "_ZGVnN4v_sqrtf", FIXED(4)) 599 600TLI_DEFINE_VECFUNC( "tanf", "_ZGVnN4v_tanf", FIXED(4)) 601TLI_DEFINE_VECFUNC( "llvm.tan.f32", "_ZGVnN4v_tanf", FIXED(4)) 602 603TLI_DEFINE_VECFUNC( "tanhf", "_ZGVnN4v_tanhf", FIXED(4)) 604TLI_DEFINE_VECFUNC( "llvm.tanh.f32", "_ZGVnN4v_tanhf", FIXED(4)) 605 606TLI_DEFINE_VECFUNC( "tgammaf", "_ZGVnN4v_tgammaf", FIXED(4)) 607TLI_DEFINE_VECFUNC( "llvm.tgamma.f32", "_ZGVnN4v_tgammaf", FIXED(4)) 608 609#elif defined(TLI_DEFINE_SLEEFGNUABI_SCALABLE_VECFUNCS) 610 611TLI_DEFINE_VECFUNC("acos", "_ZGVsMxv_acos", SCALABLE(2), MASKED) 612TLI_DEFINE_VECFUNC("acosf", "_ZGVsMxv_acosf", SCALABLE(4), MASKED) 613 614TLI_DEFINE_VECFUNC("asin", "_ZGVsMxv_asin", SCALABLE(2), MASKED) 615TLI_DEFINE_VECFUNC("asinf", "_ZGVsMxv_asinf", SCALABLE(4), MASKED) 616 617TLI_DEFINE_VECFUNC("atan", "_ZGVsMxv_atan", SCALABLE(2), MASKED) 618TLI_DEFINE_VECFUNC("atanf", "_ZGVsMxv_atanf", SCALABLE(4), MASKED) 619 620TLI_DEFINE_VECFUNC("atan2", "_ZGVsMxvv_atan2", SCALABLE(2), MASKED) 621TLI_DEFINE_VECFUNC("atan2f", "_ZGVsMxvv_atan2f", SCALABLE(4), MASKED) 622 623TLI_DEFINE_VECFUNC("atanh", "_ZGVsMxv_atanh", SCALABLE(2), MASKED) 624TLI_DEFINE_VECFUNC("atanhf", "_ZGVsMxv_atanhf", SCALABLE(4), MASKED) 625 626TLI_DEFINE_VECFUNC("cos", "_ZGVsMxv_cos", SCALABLE(2), MASKED) 627TLI_DEFINE_VECFUNC("cosf", "_ZGVsMxv_cosf", SCALABLE(4), MASKED) 628TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVsMxv_cos", SCALABLE(2), MASKED) 629TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVsMxv_cosf", SCALABLE(4), MASKED) 630 631TLI_DEFINE_VECFUNC("cosh", "_ZGVsMxv_cosh", SCALABLE(2), MASKED) 632TLI_DEFINE_VECFUNC("coshf", "_ZGVsMxv_coshf", SCALABLE(4), MASKED) 633 634TLI_DEFINE_VECFUNC("exp", "_ZGVsMxv_exp", SCALABLE(2), MASKED) 635TLI_DEFINE_VECFUNC("expf", "_ZGVsMxv_expf", SCALABLE(4), MASKED) 636TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVsMxv_exp", SCALABLE(2), MASKED) 637TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVsMxv_expf", SCALABLE(4), MASKED) 638 639TLI_DEFINE_VECFUNC("exp2", "_ZGVsMxv_exp2", SCALABLE(2), MASKED) 640TLI_DEFINE_VECFUNC("exp2f", "_ZGVsMxv_exp2f", SCALABLE(4), MASKED) 641TLI_DEFINE_VECFUNC("llvm.exp2.f64", "_ZGVsMxv_exp2", SCALABLE(2), MASKED) 642TLI_DEFINE_VECFUNC("llvm.exp2.f32", "_ZGVsMxv_exp2f", SCALABLE(4), MASKED) 643 644TLI_DEFINE_VECFUNC("exp10", "_ZGVsMxv_exp10", SCALABLE(2), MASKED) 645TLI_DEFINE_VECFUNC("exp10f", "_ZGVsMxv_exp10f", SCALABLE(4), MASKED) 646 647TLI_DEFINE_VECFUNC("lgamma", "_ZGVsMxv_lgamma", SCALABLE(2), MASKED) 648TLI_DEFINE_VECFUNC("lgammaf", "_ZGVsMxv_lgammaf", SCALABLE(4), MASKED) 649 650TLI_DEFINE_VECFUNC("log", "_ZGVsMxv_log", SCALABLE(2), MASKED) 651TLI_DEFINE_VECFUNC("logf", "_ZGVsMxv_logf", SCALABLE(4), MASKED) 652TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVsMxv_log", SCALABLE(2), MASKED) 653TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVsMxv_logf", SCALABLE(4), MASKED) 654 655TLI_DEFINE_VECFUNC( "log2", "_ZGVsMxv_log2", SCALABLE(2), MASKED) 656TLI_DEFINE_VECFUNC( "log2f", "_ZGVsMxv_log2f", SCALABLE(4), MASKED) 657TLI_DEFINE_VECFUNC( "llvm.log2.f64", "_ZGVsMxv_log2", SCALABLE(2), MASKED) 658TLI_DEFINE_VECFUNC( "llvm.log2.f32", "_ZGVsMxv_log2f", SCALABLE(4), MASKED) 659 660TLI_DEFINE_VECFUNC("log10", "_ZGVsMxv_log10", SCALABLE(2), MASKED) 661TLI_DEFINE_VECFUNC("log10f", "_ZGVsMxv_log10f", SCALABLE(4), MASKED) 662TLI_DEFINE_VECFUNC("llvm.log10.f64", "_ZGVsMxv_log10", SCALABLE(2), MASKED) 663TLI_DEFINE_VECFUNC("llvm.log10.f32", "_ZGVsMxv_log10f", SCALABLE(4), MASKED) 664 665TLI_DEFINE_VECFUNC("pow", "_ZGVsMxvv_pow", SCALABLE(2), MASKED) 666TLI_DEFINE_VECFUNC("powf", "_ZGVsMxvv_powf", SCALABLE(4), MASKED) 667TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVsMxvv_pow", SCALABLE(2), MASKED) 668TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVsMxvv_powf", SCALABLE(4), MASKED) 669 670TLI_DEFINE_VECFUNC("sin", "_ZGVsMxv_sin", SCALABLE(2), MASKED) 671TLI_DEFINE_VECFUNC("sinf", "_ZGVsMxv_sinf", SCALABLE(4), MASKED) 672TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVsMxv_sin", SCALABLE(2), MASKED) 673TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVsMxv_sinf", SCALABLE(4), MASKED) 674 675TLI_DEFINE_VECFUNC("sinh", "_ZGVsMxv_sinh", SCALABLE(2), MASKED) 676TLI_DEFINE_VECFUNC("sinhf", "_ZGVsMxv_sinhf", SCALABLE(4), MASKED) 677 678TLI_DEFINE_VECFUNC("sqrt", "_ZGVsMxv_sqrt", SCALABLE(2), MASKED) 679TLI_DEFINE_VECFUNC("sqrtf", "_ZGVsMxv_sqrtf", SCALABLE(4), MASKED) 680 681TLI_DEFINE_VECFUNC("tan", "_ZGVsMxv_tan", SCALABLE(2), MASKED) 682TLI_DEFINE_VECFUNC("tanf", "_ZGVsMxv_tanf", SCALABLE(4), MASKED) 683 684TLI_DEFINE_VECFUNC("tanh", "_ZGVsMxv_tanh", SCALABLE(2), MASKED) 685TLI_DEFINE_VECFUNC("tanhf", "_ZGVsMxv_tanhf", SCALABLE(4), MASKED) 686 687TLI_DEFINE_VECFUNC("tgamma", "_ZGVsMxv_tgamma", SCALABLE(2), MASKED) 688TLI_DEFINE_VECFUNC("tgammaf", "_ZGVsMxv_tgammaf", SCALABLE(4), MASKED) 689 690#elif defined(TLI_DEFINE_ARMPL_VECFUNCS) 691 692TLI_DEFINE_VECFUNC("acos", "armpl_vacosq_f64", FIXED(2), NOMASK) 693TLI_DEFINE_VECFUNC("acosf", "armpl_vacosq_f32", FIXED(4), NOMASK) 694TLI_DEFINE_VECFUNC("acos", "armpl_svacos_f64_x", SCALABLE(2), MASKED) 695TLI_DEFINE_VECFUNC("acosf", "armpl_svacos_f32_x", SCALABLE(4), MASKED) 696 697TLI_DEFINE_VECFUNC("acosh", "armpl_vacoshq_f64", FIXED(2), NOMASK) 698TLI_DEFINE_VECFUNC("acoshf", "armpl_vacoshq_f32", FIXED(4), NOMASK) 699TLI_DEFINE_VECFUNC("acosh", "armpl_svacosh_f64_x", SCALABLE(2), MASKED) 700TLI_DEFINE_VECFUNC("acoshf", "armpl_svacosh_f32_x", SCALABLE(4), MASKED) 701 702TLI_DEFINE_VECFUNC("asin", "armpl_vasinq_f64", FIXED(2), NOMASK) 703TLI_DEFINE_VECFUNC("asinf", "armpl_vasinq_f32", FIXED(4), NOMASK) 704TLI_DEFINE_VECFUNC("asin", "armpl_svasin_f64_x", SCALABLE(2), MASKED) 705TLI_DEFINE_VECFUNC("asinf", "armpl_svasin_f32_x", SCALABLE(4), MASKED) 706 707TLI_DEFINE_VECFUNC("asinh", "armpl_vasinhq_f64", FIXED(2), NOMASK) 708TLI_DEFINE_VECFUNC("asinhf", "armpl_vasinhq_f32", FIXED(4), NOMASK) 709TLI_DEFINE_VECFUNC("asinh", "armpl_svasinh_f64_x", SCALABLE(2), MASKED) 710TLI_DEFINE_VECFUNC("asinhf", "armpl_svasinh_f32_x", SCALABLE(4), MASKED) 711 712TLI_DEFINE_VECFUNC("atan", "armpl_vatanq_f64", FIXED(2), NOMASK) 713TLI_DEFINE_VECFUNC("atanf", "armpl_vatanq_f32", FIXED(4), NOMASK) 714TLI_DEFINE_VECFUNC("atan", "armpl_svatan_f64_x", SCALABLE(2), MASKED) 715TLI_DEFINE_VECFUNC("atanf", "armpl_svatan_f32_x", SCALABLE(4), MASKED) 716 717TLI_DEFINE_VECFUNC("atan2", "armpl_vatan2q_f64", FIXED(2), NOMASK) 718TLI_DEFINE_VECFUNC("atan2f", "armpl_vatan2q_f32", FIXED(4), NOMASK) 719TLI_DEFINE_VECFUNC("atan2", "armpl_svatan2_f64_x", SCALABLE(2), MASKED) 720TLI_DEFINE_VECFUNC("atan2f", "armpl_svatan2_f32_x", SCALABLE(4), MASKED) 721 722TLI_DEFINE_VECFUNC("atanh", "armpl_vatanhq_f64", FIXED(2), NOMASK) 723TLI_DEFINE_VECFUNC("atanhf", "armpl_vatanhq_f32", FIXED(4), NOMASK) 724TLI_DEFINE_VECFUNC("atanh", "armpl_svatanh_f64_x", SCALABLE(2), MASKED) 725TLI_DEFINE_VECFUNC("atanhf", "armpl_svatanh_f32_x", SCALABLE(4), MASKED) 726 727TLI_DEFINE_VECFUNC("cbrt", "armpl_vcbrtq_f64", FIXED(2), NOMASK) 728TLI_DEFINE_VECFUNC("cbrtf", "armpl_vcbrtq_f32", FIXED(4), NOMASK) 729TLI_DEFINE_VECFUNC("cbrt", "armpl_svcbrt_f64_x", SCALABLE(2), MASKED) 730TLI_DEFINE_VECFUNC("cbrtf", "armpl_svcbrt_f32_x", SCALABLE(4), MASKED) 731 732TLI_DEFINE_VECFUNC("copysign", "armpl_vcopysignq_f64", FIXED(2), NOMASK) 733TLI_DEFINE_VECFUNC("copysignf", "armpl_vcopysignq_f32", FIXED(4), NOMASK) 734TLI_DEFINE_VECFUNC("copysign", "armpl_svcopysign_f64_x", SCALABLE(2), MASKED) 735TLI_DEFINE_VECFUNC("copysignf", "armpl_svcopysign_f32_x", SCALABLE(4), MASKED) 736 737TLI_DEFINE_VECFUNC("cos", "armpl_vcosq_f64", FIXED(2), NOMASK) 738TLI_DEFINE_VECFUNC("cosf", "armpl_vcosq_f32", FIXED(4), NOMASK) 739TLI_DEFINE_VECFUNC("cos", "armpl_svcos_f64_x", SCALABLE(2), MASKED) 740TLI_DEFINE_VECFUNC("cosf", "armpl_svcos_f32_x", SCALABLE(4), MASKED) 741 742TLI_DEFINE_VECFUNC("llvm.cos.f64", "armpl_vcosq_f64", FIXED(2), NOMASK) 743TLI_DEFINE_VECFUNC("llvm.cos.f32", "armpl_vcosq_f32", FIXED(4), NOMASK) 744TLI_DEFINE_VECFUNC("llvm.cos.f64", "armpl_svcos_f64_x", SCALABLE(2), MASKED) 745TLI_DEFINE_VECFUNC("llvm.cos.f32", "armpl_svcos_f32_x", SCALABLE(4), MASKED) 746 747TLI_DEFINE_VECFUNC("cosh", "armpl_vcoshq_f64", FIXED(2), NOMASK) 748TLI_DEFINE_VECFUNC("coshf", "armpl_vcoshq_f32", FIXED(4), NOMASK) 749TLI_DEFINE_VECFUNC("cosh", "armpl_svcosh_f64_x", SCALABLE(2), MASKED) 750TLI_DEFINE_VECFUNC("coshf", "armpl_svcosh_f32_x", SCALABLE(4), MASKED) 751 752TLI_DEFINE_VECFUNC("erf", "armpl_verfq_f64", FIXED(2), NOMASK) 753TLI_DEFINE_VECFUNC("erff", "armpl_verfq_f32", FIXED(4), NOMASK) 754TLI_DEFINE_VECFUNC("erf", "armpl_sverf_f64_x", SCALABLE(2), MASKED) 755TLI_DEFINE_VECFUNC("erff", "armpl_sverf_f32_x", SCALABLE(4), MASKED) 756 757TLI_DEFINE_VECFUNC("erfc", "armpl_verfcq_f64", FIXED(2), NOMASK) 758TLI_DEFINE_VECFUNC("erfcf", "armpl_verfcq_f32", FIXED(4), NOMASK) 759TLI_DEFINE_VECFUNC("erfc", "armpl_sverfc_f64_x", SCALABLE(2), MASKED) 760TLI_DEFINE_VECFUNC("erfcf", "armpl_sverfc_f32_x", SCALABLE(4), MASKED) 761 762TLI_DEFINE_VECFUNC("exp", "armpl_vexpq_f64", FIXED(2), NOMASK) 763TLI_DEFINE_VECFUNC("expf", "armpl_vexpq_f32", FIXED(4), NOMASK) 764TLI_DEFINE_VECFUNC("exp", "armpl_svexp_f64_x", SCALABLE(2), MASKED) 765TLI_DEFINE_VECFUNC("expf", "armpl_svexp_f32_x", SCALABLE(4), MASKED) 766 767TLI_DEFINE_VECFUNC("llvm.exp.f64", "armpl_vexpq_f64", FIXED(2), NOMASK) 768TLI_DEFINE_VECFUNC("llvm.exp.f32", "armpl_vexpq_f32", FIXED(4), NOMASK) 769TLI_DEFINE_VECFUNC("llvm.exp.f64", "armpl_svexp_f64_x", SCALABLE(2), MASKED) 770TLI_DEFINE_VECFUNC("llvm.exp.f32", "armpl_svexp_f32_x", SCALABLE(4), MASKED) 771 772TLI_DEFINE_VECFUNC("exp2", "armpl_vexp2q_f64", FIXED(2), NOMASK) 773TLI_DEFINE_VECFUNC("exp2f", "armpl_vexp2q_f32", FIXED(4), NOMASK) 774TLI_DEFINE_VECFUNC("exp2", "armpl_svexp2_f64_x", SCALABLE(2), MASKED) 775TLI_DEFINE_VECFUNC("exp2f", "armpl_svexp2_f32_x", SCALABLE(4), MASKED) 776 777TLI_DEFINE_VECFUNC("llvm.exp2.f64", "armpl_vexp2q_f64", FIXED(2), NOMASK) 778TLI_DEFINE_VECFUNC("llvm.exp2.f32", "armpl_vexp2q_f32", FIXED(4), NOMASK) 779TLI_DEFINE_VECFUNC("llvm.exp2.f64", "armpl_svexp2_f64_x", SCALABLE(2), MASKED) 780TLI_DEFINE_VECFUNC("llvm.exp2.f32", "armpl_svexp2_f32_x", SCALABLE(4), MASKED) 781 782TLI_DEFINE_VECFUNC("exp10", "armpl_vexp10q_f64", FIXED(2), NOMASK) 783TLI_DEFINE_VECFUNC("exp10f", "armpl_vexp10q_f32", FIXED(4), NOMASK) 784TLI_DEFINE_VECFUNC("exp10", "armpl_svexp10_f64_x", SCALABLE(2), MASKED) 785TLI_DEFINE_VECFUNC("exp10f", "armpl_svexp10_f32_x", SCALABLE(4), MASKED) 786 787TLI_DEFINE_VECFUNC("expm1", "armpl_vexpm1q_f64", FIXED(2), NOMASK) 788TLI_DEFINE_VECFUNC("expm1f", "armpl_vexpm1q_f32", FIXED(4), NOMASK) 789TLI_DEFINE_VECFUNC("expm1", "armpl_svexpm1_f64_x", SCALABLE(2), MASKED) 790TLI_DEFINE_VECFUNC("expm1f", "armpl_svexpm1_f32_x", SCALABLE(4), MASKED) 791 792TLI_DEFINE_VECFUNC("fdim", "armpl_vfdimq_f64", FIXED(2), NOMASK) 793TLI_DEFINE_VECFUNC("fdimf", "armpl_vfdimq_f32", FIXED(4), NOMASK) 794TLI_DEFINE_VECFUNC("fdim", "armpl_svfdim_f64_x", SCALABLE(2), MASKED) 795TLI_DEFINE_VECFUNC("fdimf", "armpl_svfdim_f32_x", SCALABLE(4), MASKED) 796 797TLI_DEFINE_VECFUNC("fma", "armpl_vfmaq_f64", FIXED(2), NOMASK) 798TLI_DEFINE_VECFUNC("fmaf", "armpl_vfmaq_f32", FIXED(4), NOMASK) 799TLI_DEFINE_VECFUNC("fma", "armpl_svfma_f64_x", SCALABLE(2), MASKED) 800TLI_DEFINE_VECFUNC("fmaf", "armpl_svfma_f32_x", SCALABLE(4), MASKED) 801 802TLI_DEFINE_VECFUNC("fmin", "armpl_vfminq_f64", FIXED(2), NOMASK) 803TLI_DEFINE_VECFUNC("fminf", "armpl_vfminq_f32", FIXED(4), NOMASK) 804TLI_DEFINE_VECFUNC("fmin", "armpl_svfmin_f64_x", SCALABLE(2), MASKED) 805TLI_DEFINE_VECFUNC("fminf", "armpl_svfmin_f32_x", SCALABLE(4), MASKED) 806 807TLI_DEFINE_VECFUNC("fmod", "armpl_vfmodq_f64", FIXED(2), NOMASK) 808TLI_DEFINE_VECFUNC("fmodf", "armpl_vfmodq_f32", FIXED(4), NOMASK) 809TLI_DEFINE_VECFUNC("fmod", "armpl_svfmod_f64_x", SCALABLE(2), MASKED) 810TLI_DEFINE_VECFUNC("fmodf", "armpl_svfmod_f32_x", SCALABLE(4), MASKED) 811 812TLI_DEFINE_VECFUNC("hypot", "armpl_vhypotq_f64", FIXED(2), NOMASK) 813TLI_DEFINE_VECFUNC("hypotf", "armpl_vhypotq_f32", FIXED(4), NOMASK) 814TLI_DEFINE_VECFUNC("hypot", "armpl_svhypot_f64_x", SCALABLE(2), MASKED) 815TLI_DEFINE_VECFUNC("hypotf", "armpl_svhypot_f32_x", SCALABLE(4), MASKED) 816 817TLI_DEFINE_VECFUNC("lgamma", "armpl_vlgammaq_f64", FIXED(2), NOMASK) 818TLI_DEFINE_VECFUNC("lgammaf", "armpl_vlgammaq_f32", FIXED(4), NOMASK) 819TLI_DEFINE_VECFUNC("lgamma", "armpl_svlgamma_f64_x", SCALABLE(2), MASKED) 820TLI_DEFINE_VECFUNC("lgammaf", "armpl_svlgamma_f32_x", SCALABLE(4), MASKED) 821 822TLI_DEFINE_VECFUNC("log", "armpl_vlogq_f64", FIXED(2), NOMASK) 823TLI_DEFINE_VECFUNC("logf", "armpl_vlogq_f32", FIXED(4), NOMASK) 824TLI_DEFINE_VECFUNC("log", "armpl_svlog_f64_x", SCALABLE(2), MASKED) 825TLI_DEFINE_VECFUNC("logf", "armpl_svlog_f32_x", SCALABLE(4), MASKED) 826 827TLI_DEFINE_VECFUNC("llvm.log.f64", "armpl_vlogq_f64", FIXED(2), NOMASK) 828TLI_DEFINE_VECFUNC("llvm.log.f32", "armpl_vlogq_f32", FIXED(4), NOMASK) 829TLI_DEFINE_VECFUNC("llvm.log.f64", "armpl_svlog_f64_x", SCALABLE(2), MASKED) 830TLI_DEFINE_VECFUNC("llvm.log.f32", "armpl_svlog_f32_x", SCALABLE(4), MASKED) 831 832TLI_DEFINE_VECFUNC("log1p", "armpl_vlog1pq_f64", FIXED(2), NOMASK) 833TLI_DEFINE_VECFUNC("log1pf", "armpl_vlog1pq_f32", FIXED(4), NOMASK) 834TLI_DEFINE_VECFUNC("log1p", "armpl_svlog1p_f64_x", SCALABLE(2), MASKED) 835TLI_DEFINE_VECFUNC("log1pf", "armpl_svlog1p_f32_x", SCALABLE(4), MASKED) 836 837TLI_DEFINE_VECFUNC("log2", "armpl_vlog2q_f64", FIXED(2), NOMASK) 838TLI_DEFINE_VECFUNC("log2f", "armpl_vlog2q_f32", FIXED(4), NOMASK) 839TLI_DEFINE_VECFUNC("log2", "armpl_svlog2_f64_x", SCALABLE(2), MASKED) 840TLI_DEFINE_VECFUNC("log2f", "armpl_svlog2_f32_x", SCALABLE(4), MASKED) 841 842TLI_DEFINE_VECFUNC("llvm.log2.f64", "armpl_vlog2q_f64", FIXED(2), NOMASK) 843TLI_DEFINE_VECFUNC("llvm.log2.f32", "armpl_vlog2q_f32", FIXED(4), NOMASK) 844TLI_DEFINE_VECFUNC("llvm.log2.f64", "armpl_svlog2_f64_x", SCALABLE(2), MASKED) 845TLI_DEFINE_VECFUNC("llvm.log2.f32", "armpl_svlog2_f32_x", SCALABLE(4), MASKED) 846 847TLI_DEFINE_VECFUNC("log10", "armpl_vlog10q_f64", FIXED(2), NOMASK) 848TLI_DEFINE_VECFUNC("log10f", "armpl_vlog10q_f32", FIXED(4), NOMASK) 849TLI_DEFINE_VECFUNC("log10", "armpl_svlog10_f64_x", SCALABLE(2), MASKED) 850TLI_DEFINE_VECFUNC("log10f", "armpl_svlog10_f32_x", SCALABLE(4), MASKED) 851 852TLI_DEFINE_VECFUNC("llvm.log10.f64", "armpl_vlog10q_f64", FIXED(2), NOMASK) 853TLI_DEFINE_VECFUNC("llvm.log10.f32", "armpl_vlog10q_f32", FIXED(4), NOMASK) 854TLI_DEFINE_VECFUNC("llvm.log10.f64", "armpl_svlog10_f64_x", SCALABLE(2), MASKED) 855TLI_DEFINE_VECFUNC("llvm.log10.f32", "armpl_svlog10_f32_x", SCALABLE(4), MASKED) 856 857TLI_DEFINE_VECFUNC("nextafter", "armpl_vnextafterq_f64", FIXED(2), NOMASK) 858TLI_DEFINE_VECFUNC("nextafterf", "armpl_vnextafterq_f32", FIXED(4), NOMASK) 859TLI_DEFINE_VECFUNC("nextafter", "armpl_svnextafter_f64_x", SCALABLE(2), MASKED) 860TLI_DEFINE_VECFUNC("nextafterf", "armpl_svnextafter_f32_x", SCALABLE(4), MASKED) 861 862TLI_DEFINE_VECFUNC("pow", "armpl_vpowq_f64", FIXED(2), NOMASK) 863TLI_DEFINE_VECFUNC("powf", "armpl_vpowq_f32", FIXED(4), NOMASK) 864TLI_DEFINE_VECFUNC("pow", "armpl_svpow_f64_x", SCALABLE(2), MASKED) 865TLI_DEFINE_VECFUNC("powf", "armpl_svpow_f32_x", SCALABLE(4), MASKED) 866 867TLI_DEFINE_VECFUNC("llvm.pow.f64", "armpl_vpowq_f64", FIXED(2), NOMASK) 868TLI_DEFINE_VECFUNC("llvm.pow.f32", "armpl_vpowq_f32", FIXED(4), NOMASK) 869TLI_DEFINE_VECFUNC("llvm.pow.f64", "armpl_svpow_f64_x", SCALABLE(2), MASKED) 870TLI_DEFINE_VECFUNC("llvm.pow.f32", "armpl_svpow_f32_x", SCALABLE(4), MASKED) 871 872TLI_DEFINE_VECFUNC("sin", "armpl_vsinq_f64", FIXED(2), NOMASK) 873TLI_DEFINE_VECFUNC("sinf", "armpl_vsinq_f32", FIXED(4), NOMASK) 874TLI_DEFINE_VECFUNC("sin", "armpl_svsin_f64_x", SCALABLE(2), MASKED) 875TLI_DEFINE_VECFUNC("sinf", "armpl_svsin_f32_x", SCALABLE(4), MASKED) 876 877TLI_DEFINE_VECFUNC("llvm.sin.f64", "armpl_vsinq_f64", FIXED(2), NOMASK) 878TLI_DEFINE_VECFUNC("llvm.sin.f32", "armpl_vsinq_f32", FIXED(4), NOMASK) 879TLI_DEFINE_VECFUNC("llvm.sin.f64", "armpl_svsin_f64_x", SCALABLE(2), MASKED) 880TLI_DEFINE_VECFUNC("llvm.sin.f32", "armpl_svsin_f32_x", SCALABLE(4), MASKED) 881 882TLI_DEFINE_VECFUNC("sinh", "armpl_vsinhq_f64", FIXED(2), NOMASK) 883TLI_DEFINE_VECFUNC("sinhf", "armpl_vsinhq_f32", FIXED(4), NOMASK) 884TLI_DEFINE_VECFUNC("sinh", "armpl_svsinh_f64_x", SCALABLE(2), MASKED) 885TLI_DEFINE_VECFUNC("sinhf", "armpl_svsinh_f32_x", SCALABLE(4), MASKED) 886 887TLI_DEFINE_VECFUNC("sinpi", "armpl_vsinpiq_f64", FIXED(2), NOMASK) 888TLI_DEFINE_VECFUNC("sinpif", "armpl_vsinpiq_f32", FIXED(4), NOMASK) 889TLI_DEFINE_VECFUNC("sinpi", "armpl_svsinpi_f64_x", SCALABLE(2), MASKED) 890TLI_DEFINE_VECFUNC("sinpif", "armpl_svsinpi_f32_x", SCALABLE(4), MASKED) 891 892TLI_DEFINE_VECFUNC("sqrt", "armpl_vsqrtq_f64", FIXED(2), NOMASK) 893TLI_DEFINE_VECFUNC("sqrtf", "armpl_vsqrtq_f32", FIXED(4), NOMASK) 894TLI_DEFINE_VECFUNC("sqrt", "armpl_svsqrt_f64_x", SCALABLE(2), MASKED) 895TLI_DEFINE_VECFUNC("sqrtf", "armpl_svsqrt_f32_x", SCALABLE(4), MASKED) 896 897TLI_DEFINE_VECFUNC("tan", "armpl_vtanq_f64", FIXED(2), NOMASK) 898TLI_DEFINE_VECFUNC("tanf", "armpl_vtanq_f32", FIXED(4), NOMASK) 899TLI_DEFINE_VECFUNC("tan", "armpl_svtan_f64_x", SCALABLE(2), MASKED) 900TLI_DEFINE_VECFUNC("tanf", "armpl_svtan_f32_x", SCALABLE(4), MASKED) 901 902TLI_DEFINE_VECFUNC("tanh", "armpl_vtanhq_f64", FIXED(2), NOMASK) 903TLI_DEFINE_VECFUNC("tanhf", "armpl_vtanhq_f32", FIXED(4), NOMASK) 904TLI_DEFINE_VECFUNC("tanh", "armpl_svtanh_f64_x", SCALABLE(2), MASKED) 905TLI_DEFINE_VECFUNC("tanhf", "armpl_svtanh_f32_x", SCALABLE(4), MASKED) 906 907TLI_DEFINE_VECFUNC("tgamma", "armpl_vtgammaq_f64", FIXED(2), NOMASK) 908TLI_DEFINE_VECFUNC("tgammaf", "armpl_vtgammaq_f32", FIXED(4), NOMASK) 909TLI_DEFINE_VECFUNC("tgamma", "armpl_svtgamma_f64_x", SCALABLE(2), MASKED) 910TLI_DEFINE_VECFUNC("tgammaf", "armpl_svtgamma_f32_x", SCALABLE(4), MASKED) 911 912#else 913#error "Must choose which vector library functions are to be defined." 914#endif 915 916#undef MASKED 917#undef NOMASK 918#undef SCALABLE 919#undef FIXED 920 921#undef TLI_DEFINE_VECFUNC 922#undef TLI_DEFINE_ACCELERATE_VECFUNCS 923#undef TLI_DEFINE_DARWIN_LIBSYSTEM_M_VECFUNCS 924#undef TLI_DEFINE_LIBMVEC_X86_VECFUNCS 925#undef TLI_DEFINE_MASSV_VECFUNCS 926#undef TLI_DEFINE_SVML_VECFUNCS 927#undef TLI_DEFINE_SLEEFGNUABI_VF2_VECFUNCS 928#undef TLI_DEFINE_SLEEFGNUABI_VF4_VECFUNCS 929#undef TLI_DEFINE_SLEEFGNUABI_SCALABLE_VECFUNCS 930#undef TLI_DEFINE_MASSV_VECFUNCS_NAMES 931#undef TLI_DEFINE_ARMPL_VECFUNCS 932