Merge pull request #1690 from Mixaill/vcpkg-toolsetsdetection-fix

[vcpkg] testing for architectures supported by toolset

5 files changed, 74 insertions, 34 deletions

diff --git a/toolsrc/include/VcpkgPaths.h b/toolsrc/include/VcpkgPaths.h
index e4e7ba83d..d55c95fe1 100644
--- a/toolsrc/include/VcpkgPaths.h
+++ b/toolsrc/include/VcpkgPaths.h
@@ -8,11 +8,19 @@
 
 namespace vcpkg
 {
+    struct ToolsetArchOption
+    {
+        CWStringView name;
+        System::CPUArchitecture host_arch;
+        System::CPUArchitecture target_arch;
+    };
+
     struct Toolset
     {
         fs::path dumpbin;
         fs::path vcvarsall;
         CWStringView version;
+        std::vector<ToolsetArchOption> supported_architectures;
     };
 
     struct VcpkgPaths
diff --git a/toolsrc/include/vcpkg_System.h b/toolsrc/include/vcpkg_System.h
index 2ea0241f6..32da6e39c 100644
--- a/toolsrc/include/vcpkg_System.h
+++ b/toolsrc/include/vcpkg_System.h
@@ -77,6 +77,8 @@ namespace vcpkg::System
 
     CPUArchitecture get_host_processor();
 
+    std::vector<CPUArchitecture> get_supported_host_architectures();
+
     const fs::path& get_ProgramFiles_32_bit();
 
     const fs::path& get_ProgramFiles_platform_bitness();
diff --git a/toolsrc/src/VcpkgPaths.cpp b/toolsrc/src/VcpkgPaths.cpp
index 1b76fdc24..17a11b1a9 100644
--- a/toolsrc/src/VcpkgPaths.cpp
+++ b/toolsrc/src/VcpkgPaths.cpp
@@ -282,6 +282,8 @@ namespace vcpkg
 
     static std::vector<Toolset> find_toolset_instances(const VcpkgPaths& paths)
     {
+        using CPU = System::CPUArchitecture;
+
         const auto& fs = paths.get_filesystem();
 
         const std::vector<std::string> vs2017_installation_instances = get_VS2017_installation_instances(paths);
@@ -301,9 +303,26 @@ namespace vcpkg
             {
                 const fs::path vs2015_dumpbin_exe = *v / "VC" / "bin" / "dumpbin.exe";
                 paths_examined.push_back(vs2015_dumpbin_exe);
+
+                const fs::path vs2015_bin_dir = vs2015_vcvarsall_bat.parent_path() / "bin";
+                std::vector<ToolsetArchOption> supported_architectures;
+                if (fs.exists(vs2015_bin_dir / "vcvars32.bat"))
+                    supported_architectures.push_back({L"x86", CPU::X86, CPU::X86});
+                if (fs.exists(vs2015_bin_dir / "amd64\\vcvars64.bat"))
+                    supported_architectures.push_back({L"x64", CPU::X64, CPU::X64});
+                if (fs.exists(vs2015_bin_dir / "x86_amd64\\vcvarsx86_amd64.bat"))
+                    supported_architectures.push_back({L"x86_amd64", CPU::X86, CPU::X64});
+                if (fs.exists(vs2015_bin_dir / "x86_arm\\vcvarsx86_arm.bat"))
+                    supported_architectures.push_back({L"x86_arm", CPU::X86, CPU::ARM});
+                if (fs.exists(vs2015_bin_dir / "amd64_x86\\vcvarsamd64_x86.bat"))
+                    supported_architectures.push_back({L"amd64_x86", CPU::X64, CPU::X86});
+                if (fs.exists(vs2015_bin_dir / "amd64_arm\\vcvarsamd64_arm.bat"))
+                    supported_architectures.push_back({L"amd64_arm", CPU::X64, CPU::ARM});
+
                 if (fs.exists(vs2015_dumpbin_exe))
                 {
-                    found_toolsets.push_back({vs2015_dumpbin_exe, vs2015_vcvarsall_bat, L"v140"});
+                    found_toolsets.push_back(
+                        {vs2015_dumpbin_exe, vs2015_vcvarsall_bat, L"v140", supported_architectures});
                 }
             }
         }
@@ -315,10 +334,26 @@ namespace vcpkg
             const fs::path vc_dir = instance / "VC";
 
             // Skip any instances that do not have vcvarsall.
-            const fs::path vcvarsall_bat = vc_dir / "Auxiliary" / "Build" / "vcvarsall.bat";
+            const fs::path vcvarsall_dir = vc_dir / "Auxiliary" / "Build";
+            const fs::path vcvarsall_bat = vcvarsall_dir / "vcvarsall.bat";
             paths_examined.push_back(vcvarsall_bat);
             if (!fs.exists(vcvarsall_bat)) continue;
 
+            // Get all supported architectures
+            std::vector<ToolsetArchOption> supported_architectures;
+            if (fs.exists(vcvarsall_dir / "vcvars32.bat"))
+                supported_architectures.push_back({L"x86", CPU::X86, CPU::X86});
+            if (fs.exists(vcvarsall_dir / "vcvars64.bat"))
+                supported_architectures.push_back({L"amd64", CPU::X64, CPU::X64});
+            if (fs.exists(vcvarsall_dir / "vcvarsx86_amd64.bat"))
+                supported_architectures.push_back({L"x86_amd64", CPU::X86, CPU::X64});
+            if (fs.exists(vcvarsall_dir / "vcvarsx86_arm.bat"))
+                supported_architectures.push_back({L"x86_arm", CPU::X86, CPU::ARM});
+            if (fs.exists(vcvarsall_dir / "vcvarsamd64_x86.bat"))
+                supported_architectures.push_back({L"amd64_x86", CPU::X64, CPU::X86});
+            if (fs.exists(vcvarsall_dir / "vcvarsamd64_arm.bat"))
+                supported_architectures.push_back({L"amd64_arm", CPU::X64, CPU::ARM});
+
             // Locate the "best" MSVC toolchain version
             const fs::path msvc_path = vc_dir / "Tools" / "MSVC";
             std::vector<fs::path> msvc_subdirectories = fs.get_files_non_recursive(msvc_path);
@@ -335,7 +370,7 @@ namespace vcpkg
                 paths_examined.push_back(dumpbin_path);
                 if (fs.exists(dumpbin_path))
                 {
-                    vs2017_toolset = Toolset{dumpbin_path, vcvarsall_bat, L"v141"};
+                    vs2017_toolset = Toolset{dumpbin_path, vcvarsall_bat, L"v141", supported_architectures};
                     break;
                 }
             }
