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#if !(defined(TLI_DEFINE_VECFUNC)) 21#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) {SCAL, VEC, VF}, 22#endif 23 24#if defined(TLI_DEFINE_ACCELERATE_VECFUNCS) 25// Accelerate framework's Vector Functions 26 27// Floating-Point Arithmetic and Auxiliary Functions 28TLI_DEFINE_VECFUNC("ceilf", "vceilf", 4) 29TLI_DEFINE_VECFUNC("fabsf", "vfabsf", 4) 30TLI_DEFINE_VECFUNC("llvm.fabs.f32", "vfabsf", 4) 31TLI_DEFINE_VECFUNC("floorf", "vfloorf", 4) 32TLI_DEFINE_VECFUNC("sqrtf", "vsqrtf", 4) 33TLI_DEFINE_VECFUNC("llvm.sqrt.f32", "vsqrtf", 4) 34 35// Exponential and Logarithmic Functions 36TLI_DEFINE_VECFUNC("expf", "vexpf", 4) 37TLI_DEFINE_VECFUNC("llvm.exp.f32", "vexpf", 4) 38TLI_DEFINE_VECFUNC("expm1f", "vexpm1f", 4) 39TLI_DEFINE_VECFUNC("logf", "vlogf", 4) 40TLI_DEFINE_VECFUNC("llvm.log.f32", "vlogf", 4) 41TLI_DEFINE_VECFUNC("log1pf", "vlog1pf", 4) 42TLI_DEFINE_VECFUNC("log10f", "vlog10f", 4) 43TLI_DEFINE_VECFUNC("llvm.log10.f32", "vlog10f", 4) 44TLI_DEFINE_VECFUNC("logbf", "vlogbf", 4) 45 46// Trigonometric Functions 47TLI_DEFINE_VECFUNC("sinf", "vsinf", 4) 48TLI_DEFINE_VECFUNC("llvm.sin.f32", "vsinf", 4) 49TLI_DEFINE_VECFUNC("cosf", "vcosf", 4) 50TLI_DEFINE_VECFUNC("llvm.cos.f32", "vcosf", 4) 51TLI_DEFINE_VECFUNC("tanf", "vtanf", 4) 52TLI_DEFINE_VECFUNC("asinf", "vasinf", 4) 53TLI_DEFINE_VECFUNC("acosf", "vacosf", 4) 54TLI_DEFINE_VECFUNC("atanf", "vatanf", 4) 55 56// Hyperbolic Functions 57TLI_DEFINE_VECFUNC("sinhf", "vsinhf", 4) 58TLI_DEFINE_VECFUNC("coshf", "vcoshf", 4) 59TLI_DEFINE_VECFUNC("tanhf", "vtanhf", 4) 60TLI_DEFINE_VECFUNC("asinhf", "vasinhf", 4) 61TLI_DEFINE_VECFUNC("acoshf", "vacoshf", 4) 62TLI_DEFINE_VECFUNC("atanhf", "vatanhf", 4) 63 64 65#elif defined(TLI_DEFINE_LIBMVEC_X86_VECFUNCS) 66// GLIBC Vector math Functions 67 68TLI_DEFINE_VECFUNC("sin", "_ZGVbN2v_sin", 2) 69TLI_DEFINE_VECFUNC("sin", "_ZGVdN4v_sin", 4) 70 71TLI_DEFINE_VECFUNC("sinf", "_ZGVbN4v_sinf", 4) 72TLI_DEFINE_VECFUNC("sinf", "_ZGVdN8v_sinf", 8) 73 74TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVbN2v_sin", 2) 75TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVdN4v_sin", 4) 76 77TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVbN4v_sinf", 4) 78TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVdN8v_sinf", 8) 79 80TLI_DEFINE_VECFUNC("cos", "_ZGVbN2v_cos", 2) 81TLI_DEFINE_VECFUNC("cos", "_ZGVdN4v_cos", 4) 82 83TLI_DEFINE_VECFUNC("cosf", "_ZGVbN4v_cosf", 4) 84TLI_DEFINE_VECFUNC("cosf", "_ZGVdN8v_cosf", 8) 85 86TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVbN2v_cos", 2) 87TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVdN4v_cos", 4) 88 89TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVbN4v_cosf", 4) 90TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVdN8v_cosf", 8) 91 92TLI_DEFINE_VECFUNC("pow", "_ZGVbN2vv_pow", 2) 93TLI_DEFINE_VECFUNC("pow", "_ZGVdN4vv_pow", 4) 94 95TLI_DEFINE_VECFUNC("powf", "_ZGVbN4vv_powf", 4) 96TLI_DEFINE_VECFUNC("powf", "_ZGVdN8vv_powf", 8) 97 98TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVbN2vv___pow_finite", 2) 99TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVdN4vv___pow_finite", 4) 100 101TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVbN4vv___powf_finite", 4) 102TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVdN8vv___powf_finite", 8) 103 104TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVbN2vv_pow", 2) 105TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVdN4vv_pow", 4) 106 107TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVbN4vv_powf", 4) 108TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVdN8vv_powf", 8) 109 110TLI_DEFINE_VECFUNC("exp", "_ZGVbN2v_exp", 2) 111TLI_DEFINE_VECFUNC("exp", "_ZGVdN4v_exp", 4) 112 113TLI_DEFINE_VECFUNC("expf", "_ZGVbN4v_expf", 4) 114TLI_DEFINE_VECFUNC("expf", "_ZGVdN8v_expf", 8) 115 116TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVbN2v___exp_finite", 2) 117TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVdN4v___exp_finite", 4) 118 119TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVbN4v___expf_finite", 4) 120TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVdN8v___expf_finite", 8) 121 122TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVbN2v_exp", 2) 123TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVdN4v_exp", 4) 124 125TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVbN4v_expf", 4) 126TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVdN8v_expf", 8) 127 128TLI_DEFINE_VECFUNC("log", "_ZGVbN2v_log", 2) 129TLI_DEFINE_VECFUNC("log", "_ZGVdN4v_log", 4) 130 131TLI_DEFINE_VECFUNC("logf", "_ZGVbN4v_logf", 4) 132TLI_DEFINE_VECFUNC("logf", "_ZGVdN8v_logf", 8) 133 134TLI_DEFINE_VECFUNC("__log_finite", "_ZGVbN2v___log_finite", 2) 135TLI_DEFINE_VECFUNC("__log_finite", "_ZGVdN4v___log_finite", 4) 136 137TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVbN4v___logf_finite", 4) 138TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVdN8v___logf_finite", 8) 139 140TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVbN2v_log", 2) 141TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVdN4v_log", 4) 142 143TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVbN4v_logf", 4) 144TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVdN8v_logf", 8) 145 146#elif defined(TLI_DEFINE_MASSV_VECFUNCS) 147// IBM MASS library's vector Functions 148 149// Floating-Point Arithmetic and Auxiliary Functions 150TLI_DEFINE_VECFUNC("cbrt", "__cbrtd2_massv", 2) 151TLI_DEFINE_VECFUNC("cbrtf", "__cbrtf4_massv", 4) 152TLI_DEFINE_VECFUNC("pow", "__powd2_massv", 2) 153TLI_DEFINE_VECFUNC("llvm.pow.f64", "__powd2_massv", 2) 154TLI_DEFINE_VECFUNC("powf", "__powf4_massv", 4) 155TLI_DEFINE_VECFUNC("llvm.pow.f32", "__powf4_massv", 4) 156TLI_DEFINE_VECFUNC("sqrt", "__sqrtd2_massv", 2) 157TLI_DEFINE_VECFUNC("llvm.sqrt.f64", "__sqrtd2_massv", 2) 158TLI_DEFINE_VECFUNC("sqrtf", "__sqrtf4_massv", 4) 159TLI_DEFINE_VECFUNC("llvm.sqrt.f32", "__sqrtf4_massv", 4) 160 161// Exponential and Logarithmic Functions 162TLI_DEFINE_VECFUNC("exp", "__expd2_massv", 2) 163TLI_DEFINE_VECFUNC("llvm.exp.f64", "__expd2_massv", 2) 164TLI_DEFINE_VECFUNC("expf", "__expf4_massv", 4) 165TLI_DEFINE_VECFUNC("llvm.exp.f32", "__expf4_massv", 4) 166TLI_DEFINE_VECFUNC("exp2", "__exp2d2_massv", 2) 167TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__exp2d2_massv", 2) 168TLI_DEFINE_VECFUNC("exp2f", "__exp2f4_massv", 4) 169TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__exp2f4_massv", 4) 170TLI_DEFINE_VECFUNC("expm1", "__expm1d2_massv", 2) 171TLI_DEFINE_VECFUNC("expm1f", "__expm1f4_massv", 4) 172TLI_DEFINE_VECFUNC("log", "__logd2_massv", 2) 173TLI_DEFINE_VECFUNC("llvm.log.f64", "__logd2_massv", 2) 174TLI_DEFINE_VECFUNC("logf", "__logf4_massv", 4) 175TLI_DEFINE_VECFUNC("llvm.log.f32", "__logf4_massv", 4) 176TLI_DEFINE_VECFUNC("log1p", "__log1pd2_massv", 2) 177TLI_DEFINE_VECFUNC("log1pf", "__log1pf4_massv", 4) 178TLI_DEFINE_VECFUNC("log10", "__log10d2_massv", 2) 179TLI_DEFINE_VECFUNC("llvm.log10.f64", "__log10d2_massv", 2) 180TLI_DEFINE_VECFUNC("log10f", "__log10f4_massv", 4) 181TLI_DEFINE_VECFUNC("llvm.log10.f32", "__log10f4_massv", 4) 182TLI_DEFINE_VECFUNC("log2", "__log2d2_massv", 2) 183TLI_DEFINE_VECFUNC("llvm.log2.f64", "__log2d2_massv", 2) 184TLI_DEFINE_VECFUNC("log2f", "__log2f4_massv", 4) 185TLI_DEFINE_VECFUNC("llvm.log2.f32", "__log2f4_massv", 4) 186 187// Trigonometric Functions 188TLI_DEFINE_VECFUNC("sin", "__sind2_massv", 2) 189TLI_DEFINE_VECFUNC("llvm.sin.f64", "__sind2_massv", 2) 190TLI_DEFINE_VECFUNC("sinf", "__sinf4_massv", 4) 191TLI_DEFINE_VECFUNC("llvm.sin.f32", "__sinf4_massv", 4) 192TLI_DEFINE_VECFUNC("cos", "__cosd2_massv", 2) 193TLI_DEFINE_VECFUNC("llvm.cos.f64", "__cosd2_massv", 2) 194TLI_DEFINE_VECFUNC("cosf", "__cosf4_massv", 4) 195TLI_DEFINE_VECFUNC("llvm.cos.f32", "__cosf4_massv", 4) 196TLI_DEFINE_VECFUNC("tan", "__tand2_massv", 2) 197TLI_DEFINE_VECFUNC("tanf", "__tanf4_massv", 4) 198TLI_DEFINE_VECFUNC("asin", "__asind2_massv", 2) 199TLI_DEFINE_VECFUNC("asinf", "__asinf4_massv", 4) 200TLI_DEFINE_VECFUNC("acos", "__acosd2_massv", 2) 201TLI_DEFINE_VECFUNC("acosf", "__acosf4_massv", 4) 202TLI_DEFINE_VECFUNC("atan", "__atand2_massv", 2) 203TLI_DEFINE_VECFUNC("atanf", "__atanf4_massv", 4) 204TLI_DEFINE_VECFUNC("atan2", "__atan2d2_massv", 2) 205TLI_DEFINE_VECFUNC("atan2f", "__atan2f4_massv", 4) 206 207// Hyperbolic Functions 208TLI_DEFINE_VECFUNC("sinh", "__sinhd2_massv", 2) 209TLI_DEFINE_VECFUNC("sinhf", "__sinhf4_massv", 4) 210TLI_DEFINE_VECFUNC("cosh", "__coshd2_massv", 2) 211TLI_DEFINE_VECFUNC("coshf", "__coshf4_massv", 4) 212TLI_DEFINE_VECFUNC("tanh", "__tanhd2_massv", 2) 213TLI_DEFINE_VECFUNC("tanhf", "__tanhf4_massv", 4) 214TLI_DEFINE_VECFUNC("asinh", "__asinhd2_massv", 2) 215TLI_DEFINE_VECFUNC("asinhf", "__asinhf4_massv", 4) 216TLI_DEFINE_VECFUNC("acosh", "__acoshd2_massv", 2) 217TLI_DEFINE_VECFUNC("acoshf", "__acoshf4_massv", 4) 218TLI_DEFINE_VECFUNC("atanh", "__atanhd2_massv", 2) 219TLI_DEFINE_VECFUNC("atanhf", "__atanhf4_massv", 4) 220 221 222#elif defined(TLI_DEFINE_SVML_VECFUNCS) 223// Intel SVM library's Vector Functions 224 225TLI_DEFINE_VECFUNC("sin", "__svml_sin2", 2) 226TLI_DEFINE_VECFUNC("sin", "__svml_sin4", 4) 227TLI_DEFINE_VECFUNC("sin", "__svml_sin8", 8) 228 229TLI_DEFINE_VECFUNC("sinf", "__svml_sinf4", 4) 230TLI_DEFINE_VECFUNC("sinf", "__svml_sinf8", 8) 231TLI_DEFINE_VECFUNC("sinf", "__svml_sinf16", 16) 232 233TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin2", 2) 234TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin4", 4) 235TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin8", 8) 236 237TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf4", 4) 238TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf8", 8) 239TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf16", 16) 240 241TLI_DEFINE_VECFUNC("cos", "__svml_cos2", 2) 242TLI_DEFINE_VECFUNC("cos", "__svml_cos4", 4) 243TLI_DEFINE_VECFUNC("cos", "__svml_cos8", 8) 244 245TLI_DEFINE_VECFUNC("cosf", "__svml_cosf4", 4) 246TLI_DEFINE_VECFUNC("cosf", "__svml_cosf8", 8) 247TLI_DEFINE_VECFUNC("cosf", "__svml_cosf16", 16) 248 249TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos2", 2) 250TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos4", 4) 251TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos8", 8) 252 253TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf4", 4) 254TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf8", 8) 255TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf16", 16) 256 257TLI_DEFINE_VECFUNC("pow", "__svml_pow2", 2) 258TLI_DEFINE_VECFUNC("pow", "__svml_pow4", 4) 259TLI_DEFINE_VECFUNC("pow", "__svml_pow8", 8) 260 261TLI_DEFINE_VECFUNC("powf", "__svml_powf4", 4) 262TLI_DEFINE_VECFUNC("powf", "__svml_powf8", 8) 263TLI_DEFINE_VECFUNC("powf", "__svml_powf16", 16) 264 265TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow2", 2) 266TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow4", 4) 267TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow8", 8) 268 269TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf4", 4) 270TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf8", 8) 271TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf16", 16) 272 273TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow2", 2) 274TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow4", 4) 275TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow8", 8) 276 277TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf4", 4) 278TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf8", 8) 279TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf16", 16) 280 281TLI_DEFINE_VECFUNC("exp", "__svml_exp2", 2) 282TLI_DEFINE_VECFUNC("exp", "__svml_exp4", 4) 283TLI_DEFINE_VECFUNC("exp", "__svml_exp8", 8) 284 285TLI_DEFINE_VECFUNC("expf", "__svml_expf4", 4) 286TLI_DEFINE_VECFUNC("expf", "__svml_expf8", 8) 287TLI_DEFINE_VECFUNC("expf", "__svml_expf16", 16) 288 289TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp2", 2) 290TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp4", 4) 291TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp8", 8) 292 293TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf4", 4) 294TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf8", 8) 295TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf16", 16) 296 297TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp2", 2) 298TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp4", 4) 299TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp8", 8) 300 301TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf4", 4) 302TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf8", 8) 303TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf16", 16) 304 305TLI_DEFINE_VECFUNC("log", "__svml_log2", 2) 306TLI_DEFINE_VECFUNC("log", "__svml_log4", 4) 307TLI_DEFINE_VECFUNC("log", "__svml_log8", 8) 308 309TLI_DEFINE_VECFUNC("logf", "__svml_logf4", 4) 310TLI_DEFINE_VECFUNC("logf", "__svml_logf8", 8) 311TLI_DEFINE_VECFUNC("logf", "__svml_logf16", 16) 312 313TLI_DEFINE_VECFUNC("__log_finite", "__svml_log2", 2) 314TLI_DEFINE_VECFUNC("__log_finite", "__svml_log4", 4) 315TLI_DEFINE_VECFUNC("__log_finite", "__svml_log8", 8) 316 317TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf4", 4) 318TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf8", 8) 319TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf16", 16) 320 321TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log2", 2) 322TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log4", 4) 323TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log8", 8) 324 325TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf4", 4) 326TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf8", 8) 327TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf16", 16) 328 329TLI_DEFINE_VECFUNC("log2", "__svml_log22", 2) 330TLI_DEFINE_VECFUNC("log2", "__svml_log24", 4) 331TLI_DEFINE_VECFUNC("log2", "__svml_log28", 8) 332 333TLI_DEFINE_VECFUNC("log2f", "__svml_log2f4", 4) 334TLI_DEFINE_VECFUNC("log2f", "__svml_log2f8", 8) 335TLI_DEFINE_VECFUNC("log2f", "__svml_log2f16", 16) 336 337TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log22", 2) 338TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log24", 4) 339TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log28", 8) 340 341TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f4", 4) 342TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f8", 8) 343TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f16", 16) 344 345TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log22", 2) 346TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log24", 4) 347TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log28", 8) 348 349TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f4", 4) 350TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f8", 8) 351TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f16", 16) 352 353TLI_DEFINE_VECFUNC("log10", "__svml_log102", 2) 354TLI_DEFINE_VECFUNC("log10", "__svml_log104", 4) 355TLI_DEFINE_VECFUNC("log10", "__svml_log108", 8) 356 357TLI_DEFINE_VECFUNC("log10f", "__svml_log10f4", 4) 358TLI_DEFINE_VECFUNC("log10f", "__svml_log10f8", 8) 359TLI_DEFINE_VECFUNC("log10f", "__svml_log10f16", 16) 360 361TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log102", 2) 362TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log104", 4) 363TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log108", 8) 364 365TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f4", 4) 366TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f8", 8) 367TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f16", 16) 368 369TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log102", 2) 370TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log104", 4) 371TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log108", 8) 372 373TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f4", 4) 374TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f8", 8) 375TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f16", 16) 376 377TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt2", 2) 378TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt4", 4) 379TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt8", 8) 380 381TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf4", 4) 382TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf8", 8) 383TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf16", 16) 384 385TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt2", 2) 386TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt4", 4) 387TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt8", 8) 388 389TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf4", 4) 390TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf8", 8) 391TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf16", 16) 392 393TLI_DEFINE_VECFUNC("exp2", "__svml_exp22", 2) 394TLI_DEFINE_VECFUNC("exp2", "__svml_exp24", 4) 395TLI_DEFINE_VECFUNC("exp2", "__svml_exp28", 8) 396 397TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f4", 4) 398TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f8", 8) 399TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f16", 16) 400 401TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp22", 2) 402TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp24", 4) 403TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp28", 8) 404 405TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f4", 4) 406TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f8", 8) 407TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f16", 16) 408 409TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp22", 2) 410TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp24", 4) 411TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp28", 8) 412 413TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f4", 4) 414TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f8", 8) 415TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f16", 16) 416 417#else 418#error "Must choose which vector library functions are to be defined." 419#endif 420 421#undef TLI_DEFINE_VECFUNC 422#undef TLI_DEFINE_ACCELERATE_VECFUNCS 423#undef TLI_DEFINE_LIBMVEC_X86_VECFUNCS 424#undef TLI_DEFINE_MASSV_VECFUNCS 425#undef TLI_DEFINE_SVML_VECFUNCS 426#undef TLI_DEFINE_MASSV_VECFUNCS_NAMES 427