Use llvm::VersionTuple instead of manual version marshalling

[labath]

Summary

This has multiple advantages:

• we need only one function argument/instance variable instead of three
• no need to default initialize variables
• no custom parsing code
• VersionTuple has comparison operators, which makes version comparisons much simpler

I think this touches a lot of code which is not very well tested, so I'd
appreciate it if you can double-check the transformations in the code that you
are familiar with.

[labath]

Fix a typo in netbsd code.

[aprantl]

Just FYI, I just came across this patch while debugging strangeness in PlatformDarwin.cpp and unfortunately this patch isn't NFC. VersionTuple::tryParse() can deal with an optional third (micro) component, but the parse will fail when there are extra characters after the version number (in my case trying to parse the substring "12.0.sdk" out of "iPhoneSimulator12.0.sdk" now fails after this patch). I'll fix it and try to add a unit test ...

lldb/trunk/include/lldb/Core/Module.h

public:
   ///
   /// If the Section file addresses for a module are updated, this method
   /// should be called.  Any parts of the module, object file, or symbol file
   /// that has cached those file addresses must invalidate or update its
   /// cache.
   //------------------------------------------------------------------
   virtual void SectionFileAddressesChanged();
 
-  uint32_t GetVersion(uint32_t *versions, uint32_t num_versions);
+  llvm::VersionTuple GetVersion();
 
   //------------------------------------------------------------------
   /// Load an object file from memory.
   ///
   /// If available, the size of the object file in memory may be passed to
   /// avoid additional round trips to process memory. If the size is not
   /// provided, a default value is used. This value should be large enough to
   /// enable the ObjectFile plugins to read the header of the object file

lldb/trunk/include/lldb/Host/freebsd/HostInfoFreeBSD.h

 //===-- HostInfoFreeBSD.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_freebsd_HostInfoFreeBSD_h_
 #define lldb_Host_freebsd_HostInfoFreeBSD_h_
 
 #include "lldb/Host/posix/HostInfoPosix.h"
 #include "lldb/Utility/FileSpec.h"
+#include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class HostInfoFreeBSD : public HostInfoPosix {
 public:
-  static bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update);
+  static llvm::VersionTuple GetOSVersion();
   static bool GetOSBuildString(std::string &s);
   static bool GetOSKernelDescription(std::string &s);
   static FileSpec GetProgramFileSpec();
 };
 }
 
 #endif

lldb/trunk/include/lldb/Host/linux/HostInfoLinux.h

 //===-- HostInfoLinux.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_linux_HostInfoLinux_h_
 #define lldb_Host_linux_HostInfoLinux_h_
 
 #include "lldb/Host/posix/HostInfoPosix.h"
 #include "lldb/Utility/FileSpec.h"
-
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/VersionTuple.h"
 
 #include <string>
 
 namespace lldb_private {
 
 class HostInfoLinux : public HostInfoPosix {
   friend class HostInfoBase;
 
 private:
   // Static class, unconstructable.
   HostInfoLinux();
   ~HostInfoLinux();
 
 public:
   static void Initialize();
 
-  static bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update);
+  static llvm::VersionTuple GetOSVersion();
   static bool GetOSBuildString(std::string &s);
   static bool GetOSKernelDescription(std::string &s);
   static llvm::StringRef GetDistributionId();
   static FileSpec GetProgramFileSpec();
 
 protected:
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static bool ComputeSystemPluginsDirectory(FileSpec &file_spec);
   static bool ComputeUserPluginsDirectory(FileSpec &file_spec);
   static void ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                              ArchSpec &arch_64);
 };
 }
 
 #endif

lldb/trunk/include/lldb/Host/macosx/HostInfoMacOSX.h

 //===-- HostInfoMacOSX.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_macosx_HostInfoMacOSX_h_
 #define lldb_Host_macosx_HostInfoMacOSX_h_
 
 #include "lldb/Host/posix/HostInfoPosix.h"
 #include "lldb/Utility/FileSpec.h"
+#include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class ArchSpec;
 
 class HostInfoMacOSX : public HostInfoPosix {
   friend class HostInfoBase;
 
 private:
   // Static class, unconstructable.
   HostInfoMacOSX();
   ~HostInfoMacOSX();
 
 public:
-  static bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update);
+  static llvm::VersionTuple GetOSVersion();
   static bool GetOSBuildString(std::string &s);
   static bool GetOSKernelDescription(std::string &s);
   static FileSpec GetProgramFileSpec();
 
 protected:
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static void ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                              ArchSpec &arch_64);
   static bool ComputeHeaderDirectory(FileSpec &file_spec);
   static bool ComputePythonDirectory(FileSpec &file_spec);
   static bool ComputeSystemPluginsDirectory(FileSpec &file_spec);
   static bool ComputeUserPluginsDirectory(FileSpec &file_spec);
 };
 }
 
 #endif

lldb/trunk/include/lldb/Host/netbsd/HostInfoNetBSD.h

 //===-- HostInfoNetBSD.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_netbsd_HostInfoNetBSD_h_
 #define lldb_Host_netbsd_HostInfoNetBSD_h_
 
 #include "lldb/Host/posix/HostInfoPosix.h"
 #include "lldb/Utility/FileSpec.h"
+#include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class HostInfoNetBSD : public HostInfoPosix {
 public:
-  static bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update);
+  static llvm::VersionTuple GetOSVersion();
   static bool GetOSBuildString(std::string &s);
   static bool GetOSKernelDescription(std::string &s);
   static FileSpec GetProgramFileSpec();
 };
 }
 
 #endif

lldb/trunk/include/lldb/Host/windows/HostInfoWindows.h

 //===-- HostInfoWindows.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_windows_HostInfoWindows_h_
 #define lldb_Host_windows_HostInfoWindows_h_
 
 #include "lldb/Host/HostInfoBase.h"
 #include "lldb/Utility/FileSpec.h"
+#include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class HostInfoWindows : public HostInfoBase {
   friend class HostInfoBase;
 
 private:
   // Static class, unconstructable.
   HostInfoWindows();
   ~HostInfoWindows();
 
 public:
   static void Initialize();
   static void Terminate();
 
   static size_t GetPageSize();
 
-  static bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update);
+  static llvm::VersionTuple GetOSVersion();
   static bool GetOSBuildString(std::string &s);
   static bool GetOSKernelDescription(std::string &s);
   static bool GetHostname(std::string &s);
   static FileSpec GetProgramFileSpec();
   static FileSpec GetDefaultShell();
 
   static bool GetEnvironmentVar(const std::string &var_name, std::string &var);
 

lldb/trunk/include/lldb/Interpreter/OptionGroupPlatform.h

 #define liblldb_OptionGroupPlatform_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Utility/ConstString.h"
+#include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 //-------------------------------------------------------------------------
 // PlatformOptionGroup
 //
 // Make platform options available to any commands that need the settings.
 //-------------------------------------------------------------------------
 class OptionGroupPlatform : public OptionGroup {
 public:
   OptionGroupPlatform(bool include_platform_option)
       : OptionGroup(), m_platform_name(), m_sdk_sysroot(),
-        m_os_version_major(UINT32_MAX), m_os_version_minor(UINT32_MAX),
-        m_os_version_update(UINT32_MAX),
         m_include_platform_option(include_platform_option) {}
 
   ~OptionGroupPlatform() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                         ExecutionContext *execution_context) override;
public:
   void SetSDKBuild(const ConstString &sdk_build) { m_sdk_build = sdk_build; }
 
   bool PlatformMatches(const lldb::PlatformSP &platform_sp) const;
 
 protected:
   std::string m_platform_name;
   ConstString m_sdk_sysroot;
   ConstString m_sdk_build;
-  uint32_t m_os_version_major;
-  uint32_t m_os_version_minor;
-  uint32_t m_os_version_update;
+  llvm::VersionTuple m_os_version;
   bool m_include_platform_option;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionGroupPlatform_h_

lldb/trunk/include/lldb/Symbol/ObjectFile.h

 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/UnwindTable.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-private.h"
+#include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class ObjectFileJITDelegate {
 public:
   ObjectFileJITDelegate() {}
 
   virtual ~ObjectFileJITDelegate() {}
public:
   //------------------------------------------------------------------
   /// Get the object file version numbers.
   ///
   /// Many object files have a set of version numbers that describe the
   /// version of the executable or shared library. Typically there are major,
   /// minor and build, but there may be more. This function will extract the
   /// versions from object files if they are available.
   ///
-  /// If \a versions is NULL, or if \a num_versions is 0, the return value
-  /// will indicate how many version numbers are available in this object
-  /// file. Then a subsequent call can be made to this function with a value
-  /// of \a versions and \a num_versions that has enough storage to store some
-  /// or all version numbers.
-  ///
-  /// @param[out] versions
-  ///     A pointer to an array of uint32_t types that is \a num_versions
-  ///     long. If this value is NULL, the return value will indicate
-  ///     how many version numbers are required for a subsequent call
-  ///     to this function so that all versions can be retrieved. If
-  ///     the value is non-NULL, then at most \a num_versions of the
-  ///     existing versions numbers will be filled into \a versions.
-  ///     If there is no version information available, \a versions
-  ///     will be filled with \a num_versions UINT32_MAX values
-  ///     and zero will be returned.
-  ///
-  /// @param[in] num_versions
-  ///     The maximum number of entries to fill into \a versions. If
-  ///     this value is zero, then the return value will indicate
-  ///     how many version numbers there are in total so another call
-  ///     to this function can be make with adequate storage in
-  ///     \a versions to get all of the version numbers. If \a
-  ///     num_versions is less than the actual number of version
-  ///     numbers in this object file, only \a num_versions will be
-  ///     filled into \a versions (if \a versions is non-NULL).
-  ///
-  /// @return
-  ///     This function always returns the number of version numbers
-  ///     that this object file has regardless of the number of
-  ///     version numbers that were copied into \a versions.
+  /// @return
+  ///     This function returns extracted version numbers as a
+  ///     llvm::VersionTuple. In case of error an empty VersionTuple is
+  ///     returned.
   //------------------------------------------------------------------
-  virtual uint32_t GetVersion(uint32_t *versions, uint32_t num_versions) {
-    if (versions && num_versions) {
-      for (uint32_t i = 0; i < num_versions; ++i)
-        versions[i] = UINT32_MAX;
-    }
-    return 0;
-  }
+  virtual llvm::VersionTuple GetVersion() { return llvm::VersionTuple(); }
 
   //------------------------------------------------------------------
   /// Get the minimum OS version this object file can run on.
   ///
   /// Some object files have information that specifies the minimum OS version
   /// that they can be used on.
   ///
