Upstream macCatalyst support in debugserver and the dynamic library loader plugin.

[aprantl]

Summary

This patch adds support for macCatalyst processes to debugserver and the dynamic library loader plugin.

[jasonmolenda]

LGTM.

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

public:
   ///     The newly remapped filespec that is may or may not exist.
   ///
   /// \return
   ///     /b true if \a path was successfully located and \a new_path
   ///     is filled in with a new source path, \b false otherwise.
   bool RemapSourceFile(llvm::StringRef path, std::string &new_path) const;
   bool RemapSourceFile(const char *, std::string &) const = delete;
 
+  /// Update the ArchSpec to a more specific variant.
+  bool MergeArchitecture(const ArchSpec &arch_spec);
+
   /// \class LookupInfo Module.h "lldb/Core/Module.h"
   /// A class that encapsulates name lookup information.
   ///
   /// Users can type a wide variety of partial names when setting breakpoints
   /// by name or when looking for functions by name. The SymbolFile object is
   /// only required to implement name lookup for function basenames and for
   /// fully mangled names. This means if the user types in a partial name, we
   /// must reduce this to a name lookup that will work with all SymbolFile

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

 
 private:
   // Static class, unconstructable.
   HostInfoMacOSX() = delete;
   ~HostInfoMacOSX() = delete;
 
 public:
   static llvm::VersionTuple GetOSVersion();
+  static llvm::VersionTuple GetMacCatalystVersion();
   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 ComputeSystemPluginsDirectory(FileSpec &file_spec);
   static bool ComputeUserPluginsDirectory(FileSpec &file_spec);
 };
 }
 
 #endif

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

/// \see Process::Notifications
   /// platform that might itself be running natively, but have different
   /// heuristics for figuring out which OS is is emulating.
   ///
   /// \return
   ///     Returns the version tuple of the host OS. In case of failure an empty
   ///     VersionTuple is returner.
   virtual llvm::VersionTuple GetHostOSVersion() { return llvm::VersionTuple(); }
 
+  /// \return the macCatalyst version of the host OS.
+  virtual llvm::VersionTuple GetHostMacCatalystVersion() { return {}; }
+
   /// Get the target object pointer for this module.
   ///
   /// \return
   ///     A Target object pointer to the target that owns this
   ///     module.
   Target &GetTarget() { return *m_target_wp.lock(); }
 
   /// Get the const target object pointer for this module.

lldb/trunk/packages/Python/lldbsuite/test/macosx/macabi/Makefile

+LEVEL = ../../make
+
+C_SOURCES := main.c
+LD_EXTRAS := -L. -lfoo
+
+TRIPLE := x86_64-apple-ios13.0-macabi
+CFLAGS_EXTRAS := -target $(TRIPLE)
+
+all: libfoo.dylib a.out
+
+lib%.dylib: %.c
+  $(MAKE) MAKE_DSYM=YES CC=$(CC) \
+    ARCH=$(ARCH) DSYMUTIL=$(DSYMUTIL) \
+    BASENAME=$(shell basename $< .c) \
+    TRIPLE=x86_64-apple-macosx10.15 SDKROOT=$(SDKROOT) \
+    VPATH=$(SRCDIR) -I $(SRCDIR) -f $(SRCDIR)/dylib.mk all
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/macosx/macabi/TestMacABImacOSFramework.py

+# TestMacABImacOSFramework.py
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+import os
+import unittest2
+
+
+class TestMacABImacOSFramework(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIf(macos_version=["<", "10.15"])
+    @skipUnlessDarwin
+    @skipIfDarwinEmbedded
+    # There is a Clang driver change missing on llvm.org.
+    @expectedFailureAll(bugnumber="rdar://problem/54986190>")
+    def test_macabi(self):
+        """Test the x86_64-apple-ios-macabi target linked against a macos dylib"""
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "break here",
+                                          lldb.SBFileSpec('main.c'))
+        self.expect("image list -t -b",
+                    patterns=["x86_64.*-apple-ios.*-macabi a\.out",
+                              "x86_64.*-apple-macosx.* libfoo.dylib[^(]"])
+        self.expect("fr v s", "Hello MacABI")
+        self.expect("p s", "Hello MacABI")

