Call remote platform GetSupportedArchAtIndex if connected to remote.

[flackr]

Summary

Based on our IRC discussion I've updated PlatformLinux::GetSupportedArchitectureAtIndex to call the PlatformRemoteGdbServer::GetSupportedArchitectureAtIndex if connected remotely. This should return the correct thing for android (to fix those failing tests), and is also working for mac to linux.

[tberghammer]

The concept looks good, but when PlatformLinux is the host and it runs on a non Linux OS then I think it shouldn't return any supported architecture. It was always broken but it would be a good point to address it as you change the full GetSupportedArchitectureAtIndex code.

source/Plugins/Platform/Linux/PlatformLinux.cpp

88–116

I feel that this class is a bit over-design for this size of problem but I am fine with it if you prefer this way.

[flackr]

Removed class and restored to comparison to index, and ensured that the returned arch is linux, otherwise return no supported archs.

[flackr]

In D9672#170938, @tberghammer wrote:

The concept looks good, but when PlatformLinux is the host and it runs on a non Linux OS then I think it shouldn't return any supported architecture. It was always broken but it would be a good point to address it as you change the full GetSupportedArchitectureAtIndex code.

Done, checks that the host arch is Linux before returning it, else we fall back to just returning false.

source/Plugins/Platform/Linux/PlatformLinux.cpp

88–116

Removed and restored to an index check.

[tberghammer]

Looks good. Thanks for adding the check for Linux

[clayborg]

Looks fine. You will want to merge this with the other PlatformLinux::GetSupportedArchitectureAtIndex() fixes where in the non-host mode we iterate through all supported architectures.

[tberghammer]

In D9672#171299, @clayborg wrote:

Looks fine. You will want to merge this with the other PlatformLinux::GetSupportedArchitectureAtIndex() fixes where in the non-host mode we iterate through all supported architectures.

I think we don't have to merge that as we can query the supported architectures from PlatformGdbRemote. It wouldn't make too much sense for me to advertise support for an architecture which isn't (necessarily) supported by the remote target.

[ted]

The problem with querying PlatformGDBRemote is it's only valid if you're connected to the remote platform. I'm trying to set the Platform when creating a target, so there is no connection yet.

Perhaps this:

if (m_remote_platform_sp)
  return m_remote_platform_sp->GetSupportedArchitectureAtIndex(idx, arch);

<choose from list>

[tberghammer]

In that case we have to add some logic to distinguish between PlatformLinux and PlatformAndroid. Currently PlatfromAndroid uses the same GetSupportedArchitectureAtIndex function as PlatfrormLinux what will make the selection (practically) un-deterministic.

[clayborg]

Yes Ted, merge your other changes in after the:

if (m_remote_platform_sp)
    return m_remote_platform_sp->GetSupportedArchitectureAtIndex(idx, arch);

so that we can select the platform when not connected.

source/Plugins/Platform/Linux/PlatformLinux.cpp

 //===-- PlatformLinux.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/lldb-python.h"
 
 #include "PlatformLinux.h"
 #include "lldb/Host/Config.h"
 
 // C Includes
 #include <stdio.h>
-#include <vector>
 #ifndef LLDB_DISABLE_POSIX
 #include <sys/utsname.h>
 #endif
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
namespace
 
     private:
         static const PropertyDefinition*
         GetStaticPropertyDefinitions();
     };
 
     typedef std::shared_ptr<PlatformLinuxProperties> PlatformLinuxPropertiesSP;
 
-    class SupportedArchList
-    {
-    public:
-        SupportedArchList()
-        {
-            ArchSpec hostArch = HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
-            AddArch(hostArch);
-            if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit())
-                AddArch(HostInfo::GetArchitecture(HostInfo::eArchKind32));
-        }
-
-        size_t Count() const { return m_archs.size(); }
-
-        const ArchSpec& operator[](int idx) { return m_archs[idx]; }
-
-    private:
-        void AddArch(const ArchSpec& spec)
-        {
-            auto iter = std::find_if(
-                m_archs.begin(), m_archs.end(),
-                [spec](const ArchSpec& rhs) { return spec.IsExactMatch(rhs); });
-            if (iter != m_archs.end())
-                return;
-            if (spec.IsValid())
-                m_archs.push_back(spec);
-        }
-
-        std::vector<ArchSpec> m_archs;
-    };
-
 } // anonymous namespace
 
 PlatformLinuxProperties::PlatformLinuxProperties() :
     Properties ()
 {
     m_collection_sp.reset (new OptionValueProperties(GetSettingName ()));
     m_collection_sp->Initialize (GetStaticPropertyDefinitions ());
 }
 
 ConstString&
 PlatformLinuxProperties::GetSettingName ()
 {
     static ConstString g_setting_name("linux");
     return g_setting_name;
 }
 
 bool
 PlatformLinuxProperties::GetUseLlgsForLocal() const
 {
     const uint32_t idx = ePropertyUseLlgsForLocal;
     return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, GetStaticPropertyDefinitions()[idx].default_uint_value != 0);
 }
 
 const PropertyDefinition*
 PlatformLinuxProperties::GetStaticPropertyDefinitions()
 {
     static PropertyDefinition
     g_properties[] =
     {
         { "use-llgs-for-local" , OptionValue::eTypeBoolean, true, true, NULL, NULL, "Control whether the platform uses llgs for local debug sessions." },
         {  NULL        , OptionValue::eTypeInvalid, false, 0  , NULL, NULL, NULL  }
     };
 
     // Allow environment variable to disable llgs-local.
     if (getenv("PLATFORM_LINUX_DISABLE_LLGS_LOCAL"))
         g_properties[ePropertyUseLlgsForLocal].default_uint_value = false;
 
PlatformLinux::FindProcesses (const ProcessInstanceInfoMatch &match_info,
     return match_count;
 }
 
 bool
 PlatformLinux::GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch)
 {
     if (IsHost())
     {
-        static SupportedArchList architectures;
-
-        if (idx < architectures.Count())
+        ArchSpec hostArch = HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
+        if (hostArch.GetTriple().isOSLinux()) {
+            if (idx == 0)
             {
-            arch = architectures[idx];
-            return true;
+                arch = hostArch;
+                return arch.IsValid();
+            }
+            else if (idx == 1)
+            {
+                // If the default host architecture is 64-bit, look for a 32-bit variant
+                if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit())
+                {
+                    arch = HostInfo::GetArchitecture(HostInfo::eArchKind32);
+                    return arch.IsValid();
+                }
+            }
         }
     }
     else
     {
         if (m_remote_platform_sp)
             return m_remote_platform_sp->GetSupportedArchitectureAtIndex(idx, arch);
     }
     return false;