[lldb] Plumb host architecture through platform selection

[JDevlieghere]

Summary

Plumb the host architecture through platform selection in preparation for D121444.

[labath]

I'm not sure what would be a good way to denote that the new argument represents the architecture of the host running the debugged process, and not the one running lldb. This isn't helped by the fact that some of the darwin platforms use GetSystemArchitecture in their implementations (which, afaict, does mean the lldb host architecture). Having at least a comment would be nice.

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

134

I'm not sure the default argument value is that useful.

[JDevlieghere]

In D121484#3378923, @labath wrote:

I'm not sure what would be a good way to denote that the new argument represents the architecture of the host running the debugged process, and not the one running lldb. This isn't helped by the fact that some of the darwin platforms use GetSystemArchitecture in their implementations (which, afaict, does mean the lldb host architecture). Having at least a comment would be nice.

Maybe platform_host_architecture or platform_architecture?

[labath]

In D121484#3379532, @JDevlieghere wrote:

In D121484#3378923, @labath wrote:

I'm not sure what would be a good way to denote that the new argument represents the architecture of the host running the debugged process, and not the one running lldb. This isn't helped by the fact that some of the darwin platforms use GetSystemArchitecture in their implementations (which, afaict, does mean the lldb host architecture). Having at least a comment would be nice.

Maybe platform_host_architecture

Maybe. Maybe even process_host_architecture. But that's quite a mouthful.

or platform_architecture?

That still sounds confusing to me.

[JDevlieghere]

In D121484#3379564, @labath wrote:

In D121484#3379532, @JDevlieghere wrote:

In D121484#3378923, @labath wrote:

I'm not sure what would be a good way to denote that the new argument represents the architecture of the host running the debugged process, and not the one running lldb. This isn't helped by the fact that some of the darwin platforms use GetSystemArchitecture in their implementations (which, afaict, does mean the lldb host architecture). Having at least a comment would be nice.

Maybe platform_host_architecture

Maybe. Maybe even process_host_architecture. But that's quite a mouthful.

I prefer being verbose over ambiguous. Let's go with this.

or platform_architecture?

That still sounds confusing to me.

Agreed.

lldb/include/lldb/Target/Platform.h

public:
   /// macros or other similar build mechanisms in a
   /// PlatformSubclass::Initialize() function.
   ///
   /// This platform will be used as the default platform when launching or
   /// attaching to processes unless another platform is specified.
   static lldb::PlatformSP GetHostPlatform();
 
   static lldb::PlatformSP
-  GetPlatformForArchitecture(const ArchSpec &arch, ArchSpec *platform_arch_ptr);
+  GetPlatformForArchitecture(const ArchSpec &arch,
+                             const ArchSpec &process_host_arch = {},
+                             ArchSpec *platform_arch_ptr = nullptr);
 
   static const char *GetHostPlatformName();
 
   static void SetHostPlatform(const lldb::PlatformSP &platform_sp);
 
   // Find an existing platform plug-in by name
   static lldb::PlatformSP Find(ConstString name);
 
   static lldb::PlatformSP Create(ConstString name, Status &error);
 
   static lldb::PlatformSP Create(const ArchSpec &arch,
+                                 const ArchSpec &process_host_arch,
                                  ArchSpec *platform_arch_ptr, Status &error);
 
   /// Augments the triple either with information from platform or the host
   /// system (if platform is null).
   static ArchSpec GetAugmentedArchSpec(Platform *platform,
                                        llvm::StringRef triple);
 
   /// Find a platform plugin for a given process.
virtual bool GetModuleSpec(const FileSpec &module_file_spec,
                              const ArchSpec &arch, ModuleSpec &module_spec);
 
   virtual Status ConnectRemote(Args &args);
 
   virtual Status DisconnectRemote();
 
   /// Get the platform's supported architectures in the order in which they
   /// should be searched.
-  virtual std::vector<ArchSpec> GetSupportedArchitectures() = 0;
+  virtual std::vector<ArchSpec>
+  GetSupportedArchitectures(const ArchSpec &process_host_arch) = 0;
 
   virtual size_t GetSoftwareBreakpointTrapOpcode(Target &target,
                                                  BreakpointSite *bp_site);
 
   /// Launch a new process on a platform, not necessarily for debugging, it
   /// could be just for running the process.
   virtual Status LaunchProcess(ProcessLaunchInfo &launch_info);
 
   /// Perform expansion of the command-line for this launch info This can
   /// potentially involve wildcard expansion
   /// environment variable replacement, and whatever other
   /// argument magic the platform defines as part of its typical
   /// user experience
   virtual Status ShellExpandArguments(ProcessLaunchInfo &launch_info);
 
   /// Kill process on a platform.
   virtual Status KillProcess(const lldb::pid_t pid);
 
   /// Lets a platform answer if it is compatible with a given architecture and
   /// the target triple contained within.
   virtual bool IsCompatibleArchitecture(const ArchSpec &arch,
+                                        const ArchSpec &process_host_arch,
                                         bool exact_arch_match,
                                         ArchSpec *compatible_arch_ptr);
 
   /// Not all platforms will support debugging a process by spawning somehow
   /// halted for a debugger (specified using the "eLaunchFlagDebug" launch
   /// flag) and then attaching. If your platform doesn't support this,
   /// override this function and return false.
   virtual bool CanDebugProcess() { return true; }