lldb/trunk/packages/Python/lldbsuite/test/macosx/macabi/dylib.mk

+LEVEL = ../../make
+DYLIB_ONLY := YES
+DYLIB_NAME := $(BASENAME)
+DYLIB_C_SOURCES := $(DYLIB_NAME).c
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/macosx/macabi/foo.h

+int foo();

lldb/trunk/packages/Python/lldbsuite/test/macosx/macabi/foo.c

+#include "foo.h"
+
+void stop() {}
+
+int foo() {
+  stop();
+  return 0;
+}

lldb/trunk/packages/Python/lldbsuite/test/macosx/macabi/main.c

+#include "foo.h"
+int main() {
+  const char *s = "Hello MacABI!";
+  return foo(); // break here
+}

lldb/trunk/packages/Python/lldbsuite/test/make/Makefile.rules

 ARCH_CFLAGS :=
 ifneq "$(TRIPLE)" ""
   triple_space = $(subst -, ,$(TRIPLE))
   ARCH =$(word 1, $(triple_space))
   TRIPLE_VENDOR =$(word 2, $(triple_space))
   triple_os_and_version =$(shell echo $(word 3, $(triple_space)) | sed 's/\([a-z]*\)\(.*\)/\1 \2/')
   TRIPLE_OS =$(word 1, $(triple_os_and_version))
   TRIPLE_VERSION =$(word 2, $(triple_os_and_version))
+  TRIPLE_ENV =$(word 4, $(triple_space))
   ifeq "$(TRIPLE_VENDOR)" "apple"
     ifeq "$(TRIPLE_OS)" "ios"
       CODESIGN := codesign
       ifeq "$(SDKROOT)" ""
         # Set SDKROOT if it wasn't set
         ifneq (,$(findstring arm,$(ARCH)))
           SDKROOT = $(shell xcrun --sdk iphoneos --show-sdk-path)
           ifeq "$(TRIPLE_VERSION)" ""
             TRIPLE_VERSION =$(shell echo $(notdir $(SDKROOT)) | sed -e 's/.*\([0-9]\.[0-9]\).*/\1/')
           endif
           ARCH_CFLAGS :=-mios-version-min=$(TRIPLE_VERSION) -isysroot "$(SDKROOT)"
         else
+          ifeq "$(TRIPLE_ENV)" "macabi"
+            SDKROOT = $(shell xcrun --sdk macosx --show-sdk-path)
+          else
             SDKROOT = $(shell xcrun --sdk iphonesimulator --show-sdk-path)
+          endif
           ifeq "$(TRIPLE_VERSION)" ""
             TRIPLE_VERSION =$(shell echo $(notdir $(SDKROOT)) | sed -e 's/.*\([0-9]\.[0-9]\).*/\1/')
           endif
+          ifeq "$(TRIPLE_ENV)" "macabi"
+            ARCH_CFLAGS :=-mios-version-min=$(TRIPLE_VERSION) -isysroot "$(SDKROOT)"
+          else
             ARCH_CFLAGS :=-mios-simulator-version-min=$(TRIPLE_VERSION) -isysroot "$(SDKROOT)"
           endif
         endif
       endif
+    endif
     ifeq "$(TRIPLE_OS)" "watchos"
       CODESIGN := codesign
       ifeq "$(SDKROOT)" ""
         # Set SDKROOT if it wasn't set
         ifneq (,$(findstring arm,$(ARCH)))
           SDKROOT = $(shell xcrun --sdk watchos --show-sdk-path)
           ifeq "$(TRIPLE_VERSION)" ""
             TRIPLE_VERSION =$(shell echo $(notdir $(SDKROOT)) | sed -e 's/.*\([0-9]\.[0-9]\).*/\1/')

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteHostInfo.py

