Automerge: RuntimeLibcalls: Move VectorLibrary handling into TargetOptions (#167996)

This fixes the -fveclib flag getting lost on its way to the backend.

Previously this was its own cl::opt with a random boolean. Move the
flag handling into CommandFlags with other backend ABI-ish options,
and have clang directly set it, rather than forcing it to go through
command line parsing.

Prior to de68181, codegen used TargetLibraryInfo to find the vector
function. Clang has special handling for TargetLibraryInfo, where it
would
directly construct one with the vector library in the pass pipeline.
RuntimeLibcallsInfo currently is not used as an analysis in codegen, and
needs to know the vector library when constructed.

RuntimeLibraryAnalysis could follow the same trick that
TargetLibraryInfo is using in the future, but a lot more boilerplate changes
are needed to thread that analysis through codegen. Ideally this would come
from an IR module flag, and nothing would be in TargetOptions. For now, it's
better for all of these sorts of controls to be consistent.

Author: arsenm

clang/lib/CodeGen/BackendUtil.cpp

@@ -481,6 +481,36 @@ static bool initTargetOptions(const CompilerInstance &CI,
   Options.JMCInstrument = CodeGenOpts.JMCInstrument;
   Options.XCOFFReadOnlyPointers = CodeGenOpts.XCOFFReadOnlyPointers;
 
+  switch (CodeGenOpts.getVecLib()) {
+  case llvm::driver::VectorLibrary::NoLibrary:
+    Options.VectorLibrary = llvm::VectorLibrary::NoLibrary;
+    break;
+  case llvm::driver::VectorLibrary::Accelerate:
+    Options.VectorLibrary = llvm::VectorLibrary::Accelerate;
+    break;
+  case llvm::driver::VectorLibrary::Darwin_libsystem_m:
+    Options.VectorLibrary = llvm::VectorLibrary::DarwinLibSystemM;
+    break;
+  case llvm::driver::VectorLibrary::LIBMVEC:
+    Options.VectorLibrary = llvm::VectorLibrary::LIBMVEC;
+    break;
+  case llvm::driver::VectorLibrary::MASSV:
+    Options.VectorLibrary = llvm::VectorLibrary::MASSV;
+    break;
+  case llvm::driver::VectorLibrary::SVML:
+    Options.VectorLibrary = llvm::VectorLibrary::SVML;
+    break;
+  case llvm::driver::VectorLibrary::SLEEF:
+    Options.VectorLibrary = llvm::VectorLibrary::SLEEFGNUABI;
+    break;
+  case llvm::driver::VectorLibrary::ArmPL:
+    Options.VectorLibrary = llvm::VectorLibrary::ArmPL;
+    break;
+  case llvm::driver::VectorLibrary::AMDLIBM:
+    Options.VectorLibrary = llvm::VectorLibrary::AMDLIBM;
+    break;
+  }
+
   switch (CodeGenOpts.getSwiftAsyncFramePointer()) {
   case CodeGenOptions::SwiftAsyncFramePointerKind::Auto:
     Options.SwiftAsyncFramePointer =
@@ -584,6 +614,7 @@ static void setCommandLineOpts(const CodeGenOptions &CodeGenOpts,
     BackendArgs.push_back("-limit-float-precision");
     BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
   }
+
   // Check for the default "clang" invocation that won't set any cl::opt values.
   // Skip trying to parse the command line invocation to avoid the issues
   // described below.

cross-project-tests/CMakeLists.txt

@@ -104,6 +104,13 @@ add_lit_testsuite(check-cross-dtlto "Running DTLTO cross-project tests"
   DEPENDS ${CROSS_PROJECT_TEST_DEPS}
   )
 
+# veclib tests.
+add_lit_testsuite(check-cross-veclib "Running veclib cross-project tests"
+  ${CMAKE_CURRENT_BINARY_DIR}/veclib
+  EXCLUDE_FROM_CHECK_ALL
+  DEPENDS ${CROSS_PROJECT_TEST_DEPS}
+  )
+
 # Add check-cross-project-* targets.
 add_lit_testsuites(CROSS_PROJECT ${CMAKE_CURRENT_SOURCE_DIR}
   DEPENDS ${CROSS_PROJECT_TEST_DEPS}

cross-project-tests/veclib/lit.local.cfg

@@ -0,0 +1,2 @@
+if "clang" not in config.available_features:
+    config.unsupported = True

cross-project-tests/veclib/veclib-sincos.c

@@ -0,0 +1,21 @@
+// REQUIRES: aarch64-registered-target
+// RUN: %clang -S -target aarch64-unknown-linux-gnu -O2 -fno-math-errno \
+// RUN:  -fveclib=ArmPL -o - %s | FileCheck -check-prefix=ARMPL %s
+// RUN: %clang -S -target aarch64-unknown-linux-gnu -O2 -fno-math-errno \
+// RUN:  -fveclib=SLEEF -o - %s | FileCheck -check-prefix=SLEEF %s
+
+typedef __SIZE_TYPE__ size_t;
+
+void sincos(double, double *, double *);
+
+// ARMPL: armpl_vsincosq_f64
+// ARMPL: armpl_vsincosq_f64
+
+// SLEEF: _ZGVnN2vl8l8_sincos
+// SLEEF: _ZGVnN2vl8l8_sincos
+void vectorize_sincos(double *restrict x, double *restrict s,
+                      double *restrict c, size_t n) {
+  for (size_t i = 0; i < n; ++i) {
+    sincos(x[i], &s[i], &c[i]);
+  }
+}

llvm/include/llvm/Analysis/TargetLibraryInfo.h

@@ -14,6 +14,7 @@
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/IR/SystemLibraries.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/TargetParser/Triple.h"
@@ -23,7 +24,6 @@
 namespace llvm {
 
 template <typename T> class ArrayRef;
-enum class VectorLibrary;
 
 /// Provides info so a possible vectorization of a function can be
 /// computed. Function 'VectorFnName' is equivalent to 'ScalarFnName'
@@ -119,7 +119,8 @@ class TargetLibraryInfoImpl {
 
 public:
   TargetLibraryInfoImpl() = delete;
-  LLVM_ABI explicit TargetLibraryInfoImpl(const Triple &T);
+  LLVM_ABI explicit TargetLibraryInfoImpl(
+      const Triple &T, VectorLibrary VecLib = VectorLibrary::NoLibrary);
 
   // Provide value semantics.
   LLVM_ABI TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI);

llvm/include/llvm/CodeGen/CommandFlags.h

@@ -125,6 +125,8 @@ LLVM_ABI llvm::EABI getEABIVersion();
 
 LLVM_ABI llvm::DebuggerKind getDebuggerTuningOpt();
 
+LLVM_ABI llvm::VectorLibrary getVectorLibrary();
+
 LLVM_ABI bool getEnableStackSizeSection();
 
 LLVM_ABI bool getEnableAddrsig();

llvm/include/llvm/IR/RuntimeLibcalls.h

@@ -23,6 +23,7 @@
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/IR/SystemLibraries.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compiler.h"
@@ -83,7 +84,8 @@ struct RuntimeLibcallsInfo {
       const Triple &TT,
       ExceptionHandling ExceptionModel = ExceptionHandling::None,
       FloatABI::ABIType FloatABI = FloatABI::Default,
-      EABI EABIVersion = EABI::Default, StringRef ABIName = "");
+      EABI EABIVersion = EABI::Default, StringRef ABIName = "",
+      VectorLibrary VecLib = VectorLibrary::NoLibrary);
 
   explicit RuntimeLibcallsInfo(const Module &M);
 

llvm/include/llvm/IR/SystemLibraries.h

@@ -29,11 +29,6 @@ enum class VectorLibrary {
   AMDLIBM           // AMD Math Vector library.
 };
 
-/// Command line flag value for the vector math library to use
-///
-/// FIXME: This should come from a module flag, and not be mutually exclusive
-extern VectorLibrary ClVectorLibrary;
-
 } // namespace llvm
 
 #endif // LLVM_IR_SYSTEMLIBRARIES_H

llvm/include/llvm/Target/TargetOptions.h

@@ -15,6 +15,7 @@
 #define LLVM_TARGET_TARGETOPTIONS_H
 
 #include "llvm/ADT/FloatingPointMode.h"
+#include "llvm/IR/SystemLibraries.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compiler.h"
@@ -409,6 +410,9 @@ class TargetOptions {
   /// Which debugger to tune for.
   DebuggerKind DebuggerTuning = DebuggerKind::Default;
 
+  /// Vector math library to use.
+  VectorLibrary VectorLibrary = VectorLibrary::NoLibrary;
+
 private:
   /// Flushing mode to assume in default FP environment.
   DenormalMode FPDenormalMode;

llvm/lib/Analysis/TargetLibraryInfo.cpp

@@ -160,7 +160,8 @@ static void initializeBase(TargetLibraryInfoImpl &TLI, const Triple &T) {
 /// target triple. This should be carefully written so that a missing target
 /// triple gets a sane set of defaults.
 static void initializeLibCalls(TargetLibraryInfoImpl &TLI, const Triple &T,
-                               ArrayRef<StringLiteral> StandardNames) {
+                               ArrayRef<StringLiteral> StandardNames,
+                               VectorLibrary VecLib) {
   // Set IO unlocked variants as unavailable
   // Set them as available per system below
   TLI.setUnavailable(LibFunc_getc_unlocked);
@@ -924,23 +925,25 @@ static void initializeLibCalls(TargetLibraryInfoImpl &TLI, const Triple &T,
   if (T.isOSAIX())
     TLI.setUnavailable(LibFunc_memrchr);
 
-  TLI.addVectorizableFunctionsFromVecLib(ClVectorLibrary, T);
+  TLI.addVectorizableFunctionsFromVecLib(VecLib, T);
 }
 
 /// Initialize the set of available library functions based on the specified
 /// target triple. This should be carefully written so that a missing target
 /// triple gets a sane set of defaults.
 static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
-                       ArrayRef<StringLiteral> StandardNames) {
+                       ArrayRef<StringLiteral> StandardNames,
+                       VectorLibrary VecLib) {
   initializeBase(TLI, T);
-  initializeLibCalls(TLI, T, StandardNames);
+  initializeLibCalls(TLI, T, StandardNames, VecLib);
 }
 
-TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T) {
+TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T,
+                                             VectorLibrary VecLib) {
   // Default to everything being available.
   memset(AvailableArray, -1, sizeof(AvailableArray));
 
-  initialize(*this, T, StandardNames);
+  initialize(*this, T, StandardNames, VecLib);
 }
 
 TargetLibraryInfoImpl::TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI)