[llvm] infer rtlib from triple for codegen decisions

[nickdesaulniers]

Summary

alternative to https://reviews.llvm.org/D108928

https://discourse.llvm.org/t/proposal-split-built-ins-from-the-rest-of-compiler-rt/67978

To run unittests:

$ cd llvm/build; ninja UnitTests; cd -
$ ./llvm/build/unittests/TargetParser/TargetParserTests \
    --gtest_filter=TargetParserTest.getRTLib

[mstorsjo]

llvm/lib/TargetParser/Triple.cpp

1235

Depending on the actual use of this function, I think we'd need to be more careful than this, to only return a non-unknown value for the platforms where we're absolutely certain that there can't be any other choice. For platforms like apple and android, this probably is the case - possibly for some of the BSDs as well (not entirely sure).

At least for mingw targets (which do hit the isGNUEnvironment() at the top), toolchains with both libgcc and compiler-rt are in active use.

With the only use of getRTLib() as suggested in this patch, it's harmless to return libgcc (it'd be equal to returning unknown), but with the function in place, the function may be used in other ways too.

[nickdesaulniers]

• add unittest, slightly expand Triple::getRTLib with more cases.

[nickdesaulniers]

• use llvm::Triple::normalize to simplify tests

[nickdesaulniers]

• update description

[mstorsjo]

llvm/include/llvm/TargetParser/Triple.h

296

Some comments on the naming here...

There's really nothing like WINDOWS_RT - the OS itself doesn't have anything corresponding to it, but it's all a toolchain specific library - I think the most correct name for it right now would be VCRUNTIME.

Also as a nitpick/personal opinion, spelling it LIB_GCC feels weird to me, I'd just spell it LIBGCC.

llvm/lib/TargetParser/Triple.cpp

1235

Thanks - the change here seems to take care of my immediate concerns at least.

[phosek]

llvm/include/llvm/TargetParser/Triple.h

296

Another suggestion on the naming... we don't use ALL_CAPS for other enum values unless they're acronyms, so CompilerRT, Libgcc and VCRuntime would be more in line with the existing values.

llvm/include/llvm/TargetParser/Triple.h

enum ObjectFormatType {
     DXContainer,
     ELF,
     GOFF,
     MachO,
     SPIRV,
     Wasm,
     XCOFF,
   };
+  enum RTLibType {
+    UnknownRTLib,
+
+    COMPILER_RT,
+    LIB_GCC,
+    WINDOWS_RT,
+  };
 
 private:
   std::string Data;
 
   /// The parsed arch type.
   ArchType Arch{};
 
   /// The parsed subarchitecture type.
public:
   SubArchType getSubArch() const { return SubArch; }
 
   /// Get the parsed vendor type of this triple.
   VendorType getVendor() const { return Vendor; }
 
   /// Get the parsed operating system type of this triple.
   OSType getOS() const { return OS; }
 
+  /// Get the rtlib implied by this triple.
+  RTLibType getRTLib() const;
+
   /// Does this triple have the optional environment (fourth) component?
   bool hasEnvironment() const {
     return getEnvironmentName() != "";
   }
 
   /// Get the parsed environment type of this triple.
   EnvironmentType getEnvironment() const { return Environment; }
 

llvm/lib/Target/X86/X86ISelLowering.cpp

 
   if (!Subtarget.is64Bit()) {
     // These libcalls are not available in 32-bit.
     setLibcallName(RTLIB::SHL_I128, nullptr);
     setLibcallName(RTLIB::SRL_I128, nullptr);
     setLibcallName(RTLIB::SRA_I128, nullptr);
     setLibcallName(RTLIB::MUL_I128, nullptr);
     // The MULO libcall is not part of libgcc, only compiler-rt.
+    if (Subtarget.getTargetTriple().getRTLib() != Triple::COMPILER_RT)
       setLibcallName(RTLIB::MULO_I64, nullptr);
   }
   // The MULO libcall is not part of libgcc, only compiler-rt.
+  if (Subtarget.getTargetTriple().getRTLib() != Triple::COMPILER_RT)
     setLibcallName(RTLIB::MULO_I128, nullptr);
 
   // Combine sin / cos into _sincos_stret if it is available.
   if (getLibcallName(RTLIB::SINCOS_STRET_F32) != nullptr &&
       getLibcallName(RTLIB::SINCOS_STRET_F64) != nullptr) {
     setOperationAction(ISD::FSINCOS, MVT::f64, Custom);
     setOperationAction(ISD::FSINCOS, MVT::f32, Custom);
   }
 

llvm/lib/TargetParser/Triple.cpp