KNOWN_HOST_INFO_KEYS = set([
         "cpusubtype",
         "distribution_id",
         "endian",
         "hostname",
         "ostype",
         "os_build",
         "os_kernel",
         "os_version",
+        "maccatalyst_version",
         "ptrsize",
         "triple",
         "vendor",
         "watchpoint_exceptions_received",
         "default_packet_timeout",
     ])
 
     DARWIN_REQUIRED_HOST_INFO_KEYS = set([

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);
 }
 
+bool Module::MergeArchitecture(const ArchSpec &arch_spec) {
+  if (!arch_spec.IsValid())
+    return false;
+  LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_MODULES),
+           "module has arch %s, merging/replacing with arch %s",
+           m_arch.GetTriple().getTriple().c_str(),
+           arch_spec.GetTriple().getTriple().c_str());
+  if (!m_arch.IsCompatibleMatch(arch_spec)) {
+    // The new architecture is different, we just need to replace it.
+    return SetArchitecture(arch_spec);
+  }
+
+  // Merge bits from arch_spec into "merged_arch" and set our architecture.
+  ArchSpec merged_arch(m_arch);
+  merged_arch.MergeFrom(arch_spec);
+  // SetArchitecture() is a no-op if m_arch is already valid.
+  m_arch = ArchSpec();
+  return SetArchitecture(merged_arch);
+}
+
 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/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;
 }
 
