Use AIX version detection at LLVM run-time

[hubert.reinterpretcast]

Summary

AIX compilers define macros based on the version of the operating system.

This patch implements updating of versionless AIX triples to include the host AIX version. Also, the host triple detection in the build system is adjusted to strip the AIX version information so that the run-time detection is preferred.

[xingxue]

LGTM, thanks.

[hubert.reinterpretcast]

unittests/Support/Host.cpp

286 ↗

(On Diff #188803)

I am wondering if there is a more preferred way to suppress the warning. I don't think we're at the point of having maybe_unused available to us yet.

[hubert.reinterpretcast]

I'd be happy to commit this patch later this week, but I would appreciate suggestions on alternative methods to suppress the "unused" warning for the internal-linkage helper function.

llvm/trunk/cmake/modules/GetHostTriple.cmake

else( MSVC )
     set(config_guess ${LLVM_MAIN_SRC_DIR}/cmake/config.guess)
     execute_process(COMMAND sh ${config_guess}
       RESULT_VARIABLE TT_RV
       OUTPUT_VARIABLE TT_OUT
       OUTPUT_STRIP_TRAILING_WHITESPACE)
     if( NOT TT_RV EQUAL 0 )
       message(FATAL_ERROR "Failed to execute ${config_guess}")
     endif( NOT TT_RV EQUAL 0 )
-    set( value ${TT_OUT} )
+    # Defer to dynamic detection of the host AIX version.
+    string(REGEX REPLACE "-aix[0-9][^-]*" "-aix" value ${TT_OUT})
   endif( MSVC )
   set( ${var} ${value} PARENT_SCOPE )
 endfunction( get_host_triple var )

llvm/trunk/lib/Support/Unix/Host.inc

static std::string updateTripleOSVersion(std::string TargetTripleString) {
   std::string::size_type MacOSDashIdx = TargetTripleString.find("-macos");
   if (MacOSDashIdx != std::string::npos) {
     TargetTripleString.resize(MacOSDashIdx);
     // Reset the OS to darwin as the OS version from `uname` doesn't use the
     // macOS version scheme.
     TargetTripleString += "-darwin";
     TargetTripleString += getOSVersion();
   }
+  // On AIX, the AIX version and release should be that of the current host
+  // unless if the version has already been specified.
+  if (Triple(LLVM_HOST_TRIPLE).getOS() == Triple::AIX) {
+    Triple TT(TargetTripleString);
+    if (TT.getOS() == Triple::AIX && !TT.getOSMajorVersion()) {
+      struct utsname name;
+      if (uname(&name) != -1) {
+        std::string NewOSName = Triple::getOSTypeName(Triple::AIX);
+        NewOSName += name.version;
+        NewOSName += '.';
+        NewOSName += name.release;
+        NewOSName += ".0.0";
+        TT.setOSName(NewOSName);
+        return TT.str();
+      }
+    }
+  }
   return TargetTripleString;
 }
 
 std::string sys::getDefaultTargetTriple() {
   std::string TargetTripleString =
       updateTripleOSVersion(LLVM_DEFAULT_TARGET_TRIPLE);
 
   // Override the default target with an environment variable named by
   // LLVM_TARGET_TRIPLE_ENV.
 #if defined(LLVM_TARGET_TRIPLE_ENV)
   if (const char *EnvTriple = std::getenv(LLVM_TARGET_TRIPLE_ENV))
     TargetTripleString = EnvTriple;
 #endif
 
   return TargetTripleString;
 }

llvm/trunk/unittests/Support/Host.cpp

 //========- unittests/Support/Host.cpp - Host.cpp tests --------------========//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Host.h"
+#include "llvm/Config/llvm-config.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 
 #include "gtest/gtest.h"
 
EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderXT88ProcCpuInfo +
             "thunderxt88");
 
   // Verify HiSilicon processors.
   EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x48\n"
                                               "CPU part        : 0xd01"),
             "tsv110");
 }
 