-  /// If \a versions is NULL, or if \a num_versions is 0, the return value
-  /// will indicate how many version numbers are available in this object
-  /// file. Then a subsequent call can be made to this function with a value
-  /// of \a versions and \a num_versions that has enough storage to store some
-  /// or all version numbers.
-  ///
-  /// @param[out] versions
-  ///     A pointer to an array of uint32_t types that is \a num_versions
-  ///     long. If this value is NULL, the return value will indicate
-  ///     how many version numbers are required for a subsequent call
-  ///     to this function so that all versions can be retrieved. If
-  ///     the value is non-NULL, then at most \a num_versions of the
-  ///     existing versions numbers will be filled into \a versions.
-  ///     If there is no version information available, \a versions
-  ///     will be filled with \a num_versions UINT32_MAX values
-  ///     and zero will be returned.
-  ///
-  /// @param[in] num_versions
-  ///     The maximum number of entries to fill into \a versions. If
-  ///     this value is zero, then the return value will indicate
-  ///     how many version numbers there are in total so another call
-  ///     to this function can be make with adequate storage in
-  ///     \a versions to get all of the version numbers. If \a
-  ///     num_versions is less than the actual number of version
-  ///     numbers in this object file, only \a num_versions will be
-  ///     filled into \a versions (if \a versions is non-NULL).
-  ///
-  /// @return
-  ///     This function always returns the number of version numbers
-  ///     that this object file has regardless of the number of
-  ///     version numbers that were copied into \a versions.
+  /// @return
+  ///     This function returns extracted version numbers as a
+  ///     llvm::VersionTuple. In case of error an empty VersionTuple is
+  ///     returned.
   //------------------------------------------------------------------
-  virtual uint32_t GetMinimumOSVersion(uint32_t *versions,
-                                       uint32_t num_versions) {
-    if (versions && num_versions) {
-      for (uint32_t i = 0; i < num_versions; ++i)
-        versions[i] = UINT32_MAX;
-    }
-    return 0;
+  virtual llvm::VersionTuple GetMinimumOSVersion() {
+    return llvm::VersionTuple();
   }
 
   //------------------------------------------------------------------
   /// Get the SDK OS version this object file was built with.
   ///
   /// The versions arguments and returns values are the same as the
   /// GetMinimumOSVersion()
   //------------------------------------------------------------------

lldb/trunk/include/lldb/Target/Platform.h

 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Timeout.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-public.h"
+#include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class ModuleCache;
 enum MmapFlags { eMmapFlagsPrivate = 1, eMmapFlagsAnon = 2 };
 
 class PlatformProperties : public Properties {
 public:
public:
   /// Get the OS version from a connected platform.
   ///
   /// Some platforms might not be connected to a remote platform, but can
   /// figure out the OS version for a process. This is common for simulator
   /// platforms that will run native programs on the current host, but the
   /// simulator might be simulating a different OS. The \a process parameter
   /// might be specified to help to determine the OS version.
   //------------------------------------------------------------------
-  virtual bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update,
-                            Process *process = nullptr);
+  virtual llvm::VersionTuple GetOSVersion(Process *process = nullptr);
 
-  bool SetOSVersion(uint32_t major, uint32_t minor, uint32_t update);
+  bool SetOSVersion(llvm::VersionTuple os_version);
 
   bool GetOSBuildString(std::string &s);
 
   bool GetOSKernelDescription(std::string &s);
 
   // Returns the name of the platform
   ConstString GetName();
 
protected:
   bool m_system_arch_set_while_connected;
   ConstString
       m_sdk_sysroot; // the root location of where the SDK files are all located
   ConstString m_sdk_build;
   FileSpec m_working_dir; // The working directory which is used when installing
                           // modules that have no install path set
   std::string m_remote_url;
   std::string m_name;
-  uint32_t m_major_os_version;
-  uint32_t m_minor_os_version;
-  uint32_t m_update_os_version;
+  llvm::VersionTuple m_os_version;
   ArchSpec
       m_system_arch; // The architecture of the kernel or the remote platform
   typedef std::map<uint32_t, ConstString> IDToNameMap;
   // Mutex for modifying Platform data structures that should only be used for
   // non-reentrant code
   std::mutex m_mutex;
   IDToNameMap m_uid_map;
   IDToNameMap m_gid_map;

lldb/trunk/include/lldb/Target/Process.h

 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/TraceOptions.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 template <typename B, typename S> struct Range;
 
 //----------------------------------------------------------------------
 // ProcessProperties
 //----------------------------------------------------------------------
#endif
   /// Sometimes the connection to a process can detect the host OS version
   /// that the process is running on. The current platform should be checked
   /// first in case the platform is connected, but clients can fall back onto
   /// this function if the platform fails to identify the host OS version. The
   /// platform should be checked first in case you are running a simulator
   /// platform that might itself be running natively, but have different
   /// heuristics for figuring out which OS is is emulating.
   ///
-  /// @param[out] major
-  ///    The major OS version, or UINT32_MAX if it can't be determined
-  ///
-  /// @param[out] minor
-  ///    The minor OS version, or UINT32_MAX if it can't be determined
-  ///
-  /// @param[out] update
-  ///    The update OS version, or UINT32_MAX if it can't be determined
-  ///
   /// @return
-  ///     Returns \b true if the host OS version info was filled in
-  ///     and \b false otherwise.
+  ///     Returns the version tuple of the host OS. In case of failure an empty
+  ///     VersionTuple is returner.
   //------------------------------------------------------------------
-  virtual bool GetHostOSVersion(uint32_t &major, uint32_t &minor,
-                                uint32_t &update) {
-    major = UINT32_MAX;
-    minor = UINT32_MAX;
-    update = UINT32_MAX;
-    return false;
-  }
+  virtual llvm::VersionTuple GetHostOSVersion() { return llvm::VersionTuple(); }
 
   //------------------------------------------------------------------
   /// Get the target object pointer for this module.
   ///
   /// @return
   ///     A Target object pointer to the target that owns this
   ///     module.
   //------------------------------------------------------------------

lldb/trunk/include/lldb/Utility/Args.h

public:
   }
 
   static lldb::Encoding
   StringToEncoding(llvm::StringRef s,
                    lldb::Encoding fail_value = lldb::eEncodingInvalid);
 
   static uint32_t StringToGenericRegister(llvm::StringRef s);
 
-  static bool StringToVersion(llvm::StringRef string, uint32_t &major,
-                              uint32_t &minor, uint32_t &update);
-
   static const char *GetShellSafeArgument(const FileSpec &shell,
                                           const char *unsafe_arg,
                                           std::string &safe_arg);
 
   // EncodeEscapeSequences will change the textual representation of common
   // escape sequences like "\n" (two characters) into a single '\n'. It does
   // this for all of the supported escaped sequences and for the \0ooo (octal)
   // and \xXX (hex). The resulting "dst" string will contain the character

lldb/trunk/source/API/SBModule.cpp

 uint32_t SBModule::GetAddressByteSize() {
   ModuleSP module_sp(GetSP());
   if (module_sp)
     return module_sp->GetArchitecture().GetAddressByteSize();
   return sizeof(void *);
 }
 
 uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {
-  ModuleSP module_sp(GetSP());
-  if (module_sp)
-    return module_sp->GetVersion(versions, num_versions);
-  else {
-    if (versions && num_versions) {
-      for (uint32_t i = 0; i < num_versions; ++i)
-        versions[i] = UINT32_MAX;
-    }
-    return 0;
-  }
+  llvm::VersionTuple version;
+  if (ModuleSP module_sp = GetSP())
+    version = module_sp->GetVersion();
+  uint32_t result = 0;
+  if (!version.empty())
+    ++result;
+  if (version.getMinor())
+    ++result;
+  if(version.getSubminor())
+    ++result;
+
+  if (!versions)
+    return result;
+
+  if (num_versions > 0)
+    versions[0] = version.empty() ? UINT32_MAX : version.getMajor();
+  if (num_versions > 1)
+    versions[1] = version.getMinor().getValueOr(UINT32_MAX);
+  if (num_versions > 2)
+    versions[2] = version.getSubminor().getValueOr(UINT32_MAX);
+  for (uint32_t i = 3; i < num_versions; ++i)
+  return result;
 }
 
 lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
   lldb::SBFileSpec sb_file_spec;
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     SymbolVendor *symbol_vendor_ptr = module_sp->GetSymbolVendor();
     if (symbol_vendor_ptr)

lldb/trunk/source/API/SBPlatform.cpp

 const char *SBPlatform::GetHostname() {
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
     return platform_sp->GetHostname();
   return NULL;
 }
 
 uint32_t SBPlatform::GetOSMajorVersion() {
-  uint32_t major, minor, update;
-  PlatformSP platform_sp(GetSP());
-  if (platform_sp && platform_sp->GetOSVersion(major, minor, update))
-    return major;
-  return UINT32_MAX;
+  llvm::VersionTuple version;
+  if (PlatformSP platform_sp = GetSP())
+    version = platform_sp->GetOSVersion();
+  return version.empty() ? UINT32_MAX : version.getMajor();
 }
 
 uint32_t SBPlatform::GetOSMinorVersion() {
-  uint32_t major, minor, update;
-  PlatformSP platform_sp(GetSP());
-  if (platform_sp && platform_sp->GetOSVersion(major, minor, update))
-    return minor;
-  return UINT32_MAX;
+  llvm::VersionTuple version;
+  if (PlatformSP platform_sp = GetSP())
+    version = platform_sp->GetOSVersion();
+  return version.getMinor().getValueOr(UINT32_MAX);
 }
 
 uint32_t SBPlatform::GetOSUpdateVersion() {
-  uint32_t major, minor, update;
-  PlatformSP platform_sp(GetSP());
-  if (platform_sp && platform_sp->GetOSVersion(major, minor, update))
-    return update;
-  return UINT32_MAX;
+  llvm::VersionTuple version;
+  if (PlatformSP platform_sp = GetSP())
+    version = platform_sp->GetOSVersion();
+  return version.getSubminor().getValueOr(UINT32_MAX);
 }
 
 SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     sb_error.ref() = platform_sp->GetFile(src.ref(), dst.ref());
   } else {

lldb/trunk/source/Core/Module.cpp

 }
 
 bool Module::RemapSourceFile(llvm::StringRef path,
                              std::string &new_path) const {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   return m_source_mappings.RemapPath(path, new_path);
 }
 