-llvm::VersionTuple HostInfoMacOSX::GetOSVersion() {
-  static llvm::VersionTuple g_version;
-
-  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];
-      g_version.tryParse(version_str);
-    }
-  }
+static void ParseOSVersion(llvm::VersionTuple &version, NSString *Key) {
+    NSDictionary *version_info =
+      [NSDictionary dictionaryWithContentsOfFile:
+    NSString *version_value = [version_info objectForKey: Key];
+    version.tryParse(version_str);
 
+llvm::VersionTuple HostInfoMacOSX::GetOSVersion() {
+  static llvm::VersionTuple g_version;
+  if (g_version.empty())
+    ParseOSVersion(g_version, @"ProductVersion");
+  return g_version;
+}
+
+llvm::VersionTuple HostInfoMacOSX::GetMacCatalystVersion() {
+  static llvm::VersionTuple g_version;
+  if (g_version.empty())
+    ParseOSVersion(g_version, @"iOSSupportVersion");
   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);
     int err = _NSGetExecutablePath(program_fullpath, &len);
     if (err == 0)

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

public:
     bool operator==(const Segment &rhs) const {
       return name == rhs.name && vmaddr == rhs.vmaddr && vmsize == rhs.vmsize;
     }
 
     void PutToLog(lldb_private::Log *log, lldb::addr_t slide) const;
   };
 
   struct ImageInfo {
-    lldb::addr_t address;  // Address of mach header for this dylib
-    lldb::addr_t slide;    // The amount to slide all segments by if there is a
-                           // global slide.
-    lldb::addr_t mod_date; // Modification date for this dylib
-    lldb_private::FileSpec file_spec; // Resolved path for this dylib
-    lldb_private::UUID
-        uuid; // UUID for this dylib if it has one, else all zeros
-    llvm::MachO::mach_header header; // The mach header for this image
-    std::vector<Segment> segments;   // All segment vmaddr and vmsize pairs for
-                                   // this executable (from memory of inferior)
-    uint32_t load_stop_id; // The process stop ID that the sections for this
-                           // image were loaded
-    llvm::Triple::OSType os_type;   // LC_VERSION_MIN_... load command os type
-    std::string min_version_os_sdk; // LC_VERSION_MIN_... sdk value
-
-    ImageInfo()
-        : address(LLDB_INVALID_ADDRESS), slide(0), mod_date(0), file_spec(),
-          uuid(), header(), segments(), load_stop_id(0),
-          os_type(llvm::Triple::OSType::UnknownOS), min_version_os_sdk() {}
+    /// Address of mach header for this dylib.
+    lldb::addr_t address = LLDB_INVALID_ADDRESS;
+    /// The amount to slide all segments by if there is a global
+    /// slide.
+    lldb::addr_t slide = 0;
+    /// Modification date for this dylib.
+    lldb::addr_t mod_date = 0;
+    /// Resolved path for this dylib.
+    lldb_private::FileSpec file_spec;
+    /// UUID for this dylib if it has one, else all zeros.
+    lldb_private::UUID uuid;
+    /// The mach header for this image.
+    llvm::MachO::mach_header header;
+    /// All segment vmaddr and vmsize pairs for this executable (from
+    /// memory of inferior).
+    std::vector<Segment> segments;
+    /// The process stop ID that the sections for this image were
+    /// loaded.
+    uint32_t load_stop_id = 0;
+    /// LC_VERSION_MIN_... load command os type.
+    llvm::Triple::OSType os_type = llvm::Triple::OSType::UnknownOS;
+    /// LC_VERSION_MIN_... load command os environment.
+    llvm::Triple::EnvironmentType os_env =
+        llvm::Triple::EnvironmentType::UnknownEnvironment;
+    /// LC_VERSION_MIN_... SDK.
+    std::string min_version_os_sdk;
+
+    ImageInfo() = default;
 
     void Clear(bool load_cmd_data_only) {
       if (!load_cmd_data_only) {
         address = LLDB_INVALID_ADDRESS;
         slide = 0;
         mod_date = 0;
         file_spec.Clear();
         ::memset(&header, 0, sizeof(header));
       }
       uuid.Clear();
       segments.clear();
       load_stop_id = 0;
       os_type = llvm::Triple::OSType::UnknownOS;
+      os_env = llvm::Triple::EnvironmentType::UnknownEnvironment;
       min_version_os_sdk.clear();
     }
 
     bool operator==(const ImageInfo &rhs) const {
       return address == rhs.address && slide == rhs.slide &&
              mod_date == rhs.mod_date && file_spec == rhs.file_spec &&
              uuid == rhs.uuid &&
              memcmp(&header, &rhs.header, sizeof(header)) == 0 &&
-             segments == rhs.segments && os_type == rhs.os_type;
+             segments == rhs.segments && os_type == rhs.os_type &&
+             os_env == rhs.os_env;
     }
 
     bool UUIDValid() const { return uuid.IsValid(); }
 
     uint32_t GetAddressByteSize() {
       if (header.cputype) {
         if (header.cputype & llvm::MachO::CPU_ARCH_ABI64)
           return 8;
         else
           return 4;
       }
       return 0;
     }
 
-    lldb_private::ArchSpec GetArchitecture() const {
-      return lldb_private::ArchSpec(lldb_private::eArchTypeMachO,
-                                    header.cputype, header.cpusubtype);
-    }
+    lldb_private::ArchSpec GetArchitecture() const;
 
     const Segment *FindSegment(lldb_private::ConstString name) const;
 
     void PutToLog(lldb_private::Log *log) const;
 
     typedef std::vector<ImageInfo> collection;
     typedef collection::iterator iterator;
     typedef collection::const_iterator const_iterator;

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

ModuleSP DynamicLoaderDarwin::FindTargetModuleForImageInfo(
     ImageInfo &image_info, bool can_create, bool *did_create_ptr) {
   if (did_create_ptr)
     *did_create_ptr = false;
 
   Target &target = m_process->GetTarget();
   const ModuleList &target_images = target.GetImages();
   ModuleSpec module_spec(image_info.file_spec);
   module_spec.GetUUID() = image_info.uuid;
+
+  // macCatalyst support: Request matching os/environment.
+  {
+    auto &target_triple = target.GetArchitecture().GetTriple();
+    if (target_triple.getOS() == llvm::Triple::IOS &&
+        target_triple.getEnvironment() == llvm::Triple::MacABI) {
+      // Request the macCatalyst variant of frameworks that have both
+      // a PLATFORM_MACOS and a PLATFORM_MACCATALYST load command.
+      module_spec.GetArchitecture() = ArchSpec(target_triple);
+    }
+  }
+
   ModuleSP module_sp(target_images.FindFirstModule(module_spec));
 
   if (module_sp && !module_spec.GetUUID().IsValid() &&
       !module_sp->GetUUID().IsValid()) {
     // No UUID, we must rely upon the cached module modification time and the
     // modification time of the file on disk
     if (module_sp->GetModificationTime() !=
         FileSystem::Instance().GetModificationTime(module_sp->GetFileSpec()))
if (image->HasKey("min_version_os_name")) {
       else if (os_name == "ios" || os_name == "iphoneos")
         image_infos[i].os_type = llvm::Triple::IOS;
       else if (os_name == "tvos")
         image_infos[i].os_type = llvm::Triple::TvOS;
       else if (os_name == "watchos")
         image_infos[i].os_type = llvm::Triple::WatchOS;
       // NEED_BRIDGEOS_TRIPLE else if (os_name == "bridgeos")
       // NEED_BRIDGEOS_TRIPLE   image_infos[i].os_type = llvm::Triple::BridgeOS;
+      else if (os_name == "maccatalyst") {
+        image_infos[i].os_type = llvm::Triple::IOS;
+        image_infos[i].os_env = llvm::Triple::MacABI;
+      }
     }
     if (image->HasKey("min_version_os_sdk")) {
       image_infos[i].min_version_os_sdk =
           image->GetValueForKey("min_version_os_sdk")
               ->GetAsString()
               ->GetValue();
     }
 
if (image_module_sp) {
       // UpdateImageLoadAddress will return true if any segments change load
       // address. We need to check this so we don't mention that all loaded
       // shared libraries are newly loaded each time we hit out dyld breakpoint
       // since dyld will list all shared libraries each time.
       if (UpdateImageLoadAddress(image_module_sp.get(), image_infos[idx])) {
         target_images.AppendIfNeeded(image_module_sp);
         loaded_module_list.AppendIfNeeded(image_module_sp);
       }
+
+      // macCataylst support:
+      // Update the module's platform with the DYLD info.
+      ArchSpec dyld_spec = image_infos[idx].GetArchitecture();
+      if (dyld_spec.GetTriple().getOS() == llvm::Triple::IOS &&
+          dyld_spec.GetTriple().getEnvironment() == llvm::Triple::MacABI) {
+        image_module_sp->MergeArchitecture(dyld_spec);
+        const auto &target_triple = target.GetArchitecture().GetTriple();
+        // If dyld reports the process as being loaded as MACCATALYST,
+        // force-update the target's architecture to MACCATALYST.
+        if (!(target_triple.getOS() == llvm::Triple::IOS &&
+              target_triple.getEnvironment() == llvm::Triple::MacABI))
+          target.SetArchitecture(dyld_spec);
+      }
     }
   }
 
   if (loaded_module_list.GetSize() > 0) {
     if (log)
       loaded_module_list.LogUUIDAndPaths(log,
                                          "DynamicLoaderDarwin::ModulesDidLoad");
     m_process->GetTarget().ModulesDidLoad(loaded_module_list);
else
       LLDB_LOGF(log,
                 "\t\t%16s [0x%16.16" PRIx64 " - 0x%16.16" PRIx64
                 ") slide = 0x%" PRIx64,
                 name.AsCString(""), vmaddr + slide, vmaddr + slide + vmsize,
                 slide);
   }
 }
 
+lldb_private::ArchSpec DynamicLoaderDarwin::ImageInfo::GetArchitecture() const {
+  // Update the module's platform with the DYLD info.
+  lldb_private::ArchSpec arch_spec(lldb_private::eArchTypeMachO, header.cputype,
+                                   header.cpusubtype);
+  if (os_type == llvm::Triple::IOS && os_env == llvm::Triple::MacABI) {
+    llvm::Triple triple(llvm::Twine("x86_64-apple-ios") + min_version_os_sdk +
+                        "-macabi");
+    ArchSpec maccatalyst_spec(triple);
+    if (arch_spec.IsCompatibleMatch(maccatalyst_spec))
+      arch_spec.MergeFrom(maccatalyst_spec);
+  }
+  return arch_spec;
+}
+
 const DynamicLoaderDarwin::Segment *
 DynamicLoaderDarwin::ImageInfo::FindSegment(ConstString name) const {
   const size_t num_segments = segments.size();
   for (size_t i = 0; i < num_segments; ++i) {
     if (segments[i].name == name)
       return &segments[i];
   }
   return nullptr;

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

public:
   void ResetDiscoverableSettings(bool did_exec);
 
   bool GetHostInfo(bool force = false);
 
   bool GetDefaultThreadId(lldb::tid_t &tid);
 
   llvm::VersionTuple GetOSVersion();
 
+  llvm::VersionTuple GetMacCatalystVersion();
+
   bool GetOSBuildString(std::string &s);
 
   bool GetOSKernelDescription(std::string &s);
 
   ArchSpec GetSystemArchitecture();
 
   bool GetHostname(std::string &s);
 
protected:
   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;
   llvm::VersionTuple m_os_version;
+  llvm::VersionTuple m_maccatalyst_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

int GDBRemoteCommunicationClient::SendLaunchEventDataPacket(
   return -1;
 }
 
 llvm::VersionTuple GDBRemoteCommunicationClient::GetOSVersion() {
   GetHostInfo();
   return m_os_version;
 }
 
+llvm::VersionTuple GDBRemoteCommunicationClient::GetMacCatalystVersion() {
+  GetHostInfo();
+  return m_maccatalyst_version;
+}
+
 bool GDBRemoteCommunicationClient::GetOSBuildString(std::string &s) {
   if (GetHostInfo()) {
     if (!m_os_build.empty()) {
       s = m_os_build;
       return true;
     }
   }
   s.clear();
if (SendPacketAndWaitForResponse("qHostInfo", response, false) ==
         PacketResult::Success) {
       if (response.IsNormalResponse()) {
         llvm::StringRef name;
         llvm::StringRef value;
         uint32_t cpu = LLDB_INVALID_CPUTYPE;
         uint32_t sub = 0;
         std::string arch_name;
         std::string os_name;
+        std::string environment;
         std::string vendor_name;
         std::string triple;
         std::string distribution_id;
         uint32_t pointer_byte_size = 0;
         ByteOrder byte_order = eByteOrderInvalid;
         uint32_t num_keys_decoded = 0;
         while (response.GetNameColonValue(name, value)) {
           if (name.equals("cputype")) {
if (SendPacketAndWaitForResponse("qHostInfo", response, false) ==
             StringExtractor extractor(value);
             extractor.GetHexByteString(m_hostname);
             ++num_keys_decoded;
           } else if (name.equals("os_kernel")) {
             StringExtractor extractor(value);
             extractor.GetHexByteString(m_os_kernel);
             ++num_keys_decoded;
           } else if (name.equals("ostype")) {
+            if (value.equals("maccatalyst")) {
+              os_name = "ios";
+              environment = "macabi";
+            } else
               os_name = value;
             ++num_keys_decoded;
           } else if (name.equals("vendor")) {
             vendor_name = value;
             ++num_keys_decoded;
           } else if (name.equals("endian")) {
             byte_order = llvm::StringSwitch<lldb::ByteOrder>(value)
                              .Case("little", eByteOrderLittle)
                              .Case("big", eByteOrderBig)
                              .Case("pdp", eByteOrderPDP)
                              .Default(eByteOrderInvalid);
             if (byte_order != eByteOrderInvalid)
               ++num_keys_decoded;
           } else if (name.equals("ptrsize")) {
             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"...
           {
             if (!m_os_version.tryParse(value))
               ++num_keys_decoded;
+          } else if (name.equals("maccatalyst_version")) {
+            if (!m_maccatalyst_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)
               ++num_keys_decoded;
if (SendPacketAndWaitForResponse("qHostInfo", response, false) ==
                 assert(byte_order == m_host_arch.GetByteOrder());
               }
 
               if (!vendor_name.empty())
                 m_host_arch.GetTriple().setVendorName(
                     llvm::StringRef(vendor_name));
               if (!os_name.empty())
                 m_host_arch.GetTriple().setOSName(llvm::StringRef(os_name));
+              if (!environment.empty())
+                m_host_arch.GetTriple().setEnvironmentName(environment);
             }
           } else {
             std::string triple;
             triple += arch_name;
             if (!vendor_name.empty() || !os_name.empty()) {
               triple += '-';
               if (vendor_name.empty())
                 triple += "unknown";
if (SendPacketAndWaitForResponse("qProcessInfo", response, false) ==
       PacketResult::Success) {
     if (response.IsNormalResponse()) {
       llvm::StringRef name;
       llvm::StringRef value;
       uint32_t cpu = LLDB_INVALID_CPUTYPE;
       uint32_t sub = 0;
       std::string arch_name;
       std::string os_name;
+      std::string environment;
       std::string vendor_name;
       std::string triple;
       std::string elf_abi;
       uint32_t pointer_byte_size = 0;
       StringExtractor extractor;
       ByteOrder byte_order = eByteOrderInvalid;
       uint32_t num_keys_decoded = 0;
       lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
       while (response.GetNameColonValue(name, value)) {
         if (name.equals("cputype")) {
           if (!value.getAsInteger(16, cpu))
             ++num_keys_decoded;
         } else if (name.equals("cpusubtype")) {
           if (!value.getAsInteger(16, sub))
             ++num_keys_decoded;
         } else if (name.equals("triple")) {
           StringExtractor extractor(value);
           extractor.GetHexByteString(triple);
           ++num_keys_decoded;
         } else if (name.equals("ostype")) {
+          if (value.equals("maccatalyst")) {
+            os_name = "ios";
+            environment = "macabi";
+          } else
             os_name = value;
           ++num_keys_decoded;
         } else if (name.equals("vendor")) {
           vendor_name = value;
           ++num_keys_decoded;
         } else if (name.equals("endian")) {
           byte_order = llvm::StringSwitch<lldb::ByteOrder>(value)
                            .Case("little", eByteOrderLittle)
                            .Case("big", eByteOrderBig)
if (response.IsNormalResponse()) {
         m_process_arch.SetTriple(triple.c_str());
         m_process_arch.SetFlags(elf_abi);
         if (pointer_byte_size) {
           assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
         }
       } else if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() &&
                  !vendor_name.empty()) {
         llvm::Triple triple(llvm::Twine("-") + vendor_name + "-" + os_name);
+        if (!environment.empty())
+            triple.setEnvironmentName(environment);
 
         assert(triple.getObjectFormat() != llvm::Triple::UnknownObjectFormat);
         assert(triple.getObjectFormat() != llvm::Triple::Wasm);
         assert(triple.getObjectFormat() != llvm::Triple::XCOFF);
         switch (triple.getObjectFormat()) {
         case llvm::Triple::MachO:
           m_process_arch.SetArchitecture(eArchTypeMachO, cpu, sub);
           break;
if (response.IsNormalResponse()) {
         if (pointer_byte_size) {
           assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
         }
         if (byte_order != eByteOrderInvalid) {
           assert(byte_order == m_process_arch.GetByteOrder());
         }
         m_process_arch.GetTriple().setVendorName(llvm::StringRef(vendor_name));
         m_process_arch.GetTriple().setOSName(llvm::StringRef(os_name));
+        m_process_arch.GetTriple().setEnvironmentName(llvm::StringRef(environment));
         m_host_arch.GetTriple().setVendorName(llvm::StringRef(vendor_name));
         m_host_arch.GetTriple().setOSName(llvm::StringRef(os_name));
+        m_host_arch.GetTriple().setEnvironmentName(llvm::StringRef(environment));
       }
       return true;
     }
   } else {
     m_qProcessInfo_is_valid = eLazyBoolNo;
   }
 
   return false;

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

#endif
   }
 
   llvm::VersionTuple version = HostInfo::GetOSVersion();
   if (!version.empty()) {
     response.Format("os_version:{0}", version.getAsString());
     response.PutChar(';');
   }
 
+#if defined(__APPLE__)
+  llvm::VersionTuple maccatalyst_version = HostInfo::GetMacCatalystVersion();
+  if (!maccatalyst_version.empty()) {
+    response.Format("maccatalyst_version:{0}",
+                    maccatalyst_version.getAsString());
+    response.PutChar(';');
+  }
+#endif
+
   std::string s;
   if (HostInfo::GetOSBuildString(s)) {
     response.PutCString("os_build:");
     response.PutStringAsRawHex8(s);
     response.PutChar(';');
   }
   if (HostInfo::GetOSKernelDescription(s)) {
     response.PutCString("os_kernel:");

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

public:
 
   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;
 
   llvm::VersionTuple GetHostOSVersion() override;
+  llvm::VersionTuple GetHostMacCatalystVersion() override;
 
   llvm::Error LoadModules() override;
 
   llvm::Expected<LoadedModuleInfoList> GetLoadedModuleList() 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 ModuleSpec &spec : *module_specs)
                                            triple.getTriple())] = spec;
   }
 }
 
 llvm::VersionTuple ProcessGDBRemote::GetHostOSVersion() {
   return m_gdb_comm.GetOSVersion();
 }
 
+llvm::VersionTuple ProcessGDBRemote::GetHostMacCatalystVersion() {
+  return m_gdb_comm.GetMacCatalystVersion();
+}
+
 namespace {
 
 typedef std::vector<std::string> stringVec;
 
 typedef std::vector<struct GdbServerRegisterInfo> GDBServerRegisterVec;
 struct RegisterSetInfo {
   ConstString name;
 };

lldb/trunk/tools/debugserver/source/MacOSX/MachProcess.mm

if (lc.cmd == LC_UUID) {
       if (ReadMemory(load_cmds_p, sizeof(struct uuid_command), &uuidcmd) ==
           sizeof(struct uuid_command))
         uuid_copy(inf.uuid, uuidcmd.uuid);
     }
 
     uint32_t major_version, minor_version, patch_version;
     if (const char *lc_platform = GetDeploymentInfo(
             lc, load_cmds_p, major_version, minor_version, patch_version)) {
-      // APPLE INTERNAL: macCatalyst support
+      // macCatalyst support.
+      //
       // This handles two special cases:
-      // 1. Zippered frameworks have two deployment info load commands.
-      //    Make sure to select the requested one.
-      // 2. The xctest binary is a pure macOS binary but is launched with
-      //    DYLD_FORCE_PLATFORM=6.
+      //
+      // 1. Frameworks that have both a PLATFORM_MACOS and a
+      //    PLATFORM_MACCATALYST load command.  Make sure to select
+      //    the requested one.
+      //
+      // 2. The xctest binary is a pure macOS binary but is launched
+      //    with DYLD_FORCE_PLATFORM=6.
       if (dyld_platform == PLATFORM_MACCATALYST &&
           inf.mach_header.filetype == MH_EXECUTE &&
           inf.min_version_os_name.empty() &&
           (strcmp("macosx", lc_platform) == 0)) {
         // DYLD says this *is* a macCatalyst process. If we haven't
         // parsed any load commands, transform a macOS load command
         // into a generic macCatalyst load command. It will be
         // overwritten by a more specific one if there is one.  This
         // is only done for the main executable. It is perfectly fine
         // for a macCatalyst binary to link against a macOS-only framework.
         inf.min_version_os_name = "maccatalyst";
         inf.min_version_os_version = GetMacCatalystVersionString();
       } else if (dyld_platform != PLATFORM_MACCATALYST &&
                  inf.min_version_os_name == "macosx") {
-        // This is a zippered binary and the process is not running as
-        // PLATFORM_MACCATALYST. Stick with the macosx load command
-        // that we've already processed, ignore this one, which is
-        // presumed to be a PLATFORM_MACCATALYST one.
+        // This is a binary with both PLATFORM_MACOS and
+        // PLATFORM_MACCATALYST load commands and the process is not
+        // running as PLATFORM_MACCATALYST. Stick with the
+        // "macosx" load command that we've already processed,
+        // ignore this one, which is presumed to be a
+        // PLATFORM_MACCATALYST one.
       } else {
         inf.min_version_os_name = lc_platform;
         inf.min_version_os_version = "";
         inf.min_version_os_version += std::to_string(major_version);
         inf.min_version_os_version += ".";
         inf.min_version_os_version += std::to_string(minor_version);
         if (patch_version != 0) {
           inf.min_version_os_version += ".";