-#if defined(__APPLE__)
-TEST_F(HostTest, getMacOSHostVersion) {
+static bool runAndGetCommandOutput(
+    const char *ExePath, ArrayRef<llvm::StringRef> argv,
+    std::unique_ptr<char[]> &Buffer, off_t &Size) {
+  bool Success = false;
+  [ExePath, argv, &Buffer, &Size, &Success] {
     using namespace llvm::sys;
-  llvm::Triple HostTriple(getProcessTriple());
-  if (!HostTriple.isMacOSX())
-    return;
-
     SmallString<128> TestDirectory;
     ASSERT_NO_ERROR(fs::createUniqueDirectory("host_test", TestDirectory));
+
     SmallString<128> OutputFile(TestDirectory);
     path::append(OutputFile, "out");
-
-  const char *SwVersPath = "/usr/bin/sw_vers";
-  StringRef argv[] = {SwVersPath, "-productVersion"};
     StringRef OutputPath = OutputFile.str();
-  const Optional<StringRef> Redirects[] = {/*STDIN=*/None,
-                                           /*STDOUT=*/OutputPath,
-                                           /*STDERR=*/None};
-  int RetCode = ExecuteAndWait(SwVersPath, argv, /*env=*/llvm::None, Redirects);
+
+    const Optional<StringRef> Redirects[] = {
+        /*STDIN=*/None, /*STDOUT=*/OutputPath, /*STDERR=*/None};
+    int RetCode = ExecuteAndWait(ExePath, argv, /*env=*/llvm::None, Redirects);
     ASSERT_EQ(0, RetCode);
 
     int FD = 0;
     ASSERT_NO_ERROR(fs::openFileForRead(OutputPath, FD));
-  off_t Size = ::lseek(FD, 0, SEEK_END);
+    Size = ::lseek(FD, 0, SEEK_END);
     ASSERT_NE(-1, Size);
     ::lseek(FD, 0, SEEK_SET);
-  std::unique_ptr<char[]> Buffer = llvm::make_unique<char[]>(Size);
+    Buffer = llvm::make_unique<char[]>(Size);
     ASSERT_EQ(::read(FD, Buffer.get(), Size), Size);
     ::close(FD);
 
-  // Ensure that the two versions match.
+    ASSERT_NO_ERROR(fs::remove(OutputPath));
+    ASSERT_NO_ERROR(fs::remove(TestDirectory.str()));
+    Success = true;
+  }();
+  return Success;
+}
+
+TEST_F(HostTest, DummyRunAndGetCommandOutputUse) {
+  // Suppress defined-but-not-used warnings when the tests using the helper are
+  // disabled.
+  (void) runAndGetCommandOutput;
+}
+
+#if defined(__APPLE__)
+TEST_F(HostTest, getMacOSHostVersion) {
+  using namespace llvm::sys;
+  llvm::Triple HostTriple(getProcessTriple());
+  if (!HostTriple.isMacOSX())
+    return;
+
+  const char *SwVersPath = "/usr/bin/sw_vers";
+  StringRef argv[] = {SwVersPath, "-productVersion"};
+  std::unique_ptr<char[]> Buffer;
+  off_t Size;
+  ASSERT_EQ(runAndGetCommandOutput(SwVersPath, argv, Buffer, Size), true);
   StringRef SystemVersion(Buffer.get(), Size);
+
+  // Ensure that the two versions match.
   unsigned SystemMajor, SystemMinor, SystemMicro;
   ASSERT_EQ(llvm::Triple((Twine("x86_64-apple-macos") + SystemVersion))
                 .getMacOSXVersion(SystemMajor, SystemMinor, SystemMicro),
             true);
   unsigned HostMajor, HostMinor, HostMicro;
   ASSERT_EQ(HostTriple.getMacOSXVersion(HostMajor, HostMinor, HostMicro), true);
 
   // Don't compare the 'Micro' version, as it's always '0' for the 'Darwin'
   // triples.
   ASSERT_EQ(std::tie(SystemMajor, SystemMinor), std::tie(HostMajor, HostMinor));
+}
+#endif
 
-  ASSERT_NO_ERROR(fs::remove(OutputPath));
-  ASSERT_NO_ERROR(fs::remove(TestDirectory.str()));
+#if defined(_AIX)
+TEST_F(HostTest, AIXVersionDetect) {
+  using namespace llvm::sys;
+
+  llvm::Triple HostTriple(getProcessTriple());
+  ASSERT_EQ(HostTriple.getOS(), Triple::AIX);
+
+  llvm::Triple ConfiguredHostTriple(LLVM_HOST_TRIPLE);
+  ASSERT_EQ(ConfiguredHostTriple.getOS(), Triple::AIX);
+
+  const char *ExePath = "/usr/bin/oslevel";
+  StringRef argv[] = {ExePath};
+  std::unique_ptr<char[]> Buffer;
+  off_t Size;
+  ASSERT_EQ(runAndGetCommandOutput(ExePath, argv, Buffer, Size), true);
+  StringRef SystemVersion(Buffer.get(), Size);
+
+  unsigned SystemMajor, SystemMinor, SystemMicro;
+  llvm::Triple((Twine("powerpc-ibm-aix") + SystemVersion))
+      .getOSVersion(SystemMajor, SystemMinor, SystemMicro);
+
+  // Ensure that the host triple version (major) and release (minor) numbers,
+  // unless explicitly configured, match with those of the current system.
+  if (!ConfiguredHostTriple.getOSMajorVersion()) {
+    unsigned HostMajor, HostMinor, HostMicro;
+    HostTriple.getOSVersion(HostMajor, HostMinor, HostMicro);
+    ASSERT_EQ(std::tie(SystemMajor, SystemMinor),
+              std::tie(HostMajor, HostMinor));
+  }
+
+  llvm::Triple TargetTriple(getDefaultTargetTriple());
+  if (TargetTriple.getOS() != Triple::AIX)
+    return;
+
+  // Ensure that the target triple version (major) and release (minor) numbers
+  // match with those of the current system.
+  llvm::Triple ConfiguredTargetTriple(LLVM_DEFAULT_TARGET_TRIPLE);
+  if (ConfiguredTargetTriple.getOSMajorVersion())
+    return; // The version was configured explicitly; skip.
+
+  unsigned TargetMajor, TargetMinor, TargetMicro;
+  TargetTriple.getOSVersion(TargetMajor, TargetMinor, TargetMicro);
+  ASSERT_EQ(std::tie(SystemMajor, SystemMinor),
+            std::tie(TargetMajor, TargetMinor));
 }
 #endif