-uint32_t Module::GetVersion(uint32_t *versions, uint32_t num_versions) {
-  ObjectFile *obj_file = GetObjectFile();
-  if (obj_file)
-    return obj_file->GetVersion(versions, num_versions);
-
-  if (versions != nullptr && num_versions != 0) {
-    for (uint32_t i = 0; i < num_versions; ++i)
-      versions[i] = LLDB_INVALID_MODULE_VERSION;
-  }
-  return 0;
+llvm::VersionTuple Module::GetVersion() {
+  if (ObjectFile *obj_file = GetObjectFile())
+    return obj_file->GetVersion();
+  return llvm::VersionTuple();
 }
 
 bool Module::GetIsDynamicLinkEditor() {
   ObjectFile *obj_file = GetObjectFile();
 
   if (obj_file)
     return obj_file->GetIsDynamicLinkEditor();
 
   return false;
 }

lldb/trunk/source/Host/freebsd/HostInfoFreeBSD.cpp

 #include <string.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
 #include <unistd.h>
 
 using namespace lldb_private;
 
-bool HostInfoFreeBSD::GetOSVersion(uint32_t &major, uint32_t &minor,
-                                   uint32_t &update) {
+llvm::VersionTuple HostInfoFreeBSD::GetOSVersion() {
   struct utsname un;
 
   ::memset(&un, 0, sizeof(utsname));
   if (uname(&un) < 0)
     return false;
 
-  int status = sscanf(un.release, "%u.%u", &major, &minor);
-  return status == 2;
+  unsigned major, minor;
+  if (2 == sscanf(un.release, "%u.%u", &major, &minor))
+    return llvm::VersionTuple(major, minor);
+  return llvm::VersionTuple();
 }
 
 bool HostInfoFreeBSD::GetOSBuildString(std::string &s) {
   int mib[2] = {CTL_KERN, KERN_OSREV};
   char osrev_str[12];
   uint32_t osrev = 0;
   size_t osrev_len = sizeof(osrev);
 
if (!g_program_filespec) {
     if (sysctl(exe_path_mib, 4, NULL, &exe_path_size, NULL, 0) == 0) {
       char *exe_path = new char[exe_path_size];
       if (sysctl(exe_path_mib, 4, exe_path, &exe_path_size, NULL, 0) == 0)
         g_program_filespec.SetFile(exe_path, false, FileSpec::Style::native);
       delete[] exe_path;
     }
   }
   return g_program_filespec;
-}
+}
 

lldb/trunk/source/Host/linux/HostInfoLinux.cpp

 
 #include <algorithm>
 #include <mutex> // std::once
 
 using namespace lldb_private;
 
 namespace {
 struct HostInfoLinuxFields {
-  HostInfoLinuxFields() : m_os_major(0), m_os_minor(0), m_os_update(0) {}
-
   std::string m_distribution_id;
-  uint32_t m_os_major;
-  uint32_t m_os_minor;
-  uint32_t m_os_update;
+  llvm::VersionTuple m_os_version;
 };
 
 HostInfoLinuxFields *g_fields = nullptr;
 }
 
 void HostInfoLinux::Initialize() {
   HostInfoPosix::Initialize();
 
   g_fields = new HostInfoLinuxFields();
 }
 
-bool HostInfoLinux::GetOSVersion(uint32_t &major, uint32_t &minor,
-                                 uint32_t &update) {
-  static bool success = false;
+llvm::VersionTuple HostInfoLinux::GetOSVersion() {
   static llvm::once_flag g_once_flag;
   llvm::call_once(g_once_flag, []() {
-
     struct utsname un;
-    if (uname(&un) == 0) {
-      int status = sscanf(un.release, "%u.%u.%u", &g_fields->m_os_major,
-                          &g_fields->m_os_minor, &g_fields->m_os_update);
-      if (status == 3)
-        success = true;
-      else {
-        // Some kernels omit the update version, so try looking for just "X.Y"
-        // and set update to 0.
-        g_fields->m_os_update = 0;
-        status = sscanf(un.release, "%u.%u", &g_fields->m_os_major,
-                        &g_fields->m_os_minor);
-        if (status == 2)
-          success = true;
-      }
-    }
+    if (uname(&un) != 0)
+      return;
+
+    llvm::StringRef release = un.release;
+    // The kernel release string can include a lot of stuff (e.g.
+    // 4.9.0-6-amd64). We're only interested in the numbered prefix.
+    release = release.substr(0, release.find_first_not_of("0123456789."));
+    g_fields->m_os_version.tryParse(release);
   });
 
-  major = g_fields->m_os_major;
-  minor = g_fields->m_os_minor;
-  update = g_fields->m_os_update;
-  return success;
+  return g_fields->m_os_version;
 }
 
 bool HostInfoLinux::GetOSBuildString(std::string &s) {
   struct utsname un;
   ::memset(&un, 0, sizeof(utsname));
   s.clear();
 
   if (uname(&un) < 0)

lldb/trunk/source/Host/macosx/objcxx/HostInfoMacOSX.mm

bool HostInfoMacOSX::GetOSKernelDescription(std::string &s) {
   if (::sysctl(mib, 2, cstr, &cstr_len, NULL, 0) == 0) {
     s.assign(cstr, cstr_len);
     return true;
   }
   s.clear();
   return false;
 }
 
-bool HostInfoMacOSX::GetOSVersion(uint32_t &major, uint32_t &minor,
-                                  uint32_t &update) {
-  static uint32_t g_major = 0;
-  static uint32_t g_minor = 0;
-  static uint32_t g_update = 0;
+llvm::VersionTuple HostInfoMacOSX::GetOSVersion() {
+  static llvm::VersionTuple g_version;
 
-  if (g_major == 0) {
+  if (g_version.empty()) {
     @autoreleasepool {
       NSDictionary *version_info = [NSDictionary
           dictionaryWithContentsOfFile:
               @"/System/Library/CoreServices/SystemVersion.plist"];
       NSString *version_value = [version_info objectForKey:@"ProductVersion"];
       const char *version_str = [version_value UTF8String];
-      if (version_str)
-        Args::StringToVersion(llvm::StringRef(version_str), g_major, g_minor,
-                              g_update);
+      g_version.tryParse(version_str);
     }
   }
 
-  if (g_major != 0) {
-    major = g_major;
-    minor = g_minor;
-    update = g_update;
-    return true;
-  }
-  return false;
+  return g_version;
 }
 
 FileSpec HostInfoMacOSX::GetProgramFileSpec() {
   static FileSpec g_program_filespec;
   if (!g_program_filespec) {
     char program_fullpath[PATH_MAX];
     // If DST is NULL, then return the number of bytes needed.
     uint32_t len = sizeof(program_fullpath);

lldb/trunk/source/Host/netbsd/HostInfoNetBSD.cpp

 #include <string.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
 #include <unistd.h>
 
 using namespace lldb_private;
 
-bool HostInfoNetBSD::GetOSVersion(uint32_t &major, uint32_t &minor,
-                                  uint32_t &update) {
+llvm::VersionTuple HostInfoNetBSD::GetOSVersion() {
   struct utsname un;
 
   ::memset(&un, 0, sizeof(un));
   if (::uname(&un) < 0)
     return false;
 
   /* Accept versions like 7.99.21 and 6.1_STABLE */
   int status = ::sscanf(un.release, "%" PRIu32 ".%" PRIu32 ".%" PRIu32, &major,
                         &minor, &update);
   switch (status) {
-  case 0:
-    return false;
   case 1:
-    minor = 0;
-  /* FALLTHROUGH */
+    return llvm::VersionTuple(major);
   case 2:
-    update = 0;
-  /* FALLTHROUGH */
+    return llvm::VersionTuple(major, minor);
   case 3:
-  default:
-    return true;
+    return llvm::VersionTuple(major, minor, update);
   }
+  return llvm::VersionTuple();
 }
 
 bool HostInfoNetBSD::GetOSBuildString(std::string &s) {
   int mib[2] = {CTL_KERN, KERN_OSREV};
   char osrev_str[12];
   int osrev = 0;
   size_t osrev_len = sizeof(osrev);
 

lldb/trunk/source/Host/windows/HostInfoWindows.cpp

 }
 
 size_t HostInfoWindows::GetPageSize() {
   SYSTEM_INFO systemInfo;
   GetNativeSystemInfo(&systemInfo);
   return systemInfo.dwPageSize;
 }
 
-bool HostInfoWindows::GetOSVersion(uint32_t &major, uint32_t &minor,
-                                   uint32_t &update) {
+llvm::VersionTuple HostInfoWindows::GetOSVersion() {
   OSVERSIONINFOEX info;
 
   ZeroMemory(&info, sizeof(OSVERSIONINFOEX));
   info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
 #pragma warning(push)
 #pragma warning(disable : 4996)
   // Starting with Microsoft SDK for Windows 8.1, this function is deprecated
   // in favor of the new Windows Version Helper APIs.  Since we don't specify a
   // minimum SDK version, it's easier to simply disable the warning rather than
   // try to support both APIs.
-  if (GetVersionEx((LPOSVERSIONINFO)&info) == 0) {
-    return false;
-  }
+  if (GetVersionEx((LPOSVERSIONINFO)&info) == 0)
+    return llvm::VersionTuple();
 #pragma warning(pop)
 
-  major = info.dwMajorVersion;
-  minor = info.dwMinorVersion;
-  update = info.wServicePackMajor;
-
-  return true;
+  return llvm::VersionTuple(info.dwMajorVersion, info.dwMinorVersion,
+                            info.wServicePackMajor);
 }
 
 bool HostInfoWindows::GetOSBuildString(std::string &s) {
   s.clear();
   uint32_t major, minor, update;
   if (!GetOSVersion(major, minor, update))
     return false;
 

lldb/trunk/source/Interpreter/OptionGroupPlatform.cpp

if (!m_platform_name.empty()) {
     }
   } else if (arch.IsValid()) {
     platform_sp = Platform::Create(arch, &platform_arch, error);
   }
 
   if (platform_sp) {
     interpreter.GetDebugger().GetPlatformList().Append(platform_sp,
                                                        make_selected);
-    if (m_os_version_major != UINT32_MAX) {
-      platform_sp->SetOSVersion(m_os_version_major, m_os_version_minor,
-                                m_os_version_update);
-    }
+    if (!m_os_version.empty())
+      platform_sp->SetOSVersion(m_os_version);
 
     if (m_sdk_sysroot)
       platform_sp->SetSDKRootDirectory(m_sdk_sysroot);
 
     if (m_sdk_build)
       platform_sp->SetSDKBuild(m_sdk_build);
   }
 
   return platform_sp;
 }
 
 void OptionGroupPlatform::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_platform_name.clear();
   m_sdk_sysroot.Clear();
   m_sdk_build.Clear();
-  m_os_version_major = UINT32_MAX;
-  m_os_version_minor = UINT32_MAX;
-  m_os_version_update = UINT32_MAX;
+  m_os_version = llvm::VersionTuple();
 }
 
 static OptionDefinition g_option_table[] = {
     {LLDB_OPT_SET_ALL, false, "platform", 'p', OptionParser::eRequiredArgument,
      nullptr, nullptr, 0, eArgTypePlatform, "Specify name of the platform to "
                                             "use for this target, creating the "
                                             "platform if necessary."},
     {LLDB_OPT_SET_ALL, false, "version", 'v', OptionParser::eRequiredArgument,
OptionGroupPlatform::SetOptionValue(uint32_t option_idx,
   const int short_option = g_option_table[option_idx].short_option;
 
   switch (short_option) {
   case 'p':
     m_platform_name.assign(option_arg);
     break;
 
   case 'v':
-    if (!Args::StringToVersion(option_arg, m_os_version_major,
-                               m_os_version_minor, m_os_version_update))
-      error.SetErrorStringWithFormat("invalid version string '%s'",
-                                     option_arg.str().c_str());
+    if (m_os_version.tryParse(option_arg))
+      error.SetErrorStringWithFormatv("invalid version string '{0}'",
+                                      option_arg);
     break;
 
   case 'b':
     m_sdk_build.SetString(option_arg);
     break;
 
   case 'S':
     m_sdk_sysroot.SetString(option_arg);
if (platform_sp) {
     }
 
     if (m_sdk_build && m_sdk_build != platform_sp->GetSDKBuild())
       return false;
 
     if (m_sdk_sysroot && m_sdk_sysroot != platform_sp->GetSDKRootDirectory())
       return false;
 
-    if (m_os_version_major != UINT32_MAX) {
-      uint32_t major, minor, update;
-      if (platform_sp->GetOSVersion(major, minor, update)) {
-        if (m_os_version_major != major)
-          return false;
-        if (m_os_version_minor != minor)
-          return false;
-        if (m_os_version_update != update)
-          return false;
-      }
-    }
+    if (!m_os_version.empty() && m_os_version != platform_sp->GetOSVersion())
     return true;
   }
   return false;
 }

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

if (target.ReadMemory(tls_addr, false, buf, tsl_data_size, error) ==
       }
     }
   }
   return LLDB_INVALID_ADDRESS;
 }
 
 bool DynamicLoaderDarwin::UseDYLDSPI(Process *process) {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-  uint32_t major, minor, update;
-
   bool use_new_spi_interface = false;
 
-  if (process->GetHostOSVersion(major, minor, update)) {
+  llvm::VersionTuple version = process->GetHostOSVersion();
+  if (!version.empty()) {
     const llvm::Triple::OSType os_type =
         process->GetTarget().GetArchitecture().GetTriple().getOS();
 
     // macOS 10.12 and newer
     if (os_type == llvm::Triple::MacOSX &&
-        (major > 10 || (major == 10 && minor >= 12))) {
+        version >= llvm::VersionTuple(10, 12))
       use_new_spi_interface = true;
-    }
 
     // iOS 10 and newer
-    if (os_type == llvm::Triple::IOS && major >= 10) {
+    if (os_type == llvm::Triple::IOS && version >= llvm::VersionTuple(10))
       use_new_spi_interface = true;
-    }
 
     // tvOS 10 and newer
-    if (os_type == llvm::Triple::TvOS && major >= 10) {
+    if (os_type == llvm::Triple::TvOS && version >= llvm::VersionTuple(10))
       use_new_spi_interface = true;
-    }
 
     // watchOS 3 and newer
-    if (os_type == llvm::Triple::WatchOS && major >= 3) {
+    if (os_type == llvm::Triple::WatchOS && version >= llvm::VersionTuple(3))
       use_new_spi_interface = true;
-    }
-  }
 
   if (log) {
     if (use_new_spi_interface)
       log->Printf(
           "DynamicLoaderDarwin::UseDYLDSPI: Use new DynamicLoader plugin");
     else
       log->Printf(
           "DynamicLoaderDarwin::UseDYLDSPI: Use old DynamicLoader plugin");
   }
   return use_new_spi_interface;
 }

lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

 }
 
 // Returns true if the load bias reported by the linker is incorrect for the
 // given entry. This function is used to handle cases where we want to work
 // around a bug in the system linker.
 static bool isLoadBiasIncorrect(Target &target, const std::string &file_path) {
   // On Android L (API 21, 22) the load address of the "/system/bin/linker"
   // isn't filled in correctly.
-  uint32_t os_major = 0, os_minor = 0, os_update = 0;
+  unsigned os_major = target.GetPlatform()->GetOSVersion().getMajor();
   if (target.GetArchitecture().GetTriple().isAndroid() &&
-      target.GetPlatform()->GetOSVersion(os_major, os_minor, os_update) &&
       (os_major == 21 || os_major == 22) &&
       (file_path == "/system/bin/linker" ||
        file_path == "/system/bin/linker64")) {
     return true;
   }
 
   return false;
 }

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

bool AppleObjCRuntime::AppleIsModuleObjCLibrary(const ModuleSP &module_sp) {
   return false;
 }
 
 // we use the version of Foundation to make assumptions about the ObjC runtime
 // on a target
 uint32_t AppleObjCRuntime::GetFoundationVersion() {
   if (!m_Foundation_major.hasValue()) {
     const ModuleList &modules = m_process->GetTarget().GetImages();
-    uint32_t major = UINT32_MAX;
     for (uint32_t idx = 0; idx < modules.GetSize(); idx++) {
       lldb::ModuleSP module_sp = modules.GetModuleAtIndex(idx);
       if (!module_sp)
         continue;
       if (strcmp(module_sp->GetFileSpec().GetFilename().AsCString(""),
                  "Foundation") == 0) {
-        module_sp->GetVersion(&major, 1);
-        m_Foundation_major = major;
-        return major;
+        m_Foundation_major = module_sp->GetVersion().getMajor();
+        return *m_Foundation_major;
       }
     }
     return LLDB_INVALID_MODULE_VERSION;
   } else
     return m_Foundation_major.getValue();
 }
 
 void AppleObjCRuntime::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,

lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

public:
 
   lldb::RegisterContextSP
   GetThreadContextAtIndex(uint32_t idx, lldb_private::Thread &thread) override;
 
   ObjectFile::Type CalculateType() override;
 
   ObjectFile::Strata CalculateStrata() override;
 
-  uint32_t GetVersion(uint32_t *versions, uint32_t num_versions) override;
+  llvm::VersionTuple GetVersion() override;
 
-  uint32_t GetMinimumOSVersion(uint32_t *versions,
-                               uint32_t num_versions) override;
+  llvm::VersionTuple GetMinimumOSVersion() override;
 
   uint32_t GetSDKVersion(uint32_t *versions, uint32_t num_versions) override;
 
   bool GetIsDynamicLinkEditor() override;
 
   static bool ParseHeader(lldb_private::DataExtractor &data,
                           lldb::offset_t *data_offset_ptr,
                           llvm::MachO::mach_header &header);
protected:
   static const lldb_private::ConstString &GetSegmentNameDATA_CONST();
   static const lldb_private::ConstString &GetSegmentNameOBJC();
   static const lldb_private::ConstString &GetSegmentNameLINKEDIT();
   static const lldb_private::ConstString &GetSectionNameEHFrame();
 
   llvm::MachO::dysymtab_command m_dysymtab;
   std::vector<llvm::MachO::segment_command_64> m_mach_segments;
   std::vector<llvm::MachO::section_64> m_mach_sections;
-  std::vector<uint32_t> m_min_os_versions;
+  llvm::Optional<llvm::VersionTuple> m_min_os_version;
   std::vector<uint32_t> m_sdk_versions;
   typedef lldb_private::RangeVector<uint32_t, uint32_t> FileRangeArray;
   lldb_private::Address m_entry_point_address;
   FileRangeArray m_thread_context_offsets;
   bool m_thread_context_offsets_valid;
   lldb_private::FileSpecList m_reexported_dylibs;
   bool m_allow_assembly_emulation_unwind_plans;
 };
 
 #endif // liblldb_ObjectFileMachO_h_

lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

ObjectFile::Strata ObjectFileMachO::CalculateStrata() {
   case MH_KEXT_BUNDLE:
     return eStrataKernel; // 0xBu
   default:
     break;
   }
   return eStrataUnknown;
 }
 
-uint32_t ObjectFileMachO::GetVersion(uint32_t *versions,
-                                     uint32_t num_versions) {
+llvm::VersionTuple ObjectFileMachO::GetVersion() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     struct dylib_command load_cmd;
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     uint32_t version_cmd = 0;
     uint64_t version = 0;
     uint32_t i;
for (i = 0; i < m_header.ncmds; ++i) {
         }
         break; // Break for now unless there is another more complete version
                // number load command in the future.
       }
       offset = cmd_offset + load_cmd.cmdsize;
     }
 
     if (version_cmd == LC_ID_DYLIB) {
-      if (versions != NULL && num_versions > 0) {
-        if (num_versions > 0)
-          versions[0] = (version & 0xFFFF0000ull) >> 16;
-        if (num_versions > 1)
-          versions[1] = (version & 0x0000FF00ull) >> 8;
-        if (num_versions > 2)
-          versions[2] = (version & 0x000000FFull);
-        // Fill in an remaining version numbers with invalid values
-        for (i = 3; i < num_versions; ++i)
-          versions[i] = UINT32_MAX;
-      }
-      // The LC_ID_DYLIB load command has a version with 3 version numbers in
-      // it, so always return 3
-      return 3;
+      unsigned major = (version & 0xFFFF0000ull) >> 16;
+      unsigned minor = (version & 0x0000FF00ull) >> 8;
+      unsigned subminor = (version & 0x000000FFull);
+      return llvm::VersionTuple(major, minor, subminor);
     }
   }
-  return false;
+  return llvm::VersionTuple();
 }
 
 bool ObjectFileMachO::GetArchitecture(ArchSpec &arch) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     return GetArchitecture(m_header, m_data,
                            MachHeaderSizeFromMagic(m_header.magic), arch);
