[lldb] Fix platform selection on Apple Silicon

[JDevlieghere]

Summary

Currently, when connecting to a remote iOS device from the command line on Apple Silicon, we end up using the host platform (PlatfromMacOSX) instead of remote-ios (PlatformRemoteiOS). The reason is that PlatfromMacOSX includes arm64-apple-ios and arm64e-apple-ios as compatible architectures, presumably to support debugging iOS Apps on Apple Silicon [1]. The problem is that if we use the host platform, we don't look for an expanded shared cache on disk and end up reading everything from memory, incurring a significant performance hit.

The crux of this patch is to make PlatfromMacOSX not compatible with arm64(e)-apple-ios. As a result, we now use remote-ios (PlatformRemoteiOS) for debugging iOS apps on Apple Silicon. This has the (unintended) side effect that unlike the host platform, we would no longer check our local shared cache, and incur a performance hit. To avoid that, PlatformRemoteiOS will now also check the local cache to support this use case.

[1] https://support.apple.com/guide/app-store/iphone-ipad-apps-mac-apple-silicon-fird2c7092da/mac

[jasonmolenda]

I see what you're doing, yeah, this makes sense. Sometimes with firmware debugging, we pick a random platform (basically) and this might change which platform gets picked, host versus remote-ios, but I don't think it will matter for them.

[JDevlieghere]

Avoid a performance hit for debugging iOS apps on AS Mac.

[friss]

LGTM

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

size_t GetSoftwareBreakpointTrapOpcode(
       lldb_private::BreakpointSite *bp_site) override;
 
   lldb::BreakpointSP
   SetThreadCreationBreakpoint(lldb_private::Target &target) override;
 
   bool ModuleIsExcludedForUnconstrainedSearches(
       lldb_private::Target &target, const lldb::ModuleSP &module_sp) override;
 
-  void ARMGetSupportedArchitectures(std::vector<lldb_private::ArchSpec> &archs);
+  void
+  ARMGetSupportedArchitectures(std::vector<lldb_private::ArchSpec> &archs,
+                               llvm::Optional<llvm::Triple::OSType> os = {});
 
   void x86GetSupportedArchitectures(std::vector<lldb_private::ArchSpec> &archs);
 
   uint32_t GetResumeCountForLaunchInfo(
       lldb_private::ProcessLaunchInfo &launch_info) override;
 
   lldb::ProcessSP DebugProcess(lldb_private::ProcessLaunchInfo &launch_info,
                                lldb_private::Debugger &debugger,
protected:
 
   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,
       llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules, bool *did_create_ptr);
 
+  virtual bool CheckLocalSharedCache() const { return IsHost(); }
+
   struct SDKEnumeratorInfo {
     lldb_private::FileSpec found_path;
     lldb_private::XcodeSDK::Type sdk_type;
   };
 
   static lldb_private::FileSystem::EnumerateDirectoryResult
   DirectoryEnumerator(void *baton, llvm::sys::fs::file_type file_type,
                       llvm::StringRef path);

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

LLDB_LOGF(log,
             module_spec.GetFileSpec().GetFilename().AsCString(),
             module_spec.GetPlatformFileSpec().GetDirectory().AsCString(),
             module_spec.GetPlatformFileSpec().GetFilename().AsCString(),
             module_spec.GetSymbolFileSpec().GetDirectory().AsCString(),
             module_spec.GetSymbolFileSpec().GetFilename().AsCString());
 
   Status err;
 
