Merge commit '40d5eeac6cd8' from llvm.org/main into next

Author: git apple-llvm automerger

clang/lib/ARCMigrate/ARCMT.cpp

@@ -162,7 +162,9 @@ static bool HasARCRuntime(CompilerInvocation &origCI) {
     return triple.getOSMajorVersion() >= 11;
 
   if (triple.getOS() == llvm::Triple::MacOSX) {
-    return triple.getOSVersion() >= VersionTuple(10, 7);
+    unsigned Major, Minor, Micro;
+    triple.getOSVersion(Major, Minor, Micro);
+    return Major > 10 || (Major == 10 && Minor >= 7);
   }
 
   return false;

clang/lib/Basic/Targets/OSTargets.cpp

@@ -51,12 +51,12 @@ void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
     Builder.defineMacro("_REENTRANT");
 
   // Get the platform type and version number from the triple.
-  VersionTuple OsVersion;
+  unsigned Maj, Min, Rev;
   if (Triple.isMacOSX()) {
-    Triple.getMacOSXVersion(OsVersion);
+    Triple.getMacOSXVersion(Maj, Min, Rev);
     PlatformName = "macos";
   } else {
-    OsVersion = Triple.getOSVersion();
+    Triple.getOSVersion(Maj, Min, Rev);
     PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
     if (PlatformName == "ios" && Triple.isMacCatalystEnvironment())
       PlatformName = "maccatalyst";
@@ -66,29 +66,29 @@ void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
   // generating code for Win32 ABI. No need to emit
   // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
   if (PlatformName == "win32") {
-    PlatformMinVersion = OsVersion;
+    PlatformMinVersion = VersionTuple(Maj, Min, Rev);
     return;
   }
 
   // Set the appropriate OS version define.
   if (Triple.isiOS()) {
-    assert(OsVersion < VersionTuple(100) && "Invalid version!");
+    assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
     char Str[7];
-    if (OsVersion.getMajor() < 10) {
-      Str[0] = '0' + OsVersion.getMajor();
-      Str[1] = '0' + (OsVersion.getMinor().getValueOr(0) / 10);
-      Str[2] = '0' + (OsVersion.getMinor().getValueOr(0) % 10);
-      Str[3] = '0' + (OsVersion.getSubminor().getValueOr(0) / 10);
-      Str[4] = '0' + (OsVersion.getSubminor().getValueOr(0) % 10);
+    if (Maj < 10) {
+      Str[0] = '0' + Maj;
+      Str[1] = '0' + (Min / 10);
+      Str[2] = '0' + (Min % 10);
+      Str[3] = '0' + (Rev / 10);
+      Str[4] = '0' + (Rev % 10);
       Str[5] = '\0';
     } else {
       // Handle versions >= 10.
-      Str[0] = '0' + (OsVersion.getMajor() / 10);
-      Str[1] = '0' + (OsVersion.getMajor() % 10);
-      Str[2] = '0' + (OsVersion.getMinor().getValueOr(0) / 10);
-      Str[3] = '0' + (OsVersion.getMinor().getValueOr(0) % 10);
-      Str[4] = '0' + (OsVersion.getSubminor().getValueOr(0) / 10);
-      Str[5] = '0' + (OsVersion.getSubminor().getValueOr(0) % 10);
+      Str[0] = '0' + (Maj / 10);
+      Str[1] = '0' + (Maj % 10);
+      Str[2] = '0' + (Min / 10);
+      Str[3] = '0' + (Min % 10);
+      Str[4] = '0' + (Rev / 10);
+      Str[5] = '0' + (Rev % 10);
       Str[6] = '\0';
     }
     if (Triple.isTvOS())
@@ -98,36 +98,36 @@ void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
                           Str);
 
   } else if (Triple.isWatchOS()) {
-    assert(OsVersion < VersionTuple(10) && "Invalid version!");
+    assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
     char Str[6];
-    Str[0] = '0' + OsVersion.getMajor();
-    Str[1] = '0' + (OsVersion.getMinor().getValueOr(0) / 10);
-    Str[2] = '0' + (OsVersion.getMinor().getValueOr(0) % 10);
-    Str[3] = '0' + (OsVersion.getSubminor().getValueOr(0) / 10);
-    Str[4] = '0' + (OsVersion.getSubminor().getValueOr(0) % 10);
+    Str[0] = '0' + Maj;
+    Str[1] = '0' + (Min / 10);
+    Str[2] = '0' + (Min % 10);
+    Str[3] = '0' + (Rev / 10);
+    Str[4] = '0' + (Rev % 10);
     Str[5] = '\0';
     Builder.defineMacro("__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__", Str);
   } else if (Triple.isMacOSX()) {
     // Note that the Driver allows versions which aren't representable in the
     // define (because we only get a single digit for the minor and micro
     // revision numbers). So, we limit them to the maximum representable
     // version.
-    assert(OsVersion < VersionTuple(100) && "Invalid version!");
+    assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
     char Str[7];
-    if (OsVersion < VersionTuple(10, 10)) {
-      Str[0] = '0' + (OsVersion.getMajor() / 10);
-      Str[1] = '0' + (OsVersion.getMajor() % 10);
-      Str[2] = '0' + std::min(OsVersion.getMinor().getValueOr(0), 9U);
-      Str[3] = '0' + std::min(OsVersion.getSubminor().getValueOr(0), 9U);
+    if (Maj < 10 || (Maj == 10 && Min < 10)) {
+      Str[0] = '0' + (Maj / 10);
+      Str[1] = '0' + (Maj % 10);
+      Str[2] = '0' + std::min(Min, 9U);
+      Str[3] = '0' + std::min(Rev, 9U);
       Str[4] = '\0';
     } else {
       // Handle versions > 10.9.
-      Str[0] = '0' + (OsVersion.getMajor() / 10);
-      Str[1] = '0' + (OsVersion.getMajor() % 10);
-      Str[2] = '0' + (OsVersion.getMinor().getValueOr(0) / 10);
-      Str[3] = '0' + (OsVersion.getMinor().getValueOr(0) % 10);
-      Str[4] = '0' + (OsVersion.getSubminor().getValueOr(0) / 10);
-      Str[5] = '0' + (OsVersion.getSubminor().getValueOr(0) % 10);
+      Str[0] = '0' + (Maj / 10);
+      Str[1] = '0' + (Maj % 10);
+      Str[2] = '0' + (Min / 10);
+      Str[3] = '0' + (Min % 10);
+      Str[4] = '0' + (Rev / 10);
+      Str[5] = '0' + (Rev % 10);
       Str[6] = '\0';
     }
     Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
@@ -137,7 +137,7 @@ void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
   if (Triple.isOSDarwin())
     Builder.defineMacro("__MACH__");
 
-  PlatformMinVersion = OsVersion;
+  PlatformMinVersion = VersionTuple(Maj, Min, Rev);
 }
 
 static void addMinGWDefines(const llvm::Triple &Triple, const LangOptions &Opts,

clang/lib/Basic/Targets/OSTargets.h

@@ -148,7 +148,9 @@ class LLVM_LIBRARY_VISIBILITY DarwinTargetInfo : public OSTargetInfo<Target> {
       return 64;
     }
 
-    if (T.getOSVersion() < MinVersion)
+    unsigned Major, Minor, Micro;
+    T.getOSVersion(Major, Minor, Micro);
+    if (llvm::VersionTuple(Major, Minor, Micro) < MinVersion)
       return 64;
     return OSTargetInfo<Target>::getExnObjectAlignment();
   }
@@ -292,7 +294,7 @@ class LLVM_LIBRARY_VISIBILITY HaikuTargetInfo : public OSTargetInfo<Target> {
     Builder.defineMacro("__HAIKU__");
     Builder.defineMacro("__ELF__");
     DefineStd(Builder, "unix", Opts);
-    if (this->HasFloat128)
+    if (this->HasFloat128) 
       Builder.defineMacro("__FLOAT128__");
   }
 
@@ -374,9 +376,10 @@ class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> {
     Builder.defineMacro("__ELF__");
     if (Triple.isAndroid()) {
       Builder.defineMacro("__ANDROID__", "1");
+      unsigned Maj, Min, Rev;
+      Triple.getEnvironmentVersion(Maj, Min, Rev);
       this->PlatformName = "android";
-      this->PlatformMinVersion = Triple.getEnvironmentVersion();
-      const unsigned Maj = this->PlatformMinVersion.getMajor();
+      this->PlatformMinVersion = VersionTuple(Maj, Min, Rev);
       if (Maj) {
         Builder.defineMacro("__ANDROID_MIN_SDK_VERSION__", Twine(Maj));
         // This historical but ambiguous name for the minSdkVersion macro. Keep
@@ -690,32 +693,23 @@ class AIXTargetInfo : public OSTargetInfo<Target> {
     if (Opts.EnableAIXExtendedAltivecABI)
       Builder.defineMacro("__EXTABI__");
 
-    VersionTuple OsVersion = Triple.getOSVersion();
+    unsigned Major, Minor, Micro;
+    Triple.getOSVersion(Major, Minor, Micro);
 
     // Define AIX OS-Version Macros.
     // Includes logic for legacy versions of AIX; no specific intent to support.
-    if (OsVersion >= VersionTuple(3, 2))
-      Builder.defineMacro("_AIX32");
-    if (OsVersion >= VersionTuple(4, 1))
-      Builder.defineMacro("_AIX41");
-    if (OsVersion >= VersionTuple(4, 3))
-      Builder.defineMacro("_AIX43");
-    if (OsVersion >= VersionTuple(5, 0))
-      Builder.defineMacro("_AIX50");
-    if (OsVersion >= VersionTuple(5, 1))
-      Builder.defineMacro("_AIX51");
-    if (OsVersion >= VersionTuple(5, 2))
-      Builder.defineMacro("_AIX52");
-    if (OsVersion >= VersionTuple(5, 3))
-      Builder.defineMacro("_AIX53");
-    if (OsVersion >= VersionTuple(6, 1))
-      Builder.defineMacro("_AIX61");
-    if (OsVersion >= VersionTuple(7, 1))
-      Builder.defineMacro("_AIX71");
-    if (OsVersion >= VersionTuple(7, 2))
-      Builder.defineMacro("_AIX72");
-    if (OsVersion >= VersionTuple(7, 3))
-      Builder.defineMacro("_AIX73");
+    std::pair<int, int> OsVersion = {Major, Minor};
+    if (OsVersion >= std::make_pair(3, 2)) Builder.defineMacro("_AIX32");
+    if (OsVersion >= std::make_pair(4, 1)) Builder.defineMacro("_AIX41");
+    if (OsVersion >= std::make_pair(4, 3)) Builder.defineMacro("_AIX43");
+    if (OsVersion >= std::make_pair(5, 0)) Builder.defineMacro("_AIX50");
+    if (OsVersion >= std::make_pair(5, 1)) Builder.defineMacro("_AIX51");
+    if (OsVersion >= std::make_pair(5, 2)) Builder.defineMacro("_AIX52");
+    if (OsVersion >= std::make_pair(5, 3)) Builder.defineMacro("_AIX53");
+    if (OsVersion >= std::make_pair(6, 1)) Builder.defineMacro("_AIX61");
+    if (OsVersion >= std::make_pair(7, 1)) Builder.defineMacro("_AIX71");
+    if (OsVersion >= std::make_pair(7, 2)) Builder.defineMacro("_AIX72");
+    if (OsVersion >= std::make_pair(7, 3)) Builder.defineMacro("_AIX73");
 
     // FIXME: Do not define _LONG_LONG when -fno-long-long is specified.
     Builder.defineMacro("_LONG_LONG");

clang/lib/Basic/Targets/X86.h

@@ -472,9 +472,10 @@ class LLVM_LIBRARY_VISIBILITY NetBSDI386TargetInfo
       : NetBSDTargetInfo<X86_32TargetInfo>(Triple, Opts) {}
 
   unsigned getFloatEvalMethod() const override {
-    VersionTuple OsVersion = getTriple().getOSVersion();
+    unsigned Major, Minor, Micro;
+    getTriple().getOSVersion(Major, Minor, Micro);
     // New NetBSD uses the default rounding mode.
-    if (OsVersion >= VersionTuple(6, 99, 26) || OsVersion.getMajor() == 0)
+    if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 26) || Major == 0)
       return X86_32TargetInfo::getFloatEvalMethod();
     // NetBSD before 6.99.26 defaults to "double" rounding.
     return 1;

clang/lib/Driver/ToolChains/Darwin.cpp

@@ -1448,8 +1448,8 @@ static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion) {
   llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
   if (!SystemTriple.isMacOSX())
     return std::string(MacOSSDKVersion);
-  VersionTuple SystemVersion;
-  SystemTriple.getMacOSXVersion(SystemVersion);
+  SystemTriple.getMacOSXVersion(Major, Minor, Micro);
+  VersionTuple SystemVersion(Major, Minor, Micro);
   bool HadExtra;
   if (!Driver::GetReleaseVersion(MacOSSDKVersion, Major, Minor, Micro,
                                  HadExtra))
@@ -1590,10 +1590,12 @@ struct DarwinPlatform {
                    const Optional<DarwinSDKInfo> &SDKInfo) {
     DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
                           A);
-    VersionTuple OsVersion = TT.getOSVersion();
-    if (OsVersion.getMajor() == 0)
+    unsigned Major, Minor, Micro;
+    TT.getOSVersion(Major, Minor, Micro);
+    if (Major == 0)
       Result.HasOSVersion = false;
-    Result.setEnvironment(TT.getEnvironment(), OsVersion, SDKInfo);
+    Result.setEnvironment(TT.getEnvironment(),
+                          VersionTuple(Major, Minor, Micro), SDKInfo);
     return Result;
   }
   static DarwinPlatform
@@ -1839,7 +1841,7 @@ inferDeploymentTargetFromSDK(DerivedArgList &Args,
 
 std::string getOSVersion(llvm::Triple::OSType OS, const llvm::Triple &Triple,
                          const Driver &TheDriver) {
-  VersionTuple OsVersion;
+  unsigned Major, Minor, Micro;
   llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
   switch (OS) {
   case llvm::Triple::Darwin:
@@ -1848,32 +1850,32 @@ std::string getOSVersion(llvm::Triple::OSType OS, const llvm::Triple &Triple,
     // macos, use the host triple to infer OS version.
     if (Triple.isMacOSX() && SystemTriple.isMacOSX() &&
         !Triple.getOSMajorVersion())
-      SystemTriple.getMacOSXVersion(OsVersion);
-    else if (!Triple.getMacOSXVersion(OsVersion))
+      SystemTriple.getMacOSXVersion(Major, Minor, Micro);
+    else if (!Triple.getMacOSXVersion(Major, Minor, Micro))
       TheDriver.Diag(diag::err_drv_invalid_darwin_version)
           << Triple.getOSName();
     break;
   case llvm::Triple::IOS:
     if (Triple.isMacCatalystEnvironment() && !Triple.getOSMajorVersion()) {
-      OsVersion = VersionTuple(13, 1);
+      Major = 13;
+      Minor = 1;
+      Micro = 0;
     } else
-      OsVersion = Triple.getiOSVersion();
+      Triple.getiOSVersion(Major, Minor, Micro);
     break;
   case llvm::Triple::TvOS:
-    OsVersion = Triple.getOSVersion();
+    Triple.getOSVersion(Major, Minor, Micro);
     break;
   case llvm::Triple::WatchOS:
-    OsVersion = Triple.getWatchOSVersion();
+    Triple.getWatchOSVersion(Major, Minor, Micro);
     break;
   default:
     llvm_unreachable("Unexpected OS type");
     break;
   }
 
   std::string OSVersion;
-  llvm::raw_string_ostream(OSVersion)
-      << OsVersion.getMajor() << '.' << OsVersion.getMinor().getValueOr(0)
-      << '.' << OsVersion.getSubminor().getValueOr(0);
+  llvm::raw_string_ostream(OSVersion) << Major << '.' << Minor << '.' << Micro;
   return OSVersion;
 }
 
@@ -1943,13 +1945,15 @@ getDeploymentTargetFromMTargetOSArg(DerivedArgList &Args,
     return None;
   }
 
-  VersionTuple Version = TT.getOSVersion();
-  if (!Version.getMajor()) {
+  unsigned Major, Minor, Micro;
+  TT.getOSVersion(Major, Minor, Micro);
+  if (!Major) {
     TheDriver.Diag(diag::err_drv_invalid_version_number)
         << A->getAsString(Args);
     return None;
   }
-  return DarwinPlatform::createFromMTargetOS(TT.getOS(), Version,
+  return DarwinPlatform::createFromMTargetOS(TT.getOS(),
+                                             VersionTuple(Major, Minor, Micro),
                                              TT.getEnvironment(), A, SDKInfo);
 }
 

clang/lib/Driver/ToolChains/Linux.cpp

@@ -277,11 +277,14 @@ Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
     // Android sysroots contain a library directory for each supported OS
     // version as well as some unversioned libraries in the usual multiarch
     // directory.
-    addPathIfExists(
-        D,
-        SysRoot + "/usr/lib/" + MultiarchTriple + "/" +
-            llvm::to_string(Triple.getEnvironmentVersion().getMajor()),
-        Paths);
+    unsigned Major;
+    unsigned Minor;
+    unsigned Micro;
+    Triple.getEnvironmentVersion(Major, Minor, Micro);
+    addPathIfExists(D,
+                    SysRoot + "/usr/lib/" + MultiarchTriple + "/" +
+                        llvm::to_string(Major),
+                    Paths);
   }
 
   addPathIfExists(D, SysRoot + "/usr/lib/" + MultiarchTriple, Paths);

clang/lib/Driver/ToolChains/MSVC.cpp

@@ -1194,6 +1194,14 @@ bool MSVCToolChain::getUniversalCRTLibraryPath(const ArgList &Args,
   return true;
 }
 
+static VersionTuple getMSVCVersionFromTriple(const llvm::Triple &Triple) {
+  unsigned Major, Minor, Micro;
+  Triple.getEnvironmentVersion(Major, Minor, Micro);
+  if (Major || Minor || Micro)
+    return VersionTuple(Major, Minor, Micro);
+  return VersionTuple();
+}
+
 static VersionTuple getMSVCVersionFromExe(const std::string &BinDir) {
   VersionTuple Version;
 #ifdef _WIN32
@@ -1366,7 +1374,7 @@ VersionTuple MSVCToolChain::computeMSVCVersion(const Driver *D,
   bool IsWindowsMSVC = getTriple().isWindowsMSVCEnvironment();
   VersionTuple MSVT = ToolChain::computeMSVCVersion(D, Args);
   if (MSVT.empty())
-    MSVT = getTriple().getEnvironmentVersion();
+    MSVT = getMSVCVersionFromTriple(getTriple());
   if (MSVT.empty() && IsWindowsMSVC)
     MSVT = getMSVCVersionFromExe(getSubDirectoryPath(SubDirectoryType::Bin));
   if (MSVT.empty() &&