VersionTuple Triple::getOSVersion() const {
   if (OSName.startswith(OSTypeName))
     OSName = OSName.substr(OSTypeName.size());
   else if (getOS() == MacOSX)
     OSName.consume_front("macos");
 
   return parseVersionFromName(OSName);
 }
 
+Triple::RTLibType Triple::getRTLib() const {
+  if (isAndroid() || isOSDarwin() || isOSFuchsia())
+    return COMPILER_RT;
+
+  if (isGNUEnvironment()) {
+    if (isOSWindows())
+      return UnknownRTLib;
+    return LIB_GCC;
+  }
+
+  if (isOSWindows())
+    return WINDOWS_RT;
+
+  // TODO: more conditions, look at GetDefaultRuntimeLibType in clang for
+  // inspiration.
+  // Looks like AIX uses compiler-rt.
+  // "bare metal" uses compiler-rt.
+  // Fuchsia uses compiler-rt.
+  // openbsd uses compiler-rt.
+  // wasm uses compiler-rt.
+  return UnknownRTLib;
+}
+
 bool Triple::getMacOSXVersion(VersionTuple &Version) const {
   Version = getOSVersion();
 
   switch (getOS()) {
   default: llvm_unreachable("unexpected OS for Darwin triple");
   case Darwin:
     // Default to darwin8, i.e., MacOSX 10.4.
     if (Version.getMajor() == 0)

llvm/test/CodeGen/X86/overflow-intrinsic-optimizations.ll

-; RUN: llc %s -mtriple=i386 -o - | FileCheck %s
+; RUN: llc %s -mtriple=i386-linux-gnu -o - | FileCheck %s --check-prefix=CHECK-LIBGCC
+; RUN: llc %s -mtriple=i386 -o - | FileCheck %s --check-prefix=CHECK-COMPILERRT
 
 define i1 @no__mulodi4(i32 %a, i64 %b, ptr %c) {
 ; CHECK-LABEL: no__mulodi4:
-; CHECK-NOT: calll __mulodi4
+; CHECK-LIBGCC-NOT: calll __mulodi4
+; CHECK-COMPILERRT: calll __mulodi4
 entry:
   %0 = sext i32 %a to i64
   %1 = call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %0, i64 %b)
   %2 = extractvalue { i64, i1 } %1, 1
   %3 = extractvalue { i64, i1 } %1, 0
   %4 = trunc i64 %3 to i32
   %5 = sext i32 %4 to i64
   %6 = icmp ne i64 %3, %5
   %7 = or i1 %2, %6
   store i32 %4, ptr %c, align 4
   ret i1 %7
 }
 
 declare { i64, i1 } @llvm.smul.with.overflow.i64(i64, i64)

llvm/unittests/TargetParser/TargetParserTest.cpp

TEST(TargetParserTest, AArch64ArchExtFeature) {
   for (unsigned i = 0; i < std::size(ArchExt); i++) {
     EXPECT_EQ(StringRef(ArchExt[i][2]),
               AArch64::getArchExtFeature(ArchExt[i][0]));
     EXPECT_EQ(StringRef(ArchExt[i][3]),
               AArch64::getArchExtFeature(ArchExt[i][1]));
   }
 }
 
+static Triple::RTLibType RT(const char* triple) {
+  llvm::Triple Triple(llvm::Triple::normalize(triple));
+  return Triple.getRTLib();
+}
+
+TEST(TargetParserTest, getRTLib) {
+  const char* compiler_rt_triples [] = {
+    "aarch64-linux-android", "aarch64-apple-ios", "x86_64-fuchsia",
+  };
+  const char* lib_gcc_triples [] = {
+    "x86_64-linux-gnu",
+  };
+  const char* windows_rt_triples [] = {
+    "x86_64-pc-windows-msvc"
+  };
+  const char* unknown_rt_triples [] = {
+    "x86_64-w64-mingw32", "x86_64-pc-mingw32", "i386-pc-mingw32",
+    "i686-pc-mingw32", "x86_64-w64-windows-gnu", "i686-w64-windows-gnu"
+  };
+  for (const char* T : compiler_rt_triples)
+    EXPECT_EQ(RT(T), Triple::COMPILER_RT);
+  for (const char* T : lib_gcc_triples)
+    EXPECT_EQ(RT(T), Triple::LIB_GCC);
+  for (const char* T : windows_rt_triples)
+    EXPECT_EQ(RT(T), Triple::WINDOWS_RT);
+  for (const char* T : unknown_rt_triples)
+    EXPECT_EQ(RT(T), Triple::UnknownRTLib);
+}
+
 } // namespace