https://github.com/pawosm-arm updated https://github.com/llvm/llvm-project/pull/234621
>From 134d182785933467a0e44d1000554e0e90e46eb6 Mon Sep 17 00:00:00 2001 From: Paul Osmialowski <[email protected]> Date: Wed, 21 Oct 2026 17:07:11 +0000 Subject: [PATCH] [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..7910b0cf300cea 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> using namespace clang::driver; @@ -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 } _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
