Fix supported Architectures for PlatformWindows

[zturner]

Summary

i386, i486, i486sx, and i686 are all indistinguishable as far as PE/COFF files are concerned. This patch adds support for all of these architectures to PlatformWindows.

[majnemer]

source/Plugins/Platform/Windows/PlatformWindows.cpp

47

This does not appear to be a valid triple, using it in clang gives the following:
error: unknown target triple 'i486sx-pc-windows-msvc', please use -triple or -arch

[zturner]

Remove i486 and i486sx, only support i386 and i686

[zturner]

Closed by commit rL214092 (authored by @zturner).

include/lldb/Core/ArchSpec.h

enum Core
 
         kCore_invalid,
         // The following constants are used for wildcard matching only
         kCore_any,
         kCore_arm_any,
         kCore_ppc_any,
         kCore_ppc64_any,
         kCore_x86_32_any,
+        kCore_x86_64_any,
         kCore_hexagon_any,
 
         kCore_arm_first     = eCore_arm_generic,
         kCore_arm_last      = eCore_arm_xscale,
 
         kCore_thumb_first   = eCore_thumb,
         kCore_thumb_last    = eCore_thumbv7em,
 
         kCore_ppc_first     = eCore_ppc_generic,
         kCore_ppc_last      = eCore_ppc_ppc970,
 
         kCore_ppc64_first   = eCore_ppc64_generic,
         kCore_ppc64_last    = eCore_ppc64_ppc970_64,
 
         kCore_x86_32_first  = eCore_x86_32_i386,
         kCore_x86_32_last   = eCore_x86_32_i686,
 
+        kCore_x86_64_first  = eCore_x86_64_x86_64,
+        kCore_x86_64_last   = eCore_x86_64_x86_64h,
+
         kCore_hexagon_first  = eCore_hexagon_generic,
         kCore_hexagon_last   = eCore_hexagon_hexagonv5
     };
 
     //------------------------------------------------------------------
     /// Default constructor.
     ///
     /// Default constructor that initializes the object with invalid

source/Core/ArchSpec.cpp