lldb/source/Interpreter/OptionGroupPlatform.cpp

 PlatformSP OptionGroupPlatform::CreatePlatformWithOptions(
     CommandInterpreter &interpreter, const ArchSpec &arch, bool make_selected,
     Status &error, ArchSpec &platform_arch) const {
   PlatformSP platform_sp;
 
   if (!m_platform_name.empty()) {
     platform_sp = Platform::Create(ConstString(m_platform_name.c_str()), error);
     if (platform_sp) {
-      if (platform_arch.IsValid() &&
-          !platform_sp->IsCompatibleArchitecture(arch, false, &platform_arch)) {
+      if (platform_arch.IsValid() && !platform_sp->IsCompatibleArchitecture(
+                                         arch, {}, false, &platform_arch)) {
         error.SetErrorStringWithFormatv("platform '{0}' doesn't support '{1}'",
                                         platform_sp->GetPluginName(),
                                         arch.GetTriple().getTriple());
         platform_sp.reset();
         return platform_sp;
       }
     }
   } else if (arch.IsValid()) {
-    platform_sp = Platform::Create(arch, &platform_arch, error);
+    platform_sp = Platform::Create(arch, {}, &platform_arch, error);
   }
 
   if (platform_sp) {
     interpreter.GetDebugger().GetPlatformList().Append(platform_sp,
                                                        make_selected);
     if (!m_os_version.empty())
       platform_sp->SetOSVersion(m_os_version);
 

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h

public:
 
   // lldb_private::Platform functions
   llvm::StringRef GetDescription() override {
     return GetPluginDescriptionStatic(IsHost());
   }
 
   void GetStatus(Stream &strm) override;
 
-  std::vector<ArchSpec> GetSupportedArchitectures() override;
+  std::vector<ArchSpec>
+  GetSupportedArchitectures(const ArchSpec &process_host_arch) override;
 
   bool CanDebugProcess() override;
 
   void CalculateTrapHandlerSymbolNames() override;
 
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

if (is_host) {
     m_supported_architectures = CreateArchList(
         {llvm::Triple::x86_64, llvm::Triple::x86, llvm::Triple::aarch64,
          llvm::Triple::arm, llvm::Triple::mips64, llvm::Triple::ppc64,
          llvm::Triple::ppc},
         llvm::Triple::FreeBSD);
   }
 }
 
-std::vector<ArchSpec> PlatformFreeBSD::GetSupportedArchitectures() {
+std::vector<ArchSpec>
+PlatformFreeBSD::GetSupportedArchitectures(const ArchSpec &process_host_arch) {
   if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetSupportedArchitectures();
+    return m_remote_platform_sp->GetSupportedArchitectures(process_host_arch);
   return m_supported_architectures;
 }
 
 void PlatformFreeBSD::GetStatus(Stream &strm) {
   Platform::GetStatus(strm);
 
 #if LLDB_ENABLE_POSIX
   // Display local kernel information only when we are running in host mode.

lldb/source/Plugins/Platform/Linux/PlatformLinux.h

public:
 
   // lldb_private::Platform functions
   llvm::StringRef GetDescription() override {
     return GetPluginDescriptionStatic(IsHost());
   }
 
   void GetStatus(Stream &strm) override;
 
-  std::vector<ArchSpec> GetSupportedArchitectures() override;
+  std::vector<ArchSpec>
+  GetSupportedArchitectures(const ArchSpec &process_host_arch) override;
 
   uint32_t GetResumeCountForLaunchInfo(ProcessLaunchInfo &launch_info) override;
 
   bool CanDebugProcess() override;
 
   void CalculateTrapHandlerSymbolNames() override;
 
   lldb::UnwindPlanSP GetTrapHandlerUnwindPlan(const llvm::Triple &triple,

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

m_supported_architectures = CreateArchList(
         {llvm::Triple::x86_64, llvm::Triple::x86, llvm::Triple::arm,
          llvm::Triple::aarch64, llvm::Triple::mips64, llvm::Triple::mips64,
          llvm::Triple::hexagon, llvm::Triple::mips, llvm::Triple::mips64el,
          llvm::Triple::mipsel, llvm::Triple::systemz},
         llvm::Triple::Linux);
   }
 }
 
-std::vector<ArchSpec> PlatformLinux::GetSupportedArchitectures() {
+std::vector<ArchSpec>
+PlatformLinux::GetSupportedArchitectures(const ArchSpec &process_host_arch) {
   if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetSupportedArchitectures();
+    return m_remote_platform_sp->GetSupportedArchitectures(process_host_arch);
   return m_supported_architectures;
 }
 
 void PlatformLinux::GetStatus(Stream &strm) {
   Platform::GetStatus(strm);
 
 #if LLDB_ENABLE_POSIX
   // Display local kernel information only when we are running in host mode.

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

public:
 
   lldb_private::Status DisconnectRemote() override;
 
   lldb::ProcessSP DebugProcess(lldb_private::ProcessLaunchInfo &launch_info,
                                lldb_private::Debugger &debugger,
                                lldb_private::Target &target,
                                lldb_private::Status &error) override;
 
-  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures(
+      const lldb_private::ArchSpec &process_host_arch) override;
 
   lldb_private::Status ResolveExecutable(
       const lldb_private::ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
       const lldb_private::FileSpecList *module_search_paths_ptr) override;
 
   lldb_private::Status
   GetSharedModule(const lldb_private::ModuleSpec &module_spec,
                   lldb_private::Process *process, lldb::ModuleSP &module_sp,

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

CoreSimulatorSupport::Device PlatformAppleSimulator::GetSimulatorDevice() {
 
   if (m_device.hasValue())
     return m_device.getValue();
   else
     return CoreSimulatorSupport::Device();
 }
 #endif
 
-std::vector<ArchSpec> PlatformAppleSimulator::GetSupportedArchitectures() {
+std::vector<ArchSpec> PlatformAppleSimulator::GetSupportedArchitectures(
+    const ArchSpec &process_host_arch) {
   std::vector<ArchSpec> result(m_supported_triples.size());
   llvm::transform(m_supported_triples, result.begin(),
                   [](llvm::StringRef triple) { return ArchSpec(triple); });
   return result;
 }
 
 PlatformSP PlatformAppleSimulator::CreateInstance(
     const char *class_name, const char *description, ConstString plugin_name,
if (resolved_module_spec.GetArchitecture().IsValid()) {
       exe_module_sp.reset();
     }
     // No valid architecture was specified or the exact ARM slice wasn't found
     // so ask the platform for the architectures that we should be using (in
     // the correct order) and see if we can find a match that way
     StreamString arch_names;
     llvm::ListSeparator LS;
     ArchSpec platform_arch;
-    for (const ArchSpec &arch : GetSupportedArchitectures()) {
+    for (const ArchSpec &arch : GetSupportedArchitectures({})) {
       resolved_module_spec.GetArchitecture() = arch;
 
       // Only match x86 with x86 and x86_64 with x86_64...
       if (!module_spec.GetArchitecture().IsValid() ||
           module_spec.GetArchitecture().GetCore() ==
               resolved_module_spec.GetArchitecture().GetCore()) {
         error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
                                             NULL, NULL, NULL);

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

public:
 
   lldb_private::Status
   GetSharedModule(const lldb_private::ModuleSpec &module_spec,
                   lldb_private::Process *process, lldb::ModuleSP &module_sp,
                   const lldb_private::FileSpecList *module_search_paths_ptr,
                   llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules,
                   bool *did_create_ptr) override;
 
-  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures(
+      const lldb_private::ArchSpec &process_host_arch) override;
 
   bool SupportsModules() override { return false; }
 
   void CalculateTrapHandlerSymbolNames() override;
 
 protected:
   // Map from kext bundle ID ("com.apple.filesystems.exfat") to FileSpec for the
   // kext bundle on

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

if (FileSystem::Instance().Exists(exe_file)) {
       }
       exe_module_sp.reset();
     }
   }
 
   return {};
 }
 
-std::vector<ArchSpec> PlatformDarwinKernel::GetSupportedArchitectures() {
+std::vector<ArchSpec> PlatformDarwinKernel::GetSupportedArchitectures(
+    const ArchSpec &process_host_arch) {
   std::vector<ArchSpec> result;
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
   ARMGetSupportedArchitectures(result);
 #else
   x86GetSupportedArchitectures(result);
 #endif
   return result;
 }

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

public:
   llvm::StringRef GetDescription() override { return GetDescriptionStatic(); }
 
   lldb_private::Status
   GetFile(const lldb_private::FileSpec &source,
           const lldb_private::FileSpec &destination) override {
     return PlatformDarwin::GetFile(source, destination);
   }
 
-  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures(
+      const lldb_private::ArchSpec &process_host_arch) override;
 
   lldb_private::ConstString
   GetSDKDirectory(lldb_private::Target &target) override;
 
   void
   AddClangModuleCompilationOptions(lldb_private::Target *target,
                                    std::vector<std::string> &options) override {
     return PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
         target, options, lldb_private::XcodeSDK::Type::MacOSX);
   }
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMMACOSX_H

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

ConstString PlatformMacOSX::GetSDKDirectory(lldb_private::Target &target) {
   if (fspec) {
     if (FileSystem::Instance().Exists(fspec))
       return ConstString(fspec.GetPath());
   }
 
   return {};
 }
 
-std::vector<ArchSpec> PlatformMacOSX::GetSupportedArchitectures() {
+std::vector<ArchSpec>
+PlatformMacOSX::GetSupportedArchitectures(const ArchSpec &process_host_arch) {
   std::vector<ArchSpec> result;
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
   // macOS for ARM64 support both native and translated x86_64 processes
 
   // When cmdline lldb is run on iOS, watchOS, etc, it is still
   // using "PlatformMacOSX".
   llvm::Triple::OSType host_os = GetHostOSType();
   ARMGetSupportedArchitectures(result, host_os);

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

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

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

#endif
 
   return lldb::PlatformSP();
 }
 
 llvm::StringRef PlatformRemoteAppleBridge::GetDescriptionStatic() {
   return "Remote BridgeOS platform plug-in.";
 }
 
-std::vector<ArchSpec> PlatformRemoteAppleBridge::GetSupportedArchitectures() {
+std::vector<ArchSpec> PlatformRemoteAppleBridge::GetSupportedArchitectures(
+    const ArchSpec &process_host_arch) {
   return {ArchSpec("arm64-apple-bridgeos")};
 }
 
 llvm::StringRef PlatformRemoteAppleBridge::GetDeviceSupportDirectoryName() {
   return "BridgeOS DeviceSupport";
 }
 
 llvm::StringRef PlatformRemoteAppleBridge::GetPlatformName() {
   return "BridgeOS.platform";
 }

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

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

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

#endif
 
   return lldb::PlatformSP();
 }
 
 llvm::StringRef PlatformRemoteAppleTV::GetDescriptionStatic() {
   return "Remote Apple TV platform plug-in.";
 }
 
-std::vector<ArchSpec> PlatformRemoteAppleTV::GetSupportedArchitectures() {
+std::vector<ArchSpec> PlatformRemoteAppleTV::GetSupportedArchitectures(
+    const ArchSpec &process_host_arch) {
   ArchSpec system_arch(GetSystemArchitecture());
 
   const ArchSpec::Core system_core = system_arch.GetCore();
   switch (system_core) {
   default:
   case ArchSpec::eCore_arm_arm64:
     return {ArchSpec("arm64-apple-tvos"), ArchSpec("armv7s-apple-tvos"),
             ArchSpec("armv7-apple-tvos"), ArchSpec("thumbv7s-apple-tvos"),

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

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

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

 llvm::StringRef PlatformRemoteAppleWatch::GetDescriptionStatic() {
   return "Remote Apple Watch platform plug-in.";
 }
 
 /// Default Constructor
 PlatformRemoteAppleWatch::PlatformRemoteAppleWatch()
     : PlatformRemoteDarwinDevice() {}
 
-std::vector<ArchSpec> PlatformRemoteAppleWatch::GetSupportedArchitectures() {
+std::vector<ArchSpec>
+PlatformRemoteAppleWatch::GetSupportedArchitectures(const ArchSpec &host_info) {
   ArchSpec system_arch(GetSystemArchitecture());
 
   const ArchSpec::Core system_core = system_arch.GetCore();
   switch (system_core) {
   default:
   case ArchSpec::eCore_arm_arm64:
     return {
         ArchSpec("arm64-apple-watchos"),    ArchSpec("armv7k-apple-watchos"),

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

if (resolved_module_spec.GetArchitecture().IsValid() ||
         return error;
       exe_module_sp.reset();
     }
     // No valid architecture was specified or the exact ARM slice wasn't found
     // so ask the platform for the architectures that we should be using (in
     // the correct order) and see if we can find a match that way
     StreamString arch_names;
     llvm::ListSeparator LS;
-    for (const ArchSpec &arch : GetSupportedArchitectures()) {
+    ArchSpec process_host_arch;
+    for (const ArchSpec &arch : GetSupportedArchitectures(process_host_arch)) {
       resolved_module_spec.GetArchitecture() = arch;
       error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
                                           nullptr, nullptr, nullptr);
       // Did we find an executable using one of the
       if (error.Success()) {
         if (exe_module_sp && exe_module_sp->GetObjectFile())
           break;
         else

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

public:
 
   llvm::StringRef GetDescription() override { return GetDescriptionStatic(); }
 
   lldb_private::Status
   GetFileWithUUID(const lldb_private::FileSpec &platform_file,
                   const lldb_private::UUID *uuid_ptr,
                   lldb_private::FileSpec &local_file) override;
 
-  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures(
+      const lldb_private::ArchSpec &process_host_arch) override;
 
 protected:
   llvm::StringRef GetDeviceSupportDirectoryName() override;
   llvm::StringRef GetPlatformName() override;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEMACOSX_H

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

#endif
   }
 
   LLDB_LOGF(log, "PlatformRemoteMacOSX::%s() aborting creation of platform",
             __FUNCTION__);
 
   return PlatformSP();
 }
 
-std::vector<ArchSpec> PlatformRemoteMacOSX::GetSupportedArchitectures() {
+std::vector<ArchSpec>
+PlatformRemoteMacOSX::GetSupportedArchitectures(const ArchSpec &host_info) {
   // macOS for ARM64 support both native and translated x86_64 processes
   std::vector<ArchSpec> 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"));

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

public:
 
   // lldb_private::Platform functions
 
   llvm::StringRef GetDescription() override { return GetDescriptionStatic(); }
 
   // lldb_private::PluginInterface functions
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
-  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures(
+      const lldb_private::ArchSpec &process_host_arch) 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

 llvm::StringRef PlatformRemoteiOS::GetDescriptionStatic() {
   return "Remote iOS platform plug-in.";
 }
 
 /// Default Constructor
 PlatformRemoteiOS::PlatformRemoteiOS()
     : PlatformRemoteDarwinDevice() {}
 
-std::vector<ArchSpec> PlatformRemoteiOS::GetSupportedArchitectures() {
+std::vector<ArchSpec> PlatformRemoteiOS::GetSupportedArchitectures(
+    const ArchSpec &process_host_arch) {
   std::vector<ArchSpec> 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

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.h

public:
 
   // lldb_private::Platform functions
   llvm::StringRef GetDescription() override {
     return GetPluginDescriptionStatic(IsHost());
   }
 
   void GetStatus(Stream &strm) override;
 
-  std::vector<ArchSpec> GetSupportedArchitectures() override;
+  std::vector<ArchSpec>
+  GetSupportedArchitectures(const ArchSpec &process_host_arch) override;
 
   uint32_t GetResumeCountForLaunchInfo(ProcessLaunchInfo &launch_info) override;
 
   bool CanDebugProcess() override;
 
   void CalculateTrapHandlerSymbolNames() override;
 
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

if (hostArch.GetTriple().isArch64Bit()) {
           HostInfo::GetArchitecture(HostInfo::eArchKind32));
     }
   } else {
     m_supported_architectures = CreateArchList(
         {llvm::Triple::x86_64, llvm::Triple::x86}, llvm::Triple::NetBSD);
   }
 }
 
-std::vector<ArchSpec> PlatformNetBSD::GetSupportedArchitectures() {
+std::vector<ArchSpec>
+PlatformNetBSD::GetSupportedArchitectures(const ArchSpec &process_host_arch) {
   if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetSupportedArchitectures();
+    return m_remote_platform_sp->GetSupportedArchitectures(process_host_arch);
   return m_supported_architectures;
 }
 
 void PlatformNetBSD::GetStatus(Stream &strm) {
   Platform::GetStatus(strm);
 
 #if LLDB_ENABLE_POSIX
   // Display local kernel information only when we are running in host mode.

lldb/source/Plugins/Platform/OpenBSD/PlatformOpenBSD.h

public:
 
   // lldb_private::Platform functions
   llvm::StringRef GetDescription() override {
     return GetPluginDescriptionStatic(IsHost());
   }
 
   void GetStatus(Stream &strm) override;
 
-  std::vector<ArchSpec> GetSupportedArchitectures() override;
+  std::vector<ArchSpec>
+  GetSupportedArchitectures(const ArchSpec &process_host_arch) override;
 
   bool CanDebugProcess() override;
 
   void CalculateTrapHandlerSymbolNames() override;
 
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,

lldb/source/Plugins/Platform/OpenBSD/PlatformOpenBSD.cpp

PlatformOpenBSD::PlatformOpenBSD(bool is_host)
   } else {
     m_supported_architectures =
         CreateArchList({llvm::Triple::x86_64, llvm::Triple::x86,
                         llvm::Triple::aarch64, llvm::Triple::arm},
                        llvm::Triple::OpenBSD);
   }
 }
 
-std::vector<ArchSpec> PlatformOpenBSD::GetSupportedArchitectures() {
+std::vector<ArchSpec>
+PlatformOpenBSD::GetSupportedArchitectures(const ArchSpec &process_host_arch) {
   if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetSupportedArchitectures();
+    return m_remote_platform_sp->GetSupportedArchitectures(process_host_arch);
   return m_supported_architectures;
 }
 
 void PlatformOpenBSD::GetStatus(Stream &strm) {
   Platform::GetStatus(strm);
 
 #if LLDB_ENABLE_POSIX
   // Display local kernel information only when we are running in host mode.

lldb/source/Plugins/Platform/QemuUser/PlatformQemuUser.h

public:
   llvm::StringRef GetDescription() override {
     return GetPluginDescriptionStatic();
   }
 
   UserIDResolver &GetUserIDResolver() override {
     return HostInfo::GetUserIDResolver();
   }
 
-  std::vector<ArchSpec> GetSupportedArchitectures() override;
+  std::vector<ArchSpec>
+  GetSupportedArchitectures(const ArchSpec &process_host_arch) override;
 
   lldb::ProcessSP DebugProcess(ProcessLaunchInfo &launch_info,
                                Debugger &debugger, Target &target,
                                Status &error) override;
 
   lldb::ProcessSP Attach(ProcessAttachInfo &attach_info, Debugger &debugger,
                          Target *target, Status &status) override {
     status.SetErrorString("Not supported");

lldb/source/Plugins/Platform/QemuUser/PlatformQemuUser.cpp

 }
 
 PlatformSP PlatformQemuUser::CreateInstance(bool force, const ArchSpec *arch) {
   if (force)
     return PlatformSP(new PlatformQemuUser());
   return nullptr;
 }
 
-std::vector<ArchSpec> PlatformQemuUser::GetSupportedArchitectures() {
+std::vector<ArchSpec>
+PlatformQemuUser::GetSupportedArchitectures(const ArchSpec &process_host_arch) {
   llvm::Triple triple = HostInfo::GetArchitecture().GetTriple();
   triple.setEnvironment(llvm::Triple::UnknownEnvironment);
   triple.setArchName(GetGlobalProperties().GetArchitecture());
   if (triple.getArch() != llvm::Triple::UnknownArch)
     return {ArchSpec(triple)};
   return {};
 }
 

lldb/source/Plugins/Platform/Windows/PlatformWindows.h

lldb::ProcessSP DebugProcess(lldb_private::ProcessLaunchInfo &launch_info,
                                lldb_private::Target &target,
                                lldb_private::Status &error) override;
 
   lldb::ProcessSP Attach(lldb_private::ProcessAttachInfo &attach_info,
                          lldb_private::Debugger &debugger,
                          lldb_private::Target *target,
                          lldb_private::Status &error) override;
 
-  std::vector<ArchSpec> GetSupportedArchitectures() override {
+  std::vector<ArchSpec>
+  GetSupportedArchitectures(const ArchSpec &process_host_arch) override {
     return m_supported_architectures;
   }
 
   void GetStatus(lldb_private::Stream &strm) override;
 
   bool CanDebugProcess() override;
 
   // FIXME not sure what the _sigtramp equivalent would be on this platform

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

lldb::ProcessSP DebugProcess(ProcessLaunchInfo &launch_info,
                                Debugger &debugger, Target &target,
                                Status &error) override;
 
   lldb::ProcessSP Attach(ProcessAttachInfo &attach_info, Debugger &debugger,
                          Target *target, // Can be NULL, if NULL create a new
                                          // target, else use existing one
                          Status &error) override;
 
-  std::vector<ArchSpec> GetSupportedArchitectures() override {
+  std::vector<ArchSpec>
+  GetSupportedArchitectures(const ArchSpec &process_host_arch) override {
     return m_supported_architectures;
   }
 
   size_t GetSoftwareBreakpointTrapOpcode(Target &target,
                                          BreakpointSite *bp_site) override;
 
   bool GetRemoteOSVersion() override;
 

lldb/source/Target/Platform.cpp

PlatformSP Platform::Create(ConstString name, Status &error) {
   if (platform_sp) {
     std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
     GetPlatformList().push_back(platform_sp);
   }
 
   return platform_sp;
 }
 
-PlatformSP Platform::Create(const ArchSpec &arch, ArchSpec *platform_arch_ptr,
-                            Status &error) {
+PlatformSP Platform::Create(const ArchSpec &arch,
+                            const ArchSpec &process_host_arch,
+                            ArchSpec *platform_arch_ptr, Status &error) {
   lldb::PlatformSP platform_sp;
   if (arch.IsValid()) {
     // Scope for locker
     {
       // First try exact arch matches across all platforms already created
       std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
       for (const auto &platform_sp : GetPlatformList()) {
-        if (platform_sp->IsCompatibleArchitecture(arch, true,
+        if (platform_sp->IsCompatibleArchitecture(arch, process_host_arch, true,
                                                   platform_arch_ptr))
           return platform_sp;
       }
 
       // Next try compatible arch matches across all platforms already created
       for (const auto &platform_sp : GetPlatformList()) {
-        if (platform_sp->IsCompatibleArchitecture(arch, false,
-                                                  platform_arch_ptr))
+        if (platform_sp->IsCompatibleArchitecture(arch, process_host_arch,
+                                                  false, platform_arch_ptr))
           return platform_sp;
       }
     }
 
     PlatformCreateInstance create_callback;
     // First try exact arch matches across all platform plug-ins
     uint32_t idx;
     for (idx = 0; (create_callback =
                        PluginManager::GetPlatformCreateCallbackAtIndex(idx));
          ++idx) {
       if (create_callback) {
         platform_sp = create_callback(false, &arch);
         if (platform_sp &&
-            platform_sp->IsCompatibleArchitecture(arch, true,
+            platform_sp->IsCompatibleArchitecture(arch, process_host_arch, true,
                                                   platform_arch_ptr)) {
           std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
           GetPlatformList().push_back(platform_sp);
           return platform_sp;
         }
       }
     }
     // Next try compatible arch matches across all platform plug-ins
     for (idx = 0; (create_callback =
                        PluginManager::GetPlatformCreateCallbackAtIndex(idx));
          ++idx) {
       if (create_callback) {
         platform_sp = create_callback(false, &arch);
         if (platform_sp &&
-            platform_sp->IsCompatibleArchitecture(arch, false,
-                                                  platform_arch_ptr)) {
+            platform_sp->IsCompatibleArchitecture(arch, process_host_arch,
+                                                  false, platform_arch_ptr)) {
           std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
           GetPlatformList().push_back(platform_sp);
           return platform_sp;
         }
       }
     }
   } else
     error.SetErrorString("invalid platform name");
if (module_spec.GetArchitecture().IsValid()) {
       error = ModuleList::GetSharedModule(module_spec, exe_module_sp,
                                           module_search_paths_ptr, nullptr,
                                           nullptr);
     } else {
       // No valid architecture was specified, ask the platform for the
       // architectures that we should be using (in the correct order) and see
       // if we can find a match that way
       ModuleSpec arch_module_spec(module_spec);
-      for (const ArchSpec &arch : GetSupportedArchitectures()) {
+      ArchSpec process_host_arch;
+      for (const ArchSpec &arch :
+           GetSupportedArchitectures(process_host_arch)) {
         arch_module_spec.GetArchitecture() = arch;
         error = ModuleList::GetSharedModule(arch_module_spec, exe_module_sp,
                                             module_search_paths_ptr, nullptr,
                                             nullptr);
         // Did we find an executable using one of the
         if (error.Success() && exe_module_sp)
           break;
       }
if (resolved_module_spec.GetArchitecture().IsValid() ||
         return error;
       exe_module_sp.reset();
     }
     // No valid architecture was specified or the exact arch wasn't found so
     // ask the platform for the architectures that we should be using (in the
     // correct order) and see if we can find a match that way
     StreamString arch_names;
     llvm::ListSeparator LS;
-    for (const ArchSpec &arch : GetSupportedArchitectures()) {
+    ArchSpec process_host_arch;
+    for (const ArchSpec &arch : GetSupportedArchitectures(process_host_arch)) {
       resolved_module_spec.GetArchitecture() = arch;
       error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
                                           module_search_paths_ptr, nullptr,
                                           nullptr);
       // Did we find an executable using one of the
       if (error.Success()) {
         if (exe_module_sp && exe_module_sp->GetObjectFile())
           break;
ArchSpec Platform::GetAugmentedArchSpec(llvm::StringRef triple) {
   if (!ArchSpec::ContainsOnlyArch(normalized_triple))
     return ArchSpec(triple);
 
   if (auto kind = HostInfo::ParseArchitectureKind(triple))
     return HostInfo::GetArchitecture(*kind);
 
   ArchSpec compatible_arch;
   ArchSpec raw_arch(triple);
-  if (!IsCompatibleArchitecture(raw_arch, false, &compatible_arch))
+  if (!IsCompatibleArchitecture(raw_arch, {}, false, &compatible_arch))
     return raw_arch;
 
   if (!compatible_arch.IsValid())
     return ArchSpec(normalized_triple);
 
   const llvm::Triple &compatible_triple = compatible_arch.GetTriple();
   if (normalized_triple.getVendorName().empty())
     normalized_triple.setVendor(compatible_triple.getVendor());
LLDB_LOGF(log, "Platform::%s LaunchProcess() failed: %s", __FUNCTION__,
               error.AsCString());
   }
 
   return process_sp;
 }
 
 lldb::PlatformSP
 Platform::GetPlatformForArchitecture(const ArchSpec &arch,
+                                     const ArchSpec &process_host_arch,
                                      ArchSpec *platform_arch_ptr) {
   lldb::PlatformSP platform_sp;
   Status error;
   if (arch.IsValid())
-    platform_sp = Platform::Create(arch, platform_arch_ptr, error);
+    platform_sp =
+        Platform::Create(arch, process_host_arch, platform_arch_ptr, error);
   return platform_sp;
 }
 
 std::vector<ArchSpec>
 Platform::CreateArchList(llvm::ArrayRef<llvm::Triple::ArchType> archs,
                          llvm::Triple::OSType os) {
   std::vector<ArchSpec> list;
   for(auto arch : archs) {
     llvm::Triple triple;
     triple.setArch(arch);
     triple.setOS(os);
     list.push_back(ArchSpec(triple));
   }
   return list;
 }
 
 /// Lets a platform answer if it is compatible with a given
 /// architecture and the target triple contained within.
 bool Platform::IsCompatibleArchitecture(const ArchSpec &arch,
+                                        const ArchSpec &process_host_arch,
                                         bool exact_arch_match,
                                         ArchSpec *compatible_arch_ptr) {
   // If the architecture is invalid, we must answer true...
   if (arch.IsValid()) {
     ArchSpec platform_arch;
     auto match = exact_arch_match ? &ArchSpec::IsExactMatch
                                   : &ArchSpec::IsCompatibleMatch;
-    for (const ArchSpec &platform_arch : GetSupportedArchitectures()) {
+    for (const ArchSpec &platform_arch :
+         GetSupportedArchitectures(process_host_arch)) {
       if ((arch.*match)(platform_arch)) {
         if (compatible_arch_ptr)
           *compatible_arch_ptr = platform_arch;
         return true;
       }
     }
   }
   if (compatible_arch_ptr)

 
 Status Platform::GetRemoteSharedModule(const ModuleSpec &module_spec,
                                        Process *process,
                                        lldb::ModuleSP &module_sp,
                                        const ModuleResolver &module_resolver,
                                        bool *did_create_ptr) {
   // Get module information from a target.
   ModuleSpec resolved_module_spec;
+  ArchSpec process_host_arch;
   bool got_module_spec = false;
   if (process) {
+    process_host_arch = process->GetSystemArchitecture();
     // Try to get module information from the process
     if (process->GetModuleSpec(module_spec.GetFileSpec(),
                                module_spec.GetArchitecture(),
                                resolved_module_spec)) {
       if (!module_spec.GetUUID().IsValid() ||
           module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
         got_module_spec = true;
       }
     }
   }
 
   if (!module_spec.GetArchitecture().IsValid()) {
     Status error;
     // No valid architecture was specified, ask the platform for the
     // architectures that we should be using (in the correct order) and see if
     // we can find a match that way
     ModuleSpec arch_module_spec(module_spec);
-    for (const ArchSpec &arch : GetSupportedArchitectures()) {
+    for (const ArchSpec &arch : GetSupportedArchitectures(process_host_arch)) {
       arch_module_spec.GetArchitecture() = arch;
       error = ModuleList::GetSharedModule(arch_module_spec, module_sp, nullptr,
                                           nullptr, nullptr);
       // Did we find an executable using one of the
       if (error.Success() && module_sp)
         break;
     }
     if (module_sp) {

lldb/source/Target/Process.cpp

if (process_arch.IsValid()) {
     }
   }
 
   // We just attached.  If we have a platform, ask it for the process
   // architecture, and if it isn't the same as the one we've already set,
   // switch architectures.
   PlatformSP platform_sp(GetTarget().GetPlatform());
   assert(platform_sp);
+  ArchSpec process_host_arch = GetSystemArchitecture();
   if (platform_sp) {
     const ArchSpec &target_arch = GetTarget().GetArchitecture();
     if (target_arch.IsValid() &&
-        !platform_sp->IsCompatibleArchitecture(target_arch, false, nullptr)) {
+        !platform_sp->IsCompatibleArchitecture(target_arch, process_host_arch,
+                                               false, nullptr)) {
       ArchSpec platform_arch;
-      platform_sp =
-          platform_sp->GetPlatformForArchitecture(target_arch, &platform_arch);
+      platform_sp = platform_sp->GetPlatformForArchitecture(
+          target_arch, process_host_arch, &platform_arch);
       if (platform_sp) {
         GetTarget().SetPlatform(platform_sp);
         GetTarget().SetArchitecture(platform_arch);
         LLDB_LOG(log,
                  "switching platform to {0} and architecture to {1} based on "
                  "info from attach",
                  platform_sp->GetName(), platform_arch.GetTriple().getTriple());
       }

lldb/source/Target/RemoteAwarePlatform.cpp

// it another try.
             resolved_module_spec.GetArchitecture().GetArchitectureName());
       }
     } else {
       // No valid architecture was specified, ask the platform for the
       // architectures that we should be using (in the correct order) and see
       // if we can find a match that way
       StreamString arch_names;
       llvm::ListSeparator LS;
-      for (const ArchSpec &arch : GetSupportedArchitectures()) {
+      ArchSpec process_host_arch;
+      for (const ArchSpec &arch :
+           GetSupportedArchitectures(process_host_arch)) {
         resolved_module_spec.GetArchitecture() = arch;
         error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
                                             module_search_paths_ptr, nullptr, nullptr);
         // Did we find an executable using one of the
         if (error.Success()) {
           if (exe_module_sp && exe_module_sp->GetObjectFile())
             break;
           else

lldb/source/Target/Target.cpp

bool Target::SetArchitecture(const ArchSpec &arch_spec, bool set_platform) {
 
   // Changing the architecture might mean that the currently selected platform
   // isn't compatible. Set the platform correctly if we are asked to do so,
   // otherwise assume the user will set the platform manually.
   if (set_platform) {
     if (other.IsValid()) {
       auto platform_sp = GetPlatform();
       if (!platform_sp ||
-          !platform_sp->IsCompatibleArchitecture(other, false, nullptr)) {
+          !platform_sp->IsCompatibleArchitecture(other, {}, false, nullptr)) {
         ArchSpec platform_arch;
         auto arch_platform_sp =
-            Platform::GetPlatformForArchitecture(other, &platform_arch);
+            Platform::GetPlatformForArchitecture(other, {}, &platform_arch);
         if (arch_platform_sp) {
           SetPlatform(arch_platform_sp);
           if (platform_arch.IsValid())
             other = platform_arch;
         }
       }
     }
   }

lldb/source/Target/TargetList.cpp

if (num_specs > 0) {
         std::vector<PlatformSP> platforms;
         for (size_t i = 0; i < num_specs; ++i) {
           ModuleSpec module_spec;
           if (module_specs.GetModuleSpecAtIndex(i, module_spec)) {
             // First consider the platform specified by the user, if any, and
             // the selected platform otherwise.
             if (platform_sp) {
               if (platform_sp->IsCompatibleArchitecture(
-                      module_spec.GetArchitecture(), false, nullptr)) {
+                      module_spec.GetArchitecture(), {}, false, nullptr)) {
                 platforms.push_back(platform_sp);
                 continue;
               }
             }
 
             // Now consider the host platform if it is different from the
             // specified/selected platform.
             if (host_platform_sp &&
                 (!platform_sp ||
                  host_platform_sp->GetName() != platform_sp->GetName())) {
               if (host_platform_sp->IsCompatibleArchitecture(
-                      module_spec.GetArchitecture(), false, nullptr)) {
+                      module_spec.GetArchitecture(), {}, false, nullptr)) {
                 platforms.push_back(host_platform_sp);
                 continue;
               }
             }
 
             // Finally find a platform that matches the architecture in the
             // executable file.
             PlatformSP fallback_platform_sp(
                 Platform::GetPlatformForArchitecture(
-                    module_spec.GetArchitecture(), nullptr));
+                    module_spec.GetArchitecture()));
             if (fallback_platform_sp) {
               platforms.push_back(fallback_platform_sp);
             }
           }
         }
 
         Platform *platform_ptr = nullptr;
         bool more_than_one_platforms = false;
if (num_specs > 0) {
         }
       }
     }
   }
 
   // If we have a valid architecture, make sure the current platform is
   // compatible with that architecture.
   if (!prefer_platform_arch && arch.IsValid()) {
-    if (!platform_sp->IsCompatibleArchitecture(arch, false, nullptr)) {
-      platform_sp = Platform::GetPlatformForArchitecture(arch, &platform_arch);
+    if (!platform_sp->IsCompatibleArchitecture(arch, {}, false, nullptr)) {
+      platform_sp =
+          Platform::GetPlatformForArchitecture(arch, {}, &platform_arch);
       if (platform_sp)
         debugger.GetPlatformList().SetSelectedPlatform(platform_sp);
     }
   } else if (platform_arch.IsValid()) {
     // If "arch" isn't valid, yet "platform_arch" is, it means we have an
     // executable file with a single architecture which should be used.
     ArchSpec fixed_platform_arch;
-    if (!platform_sp->IsCompatibleArchitecture(platform_arch, false, nullptr)) {
-      platform_sp = Platform::GetPlatformForArchitecture(platform_arch,
+    if (!platform_sp->IsCompatibleArchitecture(platform_arch, {}, false,
+                                               nullptr)) {
+      platform_sp = Platform::GetPlatformForArchitecture(platform_arch, {},
                                                          &fixed_platform_arch);
       if (platform_sp)
         debugger.GetPlatformList().SetSelectedPlatform(platform_sp);
     }
   }
 
   if (!platform_arch.IsValid())
     platform_arch = arch;
LLDB_SCOPED_TIMERF("TargetList::CreateTarget (file = '%s', arch = '%s')",
                      specified_arch.GetArchitectureName());
   Status error;
   const bool is_dummy_target = false;
 
   ArchSpec arch(specified_arch);
 
   if (arch.IsValid()) {
     if (!platform_sp ||
-        !platform_sp->IsCompatibleArchitecture(arch, false, nullptr))
-      platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch);
+        !platform_sp->IsCompatibleArchitecture(arch, {}, false, nullptr))
+      platform_sp =
+          Platform::GetPlatformForArchitecture(specified_arch, {}, &arch);
   }
 
   if (!platform_sp)
     platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
 
   if (!arch.IsValid())
     arch = specified_arch;
 

lldb/unittests/Platform/PlatformAppleSimulatorTest.cpp

 #ifdef __APPLE__
 
 static void testSimPlatformArchHasSimEnvironment(llvm::StringRef name) {
   Status error;
   auto platform_sp = Platform::Create(ConstString(name), error);
   ASSERT_TRUE(platform_sp);
   int num_arches = 0;
 
-  for (auto arch : platform_sp->GetSupportedArchitectures()) {
+  for (auto arch : platform_sp->GetSupportedArchitectures({})) {
     EXPECT_EQ(arch.GetTriple().getEnvironment(), llvm::Triple::Simulator);
     num_arches++;
   }
 
   EXPECT_GT(num_arches, 0);
 }
 
 TEST_F(PlatformAppleSimulatorTest, TestSimHasSimEnvionament) {
TEST_F(PlatformAppleSimulatorTest, TestHostPlatformToSim) {
   };
 
   for (auto sim : sim_platforms) {
     ArchSpec arch = platform_arch;
     arch.GetTriple().setOS(sim);
     arch.GetTriple().setEnvironment(llvm::Triple::Simulator);
 
     Status error;
-    auto platform_sp = Platform::Create(arch, nullptr, error);
+    auto platform_sp = Platform::Create(arch, {}, nullptr, error);
     EXPECT_TRUE(platform_sp);
   }
 }
 
 #endif

lldb/unittests/Target/RemoteAwarePlatformTest.cpp

 using namespace testing;
 
 class RemoteAwarePlatformTester : public RemoteAwarePlatform {
 public:
   using RemoteAwarePlatform::RemoteAwarePlatform;
 
   MOCK_METHOD0(GetDescription, llvm::StringRef());
   MOCK_METHOD0(GetPluginName, llvm::StringRef());
-  MOCK_METHOD0(GetSupportedArchitectures, std::vector<ArchSpec>());
+  MOCK_METHOD1(GetSupportedArchitectures,
+               std::vector<ArchSpec>(const ArchSpec &process_host_arch));
   MOCK_METHOD4(Attach,
                ProcessSP(ProcessAttachInfo &, Debugger &, Target *, Status &));
   MOCK_METHOD0(CalculateTrapHandlerSymbolNames, void());
 
   MOCK_METHOD2(ResolveRemoteExecutable,
                std::pair<Status, ModuleSP>(const ModuleSpec &,
                                            const FileSpecList *));
   Status ResolveRemoteExecutable(

 };
 
 class TargetPlatformTester : public Platform {
 public:
   using Platform::Platform;
 
   MOCK_METHOD0(GetDescription, llvm::StringRef());
   MOCK_METHOD0(GetPluginName, llvm::StringRef());
-  MOCK_METHOD0(GetSupportedArchitectures, std::vector<ArchSpec>());
+  MOCK_METHOD1(GetSupportedArchitectures,
+               std::vector<ArchSpec>(const ArchSpec &process_host_arch));
   MOCK_METHOD4(Attach,
                ProcessSP(ProcessAttachInfo &, Debugger &, Target *, Status &));
   MOCK_METHOD0(CalculateTrapHandlerSymbolNames, void());
   MOCK_METHOD0(GetUserIDResolver, UserIDResolver &());
 };
 
 namespace {
 class RemoteAwarePlatformTest : public testing::Test {
 public:
   static void SetUpTestCase() { FileSystem::Initialize(); }
   static void TearDownTestCase() { FileSystem::Terminate(); }
 };
 } // namespace
 
 TEST_F(RemoteAwarePlatformTest, TestResolveExecutabelOnClientByPlatform) {
   ModuleSpec executable_spec;
   ModuleSP expected_executable(new Module(executable_spec));
 
   RemoteAwarePlatformTester platform(false);
-  EXPECT_CALL(platform, GetSupportedArchitectures())
+  static const ArchSpec process_host_arch;
+  EXPECT_CALL(platform, GetSupportedArchitectures(process_host_arch))
       .WillRepeatedly(Return(std::vector<ArchSpec>()));
   EXPECT_CALL(platform, ResolveRemoteExecutable(_, _))
       .WillRepeatedly(Return(std::make_pair(Status(), expected_executable)));
 
   platform.SetRemotePlatform(std::make_shared<TargetPlatformTester>(false));
 
   ModuleSP resolved_sp;
   lldb_private::Status status =
       platform.ResolveExecutable(executable_spec, resolved_sp, nullptr);
 
   ASSERT_TRUE(status.Success());
   EXPECT_EQ(expected_executable.get(), resolved_sp.get());
 }