[clang] [llvm] [RFC][MATHVEC] Introduce the LLVM's mathvec library as yet another veclib functions provider (PR #234621)
Paul Osmialowski via cfe-commits
cfe-commits at lists.llvm.org
Thu Oct 22 06:58:45 PDT 2026
https://github.com/pawosm-arm updated https://github.com/llvm/llvm-project/pull/234621
>From e3d223c43778b0fd4adc0a244d1697efe2a05c90 Mon Sep 17 00:00:00 2001
From: Paul Osmialowski <pawel.osmialowski at arm.com>
Date: Wed, 21 Oct 2026 17:07:11 +0000
Subject: [PATCH 1/2] [RFC][MATHVEC] Introduce the LLVM's mathvec library as
yet another veclib functions provider
This includes the addition of the mathvec mappings for the LLVM's libc
vector functions.
---
clang/include/clang/Options/Options.td | 6 +-
clang/lib/Driver/ToolChains/Clang.cpp | 3 +-
clang/lib/Driver/ToolChains/CommonArgs.cpp | 36 ++++
clang/test/Driver/autocomplete.c | 1 +
clang/test/Driver/fveclib.c | 30 ++++
llvm/docs/Vectorizers.md | 2 +-
llvm/include/llvm/Analysis/VecFuncs.def | 158 ++++++++++++++++++
.../llvm/Frontend/Driver/CodeGenOptions.h | 1 +
llvm/include/llvm/IR/RuntimeLibcalls.td | 77 +++++++++
llvm/include/llvm/IR/SystemLibraries.h | 1 +
llvm/lib/Analysis/TargetLibraryInfo.cpp | 29 ++++
llvm/lib/CodeGen/CommandFlags.cpp | 2 +
llvm/lib/Frontend/Driver/CodeGenOptions.cpp | 2 +
llvm/lib/IR/RuntimeLibcalls.cpp | 2 +
.../Util/DeclareRuntimeLibcalls/mathvec.ll | 60 +++++++
15 files changed, 405 insertions(+), 5 deletions(-)
create mode 100644 llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mathvec.ll
diff --git a/clang/include/clang/Options/Options.td b/clang/include/clang/Options/Options.td
index bc2d305fc45242..ecf40ea0852c43 100644
--- a/clang/include/clang/Options/Options.td
+++ b/clang/include/clang/Options/Options.td
@@ -4065,11 +4065,11 @@ def fveclib : Joined<["-"], "fveclib=">, Group<f_Group>,
" Note: -fveclib=libmvec on AArch64 requires GLIBC 2.40 or newer.">,
HelpTextForVariants<[ClangOption, CC1Option],
"Use the given vector functions library.\n"
- " Note: -fveclib={ArmPL,SLEEF,libmvec} implies -fno-math-errno.\n"
+ " Note: -fveclib={ArmPL,SLEEF,libmvec,mathvec} implies -fno-math-errno.\n"
" Note: -fveclib=libmvec on AArch64 requires GLIBC 2.40 or newer.">,
- Values<"Accelerate,libmvec,MASSV,SVML,SLEEF,Darwin_libsystem_m,ArmPL,AMDLIBM,none">,
+ Values<"Accelerate,libmvec,mathvec,MASSV,SVML,SLEEF,Darwin_libsystem_m,ArmPL,AMDLIBM,none">,
NormalizedValuesScope<"llvm::driver::VectorLibrary">,
- NormalizedValues<["Accelerate", "LIBMVEC", "MASSV", "SVML", "SLEEF",
+ NormalizedValues<["Accelerate", "LIBMVEC", "MATHVEC", "MASSV", "SVML", "SLEEF",
"Darwin_libsystem_m", "ArmPL", "AMDLIBM", "NoLibrary"]>,
MarshallingInfoEnum<CodeGenOpts<"VecLib">, "NoLibrary">;
def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>,
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index 454673dd20f9ad..dec031b4c0b166 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -2964,7 +2964,8 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
const JobAction &JA) {
// List of veclibs which when used with -fveclib imply -fno-math-errno.
constexpr std::array VecLibImpliesNoMathErrno{llvm::StringLiteral("ArmPL"),
- llvm::StringLiteral("SLEEF")};
+ llvm::StringLiteral("SLEEF"),
+ llvm::StringLiteral("mathvec")};
bool NoMathErrnoWasImpliedByVecLib = false;
const Arg *VecLibArg = nullptr;
// Track the arg (if any) that enabled errno after -fveclib for diagnostics.
diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp
index 7d77cd0b916324..d7838faf31cb41 100644
--- a/clang/lib/Driver/ToolChains/CommonArgs.cpp
+++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp
@@ -60,6 +60,7 @@
#include "llvm/TargetParser/Host.h"
#include "llvm/TargetParser/PPCTargetParser.h"
#include <optional>
+#include <algorithm>
using namespace clang::driver;
using namespace clang::driver::tools;
@@ -573,6 +574,40 @@ void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs,
CmdArgs.push_back(Args.MakeArgString("-lm"));
if (Triple.isOSLinux())
CmdArgs.push_back(Args.MakeArgString("--pop-state"));
+ } else if (V == "mathvec") {
+ SmallVector<std::string> CandidateLibPaths(TC.getArchSpecificLibPaths());
+ if (const auto StdlibPath = TC.getStdlibPath()) {
+ for (const Multilib &M : llvm::reverse(TC.getSelectedMultilibs())) {
+ if (M.isDefault())
+ continue;
+ SmallString<128> P(*StdlibPath);
+ llvm::sys::path::append(P, M.gccSuffix());
+ CandidateLibPaths.emplace_back(std::string(P));
+ }
+ CandidateLibPaths.emplace_back(*StdlibPath);
+ }
+ for (const auto &CandidateLibPath : CandidateLibPaths) {
+ SmallString<128> P(CandidateLibPath);
+ llvm::sys::path::append(P, "libmvec.a");
+ if (TC.getVFS().exists(std::string(P))) {
+ if (Triple.isOSLinux()) {
+ CmdArgs.push_back(Args.MakeArgString("--push-state"));
+ CmdArgs.push_back(Args.MakeArgString("--as-needed"));
+ }
+ CmdArgs.push_back(Args.MakeArgString("-L" + CandidateLibPath));
+ CmdArgs.push_back(Args.MakeArgString("-lmvec"));
+ if (Triple.isOSLinux())
+ CmdArgs.push_back(Args.MakeArgString("--pop-state"));
+ SmallVector<ArgStringList::iterator> Lms;
+ for (auto it = CmdArgs.begin(); it != CmdArgs.end(); ++it) {
+ if (std::string(*it) == "-lm")
+ Lms.push_back(it);
+ }
+ for (ArgStringList::iterator &Lm : Lms)
+ std::rotate(Lm, Lm + 1, CmdArgs.end());
+ break;
+ }
+ }
}
}
@@ -1140,6 +1175,7 @@ void tools::addLTOOptions(const ToolChain &ToolChain, const ArgList &Args,
llvm::StringSwitch<std::optional<StringRef>>(ArgVecLib->getValue())
.Case("Accelerate", "Accelerate")
.Case("libmvec", "LIBMVEC")
+ .Case("mathvec", "MATHVEC")
.Case("AMDLIBM", "AMDLIBM")
.Case("MASSV", "MASSV")
.Case("SVML", "SVML")
diff --git a/clang/test/Driver/autocomplete.c b/clang/test/Driver/autocomplete.c
index 297d2e40d6d83a..345d1a876b63a9 100644
--- a/clang/test/Driver/autocomplete.c
+++ b/clang/test/Driver/autocomplete.c
@@ -86,6 +86,7 @@
// FVECLIBALL-NEXT: Darwin_libsystem_m
// FVECLIBALL-NEXT: libmvec
// FVECLIBALL-NEXT: MASSV
+// FVECLIBALL-NEXT: mathvec
// FVECLIBALL-NEXT: none
// FVECLIBALL-NEXT: SLEEF
// FVECLIBALL-NEXT: SVML
diff --git a/clang/test/Driver/fveclib.c b/clang/test/Driver/fveclib.c
index c57e9aa7a3cc23..86156b5a91f020 100644
--- a/clang/test/Driver/fveclib.c
+++ b/clang/test/Driver/fveclib.c
@@ -2,6 +2,8 @@
// RUN: %clang -### -c -fveclib=Accelerate %s 2>&1 | FileCheck --check-prefix=CHECK-ACCELERATE %s
// RUN: %clang -### -c --target=x86_64-unknown-linux-gnu -fveclib=libmvec %s 2>&1 | FileCheck --check-prefix=CHECK-libmvec %s
// RUN: %clang -### -c --target=aarch64-linux-gnu -fveclib=libmvec %s 2>&1 | FileCheck --check-prefix=CHECK-LIBMVEC-AARCH64 %s
+// RUN: %clang -### -c --target=x86_64-unknown-linux-gnu -fveclib=mathvec %s 2>&1 | FileCheck --check-prefix=CHECK-mathvec %s
+// RUN: %clang -### -c --target=aarch64-linux-gnu -fveclib=mathvec %s 2>&1 | FileCheck --check-prefix=CHECK-MATHVEC-AARCH64 %s
// RUN: %clang -### -c --target=x86_64-unknown-linux-gnu -fveclib=AMDLIBM %s 2>&1 | FileCheck --check-prefix=CHECK-AMDLIBM %s
// RUN: %clang -### -c -fveclib=MASSV %s 2>&1 | FileCheck --check-prefix=CHECK-MASSV %s
// RUN: %clang -### -c -fveclib=Darwin_libsystem_m %s 2>&1 | FileCheck --check-prefix=CHECK-DARWIN_LIBSYSTEM_M %s
@@ -14,6 +16,8 @@
// CHECK-ACCELERATE: "-fveclib=Accelerate"
// CHECK-libmvec: "-fveclib=libmvec"
// CHECK-LIBMVEC-AARCH64: "-fveclib=libmvec"
+// CHECK-mathvec: "-fveclib=mathvec"
+// CHECK-MATHVEC-AARCH64: "-fveclib=mathvec"
// CHECK-AMDLIBM: "-fveclib=AMDLIBM"
// CHECK-MASSV: "-fveclib=MASSV"
// CHECK-DARWIN_LIBSYSTEM_M: "-fveclib=Darwin_libsystem_m"
@@ -47,6 +51,12 @@
// RUN: %clang -### --target=aarch64-linux-gnu -fveclib=libmvec -flto %s 2>&1 | FileCheck --check-prefix=CHECK-LTO-LIBMVEC-AARCH64 %s
// CHECK-LTO-LIBMVEC-AARCH64: "-plugin-opt=-vector-library=LIBMVEC"
+// RUN: %clang -### --target=x86_64-unknown-linux-gnu -fveclib=mathvec -flto %s 2>&1 | FileCheck --check-prefix=CHECK-LTO-MATHVEC %s
+// CHECK-LTO-MATHVEC: "-plugin-opt=-vector-library=MATHVEC"
+
+// RUN: %clang -### --target=aarch64-linux-gnu -fveclib=mathvec -flto %s 2>&1 | FileCheck --check-prefix=CHECK-LTO-MATHVEC-AARCH64 %s
+// CHECK-LTO-MATHVEC-AARCH64: "-plugin-opt=-vector-library=MATHVEC"
+
// RUN: %clang -### --target=x86_64-unknown-linux-gnu -fveclib=AMDLIBM -flto %s 2>&1 | FileCheck --check-prefix=CHECK-LTO-AMDLIBM %s
// CHECK-LTO-AMDLIBM: "-plugin-opt=-vector-library=AMDLIBM"
@@ -76,6 +86,16 @@
// CHECK-ERRNO-LIBMVEC-AARCH64: "-fveclib=libmvec"
// CHECK-ERRNO-LIBMVEC-AARCH64-SAME: "-fmath-errno"
+// RUN: %clang -### --target=x86_64-unknown-linux-gnu -fveclib=mathvec %s 2>&1 | FileCheck --check-prefix=CHECK-ERRNO-MATHVEC %s
+// CHECK-ERRNO-MATHVEC-NOT: "-fmath-errno"
+// CHECK-ERRNO-MATHVEC: "-fveclib=mathvec"
+// CHECK-ERRNO-MATHVEC-NOT: "-fmath-errno"
+
+// RUN: %clang -### --target=aarch64-linux-gnu -fveclib=mathvec %s 2>&1 | FileCheck --check-prefix=CHECK-ERRNO-MATHVEC-AARCH64 %s
+// CHECK-ERRNO-MATHVEC-AARCH64-NOT: "-fmath-errno"
+// CHECK-ERRNO-MATHVEC-AARCH64: "-fveclib=mathvec"
+// CHECK-ERRNO-MATHVEC-AARCH64-NOT: "-fmath-errno"
+
// RUN: %clang -### --target=x86_64-unknown-linux-gnu -fveclib=AMDLIBM %s 2>&1 | FileCheck --check-prefix=CHECK-ERRNO-AMDLIBM %s
// CHECK-ERRNO-AMDLIBM: "-fveclib=AMDLIBM"
// CHECK-ERRNO-AMDLIBM-SAME: "-fmath-errno"
@@ -103,6 +123,16 @@
// CHECK-REENABLE-ERRNO-ARMPL: "-fveclib=ArmPL"
// CHECK-REENABLE-ERRNO-ARMPL-SAME: "-fmath-errno"
+// RUN: %clang -### --target=x86_64-unknown-linux-gnu -fveclib=mathvec -fmath-errno %s 2>&1 | FileCheck --check-prefix=CHECK-REENABLE-ERRNO-MATHVEC %s
+// CHECK-REENABLE-ERRNO-MATHVEC: math errno enabled by '-fmath-errno' after it was implicitly disabled by '-fveclib=mathvec', this may limit the utilization of the vector library [-Wmath-errno-enabled-with-veclib]
+// CHECK-REENABLE-ERRNO-MATHVEC: "-fveclib=mathvec"
+// CHECK-REENABLE-ERRNO-MATHVEC-SAME: "-fmath-errno"
+
+// RUN: %clang -### --target=aarch64-linux-gnu -fveclib=mathvec -fmath-errno %s 2>&1 | FileCheck --check-prefix=CHECK-REENABLE-ERRNO-MATHVEC-AARCH64 %s
+// CHECK-REENABLE-ERRNO-MATHVEC-AARCH64: math errno enabled by '-fmath-errno' after it was implicitly disabled by '-fveclib=mathvec', this may limit the utilization of the vector library [-Wmath-errno-enabled-with-veclib]
+// CHECK-REENABLE-ERRNO-MATHVEC-AARCH64: "-fveclib=mathvec"
+// CHECK-REENABLE-ERRNO-MATHVEC-AARCH64-SAME: "-fmath-errno"
+
// RUN: %clang -### --target=aarch64-linux-gnu -fveclib=SLEEF -fmath-errno %s 2>&1 | FileCheck --check-prefix=CHECK-REENABLE-ERRNO-SLEEF %s
// CHECK-REENABLE-ERRNO-SLEEF: math errno enabled by '-fmath-errno' after it was implicitly disabled by '-fveclib=SLEEF', this may limit the utilization of the vector library [-Wmath-errno-enabled-with-veclib]
// CHECK-REENABLE-ERRNO-SLEEF: "-fveclib=SLEEF"
diff --git a/llvm/docs/Vectorizers.md b/llvm/docs/Vectorizers.md
index bcb0c78e981884..f894dce9812442 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,mathvec,MASSV,SVML,SLEEF,Darwin_libsystem_m,ArmPL,AMDLIBM"
```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 6af8b633664776..d4ae28233e6ac5 100644
--- a/llvm/include/llvm/Analysis/VecFuncs.def
+++ b/llvm/include/llvm/Analysis/VecFuncs.def
@@ -590,6 +590,164 @@ TLI_DEFINE_VECFUNC("llvm.tanh.f32", "_ZGVnN4v_tanhf", FIXED(4), NOMASK, "_ZGV_LL
TLI_DEFINE_VECFUNC("llvm.tanh.f64", "_ZGVsMxv_tanh", SCALABLE(2), MASKED, "_ZGVsMxv", NOCC)
TLI_DEFINE_VECFUNC("llvm.tanh.f32", "_ZGVsMxv_tanhf", SCALABLE(4), MASKED, "_ZGVsMxv", NOCC)
+#elif defined(TLI_DEFINE_MATHVEC_X86_VECFUNCS)
+// LLVM Vector math Functions
+
+TLI_DEFINE_VECFUNC("acosf", "_ZGVdN8v_acosf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.acos.f32", "_ZGVdN8v_acosf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("acoshf", "_ZGVdN8v_acoshf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("acospif", "_ZGVdN8v_acospif", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("asinf", "_ZGVdN8v_asinf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.asin.f32", "_ZGVdN8v_asinf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("asinhf", "_ZGVdN8v_asinhf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("asinpif", "_ZGVdN8v_asinpif", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("atanf", "_ZGVdN8v_atanf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.atan.f32", "_ZGVdN8v_atanf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("cbrtf", "_ZGVdN8v_cbrtf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("cosf", "_ZGVdN8v_cosf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVdN8v_cosf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("coshf", "_ZGVdN8v_coshf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.cosh.f32", "_ZGVdN8v_coshf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("cospif", "_ZGVdN8v_cospif", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("erff", "_ZGVdN8v_erff", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("exp2f", "_ZGVdN8v_exp2f", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.exp2.f32", "_ZGVdN8v_exp2f", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("exp2m1f", "_ZGVdN8v_exp2m1f", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("exp10f", "_ZGVdN8v_exp10f", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.exp10.f32", "_ZGVdN8v_exp10f", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("exp10m1f", "_ZGVdN8v_exp10m1f", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("expf", "_ZGVdN8v_expf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVdN8v_expf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("expm1f", "_ZGVdN8v_expm1f", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("log10f", "_ZGVdN8v_log10f", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.log10.f32", "_ZGVdN8v_log10f", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("log1pf", "_ZGVdN8v_log1pf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("log2f", "_ZGVdN8v_log2f", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.log2.f32", "_ZGVdN8v_log2f", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("logf", "_ZGVdN8v_logf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVdN8v_logf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("rsqrtf", "_ZGVdN8v_rsqrtf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("sinf", "_ZGVdN8v_sinf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVdN8v_sinf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("sinhf", "_ZGVdN8v_sinhf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.sinh.f32", "_ZGVdN8v_sinhf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("sinpif", "_ZGVdN8v_sinpif", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("sqrtf", "_ZGVdN8v_sqrtf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.sqrt.f32", "_ZGVdN8v_sqrtf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("tanf", "_ZGVdN8v_tanf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.tan.f32", "_ZGVdN8v_tanf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("tanhf", "_ZGVdN8v_tanhf", FIXED(8), "_ZGV_LLVM_N8v")
+TLI_DEFINE_VECFUNC("llvm.tanh.f32", "_ZGVdN8v_tanhf", FIXED(8), "_ZGV_LLVM_N8v")
+
+TLI_DEFINE_VECFUNC("tanpif", "_ZGVdN8v_tanpif", FIXED(8), "_ZGV_LLVM_N8v")
+
+#elif defined(TLI_DEFINE_MATHVEC_AARCH64_VECFUNCS)
+// LLVM Vector math Functions
+
+TLI_DEFINE_VECFUNC("acosf", "_ZGVnN4v_acosf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.acos.f32", "_ZGVnN4v_acosf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("acoshf", "_ZGVnN4v_acoshf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("acospif", "_ZGVnN4v_acospif", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("asinf", "_ZGVnN4v_asinf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.asin.f32", "_ZGVnN4v_asinf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("asinhf", "_ZGVnN4v_asinhf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("asinpif", "_ZGVnN4v_asinpif", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("atanf", "_ZGVnN4v_atanf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.atan.f32", "_ZGVnN4v_atanf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("cbrtf", "_ZGVnN4v_cbrtf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("cosf", "_ZGVnN4v_cosf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVnN4v_cosf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("coshf", "_ZGVnN4v_coshf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.cosh.f32", "_ZGVnN4v_coshf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("cospif", "_ZGVnN4v_cospif", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("erff", "_ZGVnN4v_erff", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("exp2f", "_ZGVnN4v_exp2f", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.exp2.f32", "_ZGVnN4v_exp2f", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("exp2m1f", "_ZGVnN4v_exp2m1f", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("exp10f", "_ZGVnN4v_exp10f", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.exp10.f32", "_ZGVnN4v_exp10f", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("exp10m1f", "_ZGVnN4v_exp10m1f", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("expf", "_ZGVnN4v_expf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVnN4v_expf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("expm1f", "_ZGVnN4v_expm1f", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("log10f", "_ZGVnN4v_log10f", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.log10.f32", "_ZGVnN4v_log10f", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("log1pf", "_ZGVnN4v_log1pf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("log2f", "_ZGVnN4v_log2f", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.log2.f32", "_ZGVnN4v_log2f", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("logf", "_ZGVnN4v_logf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVnN4v_logf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("rsqrtf", "_ZGVnN4v_rsqrtf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("sinf", "_ZGVnN4v_sinf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVnN4v_sinf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("sinhf", "_ZGVnN4v_sinhf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.sinh.f32", "_ZGVnN4v_sinhf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("sinpif", "_ZGVnN4v_sinpif", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("sqrtf", "_ZGVnN4v_sqrtf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.sqrt.f32", "_ZGVnN4v_sqrtf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("tanf", "_ZGVnN4v_tanf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.tan.f32", "_ZGVnN4v_tanf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("tanhf", "_ZGVnN4v_tanhf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+TLI_DEFINE_VECFUNC("llvm.tanh.f32", "_ZGVnN4v_tanhf", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
+TLI_DEFINE_VECFUNC("tanpif", "_ZGVnN4v_tanpif", FIXED(4), NOMASK, "_ZGV_LLVM_N4v", NOCC)
+
#elif defined(TLI_DEFINE_MASSV_VECFUNCS)
// IBM MASS library's vector Functions
diff --git a/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h b/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h
index 3d292139cb7d06..a6fb30e0eb3fc6 100644
--- a/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h
+++ b/llvm/include/llvm/Frontend/Driver/CodeGenOptions.h
@@ -45,6 +45,7 @@ enum class VectorLibrary {
NoLibrary, // Don't use any vector library.
Accelerate, // Use the Accelerate framework.
LIBMVEC, // GLIBC vector math library.
+ MATHVEC, // LLVM vector math library.
MASSV, // IBM MASS vector library.
SVML, // Intel short vector math library.
SLEEF, // SLEEF SIMD Library for Evaluating Elementary Functions.
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index f5c0c84cf3ff9e..0ef9180d2aee88 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -4157,6 +4157,73 @@ defset list<RuntimeLibcallImpl> LIBMVEC_AARCH64_VECFUNCS = {
def LIBMVEC__ZGVsMxvv_powf : LibmvecLibcall<POW_MASKED_NXV4F32>;
}
+//===----------------------------------------------------------------------===//
+// LLVM Vector Math library MATHVEC functions
+//===----------------------------------------------------------------------===//
+
+defvar MATHVECPrefix = "MATHVEC_";
+
+class MathvecLibcall<RuntimeLibcall P>
+ : RuntimeLibcallImpl<P, !substr(NAME, !size(MATHVECPrefix))>;
+
+defset list<RuntimeLibcallImpl> MATHVEC_X86_VECFUNCS = {
+ def MATHVEC__ZGVdN8v_acosf : MathvecLibcall<ACOS_V8F32>;
+ def MATHVEC__ZGVdN8v_acoshf : MathvecLibcall<ACOSH_V8F32>;
+ def MATHVEC__ZGVdN8v_asinf : MathvecLibcall<ASIN_V8F32>;
+ def MATHVEC__ZGVdN8v_asinhf : MathvecLibcall<ASINH_V8F32>;
+ def MATHVEC__ZGVdN8v_atanf : MathvecLibcall<ATAN_V8F32>;
+ def MATHVEC__ZGVdN8v_atanhf : MathvecLibcall<ATANH_V8F32>;
+ def MATHVEC__ZGVdN8v_cbrtf : MathvecLibcall<CBRT_V8F32>;
+ def MATHVEC__ZGVdN8v_cosf : MathvecLibcall<COS_V8F32>;
+ def MATHVEC__ZGVdN8v_coshf : MathvecLibcall<COSH_V8F32>;
+ def MATHVEC__ZGVdN8v_cospif : MathvecLibcall<COSPI_V8F32>;
+ def MATHVEC__ZGVdN8v_erff : MathvecLibcall<ERF_V8F32>;
+ def MATHVEC__ZGVdN8v_exp2f : MathvecLibcall<EXP2_V8F32>;
+ def MATHVEC__ZGVdN8v_exp10f : MathvecLibcall<EXP10_V8F32>;
+ def MATHVEC__ZGVdN8v_expf : MathvecLibcall<EXP_V8F32>;
+ def MATHVEC__ZGVdN8v_expm1f : MathvecLibcall<EXPM1_V8F32>;
+ def MATHVEC__ZGVdN8v_log10f : MathvecLibcall<LOG10_V8F32>;
+ def MATHVEC__ZGVdN8v_log1pf : MathvecLibcall<LOG1P_V8F32>;
+ def MATHVEC__ZGVdN8v_log2f : MathvecLibcall<LOG2_V8F32>;
+ def MATHVEC__ZGVdN8v_logf : MathvecLibcall<LOG_V8F32>;
+ def MATHVEC__ZGVdN8v_sinf : MathvecLibcall<SIN_V8F32>;
+ def MATHVEC__ZGVdN8v_sinhf : MathvecLibcall<SINH_V8F32>;
+ def MATHVEC__ZGVdN8v_sinpif : MathvecLibcall<SINPI_V8F32>;
+ def MATHVEC__ZGVdN8v_sqrtf : MathvecLibcall<SQRT_V8F32>;
+ def MATHVEC__ZGVdN8v_tanf : MathvecLibcall<TAN_V8F32>;
+ def MATHVEC__ZGVdN8v_tanhf : MathvecLibcall<TANH_V8F32>;
+ def MATHVEC__ZGVdN8v_tanpif : MathvecLibcall<TANPI_V8F32>;
+}
+
+defset list<RuntimeLibcallImpl> MATHVEC_AARCH64_VECFUNCS = {
+ def MATHVEC__ZGVnN4v_acosf : MathvecLibcall<ACOS_V4F32>;
+ def MATHVEC__ZGVnN4v_acoshf : MathvecLibcall<ACOSH_V4F32>;
+ def MATHVEC__ZGVnN4v_asinf : MathvecLibcall<ASIN_V4F32>;
+ def MATHVEC__ZGVnN4v_asinhf : MathvecLibcall<ASINH_V4F32>;
+ def MATHVEC__ZGVnN4v_atanf : MathvecLibcall<ATAN_V4F32>;
+ def MATHVEC__ZGVnN4v_atanhf : MathvecLibcall<ATANH_V4F32>;
+ def MATHVEC__ZGVnN4v_cbrtf : MathvecLibcall<CBRT_V4F32>;
+ def MATHVEC__ZGVnN4v_cosf : MathvecLibcall<COS_V4F32>;
+ def MATHVEC__ZGVnN4v_coshf : MathvecLibcall<COSH_V4F32>;
+ def MATHVEC__ZGVnN4v_cospif : MathvecLibcall<COSPI_V4F32>;
+ def MATHVEC__ZGVnN4v_erff : MathvecLibcall<ERF_V4F32>;
+ def MATHVEC__ZGVnN4v_exp2f : MathvecLibcall<EXP2_V4F32>;
+ def MATHVEC__ZGVnN4v_exp10f : MathvecLibcall<EXP10_V4F32>;
+ def MATHVEC__ZGVnN4v_expf : MathvecLibcall<EXP_V4F32>;
+ def MATHVEC__ZGVnN4v_expm1f : MathvecLibcall<EXPM1_V4F32>;
+ def MATHVEC__ZGVnN4v_log10f : MathvecLibcall<LOG10_V4F32>;
+ def MATHVEC__ZGVnN4v_log1pf : MathvecLibcall<LOG1P_V4F32>;
+ def MATHVEC__ZGVnN4v_log2f : MathvecLibcall<LOG2_V4F32>;
+ def MATHVEC__ZGVnN4v_logf : MathvecLibcall<LOG_V4F32>;
+ def MATHVEC__ZGVnN4v_sinf : MathvecLibcall<SIN_V4F32>;
+ def MATHVEC__ZGVnN4v_sinhf : MathvecLibcall<SINH_V4F32>;
+ def MATHVEC__ZGVnN4v_sinpif : MathvecLibcall<SINPI_V4F32>;
+ def MATHVEC__ZGVnN4v_sqrtf : MathvecLibcall<SQRT_V4F32>;
+ def MATHVEC__ZGVnN4v_tanf : MathvecLibcall<TAN_V4F32>;
+ def MATHVEC__ZGVnN4v_tanhf : MathvecLibcall<TANH_V4F32>;
+ def MATHVEC__ZGVnN4v_tanpif : MathvecLibcall<TANPI_V4F32>;
+}
+
//===----------------------------------------------------------------------===//
// IBM MASS vector library (MASSV) functions
//===----------------------------------------------------------------------===//
@@ -4915,6 +4982,16 @@ def LIBMVECAArch64Library : LibcallLibrary<"libmvec",
!filter(entry, LIBMVEC_AARCH64_VECFUNCS,
!match(entry.LibCallFuncName, "^_ZGVsMx"))), isAArch64>;
+def MATHVECX86Library : LibcallLibrary<"mathvec",
+ (add MATHVEC_X86_VECFUNCS), isX86>;
+
+def MATHVECAArch64Library : LibcallLibrary<"mathvec",
+ (add LibcallsWithCC<(add !filter(entry, MATHVEC_AARCH64_VECFUNCS,
+ !match(entry.LibCallFuncName, "^_ZGVnN"))),
+ AARCH64_VECTORCALL>,
+ !filter(entry, MATHVEC_AARCH64_VECFUNCS,
+ !match(entry.LibCallFuncName, "^_ZGVsMx"))), isAArch64>;
+
def MASSVLibrary : LibcallLibrary<"massv", (add MASSV_VECFUNCS)>;
def SVMLLibrary : LibcallLibrary<"svml", (add SVML_VECFUNCS)>;
diff --git a/llvm/include/llvm/IR/SystemLibraries.h b/llvm/include/llvm/IR/SystemLibraries.h
index 5bdf67642e0e4b..e93f71149f317f 100644
--- a/llvm/include/llvm/IR/SystemLibraries.h
+++ b/llvm/include/llvm/IR/SystemLibraries.h
@@ -22,6 +22,7 @@ enum class VectorLibrary {
Accelerate, // Use Accelerate framework.
DarwinLibSystemM, // Use Darwin's libsystem_m.
LIBMVEC, // GLIBC Vector Math library.
+ MATHVEC, // LLVM Vector Math library.
MASSV, // IBM MASS vector library.
SVML, // Intel short vector math library.
SLEEFGNUABI, // SLEEF - SIMD Library for Evaluating Elementary Functions.
diff --git a/llvm/lib/Analysis/TargetLibraryInfo.cpp b/llvm/lib/Analysis/TargetLibraryInfo.cpp
index c3469979d72047..1d00f796635cff 100644
--- a/llvm/lib/Analysis/TargetLibraryInfo.cpp
+++ b/llvm/lib/Analysis/TargetLibraryInfo.cpp
@@ -1285,6 +1285,20 @@ static constexpr VecDesc VecFuncs_LIBMVEC_AARCH64[] = {
#undef TLI_DEFINE_LIBMVEC_AARCH64_VECFUNCS
};
+static constexpr VecDesc VecFuncs_MATHVEC_X86[] = {
+#define TLI_DEFINE_MATHVEC_X86_VECFUNCS
+#include "llvm/Analysis/VecFuncs.def"
+#undef TLI_DEFINE_MATHVEC_X86_VECFUNCS
+};
+
+static constexpr VecDesc VecFuncs_MATHVEC_AARCH64[] = {
+#define TLI_DEFINE_MATHVEC_AARCH64_VECFUNCS
+#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF, MASK, VABI_PREFIX, CC) \
+ {SCAL, VEC, VF, MASK, VABI_PREFIX, CC},
+#include "llvm/Analysis/VecFuncs.def"
+#undef TLI_DEFINE_MATHVEC_AARCH64_VECFUNCS
+};
+
static constexpr VecDesc VecFuncs_MASSV[] = {
#define TLI_DEFINE_MASSV_VECFUNCS
#include "llvm/Analysis/VecFuncs.def"
@@ -1369,6 +1383,21 @@ void TargetLibraryInfoImpl::addVectorizableFunctionsFromVecLib(
}
break;
}
+ case VectorLibrary::MATHVEC: {
+ switch (TargetTriple.getArch()) {
+ default:
+ break;
+ case llvm::Triple::x86:
+ case llvm::Triple::x86_64:
+ addVectorizableFunctions(VecFuncs_MATHVEC_X86);
+ break;
+ case llvm::Triple::aarch64:
+ case llvm::Triple::aarch64_be:
+ addVectorizableFunctions(VecFuncs_MATHVEC_AARCH64);
+ break;
+ }
+ break;
+ }
case VectorLibrary::MASSV: {
addVectorizableFunctions(VecFuncs_MASSV);
break;
diff --git a/llvm/lib/CodeGen/CommandFlags.cpp b/llvm/lib/CodeGen/CommandFlags.cpp
index 3c4652405cb6a6..0f192b3bcf3bec 100644
--- a/llvm/lib/CodeGen/CommandFlags.cpp
+++ b/llvm/lib/CodeGen/CommandFlags.cpp
@@ -392,6 +392,8 @@ codegen::RegisterCodeGenFlags::RegisterCodeGenFlags() {
"Darwin libsystem_m"),
clEnumValN(VectorLibrary::LIBMVEC, "LIBMVEC",
"GLIBC Vector Math library"),
+ clEnumValN(VectorLibrary::MATHVEC, "MATHVEC",
+ "LLVM Vector Math library"),
clEnumValN(VectorLibrary::MASSV, "MASSV", "IBM MASS vector library"),
clEnumValN(VectorLibrary::SVML, "SVML", "Intel SVML library"),
clEnumValN(VectorLibrary::SLEEFGNUABI, "sleefgnuabi",
diff --git a/llvm/lib/Frontend/Driver/CodeGenOptions.cpp b/llvm/lib/Frontend/Driver/CodeGenOptions.cpp
index e893c15d76147f..e49fb032be16b9 100644
--- a/llvm/lib/Frontend/Driver/CodeGenOptions.cpp
+++ b/llvm/lib/Frontend/Driver/CodeGenOptions.cpp
@@ -25,6 +25,8 @@ convertDriverVectorLibraryToVectorLibrary(llvm::driver::VectorLibrary VecLib) {
return llvm::VectorLibrary::DarwinLibSystemM;
case llvm::driver::VectorLibrary::LIBMVEC:
return llvm::VectorLibrary::LIBMVEC;
+ case llvm::driver::VectorLibrary::MATHVEC:
+ return llvm::VectorLibrary::MATHVEC;
case llvm::driver::VectorLibrary::MASSV:
return llvm::VectorLibrary::MASSV;
case llvm::driver::VectorLibrary::SVML:
diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp
index b1a035901d3b0b..f5b8ca6cdaaa08 100644
--- a/llvm/lib/IR/RuntimeLibcalls.cpp
+++ b/llvm/lib/IR/RuntimeLibcalls.cpp
@@ -38,6 +38,8 @@ static RuntimeLibrary getVectorRuntimeLibrary(VectorLibrary VecLib) {
return RuntimeLibrary::darwin_libsystem_m;
case VectorLibrary::LIBMVEC:
return RuntimeLibrary::libmvec;
+ case VectorLibrary::MATHVEC:
+ return RuntimeLibrary::mathvec;
case VectorLibrary::MASSV:
return RuntimeLibrary::massv;
case VectorLibrary::SVML:
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mathvec.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mathvec.ll
new file mode 100644
index 00000000000000..a6c7b5722cb5f8
--- /dev/null
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mathvec.ll
@@ -0,0 +1,60 @@
+; RUN: %if x86-registered-target %{ opt -S -passes=declare-runtime-libcalls -mtriple=x86_64-unknown-linux -vector-library=MATHVEC < %s | FileCheck -check-prefix=X86 %s %}
+; RUN: %if aarch64-registered-target %{ opt -S -passes=declare-runtime-libcalls -mtriple=aarch64-unknown-linux -mattr=+neon,+sve -vector-library=MATHVEC < %s | FileCheck -check-prefix=AARCH64 %s %}
+
+; X86: declare <8 x float> @_ZGVdN8v_acosf(<8 x float>) [[ATTRS:#[0-9]+]]
+; X86: declare <8 x float> @_ZGVdN8v_acoshf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_asinf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_asinhf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_atanf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_atanhf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_cbrtf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_cosf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_coshf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_cospif(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_erff(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_exp10f(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_exp2f(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_expf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_expm1f(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_log10f(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_log1pf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_log2f(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_logf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_sinf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_sinhf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_sinpif(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_sqrtf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_tanf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_tanhf(<8 x float>) [[ATTRS]]
+; X86: declare <8 x float> @_ZGVdN8v_tanpif(<8 x float>) [[ATTRS]]
+
+; X86: attributes [[ATTRS]] = { nocallback nofree nosync nounwind willreturn }
+
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_acosf(<4 x float>) [[ATTRS:#[0-9]+]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_acoshf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_asinf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_asinhf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_atanf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_atanhf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_cbrtf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_cosf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_coshf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_cospif(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_erff(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_exp10f(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_exp2f(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_expf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_expm1f(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_log10f(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_log1pf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_log2f(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_logf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_sinf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_sinhf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_sinpif(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_sqrtf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_tanf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_tanhf(<4 x float>) [[ATTRS]]
+; AARCH64: declare aarch64_vector_pcs <4 x float> @_ZGVnN4v_tanpif(<4 x float>) [[ATTRS]]
+
+; AARCH64: attributes [[ATTRS]] = { nocallback nofree nosync nounwind willreturn }
>From a3a485d7c3f53bbffcbcf32da627cd73c44f5bd9 Mon Sep 17 00:00:00 2001
From: Paul Osmialowski <pawel.osmialowski at arm.com>
Date: Wed, 21 Oct 2026 17:07:11 +0000
Subject: [PATCH 2/2] [RFC][MATHVEC] Introduce the LLVM's mathvec library as
yet another veclib functions provider
This includes the addition of the mathvec mappings for the LLVM's libc
vector functions.
---
clang/lib/Driver/ToolChains/CommonArgs.cpp | 1 +
1 file changed, 1 insertion(+)
diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp
index d7838faf31cb41..956461de787c8f 100644
--- a/clang/lib/Driver/ToolChains/CommonArgs.cpp
+++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp
@@ -59,6 +59,7 @@
#include "llvm/TargetParser/AMDGPUTargetParser.h"
#include "llvm/TargetParser/Host.h"
#include "llvm/TargetParser/PPCTargetParser.h"
+#include <algorithm>
#include <optional>
#include <algorithm>
More information about the cfe-commits
mailing list