static const ArchDefinition g_elf_arch_def = {
     eArchTypeELF,
     llvm::array_lengthof(g_elf_arch_entries),
     g_elf_arch_entries,
     "elf",
 };
 
 static const ArchDefinitionEntry g_coff_arch_entries[] =
 {
-    { ArchSpec::eCore_x86_32_i386  , llvm::COFF::IMAGE_FILE_MACHINE_I386     , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // Intel 80386
+    { ArchSpec::eCore_x86_32_i386  , llvm::COFF::IMAGE_FILE_MACHINE_I386     , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // Intel 80x86
     { ArchSpec::eCore_ppc_generic  , llvm::COFF::IMAGE_FILE_MACHINE_POWERPC  , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // PowerPC
     { ArchSpec::eCore_ppc_generic  , llvm::COFF::IMAGE_FILE_MACHINE_POWERPCFP, LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // PowerPC (with FPU)
     { ArchSpec::eCore_arm_generic  , llvm::COFF::IMAGE_FILE_MACHINE_ARM      , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // ARM
     { ArchSpec::eCore_arm_armv7    , llvm::COFF::IMAGE_FILE_MACHINE_ARMNT    , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // ARMv7
     { ArchSpec::eCore_thumb        , llvm::COFF::IMAGE_FILE_MACHINE_THUMB    , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // ARMv7
     { ArchSpec::eCore_x86_64_x86_64, llvm::COFF::IMAGE_FILE_MACHINE_AMD64    , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }  // AMD64
 };
 
case ArchSpec::kCore_arm_any:
         if (core2 == ArchSpec::kCore_arm_any)
             return true;
         break;
     
     case ArchSpec::kCore_x86_32_any:
         if ((core2 >= ArchSpec::kCore_x86_32_first && core2 <= ArchSpec::kCore_x86_32_last) || (core2 == ArchSpec::kCore_x86_32_any))
             return true;
         break;
-        
+    case ArchSpec::kCore_x86_64_any:
+        if ((core2 >= ArchSpec::kCore_x86_64_first && core2 <= ArchSpec::kCore_x86_64_last) || (core2 == ArchSpec::kCore_x86_64_any))
+            return true;
+
     case ArchSpec::kCore_ppc_any:
         if ((core2 >= ArchSpec::kCore_ppc_first && core2 <= ArchSpec::kCore_ppc_last) || (core2 == ArchSpec::kCore_ppc_any))
             return true;
         break;
         
     case ArchSpec::kCore_ppc64_any:
         if ((core2 >= ArchSpec::kCore_ppc64_first && core2 <= ArchSpec::kCore_ppc64_last) || (core2 == ArchSpec::kCore_ppc64_any))
             return true;

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

 #include <vector>
 
 #include "lldb/Symbol/ObjectFile.h"
 
 class ObjectFilePECOFF : 
     public lldb_private::ObjectFile
 {
 public:
+    typedef enum MachineType
+    {
+        MachineUnknown = 0x0,
+        MachineAm33 = 0x1d3,
+        MachineAmd64 = 0x8664,
+        MachineArm = 0x1c0,
+        MachineArmNt = 0x1c4,
+        MachineArm64 = 0xaa64,
+        MachineEbc = 0xebc,
+        MachineX86 = 0x14c,
+        MachineIA64 = 0x200,
+        MachineM32R = 0x9041,
+        MachineMips16 = 0x266,
+        MachineMipsFpu = 0x366,
+        MachineMipsFpu16 = 0x466,
+        MachinePowerPc = 0x1f0,
+        MachinePowerPcfp = 0x1f1,
+        MachineR4000 = 0x166,
+        MachineSh3 = 0x1a2,
+        MachineSh3dsp = 0x1a3,
+        MachineSh4 = 0x1a6,
+        MachineSh5 = 0x1a8,
+        MachineThumb = 0x1c2,
+        MachineWcemIpsv2 = 0x169
+    };
     
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void
     Initialize();
     
     static void

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

if (ObjectFilePECOFF::MagicBytesMatch(data_sp))
         {
             lldb::offset_t offset = dos_header.e_lfanew;
             uint32_t pe_signature = data.GetU32(&offset);
             if (pe_signature != IMAGE_NT_SIGNATURE)
                 return false;
             if (ParseCOFFHeader(data, &offset, coff_header))
             {
                 ArchSpec spec;
-                spec.SetArchitecture(eArchTypeCOFF, coff_header.machine, LLDB_INVALID_CPUTYPE);
+                llvm::Triple::ArchType archType = llvm::Triple::UnknownArch;
+                if (coff_header.machine == MachineAmd64)
+                    spec.SetTriple("x86_64-pc-windows");
+                else if (coff_header.machine == MachineX86)
+                    spec.SetTriple("i386-pc-windows");
                 specs.Append(ModuleSpec(file, spec));
             }
         }
     }
 
     return specs.GetSize() - initial_count;
 }
 

source/Plugins/Platform/Windows/PlatformWindows.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static uint32_t g_initialize_count = 0;
 
+namespace
+{
+    class SupportedArchList
+    {
+    public:
+        SupportedArchList()
+        {
+            AddArch(ArchSpec("i686-pc-windows"));
+            AddArch(Host::GetArchitecture(Host::eSystemDefaultArchitecture));
+            AddArch(Host::GetArchitecture(Host::eSystemDefaultArchitecture32));
+            AddArch(Host::GetArchitecture(Host::eSystemDefaultArchitecture64));
+            AddArch(ArchSpec("i386-pc-windows"));
+        }
+
+        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;
+    };
+}
+
 Platform *
 PlatformWindows::CreateInstance (bool force, const lldb_private::ArchSpec *arch)
 {
     // The only time we create an instance is when we are creating a remote
     // windows platform
     const bool is_host = false;
 
     bool create = force;
PlatformWindows::GetSharedModule (const ModuleSpec &module_spec,
     if (module_sp)
         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
     return error;
 }
 
 bool
 PlatformWindows::GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch)
 {
-    // From macosx;s plugin code. For FreeBSD we may want to support more archs.
-    if (idx == 0)
-    {
-        arch = Host::GetArchitecture (Host::eSystemDefaultArchitecture);
-        return arch.IsValid();
-    }
-    else if (idx == 1)
-    {
-        ArchSpec platform_arch (Host::GetArchitecture (Host::eSystemDefaultArchitecture));
-        ArchSpec platform_arch64 (Host::GetArchitecture (Host::eSystemDefaultArchitecture64));
-        if (platform_arch.IsExactMatch(platform_arch64))
-        {
-            // This freebsd 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 = Host::GetArchitecture (Host::eSystemDefaultArchitecture32);
-            return arch.IsValid();
-        }
-    }
+    static SupportedArchList architectures;
+
+    if (idx >= architectures.Count())
         return false;
+    arch = architectures[idx];
+    return true;
 }
 
 void
 PlatformWindows::GetStatus (Stream &strm)
 {
     Platform::GetStatus(strm);
 
 #ifdef _WIN32