[llvm] [LLVM] Add support for the HVML vector library (PR #222632)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Sep 10 05:50:06 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-analysis
Author: Xiaomeng Zhang (JacketPants)
<details>
<summary>Changes</summary>
Add the Hygon vector math library (HVML) as a new -fveclib backend, mapping
16 libm functions to their hvml_* vector calls.
HVML is Hygon's vector math library for x86_64. This patch adds the
LLVM-side support:
- Add HVML to the driver-side (llvm::driver::VectorLibrary) and IR
(llvm::VectorLibrary) vector library enums.
- Register the hvml_* functions in VecFuncs.def and RuntimeLibcalls.td.
- Add the HVML vecfunc set to TargetLibraryInfo.
- Expose HVML through the opt/llc -vector-library flag.
This is the first of three incremental patches; the clang and flang driver
wiring will follow in separate patches.
---
Patch is 109.34 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/222632.diff
13 Files Affected:
- (modified) llvm/docs/Vectorizers.md (+1-1)
- (modified) llvm/include/llvm/Analysis/VecFuncs.def (+215)
- (modified) llvm/include/llvm/Frontend/Driver/CodeGenOptions.h (+2-1)
- (modified) llvm/include/llvm/IR/RuntimeLibcalls.td (+71)
- (modified) llvm/include/llvm/IR/SystemLibraries.h (+2-1)
- (modified) llvm/lib/Analysis/TargetLibraryInfo.cpp (+12)
- (modified) llvm/lib/CodeGen/CommandFlags.cpp (+3-1)
- (modified) llvm/lib/Frontend/Driver/CodeGenOptions.cpp (+2)
- (modified) llvm/test/CodeGen/Generic/replace-intrinsics-with-veclib.ll (+11)
- (added) llvm/test/Transforms/LoopVectorize/X86/hvml-calls-finite.ll (+646)
- (added) llvm/test/Transforms/LoopVectorize/X86/hvml-calls.ll (+1681)
- (modified) llvm/test/Transforms/SLPVectorizer/X86/sin-sqrt.ll (+17)
- (modified) llvm/test/Transforms/Util/add-TLI-mappings.ll (+20)
``````````diff
diff --git a/llvm/docs/Vectorizers.md b/llvm/docs/Vectorizers.md
index 2471e88654d3d..88c2deeed59be 100644
--- a/llvm/docs/Vectorizers.md
+++ b/llvm/docs/Vectorizers.md
@@ -346,7 +346,7 @@ Many of these math functions are only vectorizable if the file has been built
with a specified target vector library that provides a vector implementation
of that math function. Using clang, this is handled by the "-fveclib" command
line option with one of the following vector libraries:
-"Accelerate,libmvec,MASSV,SVML,SLEEF,Darwin_libsystem_m,ArmPL,AMDLIBM"
+"Accelerate,libmvec,MASSV,SVML,SLEEF,Darwin_libsystem_m,ArmPL,AMDLIBM,HVML"
```console
$ clang ... -fno-math-errno -fveclib=libmvec file.c
diff --git a/llvm/include/llvm/Analysis/VecFuncs.def b/llvm/include/llvm/Analysis/VecFuncs.def
index 58fe1248dae3b..45f87634fa6b3 100644
--- a/llvm/include/llvm/Analysis/VecFuncs.def
+++ b/llvm/include/llvm/Analysis/VecFuncs.def
@@ -1996,6 +1996,221 @@ TLI_DEFINE_VECFUNC("llvm.round.f32", "amd_vrs4_roundf", FIXED(4), NOMASK, "_ZGV_
TLI_DEFINE_VECFUNC("llvm.round.f64", "amd_vrd8_round", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
TLI_DEFINE_VECFUNC("llvm.round.f64", "amd_vrd4_round", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
TLI_DEFINE_VECFUNC("llvm.round.f64", "amd_vrd2_round", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+
+// Hygon vector math library (HVML) functions
+#elif defined(TLI_DEFINE_HVML_VECFUNCS)
+
+TLI_DEFINE_VECFUNC("sin", "hvml_vd2_sin", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("sin", "hvml_vd4_sin", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("sinf", "hvml_vs4_sin", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("sinf", "hvml_vs8_sin", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.sin.f64", "hvml_vd2_sin", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.sin.f64", "hvml_vd4_sin", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.sin.f32", "hvml_vs4_sin", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.sin.f32", "hvml_vs8_sin", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("cos", "hvml_vd2_cos", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("cos", "hvml_vd4_cos", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("cosf", "hvml_vs4_cos", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("cosf", "hvml_vs8_cos", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.cos.f64", "hvml_vd2_cos", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.cos.f64", "hvml_vd4_cos", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.cos.f32", "hvml_vs4_cos", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.cos.f32", "hvml_vs8_cos", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("log10", "hvml_vd2_log10", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("log10", "hvml_vd4_log10", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("log10f", "hvml_vs4_log10", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("log10f", "hvml_vs8_log10", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.log10.f64", "hvml_vd2_log10", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.log10.f64", "hvml_vd4_log10", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.log10.f32", "hvml_vs4_log10", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.log10.f32", "hvml_vs8_log10", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("__log10_finite", "hvml_vd2_log10", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("__log10_finite", "hvml_vd4_log10", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__log10f_finite", "hvml_vs4_log10", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__log10f_finite", "hvml_vs8_log10", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+// Note: the natural log entry point is named "ln" (log2/log10 keep the usual names).
+TLI_DEFINE_VECFUNC("log", "hvml_vd2_ln", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("log", "hvml_vd4_ln", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("logf", "hvml_vs4_ln", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("logf", "hvml_vs8_ln", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.log.f64", "hvml_vd2_ln", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.log.f64", "hvml_vd4_ln", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.log.f32", "hvml_vs4_ln", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.log.f32", "hvml_vs8_ln", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("__log_finite", "hvml_vd2_ln", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("__log_finite", "hvml_vd4_ln", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__logf_finite", "hvml_vs4_ln", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__logf_finite", "hvml_vs8_ln", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("tan", "hvml_vd2_tan", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("tan", "hvml_vd4_tan", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("tanf", "hvml_vs4_tan", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("tanf", "hvml_vs8_tan", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.tan.f64", "hvml_vd2_tan", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.tan.f64", "hvml_vd4_tan", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.tan.f32", "hvml_vs4_tan", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.tan.f32", "hvml_vs8_tan", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("asin", "hvml_vd2_asin", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("asin", "hvml_vd4_asin", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("asinf", "hvml_vs4_asin", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("asinf", "hvml_vs8_asin", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.asin.f64", "hvml_vd2_asin", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.asin.f64", "hvml_vd4_asin", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.asin.f32", "hvml_vs4_asin", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.asin.f32", "hvml_vs8_asin", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("__asin_finite", "hvml_vd2_asin", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("__asin_finite", "hvml_vd4_asin", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__asinf_finite", "hvml_vs4_asin", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__asinf_finite", "hvml_vs8_asin", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("acos", "hvml_vd2_acos", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("acos", "hvml_vd4_acos", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("acosf", "hvml_vs4_acos", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("acosf", "hvml_vs8_acos", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.acos.f64", "hvml_vd2_acos", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.acos.f64", "hvml_vd4_acos", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.acos.f32", "hvml_vs4_acos", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.acos.f32", "hvml_vs8_acos", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("__acos_finite", "hvml_vd2_acos", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("__acos_finite", "hvml_vd4_acos", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__acosf_finite", "hvml_vs4_acos", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__acosf_finite", "hvml_vs8_acos", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("atan", "hvml_vd2_atan", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("atan", "hvml_vd4_atan", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("atanf", "hvml_vs4_atan", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("atanf", "hvml_vs8_atan", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.atan.f64", "hvml_vd2_atan", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.atan.f64", "hvml_vd4_atan", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.atan.f32", "hvml_vs4_atan", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.atan.f32", "hvml_vs8_atan", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("pow", "hvml_vd2_pow", FIXED(2), NOMASK, "_ZGV_LLVM_N2vv")
+TLI_DEFINE_VECFUNC("pow", "hvml_vd4_pow", FIXED(4), NOMASK, "_ZGV_LLVM_N4vv")
+TLI_DEFINE_VECFUNC("powf", "hvml_vs4_pow", FIXED(4), NOMASK, "_ZGV_LLVM_N4vv")
+TLI_DEFINE_VECFUNC("powf", "hvml_vs8_pow", FIXED(8), NOMASK, "_ZGV_LLVM_N8vv")
+
+TLI_DEFINE_VECFUNC("llvm.pow.f64", "hvml_vd2_pow", FIXED(2), NOMASK, "_ZGV_LLVM_N2vv")
+TLI_DEFINE_VECFUNC("llvm.pow.f64", "hvml_vd4_pow", FIXED(4), NOMASK, "_ZGV_LLVM_N4vv")
+TLI_DEFINE_VECFUNC("llvm.pow.f32", "hvml_vs4_pow", FIXED(4), NOMASK, "_ZGV_LLVM_N4vv")
+TLI_DEFINE_VECFUNC("llvm.pow.f32", "hvml_vs8_pow", FIXED(8), NOMASK, "_ZGV_LLVM_N8vv")
+
+TLI_DEFINE_VECFUNC("__pow_finite", "hvml_vd2_pow", FIXED(2), NOMASK, "_ZGV_LLVM_N2vv")
+TLI_DEFINE_VECFUNC("__pow_finite", "hvml_vd4_pow", FIXED(4), NOMASK, "_ZGV_LLVM_N4vv")
+TLI_DEFINE_VECFUNC("__powf_finite", "hvml_vs4_pow", FIXED(4), NOMASK, "_ZGV_LLVM_N4vv")
+TLI_DEFINE_VECFUNC("__powf_finite", "hvml_vs8_pow", FIXED(8), NOMASK, "_ZGV_LLVM_N8vv")
+
+TLI_DEFINE_VECFUNC("exp", "hvml_vd2_exp", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("exp", "hvml_vd4_exp", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("expf", "hvml_vs4_exp", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("expf", "hvml_vs8_exp", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.exp.f64", "hvml_vd2_exp", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.exp.f64", "hvml_vd4_exp", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.exp.f32", "hvml_vs4_exp", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.exp.f32", "hvml_vs8_exp", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("__exp_finite", "hvml_vd2_exp", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("__exp_finite", "hvml_vd4_exp", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__expf_finite", "hvml_vs4_exp", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__expf_finite", "hvml_vs8_exp", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("sinh", "hvml_vd2_sinh", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("sinh", "hvml_vd4_sinh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("sinhf", "hvml_vs4_sinh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("sinhf", "hvml_vs8_sinh", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.sinh.f64", "hvml_vd2_sinh", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.sinh.f64", "hvml_vd4_sinh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.sinh.f32", "hvml_vs4_sinh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.sinh.f32", "hvml_vs8_sinh", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("__sinh_finite", "hvml_vd2_sinh", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("__sinh_finite", "hvml_vd4_sinh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__sinhf_finite", "hvml_vs4_sinh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__sinhf_finite", "hvml_vs8_sinh", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("cosh", "hvml_vd2_cosh", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("cosh", "hvml_vd4_cosh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("coshf", "hvml_vs4_cosh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("coshf", "hvml_vs8_cosh", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.cosh.f64", "hvml_vd2_cosh", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.cosh.f64", "hvml_vd4_cosh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.cosh.f32", "hvml_vs4_cosh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.cosh.f32", "hvml_vs8_cosh", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("__cosh_finite", "hvml_vd2_cosh", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("__cosh_finite", "hvml_vd4_cosh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__coshf_finite", "hvml_vs4_cosh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__coshf_finite", "hvml_vs8_cosh", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("tanh", "hvml_vd2_tanh", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("tanh", "hvml_vd4_tanh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("tanhf", "hvml_vs4_tanh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("tanhf", "hvml_vs8_tanh", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.tanh.f64", "hvml_vd2_tanh", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.tanh.f64", "hvml_vd4_tanh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.tanh.f32", "hvml_vs4_tanh", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.tanh.f32", "hvml_vs8_tanh", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("exp2", "hvml_vd2_exp2", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("exp2", "hvml_vd4_exp2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("exp2f", "hvml_vs4_exp2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("exp2f", "hvml_vs8_exp2", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.exp2.f64", "hvml_vd2_exp2", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.exp2.f64", "hvml_vd4_exp2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.exp2.f32", "hvml_vs4_exp2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.exp2.f32", "hvml_vs8_exp2", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("__exp2_finite", "hvml_vd2_exp2", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("__exp2_finite", "hvml_vd4_exp2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__exp2f_finite", "hvml_vs4_exp2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__exp2f_finite", "hvml_vs8_exp2", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("log2", "hvml_vd2_log2", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("log2", "hvml_vd4_log2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("log2f", "hvml_vs4_log2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("log2f", "hvml_vs8_log2", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("llvm.log2.f64", "hvml_vd2_log2", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.log2.f64", "hvml_vd4_log2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.log2.f32", "hvml_vs4_log2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.log2.f32", "hvml_vs8_log2", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("__log2_finite", "hvml_vd2_log2", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("__log2_finite", "hvml_vd4_log2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__log2f_finite", "hvml_vs4_log2", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__log2f_finite", "hvml_vs8_log2", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("sqrt", "hvml_vd2_sqrt", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("sqrt", "hvml_vd4_sqrt", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("sqrtf", "hvml_vs4_sqrt", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("sqrtf", "hvml_vs8_sqrt", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("__sqrt_finite", "hvml_vd2_sqrt", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("__sqrt_finite", "hvml_vd4_sqrt", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__sqrtf_finite", "hvml_vs4_sqrt", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("__sqrtf_finite", "hvml_vs8_sqrt", FIXED(8), NOMASK, "_ZGV_LLVM_N8v")
+
#else
#error "Must choose which vector library functions are to be defined."
#endif
diff --git a/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h b/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h
index 77ab477986d31..293d896fa65ed 100644
--- a/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h
+++ b/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h
@@ -47,7 +47,8 @@ enum class VectorLibrary {
SLEEF, // SLEEF SIMD Library for Evaluating Elementary Functions.
Darwin_libsystem_m, // Use Darwin's libsystem_m vector functions.
ArmPL, // Arm Performance Libraries.
- AMDLIBM // AMD vector math library.
+ AMDLIBM, // AMD vector math library.
+ HVML // Hygon vector math library.
};
LLVM_ABI llvm::VectorLibrary
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 14dda6baf5a53..d8435bc9c580b 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -4605,3 +4605,74 @@ defset list<RuntimeLibcallImpl> AMDLIBM_VECFUNCS = {
def amd_vrd4_round : RuntimeLibcallImpl<ROUND_V4F64>;
def amd_vrd8_round : RuntimeLibcallImpl<ROUND_V8F64>;
}
+
+//===----------------------------------------------------------------------===//
+// Hygon vector math library (HVML) functions
+//===----------------------------------------------------------------------===//
+
+defset list<RuntimeLibcallImpl> HVML_VECFUNCS = {
+ def hvml_vd2_acos : RuntimeLibcallImpl<ACOS_V2F64>;
+ def hvml_vd4_acos : RuntimeLibcallImpl<ACOS_V4F64>;
+ def hvml_vs4_acos : RuntimeLibcallImpl<ACOS_V4F32>;
+ def hvml_vs8_acos : RuntimeLibcallImpl<ACOS_V8F32>;
+ def hvml_vd2_asin : RuntimeLibcallImpl<ASIN_V2F64>;
+ def hvml_vd4_asin : RuntimeLibcallImpl<ASIN_V4F64>;
+ def hvml_vs4_asin : RuntimeLibcallImpl<ASIN_V4F32>;
+ def hvml_vs8_asin : RuntimeLibcallImpl<ASIN_V8F32>;
+ def hvml_vd2_atan : RuntimeLibcallImpl<ATAN_V2F64>;
+ def hvml_vd4_atan : RuntimeLibcallImpl<ATAN_V4F64>;
+ def hvml_vs4_atan : RuntimeLibcallImpl<ATAN_V4F32>;
+ def hvml_vs8_atan : RuntimeLibcallImpl<ATAN_V8F32>;
+ def hvml_vd2_cos : RuntimeLibcallImpl<COS_V2F64>;
+ def hvml_vd4_cos : RuntimeLibcallImpl<COS_V4F64>;
+ def hvml_vs4_cos : RuntimeLibcallImpl<COS_V4F32>;
+ def hvml_vs8_cos : RuntimeLibcallImpl<COS_V8F32>;
+ def hvml_vd2_exp : RuntimeLibcallImpl<EXP_V2F64>;
+ def hvml_vd4_exp : RuntimeLibcallImpl<EXP_V4F64>;
+ def hvml_vs4_exp : RuntimeLibcallImpl<EXP_V4F32>;
+ def hvml_vs8_exp : RuntimeLibcallImpl<EXP_V8F32>;
+ def hvml_vd2_ln : RuntimeLibcallImpl<LOG_V2F64>;
+ def hvml_vd4_ln : RuntimeLibcallImpl<LOG_V4F64>;
+ def hvml_vs4_ln : RuntimeLibcallImpl<LOG_V4F32>;
+ def hvml_vs8_ln : RuntimeLibcallImpl<LOG_V8F32>;
+ def hvml_vd2_log10 : RuntimeLibcallImpl<LOG10_V2F64>;
+ def hvml_vd4_log10 : RuntimeLibcallImpl<LOG10_V4F64>;
+ def hvml_vs4_log10 : RuntimeLibcallImpl<LOG10_V4F32>;
+ def hvml_vs8_log10 : RuntimeLibcallImpl<LOG10_V8F32>;
+ def hvml_vd2_pow : RuntimeLibcallImpl<POW_V2F64>;
+ def hvml_vd4_pow : RuntimeLibcallImpl<POW_V4F64>;
+ def hvml_vs4_pow : RuntimeLibcallImpl<POW_V4F32>;
+ def hvml_vs8_pow : RuntimeLibcallImpl<POW_V8F32>;
+ def hvml_vd2_sin : RuntimeLibcallImpl<SIN_V2F64>;
+ def hvml_vd4_sin : RuntimeLibcallImpl<SIN_V4F64>;
+ def hvml_vs4_sin : RuntimeLibcallImpl<SIN_V4F32>;
+ def hvml_vs8_sin : RuntimeLibcallImpl<SIN_V8F32>;
+ def hvml_vd2_tan : RuntimeLibcallImpl<TAN_V2F64>;
+ def hvml_vd4_tan : RuntimeLibcallImpl<TAN_V4F64>;
+ def hvml_vs4_tan : RuntimeLibcallImpl<TAN_V4F32>;
+ def hvml_vs8_tan : RuntimeLibcallImpl<TAN_V8F32>;
+ def hvml_vd2_sqrt : RuntimeLibcallImpl<SQRT_V2F64>;
+ def hvml_vd4_sqrt : RuntimeLibcallImpl<SQRT_V4F64>;
+ def hvml_vs4_sqrt : RuntimeLibcallImpl<SQRT_V4F32>;
+ def hvml_vs8_sqrt : RuntimeLibcallImpl<SQRT_V8F32>;
+ def hvml_vd2_exp2 : RuntimeLibcallImpl<EXP2_V2F64>;
+ def hvml_vd4_exp2 : RuntimeLibcallImpl<EXP2_V4F64>;
+ def hvml_vs4_exp2 : RuntimeLibcallImpl<EXP2_V4F32>;
+ def hvml_vs8_exp2 : RuntimeLibcallImpl<EXP2_V8F32>;
+ def hvml_vd2_log2 : RuntimeLibcallImpl<LOG2_V2F64>;
+ def hvml_vd4_log2 : RuntimeLibcallImpl<LOG2_V4F64>;
+ def hvml_vs4_log2 : RuntimeLibcallImpl<LOG2_V4F32>;
+ def hvml_vs8_log2 : RuntimeLibcallImpl<LOG2_V8F32>;
+ def hvml_vd2_sinh : RuntimeLibcallImpl<SINH_V2F64>;
+ def hvml_vd4_sinh : RuntimeLibcallImpl<SINH_V4F64>;
+ def hvml_vs4_sinh : RuntimeLibcallImpl<SINH_V4F32>;
+ def hvml_vs8_sinh : RuntimeLibcallImpl<SINH_V8F32>;
+ def hvml_vd2_cosh : RuntimeLibcallImpl<COSH_V2F64>;
...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/222632
More information about the llvm-commits
mailing list