diff --git a/toolsrc/src/vcpkg_Build.cpp b/toolsrc/src/vcpkg_Build.cpp
index 89f95ee9b..0ae63d4e3 100644
--- a/toolsrc/src/vcpkg_Build.cpp
+++ b/toolsrc/src/vcpkg_Build.cpp
@@ -37,39 +37,20 @@ namespace vcpkg::Build
         Checks::exit_with_message(VCPKG_LINE_INFO, "Unsupported vcvarsall target %s", cmake_system_name);
     }
 
-    CWStringView to_vcvarsall_toolchain(const std::string& target_architecture)
+    CWStringView to_vcvarsall_toolchain(const std::string& target_architecture, const Toolset& toolset)
     {
-        using CPU = System::CPUArchitecture;
+        auto maybe_target_arch = System::to_cpu_architecture(target_architecture);
+        Checks::check_exit(
+            VCPKG_LINE_INFO, maybe_target_arch.has_value(), "Invalid architecture string: %s", target_architecture);
+        auto target_arch = maybe_target_arch.value_or_exit(VCPKG_LINE_INFO);
+        auto host_architectures = System::get_supported_host_architectures();
 
-        struct ArchOption
+        for (auto&& host : host_architectures)
         {
-            CWStringView name;
-            CPU host_arch;
-            CPU target_arch;
-        };
-
-        static constexpr ArchOption X86 = {L"x86", CPU::X86, CPU::X86};
-        static constexpr ArchOption X86_X64 = {L"x86_x64", CPU::X86, CPU::X64};
-        static constexpr ArchOption X86_ARM = {L"x86_arm", CPU::X86, CPU::ARM};
-        static constexpr ArchOption X86_ARM64 = {L"x86_arm64", CPU::X86, CPU::ARM64};
-
-        static constexpr ArchOption X64 = {L"amd64", CPU::X64, CPU::X64};
-        static constexpr ArchOption X64_X86 = {L"amd64_x86", CPU::X64, CPU::X86};
-        static constexpr ArchOption X64_ARM = {L"amd64_arm", CPU::X64, CPU::ARM};
-        static constexpr ArchOption X64_ARM64 = {L"amd64_arm64", CPU::X64, CPU::ARM64};
-
-        static constexpr std::array<ArchOption, 8> VALUES = {
-            X86, X86_X64, X86_ARM, X86_ARM64, X64, X64_X86, X64_ARM, X64_ARM64};
-
-        auto target_arch = System::to_cpu_architecture(target_architecture);
-        auto host_arch = System::get_host_processor();
-
-        for (auto&& value : VALUES)
-        {
-            if (target_arch == value.target_arch && host_arch == value.host_arch)
-            {
-                return value.name;
-            }
+            auto it = Util::find_if(toolset.supported_architectures, [&](const ToolsetArchOption& opt) {
+                return host == opt.host_arch && target_arch == opt.target_arch;
+            });
+            if (it != toolset.supported_architectures.end()) return it->name;
         }
 
         Checks::exit_with_message(VCPKG_LINE_INFO, "Unsupported toolchain combination %s", target_architecture);
@@ -83,7 +64,7 @@ namespace vcpkg::Build
             tonull = L"";
         }
 
-        auto arch = to_vcvarsall_toolchain(pre_build_info.target_architecture);
+        auto arch = to_vcvarsall_toolchain(pre_build_info.target_architecture, toolset);
         auto target = to_vcvarsall_target(pre_build_info.cmake_system_name);
 
         return Strings::wformat(LR"("%s" %s %s %s 2>&1)", toolset.vcvarsall.native(), arch, target, tonull);
diff --git a/toolsrc/src/vcpkg_System.cpp b/toolsrc/src/vcpkg_System.cpp
index 2d6246d19..481f2431e 100644
--- a/toolsrc/src/vcpkg_System.cpp
+++ b/toolsrc/src/vcpkg_System.cpp
@@ -43,6 +43,20 @@ namespace vcpkg::System
         return to_cpu_architecture(Strings::to_utf8(procarch)).value_or_exit(VCPKG_LINE_INFO);
     }
 
+    std::vector<CPUArchitecture> get_supported_host_architectures()
+    {
+        std::vector<CPUArchitecture> supported_architectures;
+        supported_architectures.push_back(get_host_processor());
+
+        //AMD64 machines support to run x86 applications
+        if(supported_architectures.back()==CPUArchitecture::X64)
+        {
+            supported_architectures.push_back(CPUArchitecture::X86);
+        }
+
+        return supported_architectures;
+    }
+
     int cmd_execute_clean(const CWStringView cmd_line)
     {
         static const std::wstring system_root = get_environment_variable(L"SystemRoot").value_or_exit(VCPKG_LINE_INFO);