Index: llvm/include/llvm/Analysis/TargetLibraryInfo.h =================================================================== --- llvm/include/llvm/Analysis/TargetLibraryInfo.h +++ llvm/include/llvm/Analysis/TargetLibraryInfo.h @@ -28,7 +28,7 @@ struct VecDesc { StringRef ScalarFnName; StringRef VectorFnName; - unsigned VectorizationFactor; + ElementCount VectorizationFactor; }; enum LibFunc : unsigned { @@ -152,7 +152,7 @@ /// Return true if the function F has a vector equivalent with vectorization /// factor VF. - bool isFunctionVectorizable(StringRef F, unsigned VF) const { + bool isFunctionVectorizable(StringRef F, ElementCount VF) const { return !getVectorizedFunction(F, VF).empty(); } @@ -162,7 +162,7 @@ /// Return the name of the equivalent of F, vectorized with factor VF. If no /// such mapping exists, return the empty string. - StringRef getVectorizedFunction(StringRef F, unsigned VF) const; + StringRef getVectorizedFunction(StringRef F, ElementCount VF) const; /// Set to true iff i32 parameters to library functions should have signext /// or zeroext attributes if they correspond to C-level int or unsigned int, @@ -190,7 +190,8 @@ /// Returns the largest vectorization factor used in the list of /// vector functions. - unsigned getWidestVF(StringRef ScalarF) const; + void getWidestVF(StringRef ScalarF, unsigned &FixedVF, + unsigned &Scalable) const; }; /// Provides information about what library functions are available for @@ -305,13 +306,13 @@ bool has(LibFunc F) const { return getState(F) != TargetLibraryInfoImpl::Unavailable; } - bool isFunctionVectorizable(StringRef F, unsigned VF) const { + bool isFunctionVectorizable(StringRef F, ElementCount VF) const { return Impl->isFunctionVectorizable(F, VF); } bool isFunctionVectorizable(StringRef F) const { return Impl->isFunctionVectorizable(F); } - StringRef getVectorizedFunction(StringRef F, unsigned VF) const { + StringRef getVectorizedFunction(StringRef F, ElementCount VF) const { return Impl->getVectorizedFunction(F, VF); } @@ -397,8 +398,9 @@ } /// Returns the largest vectorization factor used in the list of /// vector functions. - unsigned getWidestVF(StringRef ScalarF) const { - return Impl->getWidestVF(ScalarF); + void getWidestVF(StringRef ScalarF, unsigned &FixedVF, + unsigned &ScalableVF) const { + Impl->getWidestVF(ScalarF, FixedVF, ScalableVF); } /// Check if the function "F" is listed in a library known to LLVM. Index: llvm/include/llvm/Analysis/VecFuncs.def =================================================================== --- llvm/include/llvm/Analysis/VecFuncs.def +++ llvm/include/llvm/Analysis/VecFuncs.def @@ -17,6 +17,9 @@ #define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) VEC, #endif +#define FIXED(NL) ElementCount::getFixed(NL) +#define SCALABLE(NL) ElementCount::getScalable(NL) + #if !(defined(TLI_DEFINE_VECFUNC)) #define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) {SCAL, VEC, VF}, #endif @@ -25,394 +28,394 @@ // Accelerate framework's Vector Functions // Floating-Point Arithmetic and Auxiliary Functions -TLI_DEFINE_VECFUNC("ceilf", "vceilf", 4) -TLI_DEFINE_VECFUNC("fabsf", "vfabsf", 4) -TLI_DEFINE_VECFUNC("llvm.fabs.f32", "vfabsf", 4) -TLI_DEFINE_VECFUNC("floorf", "vfloorf", 4) -TLI_DEFINE_VECFUNC("sqrtf", "vsqrtf", 4) -TLI_DEFINE_VECFUNC("llvm.sqrt.f32", "vsqrtf", 4) +TLI_DEFINE_VECFUNC("ceilf", "vceilf", FIXED(4)) +TLI_DEFINE_VECFUNC("fabsf", "vfabsf", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.fabs.f32", "vfabsf", FIXED(4)) +TLI_DEFINE_VECFUNC("floorf", "vfloorf", FIXED(4)) +TLI_DEFINE_VECFUNC("sqrtf", "vsqrtf", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.sqrt.f32", "vsqrtf", FIXED(4)) // Exponential and Logarithmic Functions -TLI_DEFINE_VECFUNC("expf", "vexpf", 4) -TLI_DEFINE_VECFUNC("llvm.exp.f32", "vexpf", 4) -TLI_DEFINE_VECFUNC("expm1f", "vexpm1f", 4) -TLI_DEFINE_VECFUNC("logf", "vlogf", 4) -TLI_DEFINE_VECFUNC("llvm.log.f32", "vlogf", 4) -TLI_DEFINE_VECFUNC("log1pf", "vlog1pf", 4) -TLI_DEFINE_VECFUNC("log10f", "vlog10f", 4) -TLI_DEFINE_VECFUNC("llvm.log10.f32", "vlog10f", 4) -TLI_DEFINE_VECFUNC("logbf", "vlogbf", 4) +TLI_DEFINE_VECFUNC("expf", "vexpf", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.exp.f32", "vexpf", FIXED(4)) +TLI_DEFINE_VECFUNC("expm1f", "vexpm1f", FIXED(4)) +TLI_DEFINE_VECFUNC("logf", "vlogf", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log.f32", "vlogf", FIXED(4)) +TLI_DEFINE_VECFUNC("log1pf", "vlog1pf", FIXED(4)) +TLI_DEFINE_VECFUNC("log10f", "vlog10f", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log10.f32", "vlog10f", FIXED(4)) +TLI_DEFINE_VECFUNC("logbf", "vlogbf", FIXED(4)) // Trigonometric Functions -TLI_DEFINE_VECFUNC("sinf", "vsinf", 4) -TLI_DEFINE_VECFUNC("llvm.sin.f32", "vsinf", 4) -TLI_DEFINE_VECFUNC("cosf", "vcosf", 4) -TLI_DEFINE_VECFUNC("llvm.cos.f32", "vcosf", 4) -TLI_DEFINE_VECFUNC("tanf", "vtanf", 4) -TLI_DEFINE_VECFUNC("asinf", "vasinf", 4) -TLI_DEFINE_VECFUNC("acosf", "vacosf", 4) -TLI_DEFINE_VECFUNC("atanf", "vatanf", 4) +TLI_DEFINE_VECFUNC("sinf", "vsinf", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.sin.f32", "vsinf", FIXED(4)) +TLI_DEFINE_VECFUNC("cosf", "vcosf", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.cos.f32", "vcosf", FIXED(4)) +TLI_DEFINE_VECFUNC("tanf", "vtanf", FIXED(4)) +TLI_DEFINE_VECFUNC("asinf", "vasinf", FIXED(4)) +TLI_DEFINE_VECFUNC("acosf", "vacosf", FIXED(4)) +TLI_DEFINE_VECFUNC("atanf", "vatanf", FIXED(4)) // Hyperbolic Functions -TLI_DEFINE_VECFUNC("sinhf", "vsinhf", 4) -TLI_DEFINE_VECFUNC("coshf", "vcoshf", 4) -TLI_DEFINE_VECFUNC("tanhf", "vtanhf", 4) -TLI_DEFINE_VECFUNC("asinhf", "vasinhf", 4) -TLI_DEFINE_VECFUNC("acoshf", "vacoshf", 4) -TLI_DEFINE_VECFUNC("atanhf", "vatanhf", 4) +TLI_DEFINE_VECFUNC("sinhf", "vsinhf", FIXED(4)) +TLI_DEFINE_VECFUNC("coshf", "vcoshf", FIXED(4)) +TLI_DEFINE_VECFUNC("tanhf", "vtanhf", FIXED(4)) +TLI_DEFINE_VECFUNC("asinhf", "vasinhf", FIXED(4)) +TLI_DEFINE_VECFUNC("acoshf", "vacoshf", FIXED(4)) +TLI_DEFINE_VECFUNC("atanhf", "vatanhf", FIXED(4)) #elif defined(TLI_DEFINE_LIBMVEC_X86_VECFUNCS) // GLIBC Vector math Functions -TLI_DEFINE_VECFUNC("sin", "_ZGVbN2v_sin", 2) -TLI_DEFINE_VECFUNC("sin", "_ZGVdN4v_sin", 4) +TLI_DEFINE_VECFUNC("sin", "_ZGVbN2v_sin", FIXED(2)) +TLI_DEFINE_VECFUNC("sin", "_ZGVdN4v_sin", FIXED(4)) -TLI_DEFINE_VECFUNC("sinf", "_ZGVbN4v_sinf", 4) -TLI_DEFINE_VECFUNC("sinf", "_ZGVdN8v_sinf", 8) +TLI_DEFINE_VECFUNC("sinf", "_ZGVbN4v_sinf", FIXED(4)) +TLI_DEFINE_VECFUNC("sinf", "_ZGVdN8v_sinf", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVbN2v_sin", 2) -TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVdN4v_sin", 4) +TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVbN2v_sin", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVdN4v_sin", FIXED(4)) -TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVbN4v_sinf", 4) -TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVdN8v_sinf", 8) +TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVbN4v_sinf", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVdN8v_sinf", FIXED(8)) -TLI_DEFINE_VECFUNC("cos", "_ZGVbN2v_cos", 2) -TLI_DEFINE_VECFUNC("cos", "_ZGVdN4v_cos", 4) +TLI_DEFINE_VECFUNC("cos", "_ZGVbN2v_cos", FIXED(2)) +TLI_DEFINE_VECFUNC("cos", "_ZGVdN4v_cos", FIXED(4)) -TLI_DEFINE_VECFUNC("cosf", "_ZGVbN4v_cosf", 4) -TLI_DEFINE_VECFUNC("cosf", "_ZGVdN8v_cosf", 8) +TLI_DEFINE_VECFUNC("cosf", "_ZGVbN4v_cosf", FIXED(4)) +TLI_DEFINE_VECFUNC("cosf", "_ZGVdN8v_cosf", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVbN2v_cos", 2) -TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVdN4v_cos", 4) +TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVbN2v_cos", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVdN4v_cos", FIXED(4)) -TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVbN4v_cosf", 4) -TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVdN8v_cosf", 8) +TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVbN4v_cosf", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVdN8v_cosf", FIXED(8)) -TLI_DEFINE_VECFUNC("pow", "_ZGVbN2vv_pow", 2) -TLI_DEFINE_VECFUNC("pow", "_ZGVdN4vv_pow", 4) +TLI_DEFINE_VECFUNC("pow", "_ZGVbN2vv_pow", FIXED(2)) +TLI_DEFINE_VECFUNC("pow", "_ZGVdN4vv_pow", FIXED(4)) -TLI_DEFINE_VECFUNC("powf", "_ZGVbN4vv_powf", 4) -TLI_DEFINE_VECFUNC("powf", "_ZGVdN8vv_powf", 8) +TLI_DEFINE_VECFUNC("powf", "_ZGVbN4vv_powf", FIXED(4)) +TLI_DEFINE_VECFUNC("powf", "_ZGVdN8vv_powf", FIXED(8)) -TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVbN2vv___pow_finite", 2) -TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVdN4vv___pow_finite", 4) +TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVbN2vv___pow_finite", FIXED(2)) +TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVdN4vv___pow_finite", FIXED(4)) -TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVbN4vv___powf_finite", 4) -TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVdN8vv___powf_finite", 8) +TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVbN4vv___powf_finite", FIXED(4)) +TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVdN8vv___powf_finite", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVbN2vv_pow", 2) -TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVdN4vv_pow", 4) +TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVbN2vv_pow", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVdN4vv_pow", FIXED(4)) -TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVbN4vv_powf", 4) -TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVdN8vv_powf", 8) +TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVbN4vv_powf", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVdN8vv_powf", FIXED(8)) -TLI_DEFINE_VECFUNC("exp", "_ZGVbN2v_exp", 2) -TLI_DEFINE_VECFUNC("exp", "_ZGVdN4v_exp", 4) +TLI_DEFINE_VECFUNC("exp", "_ZGVbN2v_exp", FIXED(2)) +TLI_DEFINE_VECFUNC("exp", "_ZGVdN4v_exp", FIXED(4)) -TLI_DEFINE_VECFUNC("expf", "_ZGVbN4v_expf", 4) -TLI_DEFINE_VECFUNC("expf", "_ZGVdN8v_expf", 8) +TLI_DEFINE_VECFUNC("expf", "_ZGVbN4v_expf", FIXED(4)) +TLI_DEFINE_VECFUNC("expf", "_ZGVdN8v_expf", FIXED(8)) -TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVbN2v___exp_finite", 2) -TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVdN4v___exp_finite", 4) +TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVbN2v___exp_finite", FIXED(2)) +TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVdN4v___exp_finite", FIXED(4)) -TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVbN4v___expf_finite", 4) -TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVdN8v___expf_finite", 8) +TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVbN4v___expf_finite", FIXED(4)) +TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVdN8v___expf_finite", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVbN2v_exp", 2) -TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVdN4v_exp", 4) +TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVbN2v_exp", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVdN4v_exp", FIXED(4)) -TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVbN4v_expf", 4) -TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVdN8v_expf", 8) +TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVbN4v_expf", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVdN8v_expf", FIXED(8)) -TLI_DEFINE_VECFUNC("log", "_ZGVbN2v_log", 2) -TLI_DEFINE_VECFUNC("log", "_ZGVdN4v_log", 4) +TLI_DEFINE_VECFUNC("log", "_ZGVbN2v_log", FIXED(2)) +TLI_DEFINE_VECFUNC("log", "_ZGVdN4v_log", FIXED(4)) -TLI_DEFINE_VECFUNC("logf", "_ZGVbN4v_logf", 4) -TLI_DEFINE_VECFUNC("logf", "_ZGVdN8v_logf", 8) +TLI_DEFINE_VECFUNC("logf", "_ZGVbN4v_logf", FIXED(4)) +TLI_DEFINE_VECFUNC("logf", "_ZGVdN8v_logf", FIXED(8)) -TLI_DEFINE_VECFUNC("__log_finite", "_ZGVbN2v___log_finite", 2) -TLI_DEFINE_VECFUNC("__log_finite", "_ZGVdN4v___log_finite", 4) +TLI_DEFINE_VECFUNC("__log_finite", "_ZGVbN2v___log_finite", FIXED(2)) +TLI_DEFINE_VECFUNC("__log_finite", "_ZGVdN4v___log_finite", FIXED(4)) -TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVbN4v___logf_finite", 4) -TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVdN8v___logf_finite", 8) +TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVbN4v___logf_finite", FIXED(4)) +TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVdN8v___logf_finite", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVbN2v_log", 2) -TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVdN4v_log", 4) +TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVbN2v_log", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVdN4v_log", FIXED(4)) -TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVbN4v_logf", 4) -TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVdN8v_logf", 8) +TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVbN4v_logf", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVdN8v_logf", FIXED(8)) #elif defined(TLI_DEFINE_MASSV_VECFUNCS) // IBM MASS library's vector Functions // Floating-Point Arithmetic and Auxiliary Functions -TLI_DEFINE_VECFUNC("cbrt", "__cbrtd2_massv", 2) -TLI_DEFINE_VECFUNC("cbrtf", "__cbrtf4_massv", 4) -TLI_DEFINE_VECFUNC("pow", "__powd2_massv", 2) -TLI_DEFINE_VECFUNC("llvm.pow.f64", "__powd2_massv", 2) -TLI_DEFINE_VECFUNC("powf", "__powf4_massv", 4) -TLI_DEFINE_VECFUNC("llvm.pow.f32", "__powf4_massv", 4) -TLI_DEFINE_VECFUNC("sqrt", "__sqrtd2_massv", 2) -TLI_DEFINE_VECFUNC("llvm.sqrt.f64", "__sqrtd2_massv", 2) -TLI_DEFINE_VECFUNC("sqrtf", "__sqrtf4_massv", 4) -TLI_DEFINE_VECFUNC("llvm.sqrt.f32", "__sqrtf4_massv", 4) +TLI_DEFINE_VECFUNC("cbrt", "__cbrtd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("cbrtf", "__cbrtf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("pow", "__powd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.pow.f64", "__powd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("powf", "__powf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.pow.f32", "__powf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("sqrt", "__sqrtd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.sqrt.f64", "__sqrtd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("sqrtf", "__sqrtf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.sqrt.f32", "__sqrtf4_massv", FIXED(4)) // Exponential and Logarithmic Functions -TLI_DEFINE_VECFUNC("exp", "__expd2_massv", 2) -TLI_DEFINE_VECFUNC("llvm.exp.f64", "__expd2_massv", 2) -TLI_DEFINE_VECFUNC("expf", "__expf4_massv", 4) -TLI_DEFINE_VECFUNC("llvm.exp.f32", "__expf4_massv", 4) -TLI_DEFINE_VECFUNC("exp2", "__exp2d2_massv", 2) -TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__exp2d2_massv", 2) -TLI_DEFINE_VECFUNC("exp2f", "__exp2f4_massv", 4) -TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__exp2f4_massv", 4) -TLI_DEFINE_VECFUNC("expm1", "__expm1d2_massv", 2) -TLI_DEFINE_VECFUNC("expm1f", "__expm1f4_massv", 4) -TLI_DEFINE_VECFUNC("log", "__logd2_massv", 2) -TLI_DEFINE_VECFUNC("llvm.log.f64", "__logd2_massv", 2) -TLI_DEFINE_VECFUNC("logf", "__logf4_massv", 4) -TLI_DEFINE_VECFUNC("llvm.log.f32", "__logf4_massv", 4) -TLI_DEFINE_VECFUNC("log1p", "__log1pd2_massv", 2) -TLI_DEFINE_VECFUNC("log1pf", "__log1pf4_massv", 4) -TLI_DEFINE_VECFUNC("log10", "__log10d2_massv", 2) -TLI_DEFINE_VECFUNC("llvm.log10.f64", "__log10d2_massv", 2) -TLI_DEFINE_VECFUNC("log10f", "__log10f4_massv", 4) -TLI_DEFINE_VECFUNC("llvm.log10.f32", "__log10f4_massv", 4) -TLI_DEFINE_VECFUNC("log2", "__log2d2_massv", 2) -TLI_DEFINE_VECFUNC("llvm.log2.f64", "__log2d2_massv", 2) -TLI_DEFINE_VECFUNC("log2f", "__log2f4_massv", 4) -TLI_DEFINE_VECFUNC("llvm.log2.f32", "__log2f4_massv", 4) +TLI_DEFINE_VECFUNC("exp", "__expd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.exp.f64", "__expd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("expf", "__expf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.exp.f32", "__expf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("exp2", "__exp2d2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__exp2d2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("exp2f", "__exp2f4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__exp2f4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("expm1", "__expm1d2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("expm1f", "__expm1f4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("log", "__logd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.log.f64", "__logd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("logf", "__logf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log.f32", "__logf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("log1p", "__log1pd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("log1pf", "__log1pf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("log10", "__log10d2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.log10.f64", "__log10d2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("log10f", "__log10f4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log10.f32", "__log10f4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("log2", "__log2d2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.log2.f64", "__log2d2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("log2f", "__log2f4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log2.f32", "__log2f4_massv", FIXED(4)) // Trigonometric Functions -TLI_DEFINE_VECFUNC("sin", "__sind2_massv", 2) -TLI_DEFINE_VECFUNC("llvm.sin.f64", "__sind2_massv", 2) -TLI_DEFINE_VECFUNC("sinf", "__sinf4_massv", 4) -TLI_DEFINE_VECFUNC("llvm.sin.f32", "__sinf4_massv", 4) -TLI_DEFINE_VECFUNC("cos", "__cosd2_massv", 2) -TLI_DEFINE_VECFUNC("llvm.cos.f64", "__cosd2_massv", 2) -TLI_DEFINE_VECFUNC("cosf", "__cosf4_massv", 4) -TLI_DEFINE_VECFUNC("llvm.cos.f32", "__cosf4_massv", 4) -TLI_DEFINE_VECFUNC("tan", "__tand2_massv", 2) -TLI_DEFINE_VECFUNC("tanf", "__tanf4_massv", 4) -TLI_DEFINE_VECFUNC("asin", "__asind2_massv", 2) -TLI_DEFINE_VECFUNC("asinf", "__asinf4_massv", 4) -TLI_DEFINE_VECFUNC("acos", "__acosd2_massv", 2) -TLI_DEFINE_VECFUNC("acosf", "__acosf4_massv", 4) -TLI_DEFINE_VECFUNC("atan", "__atand2_massv", 2) -TLI_DEFINE_VECFUNC("atanf", "__atanf4_massv", 4) -TLI_DEFINE_VECFUNC("atan2", "__atan2d2_massv", 2) -TLI_DEFINE_VECFUNC("atan2f", "__atan2f4_massv", 4) +TLI_DEFINE_VECFUNC("sin", "__sind2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.sin.f64", "__sind2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("sinf", "__sinf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.sin.f32", "__sinf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("cos", "__cosd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.cos.f64", "__cosd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("cosf", "__cosf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.cos.f32", "__cosf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("tan", "__tand2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("tanf", "__tanf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("asin", "__asind2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("asinf", "__asinf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("acos", "__acosd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("acosf", "__acosf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("atan", "__atand2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("atanf", "__atanf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("atan2", "__atan2d2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("atan2f", "__atan2f4_massv", FIXED(4)) // Hyperbolic Functions -TLI_DEFINE_VECFUNC("sinh", "__sinhd2_massv", 2) -TLI_DEFINE_VECFUNC("sinhf", "__sinhf4_massv", 4) -TLI_DEFINE_VECFUNC("cosh", "__coshd2_massv", 2) -TLI_DEFINE_VECFUNC("coshf", "__coshf4_massv", 4) -TLI_DEFINE_VECFUNC("tanh", "__tanhd2_massv", 2) -TLI_DEFINE_VECFUNC("tanhf", "__tanhf4_massv", 4) -TLI_DEFINE_VECFUNC("asinh", "__asinhd2_massv", 2) -TLI_DEFINE_VECFUNC("asinhf", "__asinhf4_massv", 4) -TLI_DEFINE_VECFUNC("acosh", "__acoshd2_massv", 2) -TLI_DEFINE_VECFUNC("acoshf", "__acoshf4_massv", 4) -TLI_DEFINE_VECFUNC("atanh", "__atanhd2_massv", 2) -TLI_DEFINE_VECFUNC("atanhf", "__atanhf4_massv", 4) +TLI_DEFINE_VECFUNC("sinh", "__sinhd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("sinhf", "__sinhf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("cosh", "__coshd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("coshf", "__coshf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("tanh", "__tanhd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("tanhf", "__tanhf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("asinh", "__asinhd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("asinhf", "__asinhf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("acosh", "__acoshd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("acoshf", "__acoshf4_massv", FIXED(4)) +TLI_DEFINE_VECFUNC("atanh", "__atanhd2_massv", FIXED(2)) +TLI_DEFINE_VECFUNC("atanhf", "__atanhf4_massv", FIXED(4)) #elif defined(TLI_DEFINE_SVML_VECFUNCS) // Intel SVM library's Vector Functions -TLI_DEFINE_VECFUNC("sin", "__svml_sin2", 2) -TLI_DEFINE_VECFUNC("sin", "__svml_sin4", 4) -TLI_DEFINE_VECFUNC("sin", "__svml_sin8", 8) +TLI_DEFINE_VECFUNC("sin", "__svml_sin2", FIXED(2)) +TLI_DEFINE_VECFUNC("sin", "__svml_sin4", FIXED(4)) +TLI_DEFINE_VECFUNC("sin", "__svml_sin8", FIXED(8)) -TLI_DEFINE_VECFUNC("sinf", "__svml_sinf4", 4) -TLI_DEFINE_VECFUNC("sinf", "__svml_sinf8", 8) -TLI_DEFINE_VECFUNC("sinf", "__svml_sinf16", 16) +TLI_DEFINE_VECFUNC("sinf", "__svml_sinf4", FIXED(4)) +TLI_DEFINE_VECFUNC("sinf", "__svml_sinf8", FIXED(8)) +TLI_DEFINE_VECFUNC("sinf", "__svml_sinf16", FIXED(16)) -TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin2", 2) -TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin4", 4) -TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin8", 8) +TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin2", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.sin.f64", "__svml_sin8", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf4", 4) -TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf8", 8) -TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf16", 16) +TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf8", FIXED(8)) +TLI_DEFINE_VECFUNC("llvm.sin.f32", "__svml_sinf16", FIXED(16)) -TLI_DEFINE_VECFUNC("cos", "__svml_cos2", 2) -TLI_DEFINE_VECFUNC("cos", "__svml_cos4", 4) -TLI_DEFINE_VECFUNC("cos", "__svml_cos8", 8) +TLI_DEFINE_VECFUNC("cos", "__svml_cos2", FIXED(2)) +TLI_DEFINE_VECFUNC("cos", "__svml_cos4", FIXED(4)) +TLI_DEFINE_VECFUNC("cos", "__svml_cos8", FIXED(8)) -TLI_DEFINE_VECFUNC("cosf", "__svml_cosf4", 4) -TLI_DEFINE_VECFUNC("cosf", "__svml_cosf8", 8) -TLI_DEFINE_VECFUNC("cosf", "__svml_cosf16", 16) +TLI_DEFINE_VECFUNC("cosf", "__svml_cosf4", FIXED(4)) +TLI_DEFINE_VECFUNC("cosf", "__svml_cosf8", FIXED(8)) +TLI_DEFINE_VECFUNC("cosf", "__svml_cosf16", FIXED(16)) -TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos2", 2) -TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos4", 4) -TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos8", 8) +TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos2", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.cos.f64", "__svml_cos8", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf4", 4) -TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf8", 8) -TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf16", 16) +TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf8", FIXED(8)) +TLI_DEFINE_VECFUNC("llvm.cos.f32", "__svml_cosf16", FIXED(16)) -TLI_DEFINE_VECFUNC("pow", "__svml_pow2", 2) -TLI_DEFINE_VECFUNC("pow", "__svml_pow4", 4) -TLI_DEFINE_VECFUNC("pow", "__svml_pow8", 8) +TLI_DEFINE_VECFUNC("pow", "__svml_pow2", FIXED(2)) +TLI_DEFINE_VECFUNC("pow", "__svml_pow4", FIXED(4)) +TLI_DEFINE_VECFUNC("pow", "__svml_pow8", FIXED(8)) -TLI_DEFINE_VECFUNC("powf", "__svml_powf4", 4) -TLI_DEFINE_VECFUNC("powf", "__svml_powf8", 8) -TLI_DEFINE_VECFUNC("powf", "__svml_powf16", 16) +TLI_DEFINE_VECFUNC("powf", "__svml_powf4", FIXED(4)) +TLI_DEFINE_VECFUNC("powf", "__svml_powf8", FIXED(8)) +TLI_DEFINE_VECFUNC("powf", "__svml_powf16", FIXED(16)) -TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow2", 2) -TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow4", 4) -TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow8", 8) +TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow2", FIXED(2)) +TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow4", FIXED(4)) +TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow8", FIXED(8)) -TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf4", 4) -TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf8", 8) -TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf16", 16) +TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf4", FIXED(4)) +TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf8", FIXED(8)) +TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf16", FIXED(16)) -TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow2", 2) -TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow4", 4) -TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow8", 8) +TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow2", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow8", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf4", 4) -TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf8", 8) -TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf16", 16) +TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf8", FIXED(8)) +TLI_DEFINE_VECFUNC("llvm.pow.f32", "__svml_powf16", FIXED(16)) -TLI_DEFINE_VECFUNC("exp", "__svml_exp2", 2) -TLI_DEFINE_VECFUNC("exp", "__svml_exp4", 4) -TLI_DEFINE_VECFUNC("exp", "__svml_exp8", 8) +TLI_DEFINE_VECFUNC("exp", "__svml_exp2", FIXED(2)) +TLI_DEFINE_VECFUNC("exp", "__svml_exp4", FIXED(4)) +TLI_DEFINE_VECFUNC("exp", "__svml_exp8", FIXED(8)) -TLI_DEFINE_VECFUNC("expf", "__svml_expf4", 4) -TLI_DEFINE_VECFUNC("expf", "__svml_expf8", 8) -TLI_DEFINE_VECFUNC("expf", "__svml_expf16", 16) +TLI_DEFINE_VECFUNC("expf", "__svml_expf4", FIXED(4)) +TLI_DEFINE_VECFUNC("expf", "__svml_expf8", FIXED(8)) +TLI_DEFINE_VECFUNC("expf", "__svml_expf16", FIXED(16)) -TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp2", 2) -TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp4", 4) -TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp8", 8) +TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp2", FIXED(2)) +TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp4", FIXED(4)) +TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp8", FIXED(8)) -TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf4", 4) -TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf8", 8) -TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf16", 16) +TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf4", FIXED(4)) +TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf8", FIXED(8)) +TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf16", FIXED(16)) -TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp2", 2) -TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp4", 4) -TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp8", 8) +TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp2", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp8", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf4", 4) -TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf8", 8) -TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf16", 16) +TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf8", FIXED(8)) +TLI_DEFINE_VECFUNC("llvm.exp.f32", "__svml_expf16", FIXED(16)) -TLI_DEFINE_VECFUNC("log", "__svml_log2", 2) -TLI_DEFINE_VECFUNC("log", "__svml_log4", 4) -TLI_DEFINE_VECFUNC("log", "__svml_log8", 8) +TLI_DEFINE_VECFUNC("log", "__svml_log2", FIXED(2)) +TLI_DEFINE_VECFUNC("log", "__svml_log4", FIXED(4)) +TLI_DEFINE_VECFUNC("log", "__svml_log8", FIXED(8)) -TLI_DEFINE_VECFUNC("logf", "__svml_logf4", 4) -TLI_DEFINE_VECFUNC("logf", "__svml_logf8", 8) -TLI_DEFINE_VECFUNC("logf", "__svml_logf16", 16) +TLI_DEFINE_VECFUNC("logf", "__svml_logf4", FIXED(4)) +TLI_DEFINE_VECFUNC("logf", "__svml_logf8", FIXED(8)) +TLI_DEFINE_VECFUNC("logf", "__svml_logf16", FIXED(16)) -TLI_DEFINE_VECFUNC("__log_finite", "__svml_log2", 2) -TLI_DEFINE_VECFUNC("__log_finite", "__svml_log4", 4) -TLI_DEFINE_VECFUNC("__log_finite", "__svml_log8", 8) +TLI_DEFINE_VECFUNC("__log_finite", "__svml_log2", FIXED(2)) +TLI_DEFINE_VECFUNC("__log_finite", "__svml_log4", FIXED(4)) +TLI_DEFINE_VECFUNC("__log_finite", "__svml_log8", FIXED(8)) -TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf4", 4) -TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf8", 8) -TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf16", 16) +TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf4", FIXED(4)) +TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf8", FIXED(8)) +TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf16", FIXED(16)) -TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log2", 2) -TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log4", 4) -TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log8", 8) +TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log2", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log8", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf4", 4) -TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf8", 8) -TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf16", 16) +TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf8", FIXED(8)) +TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf16", FIXED(16)) -TLI_DEFINE_VECFUNC("log2", "__svml_log22", 2) -TLI_DEFINE_VECFUNC("log2", "__svml_log24", 4) -TLI_DEFINE_VECFUNC("log2", "__svml_log28", 8) +TLI_DEFINE_VECFUNC("log2", "__svml_log22", FIXED(2)) +TLI_DEFINE_VECFUNC("log2", "__svml_log24", FIXED(4)) +TLI_DEFINE_VECFUNC("log2", "__svml_log28", FIXED(8)) -TLI_DEFINE_VECFUNC("log2f", "__svml_log2f4", 4) -TLI_DEFINE_VECFUNC("log2f", "__svml_log2f8", 8) -TLI_DEFINE_VECFUNC("log2f", "__svml_log2f16", 16) +TLI_DEFINE_VECFUNC("log2f", "__svml_log2f4", FIXED(4)) +TLI_DEFINE_VECFUNC("log2f", "__svml_log2f8", FIXED(8)) +TLI_DEFINE_VECFUNC("log2f", "__svml_log2f16", FIXED(16)) -TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log22", 2) -TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log24", 4) -TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log28", 8) +TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log22", FIXED(2)) +TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log24", FIXED(4)) +TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log28", FIXED(8)) -TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f4", 4) -TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f8", 8) -TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f16", 16) +TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f4", FIXED(4)) +TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f8", FIXED(8)) +TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f16", FIXED(16)) -TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log22", 2) -TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log24", 4) -TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log28", 8) +TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log22", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log24", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log28", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f4", 4) -TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f8", 8) -TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f16", 16) +TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f8", FIXED(8)) +TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f16", FIXED(16)) -TLI_DEFINE_VECFUNC("log10", "__svml_log102", 2) -TLI_DEFINE_VECFUNC("log10", "__svml_log104", 4) -TLI_DEFINE_VECFUNC("log10", "__svml_log108", 8) +TLI_DEFINE_VECFUNC("log10", "__svml_log102", FIXED(2)) +TLI_DEFINE_VECFUNC("log10", "__svml_log104", FIXED(4)) +TLI_DEFINE_VECFUNC("log10", "__svml_log108", FIXED(8)) -TLI_DEFINE_VECFUNC("log10f", "__svml_log10f4", 4) -TLI_DEFINE_VECFUNC("log10f", "__svml_log10f8", 8) -TLI_DEFINE_VECFUNC("log10f", "__svml_log10f16", 16) +TLI_DEFINE_VECFUNC("log10f", "__svml_log10f4", FIXED(4)) +TLI_DEFINE_VECFUNC("log10f", "__svml_log10f8", FIXED(8)) +TLI_DEFINE_VECFUNC("log10f", "__svml_log10f16", FIXED(16)) -TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log102", 2) -TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log104", 4) -TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log108", 8) +TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log102", FIXED(2)) +TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log104", FIXED(4)) +TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log108", FIXED(8)) -TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f4", 4) -TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f8", 8) -TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f16", 16) +TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f4", FIXED(4)) +TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f8", FIXED(8)) +TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f16", FIXED(16)) -TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log102", 2) -TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log104", 4) -TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log108", 8) +TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log102", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log104", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log108", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f4", 4) -TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f8", 8) -TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f16", 16) +TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f8", FIXED(8)) +TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f16", FIXED(16)) -TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt2", 2) -TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt4", 4) -TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt8", 8) +TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt2", FIXED(2)) +TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt4", FIXED(4)) +TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt8", FIXED(8)) -TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf4", 4) -TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf8", 8) -TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf16", 16) +TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf4", FIXED(4)) +TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf8", FIXED(8)) +TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf16", FIXED(16)) -TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt2", 2) -TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt4", 4) -TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt8", 8) +TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt2", FIXED(2)) +TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt4", FIXED(4)) +TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt8", FIXED(8)) -TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf4", 4) -TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf8", 8) -TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf16", 16) +TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf4", FIXED(4)) +TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf8", FIXED(8)) +TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf16", FIXED(16)) -TLI_DEFINE_VECFUNC("exp2", "__svml_exp22", 2) -TLI_DEFINE_VECFUNC("exp2", "__svml_exp24", 4) -TLI_DEFINE_VECFUNC("exp2", "__svml_exp28", 8) +TLI_DEFINE_VECFUNC("exp2", "__svml_exp22", FIXED(2)) +TLI_DEFINE_VECFUNC("exp2", "__svml_exp24", FIXED(4)) +TLI_DEFINE_VECFUNC("exp2", "__svml_exp28", FIXED(8)) -TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f4", 4) -TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f8", 8) -TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f16", 16) +TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f4", FIXED(4)) +TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f8", FIXED(8)) +TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f16", FIXED(16)) -TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp22", 2) -TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp24", 4) -TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp28", 8) +TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp22", FIXED(2)) +TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp24", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp28", FIXED(8)) -TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f4", 4) -TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f8", 8) -TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f16", 16) +TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f4", FIXED(4)) +TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f8", FIXED(8)) +TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f16", FIXED(16)) -TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp22", 2) -TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp24", 4) -TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp28", 8) +TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp22", FIXED(2)) +TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp24", FIXED(4)) +TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp28", FIXED(8)) -TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f4", 4) -TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f8", 8) -TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f16", 16) +TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f4", FIXED(4)) +TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f8", FIXED(8)) +TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f16", FIXED(16)) #else #error "Must choose which vector library functions are to be defined." Index: llvm/include/llvm/Analysis/VectorUtils.h =================================================================== --- llvm/include/llvm/Analysis/VectorUtils.h +++ llvm/include/llvm/Analysis/VectorUtils.h @@ -186,12 +186,13 @@ /// = "_LLVM_" /// = "N". Note: TLI does not support masked interfaces. /// = Number of concurrent lanes, stored in the `VectorizationFactor` -/// field of the `VecDesc` struct. +/// field of the `VecDesc` struct. If the number of lanes is scalable +/// then 'x' is printed instead. /// = "v", as many as are the numArgs. /// = the name of the scalar function. /// = the name of the vector function. std::string mangleTLIVectorName(StringRef VectorName, StringRef ScalarName, - unsigned numArgs, unsigned VF); + unsigned numArgs, ElementCount VF); /// Retrieve the `VFParamKind` from a string token. VFParamKind getVFParamKindFromString(const StringRef Token); Index: llvm/lib/Analysis/TargetLibraryInfo.cpp =================================================================== --- llvm/lib/Analysis/TargetLibraryInfo.cpp +++ llvm/lib/Analysis/TargetLibraryInfo.cpp @@ -1609,7 +1609,7 @@ } StringRef TargetLibraryInfoImpl::getVectorizedFunction(StringRef F, - unsigned VF) const { + ElementCount VF) const { F = sanitizeFunctionName(F); if (F.empty()) return F; @@ -1663,18 +1663,24 @@ void TargetLibraryInfoWrapperPass::anchor() {} -unsigned TargetLibraryInfoImpl::getWidestVF(StringRef ScalarF) const { +void TargetLibraryInfoImpl::getWidestVF(StringRef ScalarF, unsigned &FixedVF, + unsigned &ScalableVF) const { ScalarF = sanitizeFunctionName(ScalarF); + // Use '0' here because a type of the form is not the + // same as a scalar. + ScalableVF = 0; + FixedVF = 1; if (ScalarF.empty()) - return 1; + return; - unsigned VF = 1; std::vector::const_iterator I = llvm::lower_bound(VectorDescs, ScalarF, compareWithScalarFnName); while (I != VectorDescs.end() && StringRef(I->ScalarFnName) == ScalarF) { - if (I->VectorizationFactor > VF) - VF = I->VectorizationFactor; + ElementCount VF = I->VectorizationFactor; + if (VF.isScalable() && VF.getKnownMinValue() > ScalableVF) + ScalableVF = VF.getKnownMinValue(); + else if (!VF.isScalable() && VF.getFixedValue() > FixedVF) + FixedVF = VF.getFixedValue(); ++I; } - return VF; } Index: llvm/lib/Analysis/VectorUtils.cpp =================================================================== --- llvm/lib/Analysis/VectorUtils.cpp +++ llvm/lib/Analysis/VectorUtils.cpp @@ -1300,10 +1300,14 @@ std::string VFABI::mangleTLIVectorName(StringRef VectorName, StringRef ScalarName, unsigned numArgs, - unsigned VF) { + ElementCount VF) { SmallString<256> Buffer; llvm::raw_svector_ostream Out(Buffer); - Out << "_ZGV" << VFABI::_LLVM_ << "N" << VF; + Out << "_ZGV" << VFABI::_LLVM_ << "N"; + if (VF.isScalable()) + Out << 'x'; + else + Out << VF.getFixedValue(); for (unsigned I = 0; I < numArgs; ++I) Out << "v"; Out << "_" << ScalarName << "(" << VectorName << ")"; Index: llvm/lib/Transforms/Utils/InjectTLIMappings.cpp =================================================================== --- llvm/lib/Transforms/Utils/InjectTLIMappings.cpp +++ llvm/lib/Transforms/Utils/InjectTLIMappings.cpp @@ -40,7 +40,7 @@ /// lanes. The TLI assumes that all parameters and the return type of /// CI (other than void) need to be widened to a VectorType of VF /// lanes. -static void addVariantDeclaration(CallInst &CI, const unsigned VF, +static void addVariantDeclaration(CallInst &CI, const ElementCount &VF, const StringRef VFName) { Module *M = CI.getModule(); @@ -90,8 +90,10 @@ const SetVector OriginalSetOfMappings(Mappings.begin(), Mappings.end()); // All VFs in the TLI are powers of 2. - for (unsigned VF = 2, WidestVF = TLI.getWidestVF(ScalarName); VF <= WidestVF; - VF *= 2) { + unsigned WidestFixedVF, WidestScalableVF; + TLI.getWidestVF(ScalarName, WidestFixedVF, WidestScalableVF); + + auto AddVariantDecl = [&](const ElementCount &VF) { const std::string TLIName = std::string(TLI.getVectorizedFunction(ScalarName, VF)); if (!TLIName.empty()) { @@ -105,8 +107,14 @@ if (!VariantF) addVariantDeclaration(CI, VF, TLIName); } + }; + + for (unsigned VF = 2; VF <= WidestFixedVF; VF *= 2) { + AddVariantDecl(ElementCount::getFixed(VF)); } + // TODO: Add scalable variants once we're able to test them. + VFABI::setVectorVariantNames(&CI, Mappings); } Index: llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp =================================================================== --- llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp +++ llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp @@ -594,11 +594,18 @@ bool Scalarize = TLI.isFunctionVectorizable(ScalarName); // Check that all known VFs are not associated to a vector // function, i.e. the vector name is emty. - if (Scalarize) - for (unsigned VF = 2, WidestVF = TLI.getWidestVF(ScalarName); - VF <= WidestVF; VF *= 2) { - Scalarize &= !TLI.isFunctionVectorizable(ScalarName, VF); + if (Scalarize) { + unsigned WidestFixedVF, WidestScalableVF; + TLI.getWidestVF(ScalarName, WidestFixedVF, WidestScalableVF); + for (unsigned VF = 2; VF <= WidestFixedVF; VF *= 2) { + Scalarize &= + !TLI.isFunctionVectorizable(ScalarName, ElementCount::getFixed(VF)); } + for (unsigned VF = 2; VF <= WidestScalableVF; VF *= 2) { + Scalarize &= !TLI.isFunctionVectorizable(ScalarName, + ElementCount::getScalable(VF)); + } + } return Scalarize; } Index: llvm/unittests/Analysis/VectorFunctionABITest.cpp =================================================================== --- llvm/unittests/Analysis/VectorFunctionABITest.cpp +++ llvm/unittests/Analysis/VectorFunctionABITest.cpp @@ -101,9 +101,14 @@ // This test makes sure correct mangling occurs for given string. TEST_F(VFABIParserTest, ManglingVectorTLINames) { - EXPECT_EQ(VFABI::mangleTLIVectorName("vec", "scalar", 3, 4), - "_ZGV_LLVM_N4vvv_scalar(vec)"); - EXPECT_EQ(VFABI::mangleTLIVectorName("custom.call.v5", "custom.call", 1, 5), + EXPECT_EQ( + VFABI::mangleTLIVectorName("vec", "scalar", 3, ElementCount::getFixed(4)), + "_ZGV_LLVM_N4vvv_scalar(vec)"); + EXPECT_EQ(VFABI::mangleTLIVectorName("vec", "scalar", 3, + ElementCount::getScalable(4)), + "_ZGV_LLVM_Nxvvv_scalar(vec)"); + EXPECT_EQ(VFABI::mangleTLIVectorName("custom.call.v5", "custom.call", 1, + ElementCount::getFixed(5)), "_ZGV_LLVM_N5v_custom.call(custom.call.v5)"); }