[lldb] Use GetSupportedArchitectures on darwin platforms

[labath]

Summary

This finishes the GetSupportedArchitectureAtIndex migration. There are
opportunities to simplify this even further, but I am going to leave
that to the platform owners.

[JDevlieghere]

This was on my todo-list for this week but you beat me to it. Thanks for taking care of this! LGTM

[labath]

Don't worry, there's still plenty of improvement opportunities around there. :)

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;
 
-  bool GetSupportedArchitectureAtIndex(uint32_t idx,
-                                       lldb_private::ArchSpec &arch) override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() 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
 
-bool PlatformAppleSimulator::GetSupportedArchitectureAtIndex(uint32_t idx,
-                                                             ArchSpec &arch) {
-  if (idx >= m_supported_triples.size())
-    return false;
-  arch = ArchSpec(m_supported_triples[idx]);
-  return true;
+std::vector<ArchSpec> PlatformAppleSimulator::GetSupportedArchitectures() {
+  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,
     llvm::SmallVector<llvm::Triple::ArchType, 4> supported_arch,
     llvm::Triple::OSType preferred_os,
     llvm::SmallVector<llvm::Triple::OSType, 4> supported_os,
     llvm::SmallVector<llvm::StringRef, 4> supported_triples,
if (resolved_module_spec.GetArchitecture().IsValid()) {
       if (exe_module_sp && exe_module_sp->GetObjectFile())
         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;
     ArchSpec platform_arch;
-    for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
-             idx, resolved_module_spec.GetArchitecture());
-         ++idx) {
+    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);
         // Did we find an executable using one of the
         if (error.Success()) {
           if (exe_module_sp && exe_module_sp->GetObjectFile())
             break;
           else
             error.SetErrorToGenericError();
         }
 
-        if (idx > 0)
-          arch_names.PutCString(", ");
-        arch_names.PutCString(platform_arch.GetArchitectureName());
+        arch_names << LS << platform_arch.GetArchitectureName();
       }
     }
 
     if (error.Fail() || !exe_module_sp) {
       if (FileSystem::Instance().Readable(resolved_module_spec.GetFileSpec())) {
         error.SetErrorStringWithFormatv(
             "'{0}' doesn't contain any '{1}' platform architectures: {2}",
             resolved_module_spec.GetFileSpec(), GetPluginName(),

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;
 
-  bool ARMGetSupportedArchitectureAtIndex(uint32_t idx,
-                                          lldb_private::ArchSpec &arch);
+  void ARMGetSupportedArchitectures(std::vector<lldb_private::ArchSpec> &archs);
 
-  bool x86GetSupportedArchitectureAtIndex(uint32_t idx,
-                                          lldb_private::ArchSpec &arch);
+  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,
                                lldb_private::Target &target,
                                lldb_private::Status &error) override;
public:
 
   /// Return the toolchain directory the current LLDB instance is located in.
   static lldb_private::FileSpec GetCurrentToolchainDirectory();
 
   /// Return the command line tools directory the current LLDB instance is
   /// located in.
   static lldb_private::FileSpec GetCurrentCommandLineToolsDirectory();
 
-  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() override;
-
 protected:
   static const char *GetCompatibleArch(lldb_private::ArchSpec::Core core,
                                        size_t idx);
 
   struct CrashInfoAnnotations {
     uint64_t version;          // unsigned long
     uint64_t message;          // char *
     uint64_t signature_string; // char *
lldb_private::Status FindBundleBinaryInExecSearchPaths(
       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);
 
   static std::string FindComponentInPath(llvm::StringRef path,
                                          llvm::StringRef component);
 
-  virtual bool
-  GetSupportedArchitectureAtIndex(uint32_t idx,
-                                  lldb_private::ArchSpec &arch) = 0;
-
   std::string m_developer_directory;
   llvm::StringMap<std::string> m_sdk_path;
   std::mutex m_sdk_path_mutex;
 
 private:
   PlatformDarwin(const PlatformDarwin &) = delete;
   const PlatformDarwin &operator=(const PlatformDarwin &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMDARWIN_H

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

bool PlatformDarwin::ModuleIsExcludedForUnconstrainedSearches(
   ObjectFile *obj_file = module_sp->GetObjectFile();
   if (!obj_file)
     return false;
 
   ObjectFile::Type obj_type = obj_file->GetType();
   return obj_type == ObjectFile::eTypeDynamicLinker;
 }
 
-bool PlatformDarwin::x86GetSupportedArchitectureAtIndex(uint32_t idx,
-                                                        ArchSpec &arch) {
+void PlatformDarwin::x86GetSupportedArchitectures(
+    std::vector<ArchSpec> &archs) {
   ArchSpec host_arch = HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
-  if (host_arch.GetCore() == ArchSpec::eCore_x86_64_x86_64h) {
-    switch (idx) {
-    case 0:
-      arch = host_arch;
-      return true;
-
-    case 1:
-      arch.SetTriple("x86_64-apple-macosx");
-      return true;
-
-    case 2:
-      arch = HostInfo::GetArchitecture(HostInfo::eArchKind32);
-      return true;
+  archs.push_back(host_arch);
 
-    default:
-      return false;
-    }
+  if (host_arch.GetCore() == ArchSpec::eCore_x86_64_x86_64h) {
+    archs.push_back(ArchSpec("x86_64-apple-macosx"));
+    archs.push_back(HostInfo::GetArchitecture(HostInfo::eArchKind32));
   } else {
-    if (idx == 0) {
-      arch = HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
-      return arch.IsValid();
-    } else if (idx == 1) {
-      ArchSpec platform_arch(
-          HostInfo::GetArchitecture(HostInfo::eArchKindDefault));
-      ArchSpec platform_arch64(
-          HostInfo::GetArchitecture(HostInfo::eArchKind64));
-      if (platform_arch.IsExactMatch(platform_arch64)) {
-        // This macosx platform supports both 32 and 64 bit. Since we already
-        // returned the 64 bit arch for idx == 0, return the 32 bit arch for
-        // idx == 1
-        arch = HostInfo::GetArchitecture(HostInfo::eArchKind32);
-        return arch.IsValid();
-      }
-    }
-  }
-  return false;
-}
+    ArchSpec host_arch64 = HostInfo::GetArchitecture(HostInfo::eArchKind64);
+    if (host_arch.IsExactMatch(host_arch64))
+      archs.push_back(HostInfo::GetArchitecture(HostInfo::eArchKind32));
 
 static llvm::ArrayRef<const char *> GetCompatibleArchs(ArchSpec::Core core) {
   switch (core) {
   default:
     LLVM_FALLTHROUGH;
   case ArchSpec::eCore_arm_arm64e: {
     static const char *g_arm64e_compatible_archs[] = {
         "arm64e",    "arm64",    "armv7",    "armv7f",   "armv7k",   "armv7s",
const char *PlatformDarwin::GetCompatibleArch(ArchSpec::Core core, size_t idx) {
   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.
-bool PlatformDarwin::ARMGetSupportedArchitectureAtIndex(uint32_t idx,
-                                                        ArchSpec &arch) {
+void PlatformDarwin::ARMGetSupportedArchitectures(
+    std::vector<ArchSpec> &archs) {
   const ArchSpec system_arch = GetSystemArchitecture();
   const ArchSpec::Core system_core = system_arch.GetCore();
 
-  if (const char *compatible_arch = GetCompatibleArch(system_core, idx)) {
+  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);
-    arch.SetTriple(triple);
-    return true;
+    archs.push_back(ArchSpec(triple));
   }
-
-  arch.Clear();
-  return false;
 }
 
 static FileSpec GetXcodeSelectPath() {
   static FileSpec g_xcode_select_filespec;
 
   if (!g_xcode_select_filespec) {
     FileSpec xcode_select_cmd("/usr/bin/xcode-select");
     if (FileSystem::Instance().Exists(xcode_select_cmd)) {
FileSpec PlatformDarwin::GetCurrentToolchainDirectory() {
   return {};
 }
 
 FileSpec PlatformDarwin::GetCurrentCommandLineToolsDirectory() {
   if (FileSpec fspec = HostInfo::GetShlibDir())
     return FileSpec(FindComponentInPath(fspec.GetPath(), "CommandLineTools"));
   return {};
 }
-
-std::vector<ArchSpec> PlatformDarwin::GetSupportedArchitectures() {
-  std::vector<ArchSpec> result;
-  ArchSpec arch;
-  for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(idx, arch); ++idx)
-    result.push_back(arch);
-  return result;
-}

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;
 
-  bool GetSupportedArchitectureAtIndex(uint32_t idx,
-                                       lldb_private::ArchSpec &arch) override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() 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 {};
 }
 
-bool PlatformDarwinKernel::GetSupportedArchitectureAtIndex(uint32_t idx,
-                                                           ArchSpec &arch) {
+std::vector<ArchSpec> PlatformDarwinKernel::GetSupportedArchitectures() {
+  std::vector<ArchSpec> result;
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
-  return ARMGetSupportedArchitectureAtIndex(idx, arch);
+  ARMGetSupportedArchitectures(result);
 #else
-  return x86GetSupportedArchitectureAtIndex(idx, arch);
+  x86GetSupportedArchitectures(result);
 #endif
+  return result;
 }
 
 void PlatformDarwinKernel::CalculateTrapHandlerSymbolNames() {
   m_trap_handlers.push_back(ConstString("trap_from_kernel"));
   m_trap_handlers.push_back(ConstString("hndl_machine_check"));
   m_trap_handlers.push_back(ConstString("hndl_double_fault"));
   m_trap_handlers.push_back(ConstString("hndl_allintrs"));
   m_trap_handlers.push_back(ConstString("hndl_alltraps"));

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);
   }
 
-  bool GetSupportedArchitectureAtIndex(uint32_t idx,
-                                       lldb_private::ArchSpec &arch) override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() 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);
   }
-
-private:
-#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
-  uint32_t m_num_arm_arches = 0;
-#endif
 };
 
 #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 {};
 }
 
-bool PlatformMacOSX::GetSupportedArchitectureAtIndex(uint32_t idx,
-                                                     ArchSpec &arch) {
+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
-  if (!m_num_arm_arches || idx < m_num_arm_arches) {
-    bool res = ARMGetSupportedArchitectureAtIndex(idx, arch);
-    if (res)
-      return true;
-    if (!m_num_arm_arches)
-      m_num_arm_arches = idx;
-  }
+  ARMGetSupportedArchitectures(result);
 
-  // We can't use x86GetSupportedArchitectureAtIndex() because it uses
+  // We can't use x86GetSupportedArchitectures() because it uses
   // the system architecture for some of its return values and also
   // has a 32bits variant.
-  if (idx == m_num_arm_arches) {
-    arch.SetTriple("x86_64-apple-macosx");
-    return true;
-  } else if (idx == m_num_arm_arches + 1) {
-    arch.SetTriple("x86_64-apple-ios-macabi");
-    return true;
-  } else if (idx == m_num_arm_arches + 2) {
-    arch.SetTriple("arm64-apple-ios");
-    return true;
-  } else if (idx == m_num_arm_arches + 3) {
-    arch.SetTriple("arm64e-apple-ios");
-    return true;
-  }
-
-  return false;
+  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
-  return x86GetSupportedArchitectureAtIndex(idx, arch);
+  x86GetSupportedArchitectures(result);
 #endif
+  return result;
 }
 
 lldb_private::Status PlatformMacOSX::GetSharedModule(
     const lldb_private::ModuleSpec &module_spec, Process *process,
     lldb::ModuleSP &module_sp,
     const lldb_private::FileSpecList *module_search_paths_ptr,
     llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules, bool *did_create_ptr) {
   Status error = GetSharedModuleWithLocalCache(module_spec, module_sp,

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(); }
 
-  bool GetSupportedArchitectureAtIndex(uint32_t idx,
-                                       lldb_private::ArchSpec &arch) override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() 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.";
 }
 
-bool PlatformRemoteAppleBridge::GetSupportedArchitectureAtIndex(uint32_t idx,
-                                                            ArchSpec &arch) {
-  ArchSpec system_arch(GetSystemArchitecture());
-
-  const ArchSpec::Core system_core = system_arch.GetCore();
-  switch (system_core) {
-  default:
-    switch (idx) {
-    case 0:
-      arch.SetTriple("arm64-apple-bridgeos");
-      return true;
-    default:
-      break;
-    }
-    break;
-
-  case ArchSpec::eCore_arm_arm64:
-    switch (idx) {
-    case 0:
-      arch.SetTriple("arm64-apple-bridgeos");
-      return true;
-    default:
-      break;
-    }
-    break;
-  }
-  arch.Clear();
-  return false;
+std::vector<ArchSpec> PlatformRemoteAppleBridge::GetSupportedArchitectures() {
+  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(); }
 
-  bool GetSupportedArchitectureAtIndex(uint32_t idx,
-                                       lldb_private::ArchSpec &arch) override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() 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.";
 }
 
-bool PlatformRemoteAppleTV::GetSupportedArchitectureAtIndex(uint32_t idx,
-                                                            ArchSpec &arch) {
+std::vector<ArchSpec> PlatformRemoteAppleTV::GetSupportedArchitectures() {
   ArchSpec system_arch(GetSystemArchitecture());
 
   const ArchSpec::Core system_core = system_arch.GetCore();
   switch (system_core) {
   default:
-    switch (idx) {
-    case 0:
-      arch.SetTriple("arm64-apple-tvos");
-      return true;
-    case 1:
-      arch.SetTriple("armv7s-apple-tvos");
-      return true;
-    case 2:
-      arch.SetTriple("armv7-apple-tvos");
-      return true;
-    case 3:
-      arch.SetTriple("thumbv7s-apple-tvos");
-      return true;
-    case 4:
-      arch.SetTriple("thumbv7-apple-tvos");
-      return true;
-    default:
-      break;
-    }
-    break;
-
   case ArchSpec::eCore_arm_arm64:
-    switch (idx) {
-    case 0:
-      arch.SetTriple("arm64-apple-tvos");
-      return true;
-    case 1:
-      arch.SetTriple("armv7s-apple-tvos");
-      return true;
-    case 2:
-      arch.SetTriple("armv7-apple-tvos");
-      return true;
-    case 3:
-      arch.SetTriple("thumbv7s-apple-tvos");
-      return true;
-    case 4:
-      arch.SetTriple("thumbv7-apple-tvos");
-      return true;
-    default:
-      break;
-    }
-    break;
+    return {ArchSpec("arm64-apple-tvos"), ArchSpec("armv7s-apple-tvos"),
+            ArchSpec("armv7-apple-tvos"), ArchSpec("thumbv7s-apple-tvos"),
+            ArchSpec("thumbv7-apple-tvos")};
 
   case ArchSpec::eCore_arm_armv7s:
-    switch (idx) {
-    case 0:
-      arch.SetTriple("armv7s-apple-tvos");
-      return true;
-    case 1:
-      arch.SetTriple("armv7-apple-tvos");
-      return true;
-    case 2:
-      arch.SetTriple("thumbv7s-apple-tvos");
-      return true;
-    case 3:
-      arch.SetTriple("thumbv7-apple-tvos");
-      return true;
-    default:
-      break;
-    }
-    break;
+    return {ArchSpec("armv7s-apple-tvos"), ArchSpec("armv7-apple-tvos"),
+            ArchSpec("thumbv7s-apple-tvos"), ArchSpec("thumbv7-apple-tvos")};
 
   case ArchSpec::eCore_arm_armv7:
-    switch (idx) {
-    case 0:
-      arch.SetTriple("armv7-apple-tvos");
-      return true;
-    case 1:
-      arch.SetTriple("thumbv7-apple-tvos");
-      return true;
-    default:
-      break;
-    }
-    break;
+    return {ArchSpec("armv7-apple-tvos"), ArchSpec("thumbv7-apple-tvos")};
   }
-  arch.Clear();
-  return false;
 }
 
 llvm::StringRef PlatformRemoteAppleTV::GetDeviceSupportDirectoryName() {
   return "tvOS DeviceSupport";
 }
 
 llvm::StringRef PlatformRemoteAppleTV::GetPlatformName() {
   return "AppleTVOS.platform";
 }

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
 
-  bool GetSupportedArchitectureAtIndex(uint32_t idx,
-                                       lldb_private::ArchSpec &arch) override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() 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() {}
 
-bool PlatformRemoteAppleWatch::GetSupportedArchitectureAtIndex(uint32_t idx,
-                                                               ArchSpec &arch) {
+std::vector<ArchSpec> PlatformRemoteAppleWatch::GetSupportedArchitectures() {
   ArchSpec system_arch(GetSystemArchitecture());
 
   const ArchSpec::Core system_core = system_arch.GetCore();
   switch (system_core) {
   default:
-    switch (idx) {
-    case 0:
-      arch.SetTriple("arm64-apple-watchos");
-      return true;
-    case 1:
-      arch.SetTriple("armv7k-apple-watchos");
-      return true;
-    case 2:
-      arch.SetTriple("armv7s-apple-watchos");
-      return true;
-    case 3:
-      arch.SetTriple("armv7-apple-watchos");
-      return true;
-    case 4:
-      arch.SetTriple("thumbv7k-apple-watchos");
-      return true;
-    case 5:
-      arch.SetTriple("thumbv7-apple-watchos");
-      return true;
-    case 6:
-      arch.SetTriple("thumbv7s-apple-watchos");
-      return true;
-    case 7:
-      arch.SetTriple("arm64_32-apple-watchos");
-      return true;
-    default:
-      break;
-    }
-    break;
-
   case ArchSpec::eCore_arm_arm64:
-    switch (idx) {
-    case 0:
-      arch.SetTriple("arm64-apple-watchos");
-      return true;
-    case 1:
-      arch.SetTriple("armv7k-apple-watchos");
-      return true;
-    case 2:
-      arch.SetTriple("armv7s-apple-watchos");
-      return true;
-    case 3:
-      arch.SetTriple("armv7-apple-watchos");
-      return true;
-    case 4:
-      arch.SetTriple("thumbv7k-apple-watchos");
-      return true;
-    case 5:
-      arch.SetTriple("thumbv7-apple-watchos");
-      return true;
-    case 6:
-      arch.SetTriple("thumbv7s-apple-watchos");
-      return true;
-    case 7:
-      arch.SetTriple("arm64_32-apple-watchos");
-      return true;
-    default:
-      break;
-    }
-    break;
+    return {
+        ArchSpec("arm64-apple-watchos"),    ArchSpec("armv7k-apple-watchos"),
+        ArchSpec("armv7s-apple-watchos"),   ArchSpec("armv7-apple-watchos"),
+        ArchSpec("thumbv7k-apple-watchos"), ArchSpec("thumbv7-apple-watchos"),
+        ArchSpec("thumbv7s-apple-watchos"), ArchSpec("arm64_32-apple-watchos")};
 
   case ArchSpec::eCore_arm_armv7k:
-    switch (idx) {
-    case 0:
-      arch.SetTriple("armv7k-apple-watchos");
-      return true;
-    case 1:
-      arch.SetTriple("armv7s-apple-watchos");
-      return true;
-    case 2:
-      arch.SetTriple("armv7-apple-watchos");
-      return true;
-    case 3:
-      arch.SetTriple("thumbv7k-apple-watchos");
-      return true;
-    case 4:
-      arch.SetTriple("thumbv7-apple-watchos");
-      return true;
-    case 5:
-      arch.SetTriple("thumbv7s-apple-watchos");
-      return true;
-    case 6:
-      arch.SetTriple("arm64_32-apple-watchos");
-      return true;
-    default:
-      break;
-    }
-    break;
+    return {
+        ArchSpec("armv7k-apple-watchos"),  ArchSpec("armv7s-apple-watchos"),
+        ArchSpec("armv7-apple-watchos"),   ArchSpec("thumbv7k-apple-watchos"),
+        ArchSpec("thumbv7-apple-watchos"), ArchSpec("thumbv7s-apple-watchos"),
+        ArchSpec("arm64_32-apple-watchos")};
 
   case ArchSpec::eCore_arm_armv7s:
-    switch (idx) {
-    case 0:
-      arch.SetTriple("armv7s-apple-watchos");
-      return true;
-    case 1:
-      arch.SetTriple("armv7k-apple-watchos");
-      return true;
-    case 2:
-      arch.SetTriple("armv7-apple-watchos");
-      return true;
-    case 3:
-      arch.SetTriple("thumbv7k-apple-watchos");
-      return true;
-    case 4:
-      arch.SetTriple("thumbv7-apple-watchos");
-      return true;
-    case 5:
-      arch.SetTriple("thumbv7s-apple-watchos");
-      return true;
-    case 6:
-      arch.SetTriple("arm64_32-apple-watchos");
-      return true;
-    default:
-      break;
-    }
-    break;
+    return {
+        ArchSpec("armv7s-apple-watchos"),  ArchSpec("armv7k-apple-watchos"),
+        ArchSpec("armv7-apple-watchos"),   ArchSpec("thumbv7k-apple-watchos"),
+        ArchSpec("thumbv7-apple-watchos"), ArchSpec("thumbv7s-apple-watchos"),
+        ArchSpec("arm64_32-apple-watchos")};
 
   case ArchSpec::eCore_arm_armv7:
-    switch (idx) {
-    case 0:
-      arch.SetTriple("armv7-apple-watchos");
-      return true;
-    case 1:
-      arch.SetTriple("armv7k-apple-watchos");
-      return true;
-    case 2:
-      arch.SetTriple("thumbv7k-apple-watchos");
-      return true;
-    case 3:
-      arch.SetTriple("thumbv7-apple-watchos");
-      return true;
-    case 4:
-      arch.SetTriple("arm64_32-apple-watchos");
-      return true;
-    default:
-      break;
-    }
-    break;
+    return {ArchSpec("armv7-apple-watchos"), ArchSpec("armv7k-apple-watchos"),
+            ArchSpec("thumbv7k-apple-watchos"),
+            ArchSpec("thumbv7-apple-watchos"),
+            ArchSpec("arm64_32-apple-watchos")};
   }
-  arch.Clear();
-  return false;
 }
 
 llvm::StringRef PlatformRemoteAppleWatch::GetDeviceSupportDirectoryName() {
   return "watchOS DeviceSupport";
 }
 
 llvm::StringRef PlatformRemoteAppleWatch::GetPlatformName() {
   return "WatchOS.platform";
 }

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

if (resolved_module_spec.GetArchitecture().IsValid() ||
       if (exe_module_sp && exe_module_sp->GetObjectFile())
         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;
-    for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
-             idx, resolved_module_spec.GetArchitecture());
-         ++idx) {
+    llvm::ListSeparator LS;
+    for (const ArchSpec &arch : GetSupportedArchitectures()) {
+      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
           error.SetErrorToGenericError();
       }
 
-      if (idx > 0)
-        arch_names.PutCString(", ");
-      arch_names.PutCString(
-          resolved_module_spec.GetArchitecture().GetArchitectureName());
+      arch_names << LS << arch.GetArchitectureName();
     }
 
     if (error.Fail() || !exe_module_sp) {
       if (FileSystem::Instance().Readable(resolved_module_spec.GetFileSpec())) {
         error.SetErrorStringWithFormatv(
             "'{0}' doesn't contain any '{1}' platform architectures: {2}",
             resolved_module_spec.GetFileSpec(), GetPluginName(),
             arch_names.GetData());

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;
 
-  bool GetSupportedArchitectureAtIndex(uint32_t idx,
-                                       lldb_private::ArchSpec &arch) override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() override;
 
 protected:
   llvm::StringRef GetDeviceSupportDirectoryName() override;
   llvm::StringRef GetPlatformName() override;
-
-private:
-  uint32_t m_num_arm_arches = 0;
 };
 
 #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();
 }
 
-bool PlatformRemoteMacOSX::GetSupportedArchitectureAtIndex(uint32_t idx,
-                                                           ArchSpec &arch) {
+std::vector<ArchSpec> PlatformRemoteMacOSX::GetSupportedArchitectures() {
   // macOS for ARM64 support both native and translated x86_64 processes
-  if (!m_num_arm_arches || idx < m_num_arm_arches) {
-    bool res = ARMGetSupportedArchitectureAtIndex(idx, arch);
-    if (res)
-      return true;
-    if (!m_num_arm_arches)
-      m_num_arm_arches = idx;
-  }
+  std::vector<ArchSpec> result;
+  ARMGetSupportedArchitectures(result);
 
-  // We can't use x86GetSupportedArchitectureAtIndex() because it uses
+  // We can't use x86GetSupportedArchitectures() because it uses
   // the system architecture for some of its return values and also
   // has a 32bits variant.
-  if (idx == m_num_arm_arches) {
-    arch.SetTriple("x86_64-apple-macosx");
-    return true;
-  } else if (idx == m_num_arm_arches + 1) {
-    arch.SetTriple("x86_64-apple-ios-macabi");
-    return true;
-  } else if (idx == m_num_arm_arches + 2) {
-    arch.SetTriple("arm64-apple-ios");
-    return true;
-  } else if (idx == m_num_arm_arches + 3) {
-    arch.SetTriple("arm64e-apple-ios");
-    return true;
-  }
-
-  return false;
+  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"));
+  return result;
 }
 
 lldb_private::Status PlatformRemoteMacOSX::GetFileWithUUID(
     const lldb_private::FileSpec &platform_file,
     const lldb_private::UUID *uuid_ptr, lldb_private::FileSpec &local_file) {
   if (m_remote_platform_sp) {
     std::string local_os_build;
 #if !defined(__linux__)

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(); }
 
-  bool GetSupportedArchitectureAtIndex(uint32_t idx,
-                                       lldb_private::ArchSpec &arch) override;
+  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures() override;
 
 protected:
   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() {}
 
-bool PlatformRemoteiOS::GetSupportedArchitectureAtIndex(uint32_t idx,
-                                                        ArchSpec &arch) {
-  return ARMGetSupportedArchitectureAtIndex(idx, arch);
+std::vector<ArchSpec> PlatformRemoteiOS::GetSupportedArchitectures() {
+  std::vector<ArchSpec> result;
+  ARMGetSupportedArchitectures(result);
+  return result;
 }
 
 llvm::StringRef PlatformRemoteiOS::GetDeviceSupportDirectoryName() {
   return "iOS DeviceSupport";
 }
 
 llvm::StringRef PlatformRemoteiOS::GetPlatformName() {
   return "iPhoneOS.platform";
 }