if (dyld_get_all_image_infos) {
     }
   }
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS | LIBLLDB_LOG_PROCESS));
   if (log && uuid.IsValid())
     log->Printf("lldb's in-memory shared cache has a UUID of %s base address of 0x%" PRIx64, uuid.GetAsString().c_str(), base_addr);
 #endif
 }
 
-uint32_t ObjectFileMachO::GetMinimumOSVersion(uint32_t *versions,
-                                              uint32_t num_versions) {
-  if (m_min_os_versions.empty()) {
+llvm::VersionTuple ObjectFileMachO::GetMinimumOSVersion() {
+  if (!m_min_os_version) {
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
-    bool success = false;
-    for (uint32_t i = 0; success == false && i < m_header.ncmds; ++i) {
+    for (uint32_t i = 0; i < m_header.ncmds; ++i) {
       const lldb::offset_t load_cmd_offset = offset;
 
       version_min_command lc;
       if (m_data.GetU32(&offset, &lc.cmd, 2) == NULL)
         break;
       if (lc.cmd == llvm::MachO::LC_VERSION_MIN_MACOSX ||
           lc.cmd == llvm::MachO::LC_VERSION_MIN_IPHONEOS ||
           lc.cmd == llvm::MachO::LC_VERSION_MIN_TVOS ||
           lc.cmd == llvm::MachO::LC_VERSION_MIN_WATCHOS) {
         if (m_data.GetU32(&offset, &lc.version,
                           (sizeof(lc) / sizeof(uint32_t)) - 2)) {
           const uint32_t xxxx = lc.version >> 16;
           const uint32_t yy = (lc.version >> 8) & 0xffu;
           const uint32_t zz = lc.version & 0xffu;
           if (xxxx) {
-            m_min_os_versions.push_back(xxxx);
-            m_min_os_versions.push_back(yy);
-            m_min_os_versions.push_back(zz);
+            m_min_os_version = llvm::VersionTuple(xxxx, yy, zz);
+            break;
           }
-          success = true;
         }
       }
       offset = load_cmd_offset + lc.cmdsize;
     }
 
-    if (success == false) {
-      // Push an invalid value so we don't keep trying to
-      m_min_os_versions.push_back(UINT32_MAX);
+    if (!m_min_os_version) {
+      // Set version to an empty value so we don't keep trying to
+      m_min_os_version = llvm::VersionTuple();
     }
   }
 
-  if (m_min_os_versions.size() > 1 || m_min_os_versions[0] != UINT32_MAX) {
-    if (versions != NULL && num_versions > 0) {
-      for (size_t i = 0; i < num_versions; ++i) {
-        if (i < m_min_os_versions.size())
-          versions[i] = m_min_os_versions[i];
-        else
-          versions[i] = 0;
-      }
-    }
-    return m_min_os_versions.size();
-  }
-  // Call the superclasses version that will empty out the data
-  return ObjectFile::GetMinimumOSVersion(versions, num_versions);
+  return *m_min_os_version;
 }
 
 uint32_t ObjectFileMachO::GetSDKVersion(uint32_t *versions,
                                         uint32_t num_versions) {
   if (m_sdk_versions.empty()) {
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     bool success = false;
     for (uint32_t i = 0; success == false && i < m_header.ncmds; ++i) {

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.cpp

Status PlatformAndroid::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
   if (error.Fail())
     return Status("Oatdump failed: %s", error.AsCString());
 
   // Download the symbolfile from the remote device
   return GetFile(symfile_platform_filespec, dst_file_spec);
 }
 
 bool PlatformAndroid::GetRemoteOSVersion() {
-  m_major_os_version = GetSdkVersion();
-  m_minor_os_version = 0;
-  m_update_os_version = 0;
-  return m_major_os_version != 0;
+  m_os_version = llvm::VersionTuple(GetSdkVersion());
+  return !m_os_version.empty();
 }
 
 llvm::StringRef
 PlatformAndroid::GetLibdlFunctionDeclarations(lldb_private::Process *process) {
   SymbolContextList matching_symbols;
   std::vector<const char *> dl_open_names = { "__dl_dlopen", "dlopen" };
   const char *dl_open_name = nullptr;
   Target &target = process->GetTarget();

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.h

public:
   bool x86GetSupportedArchitectureAtIndex(uint32_t idx,
                                           lldb_private::ArchSpec &arch);
 
   int32_t GetResumeCountForLaunchInfo(
       lldb_private::ProcessLaunchInfo &launch_info) override;
 
   void CalculateTrapHandlerSymbolNames() override;
 
-  bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update,
-                    lldb_private::Process *process = nullptr) override;
+  llvm::VersionTuple
+  GetOSVersion(lldb_private::Process *process = nullptr) override;
 
   bool SupportsModules() override { return true; }
 
   lldb_private::ConstString
   GetFullNameForDylib(lldb_private::ConstString basename) override;
 
   lldb_private::FileSpec LocateExecutable(const char *basename) override;
 
   lldb_private::Status
   LaunchProcess(lldb_private::ProcessLaunchInfo &launch_info) override;
 
-  static std::tuple<uint32_t, uint32_t, uint32_t, llvm::StringRef>
+  static std::tuple<llvm::VersionTuple, llvm::StringRef>
   ParseVersionBuildDir(llvm::StringRef str);
 
 protected:
   void ReadLibdispatchOffsetsAddress(lldb_private::Process *process);
 
   void ReadLibdispatchOffsets(lldb_private::Process *process);
 
   virtual lldb_private::Status GetSharedModuleWithLocalCache(
       const lldb_private::ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
       const lldb_private::FileSpecList *module_search_paths_ptr,
       lldb::ModuleSP *old_module_sp_ptr, bool *did_create_ptr);
 
   enum class SDKType {
     MacOSX = 0,
     iPhoneSimulator,
     iPhoneOS,
   };
 
-  static bool SDKSupportsModules(SDKType sdk_type, uint32_t major,
-                                 uint32_t minor, uint32_t micro);
+  static bool SDKSupportsModules(SDKType sdk_type, llvm::VersionTuple version);
 
   static bool SDKSupportsModules(SDKType desired_type,
                                  const lldb_private::FileSpec &sdk_path);
 
   struct SDKEnumeratorInfo {
     lldb_private::FileSpec found_path;
     SDKType sdk_type;
   };

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

if (!g_xcode_filespec) {
         }
       }
     }
   });
 
   return g_xcode_filespec;
 }
 
-bool PlatformDarwin::SDKSupportsModules(SDKType sdk_type, uint32_t major,
-                                        uint32_t minor, uint32_t micro) {
+bool PlatformDarwin::SDKSupportsModules(SDKType sdk_type,
+                                        llvm::VersionTuple version) {
   switch (sdk_type) {
   case SDKType::MacOSX:
-    if (major > 10 || (major == 10 && minor >= 10))
-      return true;
-    break;
+    return version >= llvm::VersionTuple(10, 10);
   case SDKType::iPhoneOS:
   case SDKType::iPhoneSimulator:
-    if (major >= 8)
-      return true;
-    break;
+    return version >= llvm::VersionTuple(8);
   }
 
   return false;
 }
 
 bool PlatformDarwin::SDKSupportsModules(SDKType desired_type,
                                         const FileSpec &sdk_path) {
   ConstString last_path_component = sdk_path.GetLastPathComponent();
 
   if (last_path_component) {
     const llvm::StringRef sdk_name = last_path_component.GetStringRef();
 
     llvm::StringRef version_part;
 
     if (sdk_name.startswith(sdk_strings[(int)desired_type])) {
       version_part =
           sdk_name.drop_front(strlen(sdk_strings[(int)desired_type]));
     } else {
       return false;
     }
 
-    const size_t major_dot_offset = version_part.find('.');
-    if (major_dot_offset == llvm::StringRef::npos)
+    llvm::VersionTuple version;
+    if (version.tryParse(version_part))
       return false;
-
-    const llvm::StringRef major_version =
-        version_part.slice(0, major_dot_offset);
-    const llvm::StringRef minor_part =
-        version_part.drop_front(major_dot_offset + 1);
-
-    const size_t minor_dot_offset = minor_part.find('.');
-    if (minor_dot_offset == llvm::StringRef::npos)
-      return false;
-
-    const llvm::StringRef minor_version = minor_part.slice(0, minor_dot_offset);
-
-    unsigned int major = 0;
-    unsigned int minor = 0;
-    unsigned int micro = 0;
-
-    if (major_version.getAsInteger(10, major))
-      return false;
-
-    if (minor_version.getAsInteger(10, minor))
-      return false;
-
-    return SDKSupportsModules(desired_type, major, minor, micro);
+    return SDKSupportsModules(desired_type, version);
   }
 
   return false;
 }
 
 FileSpec::EnumerateDirectoryResult PlatformDarwin::DirectoryEnumerator(
     void *baton, llvm::sys::fs::file_type file_type, const FileSpec &spec) {
   SDKEnumeratorInfo *enumerator_info = static_cast<SDKEnumeratorInfo *>(baton);
case SDKType::iPhoneOS:
     sdks_spec.AppendPathComponent("iPhoneOS.platform");
     break;
   }
 
   sdks_spec.AppendPathComponent("Developer");
   sdks_spec.AppendPathComponent("SDKs");
 
   if (sdk_type == SDKType::MacOSX) {
-    uint32_t major = 0;
-    uint32_t minor = 0;
-    uint32_t micro = 0;
+    llvm::VersionTuple version = HostInfo::GetOSVersion();
 
-    if (HostInfo::GetOSVersion(major, minor, micro)) {
-      if (SDKSupportsModules(SDKType::MacOSX, major, minor, micro)) {
+    if (!version.empty()) {
+      if (SDKSupportsModules(SDKType::MacOSX, version)) {
         // We slightly prefer the exact SDK for this machine.  See if it is
         // there.
 
         FileSpec native_sdk_spec = sdks_spec;
         StreamString native_sdk_name;
-        native_sdk_name.Printf("MacOSX%u.%u.sdk", major, minor);
+        native_sdk_name.Printf("MacOSX%u.%u.sdk", version.getMajor(),
+                               version.getMinor().getValueOr(0));
         native_sdk_spec.AppendPathComponent(native_sdk_name.GetString());
 
         if (native_sdk_spec.Exists()) {
           return native_sdk_spec;
         }
       }
     }
   }
 
   return FindSDKInXcodeForModules(sdk_type, sdks_spec);
 }
 
-std::tuple<uint32_t, uint32_t, uint32_t, llvm::StringRef>
+std::tuple<llvm::VersionTuple, llvm::StringRef>
 PlatformDarwin::ParseVersionBuildDir(llvm::StringRef dir) {
-  uint32_t major, minor, update;
   llvm::StringRef build;
   llvm::StringRef version_str;
   llvm::StringRef build_str;
   std::tie(version_str, build_str) = dir.split(' ');
-  if (Args::StringToVersion(version_str, major, minor, update) ||
+  llvm::VersionTuple version;
+  if (!version.tryParse(version_str) ||
       build_str.empty()) {
     if (build_str.consume_front("(")) {
       size_t pos = build_str.find(')');
       build = build_str.slice(0, pos);
     }
   }
 
-  return std::make_tuple(major, minor, update, build);
+  return std::make_tuple(version, build);
 }
 
 void PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
     Target *target, std::vector<std::string> &options, SDKType sdk_type) {
   const std::vector<std::string> apple_arguments = {
       "-x",       "objective-c++", "-fobjc-arc",
       "-fblocks", "-D_ISO646_H",   "-D__ISO646_H"};
 
   options.insert(options.end(), apple_arguments.begin(), apple_arguments.end());
 
   StreamString minimum_version_option;
-  uint32_t versions[3] = {0, 0, 0};
   bool use_current_os_version = false;
   switch (sdk_type) {
   case SDKType::iPhoneOS:
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
     use_current_os_version = true;
 #else
     use_current_os_version = false;
 #endif
     break;
 
   case SDKType::iPhoneSimulator:
     use_current_os_version = false;
     break;
 
   case SDKType::MacOSX:
 #if defined(__i386__) || defined(__x86_64__)
     use_current_os_version = true;
 #else
     use_current_os_version = false;
 #endif
     break;
   }
 
-  bool versions_valid = false;
+  llvm::VersionTuple version;
   if (use_current_os_version)
-    versions_valid = GetOSVersion(versions[0], versions[1], versions[2]);
+    version = GetOSVersion();
   else if (target) {
     // Our OS doesn't match our executable so we need to get the min OS version
     // from the object file
     ModuleSP exe_module_sp = target->GetExecutableModule();
     if (exe_module_sp) {
       ObjectFile *object_file = exe_module_sp->GetObjectFile();
       if (object_file)
-        versions_valid = object_file->GetMinimumOSVersion(versions, 3) > 0;
+        version = object_file->GetMinimumOSVersion();
     }
   }
   // Only add the version-min options if we got a version from somewhere
-  if (versions_valid && versions[0] != UINT32_MAX) {
-    // Make any invalid versions be zero if needed
-    if (versions[1] == UINT32_MAX)
-      versions[1] = 0;
-    if (versions[2] == UINT32_MAX)
-      versions[2] = 0;
-
+  if (!version.empty()) {
     switch (sdk_type) {
     case SDKType::iPhoneOS:
       minimum_version_option.PutCString("-mios-version-min=");
-      minimum_version_option.PutCString(
-          llvm::VersionTuple(versions[0], versions[1], versions[2])
-              .getAsString());
+      minimum_version_option.PutCString(version.getAsString());
       break;
     case SDKType::iPhoneSimulator:
       minimum_version_option.PutCString("-mios-simulator-version-min=");
-      minimum_version_option.PutCString(
-          llvm::VersionTuple(versions[0], versions[1], versions[2])
-              .getAsString());
+      minimum_version_option.PutCString(version.getAsString());
       break;
     case SDKType::MacOSX:
       minimum_version_option.PutCString("-mmacosx-version-min=");
-      minimum_version_option.PutCString(
-          llvm::VersionTuple(versions[0], versions[1], versions[2])
-              .getAsString());
+      minimum_version_option.PutCString(version.getAsString());
     }
     options.push_back(minimum_version_option.GetString());
   }
 
   FileSpec sysroot_spec;
   // Scope for mutex locker below
   {
     std::lock_guard<std::mutex> guard(m_mutex);
ConstString PlatformDarwin::GetFullNameForDylib(ConstString basename) {
   if (basename.IsEmpty())
     return basename;
 
   StreamString stream;
   stream.Printf("lib%s.dylib", basename.GetCString());
   return ConstString(stream.GetString());
 }
 
-bool PlatformDarwin::GetOSVersion(uint32_t &major, uint32_t &minor,
-                                  uint32_t &update, Process *process) {
+llvm::VersionTuple PlatformDarwin::GetOSVersion(Process *process) {
   if (process && strstr(GetPluginName().GetCString(), "-simulator")) {
     lldb_private::ProcessInstanceInfo proc_info;
     if (Host::GetProcessInfo(process->GetID(), proc_info)) {
       const Environment &env = proc_info.GetEnvironment();
 
-      if (Args::StringToVersion(env.lookup("SIMULATOR_RUNTIME_VERSION"), major,
-                                minor, update))
-        return true;
+      llvm::VersionTuple result;
+      if (!result.tryParse(env.lookup("SIMULATOR_RUNTIME_VERSION")))
+        return result;
 
       std::string dyld_root_path = env.lookup("DYLD_ROOT_PATH");
       if (!dyld_root_path.empty()) {
         dyld_root_path += "/System/Library/CoreServices/SystemVersion.plist";
         ApplePropertyList system_version_plist(dyld_root_path.c_str());
         std::string product_version;
         if (system_version_plist.GetValueAsString("ProductVersion",
                                                   product_version)) {
-          return Args::StringToVersion(product_version, major, minor, update);
+          if (!result.tryParse(product_version))
+            return result;
         }
       }
     }
     // For simulator platforms, do NOT call back through
     // Platform::GetOSVersion() as it might call Process::GetHostOSVersion()
     // which we don't want as it will be incorrect
-    return false;
+    return llvm::VersionTuple();
   }
 
-  return Platform::GetOSVersion(major, minor, update, process);
+  return Platform::GetOSVersion(process);
 }
 
 lldb_private::FileSpec PlatformDarwin::LocateExecutable(const char *basename) {
   // A collection of SBFileSpec whose SBFileSpec.m_directory members are filled
   // in with
   // any executable directories that should be searched.
   static std::vector<FileSpec> g_executable_dirs;
 

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.h

return PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
         target, options, PlatformDarwin::SDKType::iPhoneOS);
   }
 
 protected:
   struct SDKDirectoryInfo {
     SDKDirectoryInfo(const lldb_private::FileSpec &sdk_dir_spec);
     lldb_private::FileSpec directory;
     lldb_private::ConstString build;
-    uint32_t version_major;
-    uint32_t version_minor;
-    uint32_t version_update;
+    llvm::VersionTuple version;
     bool user_cached;
   };
 
   typedef std::vector<SDKDirectoryInfo> SDKDirectoryInfoCollection;
 
   std::mutex m_sdk_dir_mutex;
   SDKDirectoryInfoCollection m_sdk_directory_infos;
   std::string m_device_support_directory;

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp

 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 PlatformRemoteDarwinDevice::SDKDirectoryInfo::SDKDirectoryInfo(
     const lldb_private::FileSpec &sdk_dir)
-    : directory(sdk_dir), build(), version_major(0), version_minor(0),
-      version_update(0), user_cached(false) {
+    : directory(sdk_dir), build(), user_cached(false) {
   llvm::StringRef dirname_str = sdk_dir.GetFilename().GetStringRef();
   llvm::StringRef build_str;
-  std::tie(version_major, version_minor, version_update, build_str) =
-      ParseVersionBuildDir(dirname_str);
+  std::tie(version, build_str) = ParseVersionBuildDir(dirname_str);
   build.SetString(build_str);
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformRemoteDarwinDevice::PlatformRemoteDarwinDevice()
     : PlatformDarwin(false), // This is a remote platform
if (UpdateSDKDirectoryInfosIfNeeded()) {
     ConstString build(m_sdk_build);
     if (build) {
       for (i = 0; i < num_sdk_infos; ++i)
         check_sdk_info[i] = m_sdk_directory_infos[i].build == build;
     }
 
     // If we are connected we can find the version of the OS the platform us
     // running on and select the right SDK
-    uint32_t major, minor, update;
-    if (GetOSVersion(major, minor, update)) {
+    llvm::VersionTuple version = GetOSVersion();
+    if (!version.empty()) {
       if (UpdateSDKDirectoryInfosIfNeeded()) {
         // First try for an exact match of major, minor and update
         for (i = 0; i < num_sdk_infos; ++i) {
           if (check_sdk_info[i]) {
-            if (m_sdk_directory_infos[i].version_major == major &&
-                m_sdk_directory_infos[i].version_minor == minor &&
-                m_sdk_directory_infos[i].version_update == update) {
+            if (m_sdk_directory_infos[i].version == version)
               return &m_sdk_directory_infos[i];
-            }
-          }
-        }
         // First try for an exact match of major and minor
         for (i = 0; i < num_sdk_infos; ++i) {
           if (check_sdk_info[i]) {
-            if (m_sdk_directory_infos[i].version_major == major &&
-                m_sdk_directory_infos[i].version_minor == minor) {
+            if (m_sdk_directory_infos[i].version.getMajor() ==
+                    version.getMajor() &&
+                m_sdk_directory_infos[i].version.getMinor() ==
+                    version.getMinor()) {
               return &m_sdk_directory_infos[i];
             }
           }
         }
         // Lastly try to match of major version only..
         for (i = 0; i < num_sdk_infos; ++i) {
           if (check_sdk_info[i]) {
-            if (m_sdk_directory_infos[i].version_major == major) {
+            if (m_sdk_directory_infos[i].version.getMajor() ==
+                version.getMajor()) {
               return &m_sdk_directory_infos[i];
             }
           }
         }
       }
     } else if (build) {
       // No version, just a build number, search for the first one that matches
       for (i = 0; i < num_sdk_infos; ++i)
         if (check_sdk_info[i])
           return &m_sdk_directory_infos[i];
     }
   }
   return NULL;
 }
 
 const PlatformRemoteDarwinDevice::SDKDirectoryInfo *
 PlatformRemoteDarwinDevice::GetSDKDirectoryForLatestOSVersion() {
   const PlatformRemoteDarwinDevice::SDKDirectoryInfo *result = NULL;
   if (UpdateSDKDirectoryInfosIfNeeded()) {
-    const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
-    // First try for an exact match of major, minor and update
-    for (uint32_t i = 0; i < num_sdk_infos; ++i) {
-      const SDKDirectoryInfo &sdk_dir_info = m_sdk_directory_infos[i];
-      if (sdk_dir_info.version_major != UINT32_MAX) {
-        if (result == NULL ||
-            sdk_dir_info.version_major > result->version_major) {
-          result = &sdk_dir_info;
-        } else if (sdk_dir_info.version_major == result->version_major) {
-          if (sdk_dir_info.version_minor > result->version_minor) {
-            result = &sdk_dir_info;
-          } else if (sdk_dir_info.version_minor == result->version_minor) {
-            if (sdk_dir_info.version_update > result->version_update) {
-              result = &sdk_dir_info;
-            }
-          }
-        }
-      }
-    }
+    auto max = std::max_element(
+        m_sdk_directory_infos.begin(), m_sdk_directory_infos.end(),
+        [](const SDKDirectoryInfo &a, const SDKDirectoryInfo &b) {
+          return a.version < b.version;
+        });
+    if (max != m_sdk_directory_infos.end())
+      result = &*max;
   }
   return result;
 }
 
 const char *PlatformRemoteDarwinDevice::GetDeviceSupportDirectory() {
   std::string platform_dir = "/Platforms/" + GetPlatformName() + "/DeviceSupport";
   if (m_device_support_directory.empty()) {
     const char *device_support_dir = GetDeveloperDirectory();

lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 bool PlatformPOSIX::SetRemoteWorkingDirectory(const FileSpec &working_dir) {
   if (IsRemote() && m_remote_platform_sp)
     return m_remote_platform_sp->SetRemoteWorkingDirectory(working_dir);
   else
     return Platform::SetRemoteWorkingDirectory(working_dir);
 }
 
 bool PlatformPOSIX::GetRemoteOSVersion() {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetOSVersion(
-        m_major_os_version, m_minor_os_version, m_update_os_version);
+  if (m_remote_platform_sp) {
+    m_os_version = m_remote_platform_sp->GetOSVersion();
+    return !m_os_version.empty();
+  }
   return false;
 }
 
 bool PlatformPOSIX::GetRemoteOSBuildString(std::string &s) {
   if (m_remote_platform_sp)
     return m_remote_platform_sp->GetRemoteOSBuildString(s);
   s.clear();
   return false;

lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.cpp

if (resolved_module_spec.GetArchitecture().IsValid()) {
       }
     }
   }
 
   return error;
 }
 
 bool PlatformWindows::GetRemoteOSVersion() {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetOSVersion(
-        m_major_os_version, m_minor_os_version, m_update_os_version);
+  if (m_remote_platform_sp) {
+    m_os_version = m_remote_platform_sp->GetOSVersion();
+    return !m_os_version.empty();
+  }
   return false;
 }
 
 bool PlatformWindows::GetRemoteOSBuildString(std::string &s) {
   if (m_remote_platform_sp)
     return m_remote_platform_sp->GetRemoteOSBuildString(s);
   s.clear();
   return false;

lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 size_t PlatformRemoteGDBServer::GetSoftwareBreakpointTrapOpcode(
     Target &target, BreakpointSite *bp_site) {
   // This isn't needed if the z/Z packets are supported in the GDB remote
   // server. But we might need a packet to detect this.
   return 0;
 }
 
 bool PlatformRemoteGDBServer::GetRemoteOSVersion() {
-  uint32_t major, minor, update;
-  if (m_gdb_client.GetOSVersion(major, minor, update)) {
-    m_major_os_version = major;
-    m_minor_os_version = minor;
-    m_update_os_version = update;
-    return true;
-  }
-  return false;
+  m_os_version = m_gdb_client.GetOSVersion();
+  return !m_os_version.empty();
 }
 
 bool PlatformRemoteGDBServer::GetRemoteOSBuildString(std::string &s) {
   return m_gdb_client.GetOSBuildString(s);
 }
 
 bool PlatformRemoteGDBServer::GetRemoteOSKernelDescription(std::string &s) {
   return m_gdb_client.GetOSKernelDescription(s);

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

public:
   bool GetSyncThreadStateSupported();
 
   void ResetDiscoverableSettings(bool did_exec);
 
   bool GetHostInfo(bool force = false);
 
   bool GetDefaultThreadId(lldb::tid_t &tid);
 
-  bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update);
+  llvm::VersionTuple GetOSVersion();
 
   bool GetOSBuildString(std::string &s);
 
   bool GetOSKernelDescription(std::string &s);
 
   ArchSpec GetSystemArchitecture();
 
   bool GetHostname(std::string &s);
lldb::tid_t m_curr_tid; // Current gdb remote protocol thread index for all
                           // other operations
   lldb::tid_t m_curr_tid_run; // Current gdb remote protocol thread index for
                               // continue, step, etc
 
   uint32_t m_num_supported_hardware_watchpoints;
 
   ArchSpec m_host_arch;
   ArchSpec m_process_arch;
-  uint32_t m_os_version_major;
-  uint32_t m_os_version_minor;
-  uint32_t m_os_version_update;
+  llvm::VersionTuple m_os_version;
   std::string m_os_build;
   std::string m_os_kernel;
   std::string m_hostname;
   std::string m_gdb_server_name; // from reply to qGDBServerVersion, empty if
                                  // qGDBServerVersion is not supported
   uint32_t m_gdb_server_version; // from reply to qGDBServerVersion, zero if
                                  // qGDBServerVersion is not supported
   std::chrono::seconds m_default_packet_timeout;

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

: GDBRemoteClientBase("gdb-remote.client", "gdb-remote.client.rx_packet"),
       m_supports_z1(true), m_supports_z2(true), m_supports_z3(true),
       m_supports_z4(true), m_supports_QEnvironment(true),
       m_supports_QEnvironmentHexEncoded(true), m_supports_qSymbol(true),
       m_qSymbol_requests_done(false), m_supports_qModuleInfo(true),
       m_supports_jThreadsInfo(true), m_supports_jModulesInfo(true),
       m_curr_pid(LLDB_INVALID_PROCESS_ID), m_curr_tid(LLDB_INVALID_THREAD_ID),
       m_curr_tid_run(LLDB_INVALID_THREAD_ID),
       m_num_supported_hardware_watchpoints(0), m_host_arch(), m_process_arch(),
-      m_os_version_major(UINT32_MAX), m_os_version_minor(UINT32_MAX),
-      m_os_version_update(UINT32_MAX), m_os_build(), m_os_kernel(),
-      m_hostname(), m_gdb_server_name(), m_gdb_server_version(UINT32_MAX),
-      m_default_packet_timeout(0), m_max_packet_size(0),
-      m_qSupported_response(), m_supported_async_json_packets_is_valid(false),
+      m_os_build(), m_os_kernel(), m_hostname(), m_gdb_server_name(),
+      m_gdb_server_version(UINT32_MAX), m_default_packet_timeout(0),
+      m_max_packet_size(0), m_qSupported_response(),
+      m_supported_async_json_packets_is_valid(false),
       m_supported_async_json_packets_sp(), m_qXfer_memory_map(),
       m_qXfer_memory_map_loaded(false) {}
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationClient::~GDBRemoteCommunicationClient() {
   if (IsConnected())
if (did_exec == false) {
     m_supports_z3 = true;
     m_supports_z4 = true;
     m_supports_QEnvironment = true;
     m_supports_QEnvironmentHexEncoded = true;
     m_supports_qSymbol = true;
     m_qSymbol_requests_done = false;
     m_supports_qModuleInfo = true;
     m_host_arch.Clear();
-    m_os_version_major = UINT32_MAX;
-    m_os_version_minor = UINT32_MAX;
-    m_os_version_update = UINT32_MAX;
+    m_os_version = llvm::VersionTuple();
     m_os_build.clear();
     m_os_kernel.clear();
     m_hostname.clear();
     m_gdb_server_name.clear();
     m_gdb_server_version = UINT32_MAX;
     m_default_packet_timeout = seconds(0);
     m_max_packet_size = 0;
     m_qSupported_response.clear();
if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
         if (error)
           return error;
       }
     }
   }
   return -1;
 }
 
-bool GDBRemoteCommunicationClient::GetOSVersion(uint32_t &major,
-                                                uint32_t &minor,
-                                                uint32_t &update) {
-  if (GetHostInfo()) {
-    if (m_os_version_major != UINT32_MAX) {
-      major = m_os_version_major;
-      minor = m_os_version_minor;
-      update = m_os_version_update;
-      return true;
-    }
-  }
-  return false;
+llvm::VersionTuple GDBRemoteCommunicationClient::GetOSVersion() {
+  GetHostInfo();
+  return m_os_version;
 }
 
 bool GDBRemoteCommunicationClient::GetOSBuildString(std::string &s) {
   if (GetHostInfo()) {
     if (!m_os_build.empty()) {
       s = m_os_build;
       return true;
     }
if (SendPacketAndWaitForResponse("qHostInfo", response, false) ==
             if (!value.getAsInteger(0, pointer_byte_size))
               ++num_keys_decoded;
           } else if (name.equals("os_version") ||
                      name.equals(
                          "version")) // Older debugserver binaries used the
                                      // "version" key instead of
                                      // "os_version"...
           {
-            Args::StringToVersion(value, m_os_version_major, m_os_version_minor,
-                                  m_os_version_update);
-            if (m_os_version_major != UINT32_MAX)
+            if (!m_os_version.tryParse(value))
               ++num_keys_decoded;
           } else if (name.equals("watchpoint_exceptions_received")) {
             m_watchpoints_trigger_after_instruction =
                 llvm::StringSwitch<LazyBool>(value)
                     .Case("before", eLazyBoolNo)
                     .Case("after", eLazyBoolYes)
                     .Default(eLazyBoolCalculate);
             if (m_watchpoints_trigger_after_instruction != eLazyBoolCalculate)

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

#endif
   case eByteOrderPDP:
     response.PutCString("endian:pdp;");
     break;
   default:
     response.PutCString("endian:unknown;");
     break;
   }
 
-  uint32_t major = UINT32_MAX;
-  uint32_t minor = UINT32_MAX;
-  uint32_t update = UINT32_MAX;
-  if (HostInfo::GetOSVersion(major, minor, update)) {
-    if (major != UINT32_MAX) {
-      response.Printf("os_version:%u", major);
-      if (minor != UINT32_MAX) {
-        response.Printf(".%u", minor);
-        if (update != UINT32_MAX)
-          response.Printf(".%u", update);
-      }
-      response.PutChar(';');
-    }
-  }
+  llvm::VersionTuple version = HostInfo::GetOSVersion();
+  if (!version.empty()) {
+    response.Format("os_version:{0}", version.getAsString());
 
   std::string s;
   if (HostInfo::GetOSBuildString(s)) {
     response.PutCString("os_build:");
     response.PutCStringAsRawHex8(s.c_str());
     response.PutChar(';');
   }
   if (HostInfo::GetOSKernelDescription(s)) {

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

public:
   void SetUserSpecifiedMaxMemoryTransferSize(uint64_t user_specified_max);
 
   bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch,
                      ModuleSpec &module_spec) override;
 
   void PrefetchModuleSpecs(llvm::ArrayRef<FileSpec> module_file_specs,
                            const llvm::Triple &triple) override;
 
-  bool GetHostOSVersion(uint32_t &major, uint32_t &minor,
-                        uint32_t &update) override;
+  llvm::VersionTuple GetHostOSVersion() override;
 
   size_t LoadModules(LoadedModuleInfoList &module_list) override;
 
   size_t LoadModules() override;
 
   Status GetFileLoadAddress(const FileSpec &file, bool &is_loaded,
                             lldb::addr_t &load_addr) override;
 

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

for (const FileSpec &spec : module_file_specs)
       m_cached_module_specs[ModuleCacheKey(spec.GetPath(),
                                            triple.getTriple())] = ModuleSpec();
     for (const ModuleSpec &spec : *module_specs)
       m_cached_module_specs[ModuleCacheKey(spec.GetFileSpec().GetPath(),
                                            triple.getTriple())] = spec;
   }
 }
 
-bool ProcessGDBRemote::GetHostOSVersion(uint32_t &major, uint32_t &minor,
-                                        uint32_t &update) {
-  if (m_gdb_comm.GetOSVersion(major, minor, update))
-    return true;
-  // We failed to get the host OS version, defer to the base implementation to
-  // correctly invalidate the arguments.
-  return Process::GetHostOSVersion(major, minor, update);
+llvm::VersionTuple ProcessGDBRemote::GetHostOSVersion() {
+  return m_gdb_comm.GetOSVersion();
 }
 
 namespace {
 
 typedef std::vector<std::string> stringVec;
 
 typedef std::vector<struct GdbServerRegisterInfo> GDBServerRegisterVec;
 struct RegisterSetInfo {

lldb/trunk/source/Target/Platform.cpp

 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 Platform::Platform(bool is_host)
     : m_is_host(is_host), m_os_version_set_while_connected(false),
       m_system_arch_set_while_connected(false), m_sdk_sysroot(), m_sdk_build(),
-      m_working_dir(), m_remote_url(), m_name(), m_major_os_version(UINT32_MAX),
-      m_minor_os_version(UINT32_MAX), m_update_os_version(UINT32_MAX),
-      m_system_arch(), m_mutex(), m_uid_map(), m_gid_map(),
-      m_max_uid_name_len(0), m_max_gid_name_len(0), m_supports_rsync(false),
-      m_rsync_opts(), m_rsync_prefix(), m_supports_ssh(false), m_ssh_opts(),
-      m_ignores_remote_hostname(false), m_trap_handlers(),
-      m_calculated_trap_handlers(false),
+      m_working_dir(), m_remote_url(), m_name(), m_system_arch(), m_mutex(),
+      m_uid_map(), m_gid_map(), m_max_uid_name_len(0), m_max_gid_name_len(0),
+      m_supports_rsync(false), m_rsync_opts(), m_rsync_prefix(),
+      m_supports_ssh(false), m_ssh_opts(), m_ignores_remote_hostname(false),
+      m_trap_handlers(), m_calculated_trap_handlers(false),
       m_module_cache(llvm::make_unique<ModuleCache>()) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
   if (log)
     log->Printf("%p Platform::Platform()", static_cast<void *>(this));
 }
 
 //------------------------------------------------------------------
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
 //------------------------------------------------------------------
 Platform::~Platform() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
   if (log)
     log->Printf("%p Platform::~Platform()", static_cast<void *>(this));
 }
 
 void Platform::GetStatus(Stream &strm) {
-  uint32_t major = UINT32_MAX;
-  uint32_t minor = UINT32_MAX;
-  uint32_t update = UINT32_MAX;
   std::string s;
   strm.Printf("  Platform: %s\n", GetPluginName().GetCString());
 
   ArchSpec arch(GetSystemArchitecture());
   if (arch.IsValid()) {
     if (!arch.GetTriple().str().empty()) {
       strm.Printf("    Triple: ");
       arch.DumpTriple(strm);
       strm.EOL();
     }
   }
 
-  if (GetOSVersion(major, minor, update)) {
-    strm.Printf("OS Version: %u", major);
-    if (minor != UINT32_MAX)
-      strm.Printf(".%u", minor);
-    if (update != UINT32_MAX)
-      strm.Printf(".%u", update);
+  llvm::VersionTuple os_version = GetOSVersion();
+  if (!os_version.empty()) {
+    strm.Format("OS Version: {0}", os_version.getAsString());
 
     if (GetOSBuildString(s))
       strm.Printf(" (%s)", s.c_str());
 
     strm.EOL();
   }
 
   if (GetOSKernelDescription(s))
if (!IsConnected())
     return;
 
   std::string specific_info(GetPlatformSpecificConnectionInformation());
 
   if (!specific_info.empty())
     strm.Printf("Platform-specific connection: %s\n", specific_info.c_str());
 }
 
-bool Platform::GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update,
-                            Process *process) {
+llvm::VersionTuple Platform::GetOSVersion(Process *process) {
   std::lock_guard<std::mutex> guard(m_mutex);
 
-  bool success = m_major_os_version != UINT32_MAX;
   if (IsHost()) {
-    if (!success) {
+    if (m_os_version.empty()) {
       // We have a local host platform
-      success = HostInfo::GetOSVersion(m_major_os_version, m_minor_os_version,
-                                       m_update_os_version);
-      m_os_version_set_while_connected = success;
+      m_os_version = HostInfo::GetOSVersion();
+      m_os_version_set_while_connected = !m_os_version.empty();
     }
   } else {
     // We have a remote platform. We can only fetch the remote
     // OS version if we are connected, and we don't want to do it
     // more than once.
 
     const bool is_connected = IsConnected();
 
     bool fetch = false;
-    if (success) {
+    if (!m_os_version.empty()) {
       // We have valid OS version info, check to make sure it wasn't manually
       // set prior to connecting. If it was manually set prior to connecting,
       // then lets fetch the actual OS version info if we are now connected.
       if (is_connected && !m_os_version_set_while_connected)
         fetch = true;
     } else {
       // We don't have valid OS version info, fetch it if we are connected
       fetch = is_connected;
     }
 
-    if (fetch) {
-      success = GetRemoteOSVersion();
-      m_os_version_set_while_connected = success;
-    }
+    if (fetch)
+      m_os_version_set_while_connected = GetRemoteOSVersion();
   }
 
-  if (success) {
-    major = m_major_os_version;
-    minor = m_minor_os_version;
-    update = m_update_os_version;
-  } else if (process) {
+  if (!m_os_version.empty())
+    return m_os_version;
+  if (process) {
     // Check with the process in case it can answer the question if a process
     // was provided
-    return process->GetHostOSVersion(major, minor, update);
+    return process->GetHostOSVersion();
   }
-  return success;
+  return llvm::VersionTuple();
 }
 
 bool Platform::GetOSBuildString(std::string &s) {
   s.clear();
 
   if (IsHost())
 #if !defined(__linux__)
     return HostInfo::GetOSBuildString(s);
if (IsHost()) {
     std::string name;
     if (HostInfo::LookupGroupName(gid, name))
       return SetCachedGroupName(gid, name.c_str(), name.size());
   }
 #endif
   return nullptr;
 }
 
-bool Platform::SetOSVersion(uint32_t major, uint32_t minor, uint32_t update) {
+bool Platform::SetOSVersion(llvm::VersionTuple version) {
   if (IsHost()) {
     // We don't need anyone setting the OS version for the host platform, we
     // should be able to figure it out by calling HostInfo::GetOSVersion(...).
     return false;
   } else {
     // We have a remote platform, allow setting the target OS version if we
     // aren't connected, since if we are connected, we should be able to
     // request the remote OS version from the connected platform.
     if (IsConnected())
       return false;
     else {
       // We aren't connected and we might want to set the OS version ahead of
       // time before we connect so we can peruse files and use a local SDK or
       // PDK cache of support files to disassemble or do other things.
-      m_major_os_version = major;
-      m_minor_os_version = minor;
-      m_update_os_version = update;
+      m_os_version = version;
       return true;
     }
   }
   return false;
 }
 
 Status
 Platform::ResolveExecutable(const ModuleSpec &module_spec,

lldb/trunk/source/Utility/Args.cpp

if (trailing) {
         s.erase(rpos + 1);
     }
   }
   if (return_null_if_empty && s.empty())
     return nullptr;
   return s.c_str();
 }
 
-bool Args::StringToVersion(llvm::StringRef string, uint32_t &major,
-                           uint32_t &minor, uint32_t &update) {
-  major = UINT32_MAX;
-  minor = UINT32_MAX;
-  update = UINT32_MAX;
-
-  if (string.empty())
-    return false;
-
-  llvm::StringRef major_str, minor_str, update_str;
-
-  std::tie(major_str, minor_str) = string.split('.');
-  std::tie(minor_str, update_str) = minor_str.split('.');
-  if (major_str.getAsInteger(10, major))
-    return false;
-  if (!minor_str.empty() && minor_str.getAsInteger(10, minor))
-    return false;
-  if (!update_str.empty() && update_str.getAsInteger(10, update))
-    return false;
-
-  return true;
-}
-
 const char *Args::GetShellSafeArgument(const FileSpec &shell,
                                        const char *unsafe_arg,
                                        std::string &safe_arg) {
   struct ShellDescriptor {
     ConstString m_basename;
     const char *m_escapables;
   };
 

lldb/trunk/unittests/Platform/PlatformDarwinTest.cpp

 #include "llvm/ADT/StringRef.h"
 
 #include <tuple>
 
 using namespace lldb;
 using namespace lldb_private;
 
 TEST(PlatformDarwinTest, TestParseVersionBuildDir) {
-  uint32_t A, B, C;
+  llvm::VersionTuple V;
   llvm::StringRef D;
 
-  std::tie(A, B, C, D) = PlatformDarwin::ParseVersionBuildDir("1.2.3 (test1)");
-  EXPECT_EQ(1u, A);
-  EXPECT_EQ(2u, B);
-  EXPECT_EQ(3u, C);
+  std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("1.2.3 (test1)");
+  EXPECT_EQ(llvm::VersionTuple(1, 2, 3), V);
   EXPECT_EQ("test1", D);
 
-  std::tie(A, B, C, D) = PlatformDarwin::ParseVersionBuildDir("2.3 (test2)");
-  EXPECT_EQ(2u, A);
-  EXPECT_EQ(3u, B);
+  std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("2.3 (test2)");
+  EXPECT_EQ(llvm::VersionTuple(2, 3), V);
   EXPECT_EQ("test2", D);
 
-  std::tie(A, B, C, D) = PlatformDarwin::ParseVersionBuildDir("3 (test3)");
-  EXPECT_EQ(3u, A);
+  std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("3 (test3)");
+  EXPECT_EQ(llvm::VersionTuple(3), V);
   EXPECT_EQ("test3", D);
 
-  std::tie(A, B, C, D) = PlatformDarwin::ParseVersionBuildDir("1.2.3 (test");
-  EXPECT_EQ(1u, A);
-  EXPECT_EQ(2u, B);
-  EXPECT_EQ(3u, C);
+  std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("1.2.3 (test");
+  EXPECT_EQ(llvm::VersionTuple(1, 2, 3), V);
   EXPECT_EQ("test", D);
 
-  std::tie(A, B, C, D) = PlatformDarwin::ParseVersionBuildDir("2.3.4 test");
-  EXPECT_EQ(2u, A);
-  EXPECT_EQ(3u, B);
-  EXPECT_EQ(4u, C);
+  std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("2.3.4 test");
+  EXPECT_EQ(llvm::VersionTuple(2, 3, 4), V);
   EXPECT_EQ("", D);
 
-  std::tie(A, B, C, D) = PlatformDarwin::ParseVersionBuildDir("3.4.5");
-  EXPECT_EQ(3u, A);
-  EXPECT_EQ(4u, B);
-  EXPECT_EQ(5u, C);
+  std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("3.4.5");
+  EXPECT_EQ(llvm::VersionTuple(3, 4, 5), V);
 }