-  if (IsHost()) {
+  if (CheckLocalSharedCache()) {
     // When debugging on the host, we are most likely using the same shared
     // cache as our inferior. The dylibs from the shared cache might not
     // exist on the filesystem, so let's use the images in our own memory
     // to create the modules.
 
     // Check if the requested image is in our shared cache.
     SharedCacheImageInfo image_info =
         HostInfo::GetSharedCacheImageInfo(module_spec.GetFileSpec().GetPath());
if (idx < compatible_archs.size())
     return compatible_archs[idx];
   return nullptr;
 }
 
 /// The architecture selection rules for arm processors These cpu subtypes have
 /// distinct names (e.g. armv7f) but armv7 binaries run fine on an armv7f
 /// processor.
 void PlatformDarwin::ARMGetSupportedArchitectures(
-    std::vector<ArchSpec> &archs) {
+    std::vector<ArchSpec> &archs, llvm::Optional<llvm::Triple::OSType> os) {
   const ArchSpec system_arch = GetSystemArchitecture();
   const ArchSpec::Core system_core = system_arch.GetCore();
 
   const char *compatible_arch;
   for (unsigned idx = 0;
        (compatible_arch = GetCompatibleArch(system_core, idx)); ++idx) {
     llvm::Triple triple;
     triple.setArchName(compatible_arch);
     triple.setVendor(llvm::Triple::VendorType::Apple);
+    if (os)
+      triple.setOS(*os);
     archs.push_back(ArchSpec(triple));
   }
 }
 
 static FileSpec GetXcodeSelectPath() {
   static FileSpec g_xcode_select_filespec;
 
   if (!g_xcode_select_filespec) {

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

ConstString PlatformMacOSX::GetSDKDirectory(lldb_private::Target &target) {
 
   return {};
 }
 
 std::vector<ArchSpec> PlatformMacOSX::GetSupportedArchitectures() {
   std::vector<ArchSpec> result;
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
   // macOS for ARM64 support both native and translated x86_64 processes
-  ARMGetSupportedArchitectures(result);
+  ARMGetSupportedArchitectures(result, llvm::Triple::MacOSX);
 
   // We can't use x86GetSupportedArchitectures() because it uses
   // the system architecture for some of its return values and also
   // has a 32bits variant.
   result.push_back(ArchSpec("x86_64-apple-macosx"));
   result.push_back(ArchSpec("x86_64-apple-ios-macabi"));
-  result.push_back(ArchSpec("arm64-apple-ios"));
-  result.push_back(ArchSpec("arm64e-apple-ios"));
 #else
   x86GetSupportedArchitectures(result);
 #endif
   return result;
 }
 
 lldb_private::Status PlatformMacOSX::GetSharedModule(
     const lldb_private::ModuleSpec &module_spec, Process *process,

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteMacOSX.cpp

LLDB_LOGF(log, "PlatformRemoteMacOSX::%s() aborting creation of platform",
             __FUNCTION__);
 
   return PlatformSP();
 }
 
 std::vector<ArchSpec> PlatformRemoteMacOSX::GetSupportedArchitectures() {
   // macOS for ARM64 support both native and translated x86_64 processes
   std::vector<ArchSpec> result;
-  ARMGetSupportedArchitectures(result);
+  ARMGetSupportedArchitectures(result, llvm::Triple::MacOSX);
 
   // We can't use x86GetSupportedArchitectures() because it uses
   // the system architecture for some of its return values and also
   // has a 32bits variant.
   result.push_back(ArchSpec("x86_64-apple-macosx"));
   result.push_back(ArchSpec("x86_64-apple-ios-macabi"));
   result.push_back(ArchSpec("arm64-apple-ios"));
   result.push_back(ArchSpec("arm64e-apple-ios"));

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.h

public:
   llvm::StringRef GetDescription() override { return GetDescriptionStatic(); }
 
   // lldb_private::PluginInterface functions
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
   std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() override;
 
 protected:
+  bool CheckLocalSharedCache() const override;
+
   llvm::StringRef GetDeviceSupportDirectoryName() override;
   llvm::StringRef GetPlatformName() override;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEIOS_H

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp

 }
 
 /// Default Constructor
 PlatformRemoteiOS::PlatformRemoteiOS()
     : PlatformRemoteDarwinDevice() {}
 
 std::vector<ArchSpec> PlatformRemoteiOS::GetSupportedArchitectures() {
   std::vector<ArchSpec> result;
-  ARMGetSupportedArchitectures(result);
+  ARMGetSupportedArchitectures(result, llvm::Triple::IOS);
   return result;
 }
 
+bool PlatformRemoteiOS::CheckLocalSharedCache() const {
+  // You can run iPhone and iPad apps on Mac with Apple Silicon. At the
+  // platform level there's no way to distinguish them from remote iOS
+  // applications. Make sure we still read from our own shared cache.
+  return true;
+}
+
 llvm::StringRef PlatformRemoteiOS::GetDeviceSupportDirectoryName() {
   return "iOS DeviceSupport";
 }
 
 llvm::StringRef PlatformRemoteiOS::GetPlatformName() {
   return "iPhoneOS.platform";
 }