diff --git a/.gitignore b/.gitignore index dbc8019016f5cf..ebd39b33fdc518 100644 --- a/.gitignore +++ b/.gitignore @@ -306,9 +306,15 @@ __pycache__/ !triplets/arm64-windows.cmake !triplets/x64-linux.cmake !triplets/x64-osx.cmake +!triplets/x64-windows-llvm.cmake +!triplets/x64-windows-intel19.cmake +!triplets/x64-windows-clang.cmake *.exe *.zip +/scripts/dummy/compiler_linker_info.txt +/scripts/dummy/build/* + ############################################################ # vcpkg - End ############################################################ diff --git a/ports/boost-modular-build-helper/boost-modular-build.cmake b/ports/boost-modular-build-helper/boost-modular-build.cmake index 59db75312106d9..1737373e41512c 100644 --- a/ports/boost-modular-build-helper/boost-modular-build.cmake +++ b/ports/boost-modular-build-helper/boost-modular-build.cmake @@ -6,7 +6,7 @@ function(boost_modular_build) endif() # Todo: this serves too similar a purpose as vcpkg_find_acquire_program() - if(CMAKE_HOST_WIN32 AND VCPKG_CMAKE_SYSTEM_NAME AND NOT VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore") + if(CMAKE_HOST_WIN32 AND NOT VCPKG_TARGET_IS_WINDOWS) get_filename_component(BOOST_BUILD_PATH "${CURRENT_INSTALLED_DIR}/../x86-windows/tools/boost-build" ABSOLUTE) elseif(NOT VCPKG_TARGET_ARCHITECTURE STREQUAL "x64" AND NOT VCPKG_TARGET_ARCHITECTURE STREQUAL "x86") get_filename_component(BOOST_BUILD_PATH "${CURRENT_INSTALLED_DIR}/../x86-windows/tools/boost-build" ABSOLUTE) @@ -34,10 +34,18 @@ function(boost_modular_build) set(REQUIREMENTS ${_bm_REQUIREMENTS}) - if(NOT VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore") + if(VCPKG_TARGET_IS_WINDOWS) set(BOOST_LIB_PREFIX) - set(BOOST_LIB_RELEASE_SUFFIX -vc140-mt.lib) - set(BOOST_LIB_DEBUG_SUFFIX -vc140-mt-gd.lib) + set(BOOST_LIB_RELEASE_SUFFIX -${VCPKG_PLATFORM_TOOLSET}-mt.lib) + set(BOOST_LIB_DEBUG_SUFFIX -${VCPKG_PLATFORM_TOOLSET}-mt-gd.lib) + if(VCPKG_PLATFORM_TOOLSET MATCHES "llvm") + string(REPLACE "llvm" "clangw10" BOOST_LIB_RELEASE_SUFFIX ${BOOST_LIB_RELEASE_SUFFIX}) + string(REPLACE "llvm" "clangw10" BOOST_LIB_DEBUG_SUFFIX ${BOOST_LIB_DEBUG_SUFFIX}) + string(REPLACE "-gd" "-d" BOOST_LIB_DEBUG_SUFFIX ${BOOST_LIB_DEBUG_SUFFIX}) + else() + string(REPLACE "v14" "vc14" BOOST_LIB_RELEASE_SUFFIX ${BOOST_LIB_RELEASE_SUFFIX}) + string(REPLACE "v14" "vc14" BOOST_LIB_DEBUG_SUFFIX ${BOOST_LIB_DEBUG_SUFFIX}) + endif() else() set(BOOST_LIB_PREFIX lib) if(VCPKG_LIBRARY_LINKAGE STREQUAL "static") @@ -153,7 +161,7 @@ function(boost_modular_build) "-sBZIP2_INCLUDE=${CURRENT_INSTALLED_DIR}/include" threading=multi ) - if(NOT VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore") + if(VCPKG_TARGET_IS_WINDOWS) list(APPEND _bm_OPTIONS threadapi=win32) else() list(APPEND _bm_OPTIONS threadapi=pthread) @@ -237,7 +245,7 @@ function(boost_modular_build) file(TO_CMAKE_PATH "${_bm_DIR}/nothing.bat" NOTHING_BAT) set(TOOLSET_OPTIONS " /EHsc -Zm800 -nologo") - if(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore") + if(VCPKG_TARGET_IS_UWP) if(NOT VCPKG_PLATFORM_TOOLSET MATCHES "v140") find_path(PATH_TO_CL cl.exe) find_path(PLATFORM_WINMD_DIR platform.winmd PATHS "${PATH_TO_CL}/../../../lib/x86/store/references" NO_DEFAULT_PATH) @@ -258,16 +266,34 @@ function(boost_modular_build) set(TOOLSET_OPTIONS "${TOOLSET_OPTIONS} -D_WIN32_WINNT=0x0602") endif() - configure_file(${_bm_DIR}/user-config.jam ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/user-config.jam @ONLY) - configure_file(${_bm_DIR}/user-config.jam ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/user-config.jam @ONLY) - if(VCPKG_PLATFORM_TOOLSET MATCHES "v14.") list(APPEND _bm_OPTIONS toolset=msvc) + elseif(VCPKG_PLATFORM_TOOLSET MATCHES "llvm") + if(NOT VCPKG_C_COMPILER OR NOT VCPKG_CXX_COMPILER OR NOT VCPKG_LINKER) + vcpkg_determine_compiler_and_linker() + message(STATUS "Detected VCPKG_CXX_COMPILER=${VCPKG_CXX_COMPILER}") + message(STATUS "Detected VCPKG_LINKER=${VCPKG_LINKER}") + file(TO_CMAKE_PATH "${VCPKG_CXX_COMPILER}" VCPKG_CXX_COMPILER) + file(TO_CMAKE_PATH "${VCPKG_LINKER}" VCPKG_LINKER) + endif() + list(APPEND _bm_OPTIONS toolset=clang-win) + elseif(VCPKG_PLATFORM_TOOLSET MATCHES "Intel") + if(NOT VCPKG_C_COMPILER OR NOT VCPKG_CXX_COMPILER OR NOT VCPKG_LINKER) + vcpkg_determine_compiler_and_linker() + message(STATUS "Detected VCPKG_CXX_COMPILER=${VCPKG_CXX_COMPILER}") + message(STATUS "Detected VCPKG_LINKER=${VCPKG_LINKER}") + file(TO_CMAKE_PATH "${VCPKG_CXX_COMPILER}" VCPKG_CXX_COMPILER) + file(TO_CMAKE_PATH "${VCPKG_LINKER}" VCPKG_LINKER) + endif() + list(APPEND _bm_OPTIONS toolset=intel-win) elseif(VCPKG_PLATFORM_TOOLSET MATCHES "external") list(APPEND _bm_OPTIONS toolset=gcc) else() message(FATAL_ERROR "Unsupported value for VCPKG_PLATFORM_TOOLSET: '${VCPKG_PLATFORM_TOOLSET}'") endif() + + configure_file(${_bm_DIR}/user-config.jam ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/user-config.jam @ONLY) + configure_file(${_bm_DIR}/user-config.jam ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/user-config.jam @ONLY) ###################### # Perform build + Package @@ -349,8 +375,6 @@ function(boost_modular_build) get_filename_component(DIRECTORY_OF_LIB_FILE ${LIB} DIRECTORY) string(REPLACE "libboost_" "boost_" NEW_FILENAME ${OLD_FILENAME}) string(REPLACE "-s-" "-" NEW_FILENAME ${NEW_FILENAME}) # For Release libs - string(REPLACE "-vc141-" "-vc140-" NEW_FILENAME ${NEW_FILENAME}) # To merge VS2017 and VS2015 binaries - string(REPLACE "-vc142-" "-vc140-" NEW_FILENAME ${NEW_FILENAME}) # To merge VS2019 and VS2015 binaries string(REPLACE "-sgd-" "-gd-" NEW_FILENAME ${NEW_FILENAME}) # For Debug libs string(REPLACE "-sgyd-" "-gyd-" NEW_FILENAME ${NEW_FILENAME}) # For Debug libs string(REPLACE "-x32-" "-" NEW_FILENAME ${NEW_FILENAME}) # To enable CMake 3.10 and earlier to locate the binaries diff --git a/ports/boost-modular-build-helper/user-config.jam b/ports/boost-modular-build-helper/user-config.jam index 78677c0ab2ec3c..f27c8210381ed7 100644 --- a/ports/boost-modular-build-helper/user-config.jam +++ b/ports/boost-modular-build-helper/user-config.jam @@ -6,6 +6,17 @@ if "@VCPKG_PLATFORM_TOOLSET@" != "external" "@NOTHING_BAT@" @TOOLSET_OPTIONS@ ; + if "@VCPKG_PLATFORM_TOOLSET@" = "llvm" + { + using clang-win : : "@VCPKG_CXX_COMPILER@" : + "@NOTHING_BAT@" + @TOOLSET_OPTIONS@ + ; + } + #using intel-win : 14.2 : "@VCPKG_CXX_COMPILER@" : + #"@NOTHING_BAT@" + #@TOOLSET_OPTIONS@ + #; } else { diff --git a/ports/zlib/CONTROL b/ports/zlib/CONTROL index aa7c7b6e92b665..601fb1bc0eda06 100644 --- a/ports/zlib/CONTROL +++ b/ports/zlib/CONTROL @@ -1,4 +1,4 @@ Source: zlib -Version: 1.2.11-5 +Version: 1.2.11-6 Homepage: https://www.zlib.net/ Description: A compression library diff --git a/scripts/cmake/vcpkg_build_cmake.cmake b/scripts/cmake/vcpkg_build_cmake.cmake index d049c907b96398..5a1eb15eb7c190 100644 --- a/scripts/cmake/vcpkg_build_cmake.cmake +++ b/scripts/cmake/vcpkg_build_cmake.cmake @@ -46,6 +46,7 @@ function(vcpkg_build_cmake) set(BUILD_ARGS "/p:VCPkgLocalAppDataDisabled=true" "/p:UseIntelMKL=No" + "/p:PlatformToolset=${VCPKG_PLATFORM_TOOLSET}" ) set(PARALLEL_ARG "/m") elseif(_VCPKG_CMAKE_GENERATOR MATCHES "NMake") diff --git a/scripts/cmake/vcpkg_build_msbuild.cmake b/scripts/cmake/vcpkg_build_msbuild.cmake index cfd429da2f26aa..4e85732d837804 100644 --- a/scripts/cmake/vcpkg_build_msbuild.cmake +++ b/scripts/cmake/vcpkg_build_msbuild.cmake @@ -70,6 +70,10 @@ function(vcpkg_build_msbuild) ${ARGN} ) + if(NOT DEFINED _csc_TARGET) + set(_csc_TARGET Rebuild) + endif() + if(NOT DEFINED _csc_RELEASE_CONFIGURATION) set(_csc_RELEASE_CONFIGURATION Release) endif() @@ -79,26 +83,29 @@ function(vcpkg_build_msbuild) if(NOT DEFINED _csc_PLATFORM) set(_csc_PLATFORM ${TRIPLET_SYSTEM_ARCH}) endif() - if(NOT DEFINED _csc_PLATFORM_TOOLSET) + if(NOT DEFINED _csc_PLATFORM_TOOLSET AND DEFINED VCPKG_PLATFORM_TOOLSET) set(_csc_PLATFORM_TOOLSET ${VCPKG_PLATFORM_TOOLSET}) endif() if(NOT DEFINED _csc_TARGET_PLATFORM_VERSION) vcpkg_get_windows_sdk(_csc_TARGET_PLATFORM_VERSION) endif() - if(NOT DEFINED _csc_TARGET) - set(_csc_TARGET Rebuild) - endif() + list(APPEND _csc_OPTIONS /t:${_csc_TARGET} /p:Platform=${_csc_PLATFORM} - /p:PlatformToolset=${_csc_PLATFORM_TOOLSET} /p:VCPkgLocalAppDataDisabled=true /p:UseIntelMKL=No /p:WindowsTargetPlatformVersion=${_csc_TARGET_PLATFORM_VERSION} /m ) + if(DEFINED _csc_PLATFORM_TOOLSET) + list(APPEND _csc_OPTIONS + /p:PlatformToolset=${_csc_PLATFORM_TOOLSET} + ) + endif() + if(VCPKG_LIBRARY_LINKAGE STREQUAL "static") # Disable LTCG for static libraries because this setting introduces ABI incompatibility between minor compiler versions # TODO: Add a way for the user to override this if they want to opt-in to incompatibility diff --git a/scripts/cmake/vcpkg_common_functions.cmake b/scripts/cmake/vcpkg_common_functions.cmake index 564ac9421b1d73..57a35d1763190b 100644 --- a/scripts/cmake/vcpkg_common_functions.cmake +++ b/scripts/cmake/vcpkg_common_functions.cmake @@ -24,6 +24,7 @@ include(vcpkg_build_nmake) include(vcpkg_install_cmake) include(vcpkg_install_meson) include(vcpkg_install_msbuild) +include(vcpkg_determine_cmake_generator) include(vcpkg_install_make) include(vcpkg_install_nmake) include(vcpkg_install_qmake) @@ -40,5 +41,7 @@ include(vcpkg_get_windows_sdk) include(vcpkg_replace_string) include(vcpkg_from_git) include(vcpkg_test_cmake) +include(vcpkg_determine_compiler_and_linker) include(vcpkg_prettify_command) include(vcpkg_buildpath_length_warning) +include(vcpkg_load_environment_from_batch) diff --git a/scripts/cmake/vcpkg_configure_cmake.cmake b/scripts/cmake/vcpkg_configure_cmake.cmake index c31955fb257ff3..6f54f7ab7c9f08 100644 --- a/scripts/cmake/vcpkg_configure_cmake.cmake +++ b/scripts/cmake/vcpkg_configure_cmake.cmake @@ -66,92 +66,30 @@ function(vcpkg_configure_cmake) ${ARGN} ) - if(NOT VCPKG_PLATFORM_TOOLSET) + if(NOT VCPKG_PLATFORM_TOOLSET AND NOT DEFINED VCPKG_DEFAULT_CMAKE_GENERATOR) message(FATAL_ERROR "Vcpkg has been updated with VS2017 support; " "however, vcpkg.exe must be rebuilt by re-running bootstrap-vcpkg.bat\n") endif() - if(CMAKE_HOST_WIN32) - if(DEFINED ENV{PROCESSOR_ARCHITEW6432}) - set(_csc_HOST_ARCHITECTURE $ENV{PROCESSOR_ARCHITEW6432}) - else() - set(_csc_HOST_ARCHITECTURE $ENV{PROCESSOR_ARCHITECTURE}) - endif() - endif() - - set(NINJA_CAN_BE_USED ON) # Ninja as generator - set(NINJA_HOST ON) # Ninja as parallel configurator - - if(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore") - set(_TARGETTING_UWP 1) - endif() - - if(_csc_HOST_ARCHITECTURE STREQUAL "x86") - # Prebuilt ninja binaries are only provided for x64 hosts - set(NINJA_CAN_BE_USED OFF) - set(NINJA_HOST OFF) - elseif(_TARGETTING_UWP) - # Ninja and MSBuild have many differences when targetting UWP, so use MSBuild to maximize existing compatibility - set(NINJA_CAN_BE_USED OFF) + if(NOT DEFINED VCPKG_DEFAULT_CMAKE_GENERATOR) + vcpkg_determine_cmake_generator(VCPKG_DEFAULT_CMAKE_GENERATOR ${_csc_PREFER_NINJA}) endif() - if(_csc_GENERATOR) + + if(_csc_GENERATOR) #If the Generator is defined in the function call there is probably a good reason for it + message(STATUS "VCPKG_DEFAULT_CMAKE_GENERATOR overwritten by port file! CMake generator is: ${_csc_GENERATOR}") set(GENERATOR ${_csc_GENERATOR}) - elseif(_csc_PREFER_NINJA AND NINJA_CAN_BE_USED) - set(GENERATOR "Ninja") - elseif(VCPKG_CHAINLOAD_TOOLCHAIN_FILE OR (VCPKG_CMAKE_SYSTEM_NAME AND NOT _TARGETTING_UWP)) - set(GENERATOR "Ninja") - - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v120") - set(GENERATOR "Visual Studio 12 2013") - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v120") - set(GENERATOR "Visual Studio 12 2013 Win64") - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v120") - set(GENERATOR "Visual Studio 12 2013 ARM") - - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v140") - set(GENERATOR "Visual Studio 14 2015") - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v140") - set(GENERATOR "Visual Studio 14 2015 Win64") - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v140") - set(GENERATOR "Visual Studio 14 2015 ARM") - - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141") - set(GENERATOR "Visual Studio 15 2017") - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141") - set(GENERATOR "Visual Studio 15 2017 Win64") - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141") - set(GENERATOR "Visual Studio 15 2017 ARM") - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141") - set(GENERATOR "Visual Studio 15 2017") - set(ARCH "ARM64") - - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142") - set(GENERATOR "Visual Studio 16 2019") - set(ARCH "Win32") - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142") - set(GENERATOR "Visual Studio 16 2019") - set(ARCH "x64") - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142") - set(GENERATOR "Visual Studio 16 2019") - set(ARCH "ARM") - elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142") - set(GENERATOR "Visual Studio 16 2019") - set(ARCH "ARM64") - else() - if(NOT VCPKG_CMAKE_SYSTEM_NAME) - set(VCPKG_CMAKE_SYSTEM_NAME Windows) - endif() - message(FATAL_ERROR "Unable to determine appropriate generator for: " - "${VCPKG_CMAKE_SYSTEM_NAME}-${VCPKG_TARGET_ARCHITECTURE}-${VCPKG_PLATFORM_TOOLSET}") + set(GENERATOR ${VCPKG_DEFAULT_CMAKE_GENERATOR}) endif() # If we use Ninja, make sure it's on PATH if(GENERATOR STREQUAL "Ninja") vcpkg_find_acquire_program(NINJA) get_filename_component(NINJA_PATH ${NINJA} DIRECTORY) + vcpkg_add_to_path("${NINJA_PATH}") + list(APPEND _csc_OPTIONS "-DCMAKE_MAKE_PROGRAM=${NINJA}") endif() @@ -159,7 +97,8 @@ function(vcpkg_configure_cmake) if(DEFINED VCPKG_CMAKE_SYSTEM_NAME) list(APPEND _csc_OPTIONS "-DCMAKE_SYSTEM_NAME=${VCPKG_CMAKE_SYSTEM_NAME}") - if(_TARGETTING_UWP AND NOT DEFINED VCPKG_CMAKE_SYSTEM_VERSION) + if(VCPKG_TARGET_IS_UWP AND NOT DEFINED VCPKG_CMAKE_SYSTEM_VERSION) + message(WARNING "Please update your UWP triplet to include VCPKG_CMAKE_SYSTEM_VERSION.") set(VCPKG_CMAKE_SYSTEM_VERSION 10.0) endif() endif() @@ -194,15 +133,15 @@ function(vcpkg_configure_cmake) endif() if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE) - if(NOT DEFINED VCPKG_CMAKE_SYSTEM_NAME OR _TARGETTING_UWP) + if(VCPKG_TARGET_IS_WINDOWS) set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/windows.cmake") - elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Linux") + elseif(VCPKG_TARGET_IS_LINUX) set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/linux.cmake") - elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Android") + elseif(VCPKG_TARGET_IS_ANDROID) set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/android.cmake") - elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Darwin") + elseif(VCPKG_TARGET_IS_OSX) set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/osx.cmake") - elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "FreeBSD") + elseif(VCPKG_TARGET_IS_FREEBSD) set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/freebsd.cmake") endif() endif() @@ -211,16 +150,8 @@ function(vcpkg_configure_cmake) list(APPEND _csc_OPTIONS "-DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}" "-DVCPKG_TARGET_TRIPLET=${TARGET_TRIPLET}" - "-DVCPKG_SET_CHARSET_FLAG=${VCPKG_SET_CHARSET_FLAG}" - "-DVCPKG_PLATFORM_TOOLSET=${VCPKG_PLATFORM_TOOLSET}" - "-DCMAKE_EXPORT_NO_PACKAGE_REGISTRY=ON" - "-DCMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY=ON" - "-DCMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY=ON" - "-DCMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP=TRUE" - "-DCMAKE_VERBOSE_MAKEFILE=ON" + "-DVCPKG_SET_CHARSET_FLAG=${VCPKG_SET_CHARSET_FLAG}" "-DVCPKG_APPLOCAL_DEPS=OFF" - "-DCMAKE_TOOLCHAIN_FILE=${SCRIPTS}/buildsystems/vcpkg.cmake" - "-DCMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION=ON" "-DVCPKG_CXX_FLAGS=${VCPKG_CXX_FLAGS}" "-DVCPKG_CXX_FLAGS_RELEASE=${VCPKG_CXX_FLAGS_RELEASE}" "-DVCPKG_CXX_FLAGS_DEBUG=${VCPKG_CXX_FLAGS_DEBUG}" @@ -230,16 +161,61 @@ function(vcpkg_configure_cmake) "-DVCPKG_CRT_LINKAGE=${VCPKG_CRT_LINKAGE}" "-DVCPKG_LINKER_FLAGS=${VCPKG_LINKER_FLAGS}" "-DVCPKG_TARGET_ARCHITECTURE=${VCPKG_TARGET_ARCHITECTURE}" + "-DCMAKE_TOOLCHAIN_FILE=${SCRIPTS}/buildsystems/vcpkg.cmake" + "-DCMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION=ON" "-DCMAKE_INSTALL_LIBDIR:STRING=lib" "-DCMAKE_INSTALL_BINDIR:STRING=bin" + "-DCMAKE_EXPORT_NO_PACKAGE_REGISTRY=ON" + "-DCMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY=ON" + "-DCMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY=ON" + "-DCMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP=TRUE" + "-DCMAKE_VERBOSE_MAKEFILE=ON" ) - - if(DEFINED ARCH) + + #Add toolset option if available + if(VCPKG_PLATFORM_TOOLSET AND NOT GENERATOR STREQUAL "Ninja") list(APPEND _csc_OPTIONS - "-A${ARCH}" + "-DVCPKG_PLATFORM_TOOLSET=${VCPKG_PLATFORM_TOOLSET}" ) + set(toolset_option "-T${VCPKG_PLATFORM_TOOLSET}") + else() + unset(toolset_option) + endif() + + if(GENERATOR STREQUAL "Ninja" AND VCPKG_TARGET_IS_WINDOWS AND DEFINED VCPKG_PLATFORM_TOOLSET) + if( (NOT DEFINED VCPKG_CXX_COMPILER OR NOT DEFINED VCPKG_C_COMPILER OR NOT DEFINED VCPKG_LINKER) + AND (DEFINED VCPKG_C_COMPILER OR DEFINED VCPKG_CXX_COMPILER OR DEFINED VCPKG_LINKER)) + message(FATAL_ERROR "All three variables VCPKG_C_COMPILER, VCPKG_CXX_COMPILER and VCPKG_LINKER must be set for target Windows.") + endif() + if(NOT VCPKG_SKIP_AUTOMATIC_COMPILER_DETECTION AND (NOT VCPKG_C_COMPILER OR NOT VCPKG_CXX_COMPILER OR NOT VCPKG_LINKER)) + vcpkg_determine_compiler_and_linker() + message(STATUS "Detected VCPKG_C_COMPILER=${VCPKG_C_COMPILER}") + message(STATUS "Detected VCPKG_CXX_COMPILER=${VCPKG_CXX_COMPILER}") + message(STATUS "Detected VCPKG_LINKER=${VCPKG_LINKER}") + endif() endif() + if(DEFINED VCPKG_C_COMPILER) + list(APPEND _csc_BUILD_TOOLS "-DCMAKE_C_COMPILER:FILEPATH=${VCPKG_C_COMPILER}") + endif() + if(DEFINED VCPKG_CXX_COMPILER) + list(APPEND _csc_BUILD_TOOLS "-DCMAKE_CXX_COMPILER:FILEPATH=${VCPKG_CXX_COMPILER}") + endif() + if(DEFINED VCPKG_LINKER) + list(APPEND _csc_BUILD_TOOLS "-DCMAKE_LINKER:FILEPATH=${VCPKG_LINKER}") + endif() + if(DEFINED VCPKG_AR) + list(APPEND _csc_BUILD_TOOLS "-DCMAKE_AR:FILEPATH=${VCPKG_AR}") + endif() + if(DEFINED VCPKG_RC_COMPILER) + list(APPEND _csc_BUILD_TOOLS "-DCMAKE_RC_COMPILER:FILEPATH=${VCPKG_RC_COMPILER}") + endif() + if(DEFINED VCPKG_RANLIB) + list(APPEND _csc_BUILD_TOOLS "-DCMAKE_RANLIB:FILEPATH=${VCPKG_RANLIB}") + endif() + if(DEFINED VCPKG_NM) + list(APPEND _csc_BUILD_TOOLS "-DCMAKE_NM:FILEPATH=${VCPKG_NM}") + endif() # Sets configuration variables for macOS builds foreach(config_var INSTALL_NAME_DIR OSX_DEPLOYMENT_TARGET OSX_SYSROOT) if(DEFINED VCPKG_${config_var}) @@ -249,22 +225,23 @@ function(vcpkg_configure_cmake) set(rel_command ${CMAKE_COMMAND} ${_csc_SOURCE_PATH} "${_csc_OPTIONS}" "${_csc_OPTIONS_RELEASE}" - -G ${GENERATOR} + "${VCPKG_ADDITIONAL_CMAKE_OPTIONS}" "${VCPKG_ADDITIONAL_CMAKE_OPTIONS_RELEASE}" + -G ${GENERATOR} ${toolset_option} -DCMAKE_BUILD_TYPE=Release - -DCMAKE_INSTALL_PREFIX=${CURRENT_PACKAGES_DIR}) + -DCMAKE_INSTALL_PREFIX=${CURRENT_PACKAGES_DIR} + ${_csc_BUILD_TOOLS}) set(dbg_command ${CMAKE_COMMAND} ${_csc_SOURCE_PATH} "${_csc_OPTIONS}" "${_csc_OPTIONS_DEBUG}" - -G ${GENERATOR} + "${VCPKG_ADDITIONAL_CMAKE_OPTIONS}" "${VCPKG_ADDITIONAL_CMAKE_OPTIONS_DEBUG}" + -G ${GENERATOR} ${toolset_option} -DCMAKE_BUILD_TYPE=Debug - -DCMAKE_INSTALL_PREFIX=${CURRENT_PACKAGES_DIR}/debug) - - if(NINJA_HOST AND CMAKE_HOST_WIN32 AND NOT _csc_DISABLE_PARALLEL_CONFIGURE) + -DCMAKE_INSTALL_PREFIX=${CURRENT_PACKAGES_DIR}/debug + ${_csc_BUILD_TOOLS}) - vcpkg_find_acquire_program(NINJA) - get_filename_component(NINJA_PATH ${NINJA} DIRECTORY) - vcpkg_add_to_path("${NINJA_PATH}") + set(_csc_DISABLE_PARALLEL_CONFIGURE "1") # Parallel configure is currently disabled? + if(VCPKG_IS_NINJA_HOST AND CMAKE_HOST_WIN32 AND NOT _csc_DISABLE_PARALLEL_CONFIGURE) #VCPKG_IS_NINJA_HOST is currently not set. Fix it when you change the line above. - #parallelize the configure step + #parallelize the configure step set(_contents "rule CreateProcess\n command = $process\n\n" ) diff --git a/scripts/cmake/vcpkg_determine_cmake_generator.cmake b/scripts/cmake/vcpkg_determine_cmake_generator.cmake new file mode 100644 index 00000000000000..0b3cddd34c5be8 --- /dev/null +++ b/scripts/cmake/vcpkg_determine_cmake_generator.cmake @@ -0,0 +1,56 @@ +function(vcpkg_is_ninja_useable OUTPUT_NINJA_USEABLE) + if(CMAKE_HOST_WIN32) + if(DEFINED ENV{PROCESSOR_ARCHITEW6432} AND NOT DEFINED VCPKG_HOST_ARCHITECTURE) + set(VCPKG_HOST_ARCHITECTURE $ENV{PROCESSOR_ARCHITEW6432}) + else() + set(VCPKG_HOST_ARCHITECTURE $ENV{PROCESSOR_ARCHITECTURE}) + endif() + endif() + if(VCPKG_HOST_ARCHITECTURE STREQUAL "x86") + # Prebuilt ninja binaries are only provided for x64 hosts + set(OUTPUT_NINJA_USEABLE OFF PARENT_SCOPE) + elseif(VCPKG_TARGET_IS_UWP) + # Ninja and MSBuild have many differences when targetting UWP, so use MSBuild to maximize existing compatibility + set(OUTPUT_NINJA_USEABLE OFF PARENT_SCOPE) + else() + set(OUTPUT_NINJA_USEABLE ON PARENT_SCOPE) + endif() +endfunction() + +## # vcpkg_determine_cmake_generator +## +## Automatically determines the cmake generator to use +## +## ## Usage +## ```cmake +## vcpkg_determine_cmake_generator(OUTPUT_GENERATOR) +## ``` +## +function(vcpkg_determine_cmake_generator OUTPUT_GENERATOR) + cmake_parse_arguments(_dcg + "PREFER_NINJA" + "" + "" + ${ARGN} + ) + vcpkg_is_ninja_useable(NINJA_USEABLE) + + + if(NOT DEFINED VCPKG_USE_NINJA) + set(VCPKG_USE_NINJA ${NINJA_USEABLE}) # Ninja as generator + endif() + + if(_dcg_PREFER_NINJA AND VCPKG_USE_NINJA) #Use Ninja for Windows targets if possible. + set(${OUTPUT_GENERATOR} "Ninja" PARENT_SCOPE) + elseif(VCPKG_CHAINLOAD_TOOLCHAIN_FILE OR NOT VCPKG_TARGET_IS_WINDOWS) #Use Ninja for everything which is not Windows. + set(${OUTPUT_GENERATOR} "Ninja" PARENT_SCOPE) + else() # Use Visual Studio Generators. + if(NOT VCPKG_CMAKE_VS_GENERATOR) + message(STATUS "CMAKE VS Generator not set: ${VCPKG_CMAKE_VS_GENERATOR}") + message(FATAL_ERROR "Unable to determine appropriate generator for triplet ${TARGET_TRIPLET}: ${VCPKG_CMAKE_SYSTEM_NAME}-${VCPKG_TARGET_ARCHITECTURE}-${VCPKG_PLATFORM_TOOLSET}") + endif() + #message(STATUS "Using CMAKE VS Generator: ${VCPKG_CMAKE_VS_GENERATOR}") + set(${OUTPUT_GENERATOR} "${VCPKG_CMAKE_VS_GENERATOR}" PARENT_SCOPE) + endif() + +endfunction() diff --git a/scripts/cmake/vcpkg_determine_compiler_and_linker.cmake b/scripts/cmake/vcpkg_determine_compiler_and_linker.cmake new file mode 100644 index 00000000000000..dda73cc4be4d5f --- /dev/null +++ b/scripts/cmake/vcpkg_determine_compiler_and_linker.cmake @@ -0,0 +1,49 @@ +## # vcpkg_determine_compiler_and_linker +## +function(vcpkg_determine_compiler_and_linker) + set(DUMMY_DIR ${VCPKG_ROOT_DIR}/scripts/dummy/) + set(COMPILER_INFO_FILE ${VCPKG_ROOT_DIR}/scripts/dummy/compiler_linker_info.txt) + file(REMOVE_RECURSE ${DUMMY_DIR}/build) + + if(EXISTS ${COMPILER_INFO_FILE}) + FILE(READ ${COMPILER_INFO_FILE} COMPILER_INFO) + string(REGEX REPLACE "([][+.*()^])" "\\\\\\1" ESCAPED_VCPKG_PLATFORM_TOOLSET "${VCPKG_PLATFORM_TOOLSET}") +# message(STATUS "Escaped Platformtoolset:${ESCAPED_VCPKG_PLATFORM_TOOLSET}") + STRING(REGEX MATCH "${ESCAPED_VCPKG_PLATFORM_TOOLSET}" TEST1 ${COMPILER_INFO}) + if(${VCPKG_VISUAL_STUDIO_PATH}) + STRING(REGEX MATCH "${VCPKG_VISUAL_STUDIO_PATH}" TEST2 ${COMPILER_INFO}) + else() + set(TEST2 "TRUE") + endif() + STRING(REGEX MATCH "${TARGET_TRIPLET}[^\n]*" TEST3 ${COMPILER_INFO}) + STRING(COMPARE EQUAL "${TARGET_TRIPLET}" "${TEST3}" TEST3) + STRING(REGEX MATCH "${VCPKG_CMAKE_VS_GENERATOR}" TEST4 ${COMPILER_INFO}) + endif() + message(STATUS "Used CMake VS generator to determine compiler/linker of toolset '${VCPKG_PLATFORM_TOOLSET}': ${VCPKG_CMAKE_VS_GENERATOR}") + if(NOT TEST1 OR NOT TEST2 OR NOT TEST3 OR NOT TEST4) + vcpkg_execute_required_process(COMMAND cmake -G ${VCPKG_CMAKE_VS_GENERATOR} -T ${VCPKG_PLATFORM_TOOLSET} -S ./ -B build/ + -DVCPKG_CMAKE_VS_GENERATOR=${VCPKG_CMAKE_VS_GENERATOR} + -DVCPKG_PLATFORM_TOOLSET=${VCPKG_PLATFORM_TOOLSET} + -DVCPKG_VISUAL_STUDIO_PATH=${VCPKG_VISUAL_STUDIO_PATH} + -DTARGET_TRIPLET=${TARGET_TRIPLET} + WORKING_DIRECTORY ${DUMMY_DIR} + LOGNAME compiler_discovery.log) + FILE(READ ${COMPILER_INFO_FILE} COMPILER_INFO) + endif() + + STRING(REGEX MATCH "VCPKG_C_COMPILER=[^\n]+" VCPKG_C_COMPILER ${COMPILER_INFO}) + STRING(REGEX MATCH "VCPKG_CXX_COMPILER=[^\n]+" VCPKG_CXX_COMPILER ${COMPILER_INFO}) + STRING(REGEX MATCH "VCPKG_LINKER=[^\n]+" VCPKG_LINKER ${COMPILER_INFO}) + STRING(REPLACE "VCPKG_C_COMPILER=" "" VCPKG_C_COMPILER ${VCPKG_C_COMPILER}) + STRING(REPLACE "VCPKG_CXX_COMPILER=" "" VCPKG_CXX_COMPILER ${VCPKG_CXX_COMPILER}) + STRING(REPLACE "VCPKG_LINKER=" "" VCPKG_LINKER ${VCPKG_LINKER}) + + message(STATUS "Using C Compiler:${VCPKG_C_COMPILER}") + message(STATUS "Using CXX Compiler:${VCPKG_CXX_COMPILER}") + message(STATUS "Using Linker:${VCPKG_LINKER}") + + set(VCPKG_C_COMPILER "${VCPKG_C_COMPILER}" PARENT_SCOPE) + set(VCPKG_CXX_COMPILER "${VCPKG_CXX_COMPILER}" PARENT_SCOPE) + set(VCPKG_LINKER "${VCPKG_LINKER}" PARENT_SCOPE) #//ERROR: Could not find proper second linker member +endfunction() + diff --git a/scripts/cmake/vcpkg_load_environment_from_batch.cmake b/scripts/cmake/vcpkg_load_environment_from_batch.cmake new file mode 100644 index 00000000000000..ac806cba72f831 --- /dev/null +++ b/scripts/cmake/vcpkg_load_environment_from_batch.cmake @@ -0,0 +1,66 @@ +function(vcpkg_load_environment_from_batch) + cmake_parse_arguments(_lefb "" "BATCH_FILE_PATH" "ARGUMENTS" ${ARGN}) + + message(STATUS "LOADING ENV") + # Get original environment + vcpkg_execute_required_process( + COMMAND "${CMAKE_COMMAND}" "-E" "environment" + WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR} + LOGNAME environment-initial + ) + file(READ ${CURRENT_BUILDTREES_DIR}/environment-initial-out.log ENVIRONMENT_INITIAL) + + # Get modified envirnoment + string (REPLACE ";" " " SPACE_SEPARATED_ARGUMENTS "${_lefb_ARGUMENTS}") + file(WRITE ${CURRENT_BUILDTREES_DIR}/get-modified-environment.bat "call \"${_lefb_BATCH_FILE_PATH}\" ${SPACE_SEPARATED_ARGUMENTS}\n\"${CMAKE_COMMAND}\" -E environment") + vcpkg_execute_required_process( + COMMAND "cmd" "/c" "${CURRENT_BUILDTREES_DIR}/get-modified-environment.bat" + WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR} + LOGNAME environment-after + ) + file(READ ${CURRENT_BUILDTREES_DIR}/environment-after-out.log ENVIRONMENT_AFTER) + + # Escape characters that have a special meaning in CMake strings. + string(REPLACE "\\" "/" ENVIRONMENT_INITIAL "${ENVIRONMENT_INITIAL}") + string(REPLACE ";" "\\\\;" ENVIRONMENT_INITIAL "${ENVIRONMENT_INITIAL}") + string(REPLACE "\n" ";" ENVIRONMENT_INITIAL "${ENVIRONMENT_INITIAL}") + + string(REPLACE "\\" "/" ENVIRONMENT_AFTER "${ENVIRONMENT_AFTER}") + string(REPLACE ";" "\\\\;" ENVIRONMENT_AFTER "${ENVIRONMENT_AFTER}") + string(REPLACE "\n" ";" ENVIRONMENT_AFTER "${ENVIRONMENT_AFTER}") + + # Apply the environment changes to the current CMake environment + foreach(AFTER_LINE ${ENVIRONMENT_AFTER}) + if("${AFTER_LINE}" MATCHES "^([^=]+)=(.+)$") + set(AFTER_VAR_NAME "${CMAKE_MATCH_1}") + set(AFTER_VAR_VALUE "${CMAKE_MATCH_2}") + + set(FOUND "FALSE") + foreach(INITIAL_LINE ${ENVIRONMENT_INITIAL}) + if("${INITIAL_LINE}" MATCHES "^([^=]+)=(.+)$") + set(INITIAL_VAR_NAME "${CMAKE_MATCH_1}") + set(INITIAL_VAR_VALUE "${CMAKE_MATCH_2}") + + if("${AFTER_VAR_NAME}" STREQUAL "${INITIAL_VAR_NAME}") + set(FOUND "TRUE") + if(NOT "${AFTER_VAR_VALUE}" STREQUAL "${INITIAL_VAR_VALUE}") + + # Variable has been modified + # NOTE: we do not revert the escape changes that have previously been applied + # since the only change that should be visible in a single environment variable + # should be a conversion from `\` to `/` and this should not have any effect on + # windows paths. + set(ENV{${AFTER_VAR_NAME}} ${AFTER_VAR_VALUE}) + endif() + endif() + endif() + endforeach() + + if(NOT ${FOUND}) + # Variable has been added + message(STATUS "ADDING ${AFTER_VAR_NAME}=${AFTER_VAR_VALUE}") + set(ENV{${AFTER_VAR_NAME}} ${AFTER_VAR_VALUE}) + endif() + endif() + endforeach() +endfunction() \ No newline at end of file diff --git a/scripts/dummy/CMakeLists.txt b/scripts/dummy/CMakeLists.txt new file mode 100644 index 00000000000000..a8cbd0c74de89f --- /dev/null +++ b/scripts/dummy/CMakeLists.txt @@ -0,0 +1,32 @@ +#Dummy CMakeLists.txt to extract costum toolset compilers & linkers within Visual Studio + +cmake_minimum_required(VERSION 3.3) +FILE(READ "${Project_BINARY_DIR}/CMakeFiles/CMakeOutput.log" MAKE_COMPILE_TEST_FILE) +message(STATUS "Trying to figure out compiler and linker") +STRING(REGEX MATCH "[^\n]+\.exe [^\n]+CMakeCCompilerId.c" VCPKG_C_COMPILER ${MAKE_COMPILE_TEST_FILE}) +#MESSAGE(STATUS "C:${VCPKG_C_COMPILER}") +STRING(REGEX MATCH "[^\n]+\.exe" VCPKG_C_COMPILER ${VCPKG_C_COMPILER}) +STRING(REGEX MATCH "[^\n]+\.exe [^\n]+CMakeCXXCompilerId.c" VCPKG_CXX_COMPILER ${MAKE_COMPILE_TEST_FILE}) +#MESSAGE(STATUS "CXX:${VCPKG_CXX_COMPILER}") +STRING(REGEX MATCH "[^\n]+\.exe" VCPKG_CXX_COMPILER ${VCPKG_CXX_COMPILER}) +STRING(REGEX MATCH "Link:\n ([A-Z]:[A-Za-z0-9_ |\\|\.|\(\)|-]+)" VCPKG_LINKER ${MAKE_COMPILE_TEST_FILE}) +#MESSAGE(STATUS "L:${VCPKG_LINKER}") +STRING(REGEX MATCH "[^\n]+\.exe" VCPKG_LINKER ${VCPKG_LINKER}) + +SET(DUMMY_OUT "compiler_linker_info.txt") +#MESSAGE(STATUS "C:${VCPKG_C_COMPILER}") +#MESSAGE(STATUS "CXX:${VCPKG_CXX_COMPILER}") +#MESSAGE(STATUS "L:${VCPKG_LINKER}") + +STRING(STRIP ${VCPKG_C_COMPILER} VCPKG_C_COMPILER) +STRING(STRIP ${VCPKG_CXX_COMPILER} VCPKG_CXX_COMPILER) +STRING(STRIP ${VCPKG_LINKER} VCPKG_LINKER) +FILE(WRITE "${DUMMY_OUT}" "VCPKG_C_COMPILER=${VCPKG_C_COMPILER}\n") +FILE(APPEND "${DUMMY_OUT}" "VCPKG_CXX_COMPILER=${VCPKG_CXX_COMPILER}\n") +FILE(APPEND "${DUMMY_OUT}" "VCPKG_LINKER=${VCPKG_LINKER}\n") + +# Data to check if we need to regenerate the dummy +FILE(APPEND "${DUMMY_OUT}" "VCPKG_PLATFORM_TOOLSET=${VCPKG_PLATFORM_TOOLSET}\n") +FILE(APPEND "${DUMMY_OUT}" "VCPKG_VISUAL_STUDIO_PATH=${VCPKG_VISUAL_STUDIO_PATH}\n") +FILE(APPEND "${DUMMY_OUT}" "VCPKG_CMAKE_VS_GENERATOR=${VCPKG_CMAKE_VS_GENERATOR}\n") +FILE(APPEND "${DUMMY_OUT}" "TARGET_TRIPLET=${TARGET_TRIPLET}\n") diff --git a/scripts/get_triplet_environment.cmake b/scripts/get_triplet_environment.cmake index 3b0b9fbefa507d..c181f7e2b6c07c 100644 --- a/scripts/get_triplet_environment.cmake +++ b/scripts/get_triplet_environment.cmake @@ -12,5 +12,8 @@ message("VCPKG_PLATFORM_TOOLSET=${VCPKG_PLATFORM_TOOLSET}") message("VCPKG_VISUAL_STUDIO_PATH=${VCPKG_VISUAL_STUDIO_PATH}") message("VCPKG_CHAINLOAD_TOOLCHAIN_FILE=${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}") message("VCPKG_BUILD_TYPE=${VCPKG_BUILD_TYPE}") +message("VCPKG_CMAKE_VS_GENERATOR=${VCPKG_CMAKE_VS_GENERATOR}") +message("VCPKG_SKIP_POST_BUILD_LIB_ARCH_CHECK=${VCPKG_SKIP_POST_BUILD_LIB_ARCH_CHECK}") message("VCPKG_ENV_PASSTHROUGH=${VCPKG_ENV_PASSTHROUGH}") message("VCPKG_PUBLIC_ABI_OVERRIDE=${VCPKG_PUBLIC_ABI_OVERRIDE}") +message("VCPKG_FORCE_LOAD_VCVARS_ENV=${VCPKG_FORCE_LOAD_VCVARS_ENV}") diff --git a/scripts/ports.cmake b/scripts/ports.cmake index cdc0bdd9971a3c..87e55293019e2f 100644 --- a/scripts/ports.cmake +++ b/scripts/ports.cmake @@ -91,8 +91,16 @@ if(CMD MATCHES "^BUILD$") set(TRIPLET_SYSTEM_ARCH ${VCPKG_TARGET_ARCHITECTURE}) include(${SCRIPTS}/cmake/vcpkg_common_definitions.cmake) include(${SCRIPTS}/cmake/vcpkg_common_functions.cmake) + + if(DEFINED VCPKG_LOAD_ENVIROMNENT_BATCH) + vcpkg_load_environment_from_batch( + BATCH_FILE_PATH ${VCPKG_LOAD_ENVIROMNENT_BATCH} + ARGUMENTS ${VCPKG_LOAD_ENVIROMNENT_BATCH_ARGS}) + endif() + include(${CURRENT_PORT_DIR}/portfile.cmake) + set(BUILD_INFO_FILE_PATH ${CURRENT_PACKAGES_DIR}/BUILD_INFO) file(WRITE ${BUILD_INFO_FILE_PATH} "CRTLinkage: ${VCPKG_CRT_LINKAGE}\n") file(APPEND ${BUILD_INFO_FILE_PATH} "LibraryLinkage: ${VCPKG_LIBRARY_LINKAGE}\n") diff --git a/scripts/toolchains/windows.cmake b/scripts/toolchains/windows.cmake index d5d7f8db510d94..64a217f2fe29b9 100644 --- a/scripts/toolchains/windows.cmake +++ b/scripts/toolchains/windows.cmake @@ -15,12 +15,18 @@ if(NOT _CMAKE_IN_TRY_COMPILE) set(CHARSET_FLAG) endif() - set(CMAKE_CXX_FLAGS " /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} /GR /EHsc /MP ${VCPKG_CXX_FLAGS}" CACHE STRING "") - set(CMAKE_C_FLAGS " /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} /MP ${VCPKG_C_FLAGS}" CACHE STRING "") - set(CMAKE_RC_FLAGS "-c65001 /DWIN32" CACHE STRING "") + if(CMAKE_CXX_COMPILER MATCHES "[Cc]lang") + set(CMAKE_CXX_FLAGS " /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} /GR /EHsc ${VCPKG_CXX_FLAGS}" CACHE STRING "") + set(CMAKE_C_FLAGS " /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} ${VCPKG_C_FLAGS}" CACHE STRING "") + set(CMAKE_RC_FLAGS "-c65001 /DWIN32" CACHE STRING "") + else() + set(CMAKE_CXX_FLAGS " /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} /GR /EHsc /MP ${VCPKG_CXX_FLAGS}" CACHE STRING "") + set(CMAKE_C_FLAGS " /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} /MP ${VCPKG_C_FLAGS}" CACHE STRING "") + set(CMAKE_RC_FLAGS "-c65001 /DWIN32" CACHE STRING "") + endif() unset(CHARSET_FLAG) - + set(CMAKE_CXX_FLAGS_DEBUG "/D_DEBUG ${VCPKG_CRT_LINK_FLAG_PREFIX}d /Z7 /Ob0 /Od /RTC1 ${VCPKG_CXX_FLAGS_DEBUG}" CACHE STRING "") set(CMAKE_C_FLAGS_DEBUG "/D_DEBUG ${VCPKG_CRT_LINK_FLAG_PREFIX}d /Z7 /Ob0 /Od /RTC1 ${VCPKG_C_FLAGS_DEBUG}" CACHE STRING "") set(CMAKE_CXX_FLAGS_RELEASE "${VCPKG_CRT_LINK_FLAG_PREFIX} /O2 /Oi /Gy /DNDEBUG /Z7 ${VCPKG_CXX_FLAGS_RELEASE}" CACHE STRING "") diff --git a/toolchain/win-clang-toolchain.cmake b/toolchain/win-clang-toolchain.cmake new file mode 100644 index 00000000000000..662841f89717d3 --- /dev/null +++ b/toolchain/win-clang-toolchain.cmake @@ -0,0 +1,80 @@ +include_guard(GLOBAL) +get_filename_component(VCPKG_ROOT "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE CACHE) + +set(CMAKE_C_STANDARD 11 CACHE STRING "") +set(CMAKE_C_STANDARD_REQUIRED ON CACHE STRING "") +set(CMAKE_C_EXTENSIONS OFF CACHE STRING "") + +set(CMAKE_CXX_STANDARD 20 CACHE STRING "") +set(CMAKE_CXX_STANDARD_REQUIRED ON CACHE STRING "") +set(CMAKE_CXX_EXTENSIONS OFF CACHE STRING "") + +include("${VCPKG_ROOT}/triplets/${VCPKG_TARGET_TRIPLET}.cmake") + +set(CMAKE_RC_COMPILER "rc.exe" CACHE STRING "") + +if(NOT VCPKG_CRT_LINKAGE STREQUAL "static") + message(FATAL_ERROR "Invalid setting for VCPKG_CRT_LINKAGE: \"${VCPKG_CRT_LINKAGE}\".") +endif() + +set(CMAKE_MSVC_RUNTIME_LIBRARY "" CACHE STRING "") + +set(LLVM_CPP_FLAGS "-mavx2 -fasm -fopenmp-simd -ffast-math -fomit-frame-pointer -fmerge-all-constants") +set(LLVM_CPP_FLAGS "${LLVM_CPP_FLAGS} -fdiagnostics-absolute-paths -fms-compatibility-version=19.23") +set(LLVM_CXX_FLAGS "-fcoroutines-ts") + +set(LLVM_CPP_FLAGS_DEBUG "-Xclang --dependent-lib=libcmtd -D_MT -D_DEBUG -g -Xclang -gcodeview") +set(LLVM_CXX_FLAGS_DEBUG "-Xclang --dependent-lib=libcpmtd") + +set(LLVM_CPP_FLAGS_RELEASE "-Xclang --dependent-lib=libcmt -D_MT -DNDEBUG") +set(LLVM_CXX_FLAGS_RELEASE "-Xclang --dependent-lib=libcpmt -fwhole-program-vtables -fvirtual-function-elimination") + +set(CMAKE_C_FLAGS "${LLVM_CPP_FLAGS} ${VCPKG_C_FLAGS}" CACHE STRING "") +set(CMAKE_CXX_FLAGS "${LLVM_CPP_FLAGS} ${LLVM_CXX_FLAGS} ${VCPKG_CXX_FLAGS}" CACHE STRING "") + +if(CMAKE_BINARY_DIR MATCHES "^${VCPKG_ROOT}") + set(CMAKE_C_FLAGS_DEBUG "-Os ${LLVM_CPP_FLAGS_DEBUG} ${VCPKG_C_FLAGS_DEBUG}" CACHE STRING "") + set(CMAKE_CXX_FLAGS_DEBUG "-Os ${LLVM_CPP_FLAGS_DEBUG} ${LLVM_CXX_FLAGS_DEBUG} ${VCPKG_CXX_FLAGS_DEBUG}" CACHE STRING "") +else() + set(CMAKE_C_FLAGS_DEBUG "-O0 ${LLVM_CPP_FLAGS_DEBUG} ${VCPKG_C_FLAGS_DEBUG}" CACHE STRING "") + set(CMAKE_CXX_FLAGS_DEBUG "-O0 ${LLVM_CPP_FLAGS_DEBUG} ${LLVM_CXX_FLAGS_DEBUG} ${VCPKG_CXX_FLAGS_DEBUG}" CACHE STRING "") +endif() + +set(CMAKE_C_FLAGS_RELEASE "-Os ${LLVM_CPP_FLAGS_RELEASE} ${VCPKG_C_FLAGS_RELEASE} -v" CACHE STRING "") +set(CMAKE_CXX_FLAGS_RELEASE "-Os ${LLVM_CPP_FLAGS_RELEASE} ${LLVM_CXX_FLAGS_RELEASE} ${VCPKG_CXX_FLAGS_RELEASE}" CACHE STRING "") + +set(CMAKE_C_FLAGS_INIT "" CACHE STRING "") +set(CMAKE_CXX_FLAGS_INIT "" CACHE STRING "") + +set(CMAKE_C_FLAGS_DEBUG_INIT "" CACHE STRING "") +set(CMAKE_CXX_FLAGS_DEBUG_INIT "" CACHE STRING "") + +set(CMAKE_C_FLAGS_RELEASE_INIT "" CACHE STRING "") +set(CMAKE_CXX_FLAGS_RELEASE_INIT "" CACHE STRING "") + +set(CMAKE_STATIC_LINKER_FLAGS "" CACHE STRING "") +set(CMAKE_SHARED_LINKER_FLAGS "${VCPKG_LINKER_FLAGS} -Wl,/DEBUG:FULL" CACHE STRING "") +set(CMAKE_EXE_LINKER_FLAGS "${VCPKG_LINKER_FLAGS} -Wl,/DEBUG:FULL" CACHE STRING "") + +if(NOT CMAKE_BINARY_DIR MATCHES "^${VCPKG_ROOT}") + set(CMAKE_STATIC_LINKER_FLAGS_DEBUG "" CACHE STRING "") + set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "-Wl,/OPT:REF,/OPT:ICF" CACHE STRING "") + set(CMAKE_EXE_LINKER_FLAGS_DEBUG "-Wl,/OPT:REF,/OPT:ICF" CACHE STRING "") +else() + set(CMAKE_STATIC_LINKER_FLAGS_DEBUG "" CACHE STRING "") + set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "-Wl,/INCREMENTAL" CACHE STRING "") + set(CMAKE_EXE_LINKER_FLAGS_DEBUG "-Wl,/INCREMENTAL" CACHE STRING "") +endif() + +set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "" CACHE STRING "") +set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "-flto=full -Wl,/OPT:REF,/OPT:ICF" CACHE STRING "") +set(CMAKE_EXE_LINKER_FLAGS_RELEASE "-flto=full -Wl,/OPT:REF,/OPT:ICF" CACHE STRING "") + +set(CMAKE_RC_FLAGS "/nologo -c65001" CACHE STRING "") + +add_definitions(-D_WIN64 -D_WINDOWS -D_WIN32_WINNT=0x0A00 -DWINVER=0x0A00) +add_definitions(-D_CRT_STDIO_ISO_WIDE_SPECIFIERS -D_CRT_NONSTDC_NO_DEPRECATE) +add_definitions(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS) +add_definitions(-D_ATL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS) + +set(SILENCE_VS_WARNINGS "${CMAKE_C_COMPILER};${CMAKE_CXX_COMPILER}") \ No newline at end of file diff --git a/toolsrc/include/vcpkg/base/system.h b/toolsrc/include/vcpkg/base/system.h index 907a692a2761fe..c5e09d31dcfa4f 100644 --- a/toolsrc/include/vcpkg/base/system.h +++ b/toolsrc/include/vcpkg/base/system.h @@ -21,6 +21,18 @@ namespace vcpkg::System Optional to_cpu_architecture(StringView arch); + inline CStringView to_string(const CPUArchitecture& arch) noexcept + { + switch (arch) + { + case CPUArchitecture::X86: return "x86"; + case CPUArchitecture::X64: return "x64"; + case CPUArchitecture::ARM: return "ARM"; + case CPUArchitecture::ARM64: return "ARM64"; + default: return "unknown"; //<- Please update if you see that + } + }; + CPUArchitecture get_host_processor(); std::vector get_supported_host_architectures(); diff --git a/toolsrc/include/vcpkg/base/system.process.h b/toolsrc/include/vcpkg/base/system.process.h index 14e2eb109f488f..b733d9f92bfdbd 100644 --- a/toolsrc/include/vcpkg/base/system.process.h +++ b/toolsrc/include/vcpkg/base/system.process.h @@ -20,7 +20,8 @@ namespace vcpkg::System std::string make_cmake_cmd(const fs::path& cmake_exe, const fs::path& cmake_script, - const std::vector& pass_variables); + const std::vector& pass_variables, + const std::string& toolset = {}); fs::path get_exe_path_of_current_process(); diff --git a/toolsrc/include/vcpkg/build.h b/toolsrc/include/vcpkg/build.h index b535698dc56cb4..079fcd14aeaeba 100644 --- a/toolsrc/include/vcpkg/build.h +++ b/toolsrc/include/vcpkg/build.h @@ -148,6 +148,9 @@ namespace vcpkg::Build Optional public_abi_override; Optional port; std::vector passthrough_env_vars; + Optional cmake_vs_generator; + Optional skip_post_build_lib_arch_check; + bool force_vcvar_load; }; std::string make_build_env_cmd(const PreBuildInfo& pre_build_info, const Toolset& toolset); @@ -163,6 +166,9 @@ namespace vcpkg::Build BUILD_TYPE, ENV_PASSTHROUGH, PUBLIC_ABI_OVERRIDE, + SKIP_POST_BUILD_LIB_ARCH_CHECK, + CMAKE_VS_GENERATOR, + FORCE_VCVARS_LOAD }; const std::unordered_map VCPKG_OPTIONS = { @@ -175,7 +181,9 @@ namespace vcpkg::Build {"VCPKG_BUILD_TYPE", VcpkgTripletVar::BUILD_TYPE}, {"VCPKG_ENV_PASSTHROUGH", VcpkgTripletVar::ENV_PASSTHROUGH}, {"VCPKG_PUBLIC_ABI_OVERRIDE", VcpkgTripletVar::PUBLIC_ABI_OVERRIDE}, - }; + {"VCPKG_SKIP_POST_BUILD_LIB_ARCH_CHECK", VcpkgTripletVar::SKIP_POST_BUILD_LIB_ARCH_CHECK}, + {"VCPKG_CMAKE_VS_GENERATOR", VcpkgTripletVar::CMAKE_VS_GENERATOR}, + {"VCPKG_FORCE_LOAD_VCVARS_ENV", VcpkgTripletVar::FORCE_VCVARS_LOAD}}; struct ExtendedBuildResult { diff --git a/toolsrc/include/vcpkg/vcpkgpaths.h b/toolsrc/include/vcpkg/vcpkgpaths.h index 8107b8201f35fe..71be4ce335ef8a 100644 --- a/toolsrc/include/vcpkg/vcpkgpaths.h +++ b/toolsrc/include/vcpkg/vcpkgpaths.h @@ -23,11 +23,19 @@ namespace vcpkg static const std::string IFW_REPOGEN = "ifw_repogen"; } - struct ToolsetArchOption + struct ToolsetMinimal + { + std::string name; + std::string vsversion; + std::string cmake_generator; + }; + + struct ArchOption { CStringView name; System::CPUArchitecture host_arch; System::CPUArchitecture target_arch; + std::vector supported_toolsets; }; struct Toolset @@ -36,8 +44,10 @@ namespace vcpkg fs::path dumpbin; fs::path vcvarsall; std::vector vcvarsall_options; - CStringView version; - std::vector supported_architectures; + std::string name; + std::string vsversion; + std::string cmake_generator; + ArchOption arch; }; namespace Build @@ -83,9 +93,10 @@ namespace vcpkg const fs::path& get_tool_exe(const std::string& tool) const; const std::string& get_tool_version(const std::string& tool) const; - /// Retrieve a toolset matching a VS version + /// Retrieve a toolset matching the requested toolset name /// - /// Valid version strings are "v120", "v140", "v141", and "". Empty string gets the latest. + /// Valid names are all names which can be found in the VS Platform folder and "". + /// An empty string gets the latest toolset. /// const Toolset& get_toolset(const Build::PreBuildInfo& prebuildinfo) const; diff --git a/toolsrc/include/vcpkg/visualstudio.h b/toolsrc/include/vcpkg/visualstudio.h index cd99db352785bf..6aedd82856aa2c 100644 --- a/toolsrc/include/vcpkg/visualstudio.h +++ b/toolsrc/include/vcpkg/visualstudio.h @@ -6,6 +6,8 @@ namespace vcpkg::VisualStudio { + const std::array& get_preferred_toolset_names() noexcept; + std::vector get_visual_studio_instances(const VcpkgPaths& paths); std::vector find_toolset_instances_preferred_first(const VcpkgPaths& paths); diff --git a/toolsrc/src/vcpkg/base/system.cpp b/toolsrc/src/vcpkg/base/system.cpp index d9c6349be8f6c0..01de4937e8f1fd 100644 --- a/toolsrc/src/vcpkg/base/system.cpp +++ b/toolsrc/src/vcpkg/base/system.cpp @@ -181,9 +181,16 @@ namespace vcpkg std::string System::make_cmake_cmd(const fs::path& cmake_exe, const fs::path& cmake_script, - const std::vector& pass_variables) + const std::vector& pass_variables, + const std::string& toolset) { const std::string cmd_cmake_pass_variables = Strings::join(" ", pass_variables, [](auto&& v) { return v.s; }); + if (!toolset.empty()) + return Strings::format(R"("%s" -T%s %s -P "%s")", + cmake_exe.u8string(), + toolset, + cmd_cmake_pass_variables, + cmake_script.generic_u8string()); return Strings::format( R"("%s" %s -P "%s")", cmake_exe.u8string(), cmd_cmake_pass_variables, cmake_script.generic_u8string()); } diff --git a/toolsrc/src/vcpkg/build.cpp b/toolsrc/src/vcpkg/build.cpp index 2037e8d26388bb..b1ae265d357da5 100644 --- a/toolsrc/src/vcpkg/build.cpp +++ b/toolsrc/src/vcpkg/build.cpp @@ -196,26 +196,7 @@ namespace vcpkg::Build static CStringView to_vcvarsall_toolchain(const std::string& target_architecture, const Toolset& toolset) { - 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(); - - for (auto&& host : host_architectures) - { - const 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. Target was: %s but supported ones were:\n%s", - target_architecture, - Strings::join(",", toolset.supported_architectures, [](const ToolsetArchOption& t) { - return t.name.c_str(); - })); + return toolset.arch.name; } static auto make_env_passthrough(const PreBuildInfo& pre_build_info) -> std::unordered_map @@ -237,8 +218,8 @@ namespace vcpkg::Build std::string make_build_env_cmd(const PreBuildInfo& pre_build_info, const Toolset& toolset) { - if (pre_build_info.external_toolchain_file.has_value()) return ""; - if (!pre_build_info.cmake_system_name.empty() && pre_build_info.cmake_system_name != "WindowsStore") return ""; + if (pre_build_info.external_toolchain_file.has_value() && !pre_build_info.force_vcvar_load) return ""; + if (!pre_build_info.cmake_system_name.empty() && pre_build_info.cmake_system_name != "WindowsStore" && !pre_build_info.force_vcvar_load) return ""; const char* tonull = " >nul"; if (Debug::g_debugging) @@ -246,13 +227,13 @@ namespace vcpkg::Build tonull = ""; } - const auto arch = to_vcvarsall_toolchain(pre_build_info.target_architecture, toolset); + const auto vs_toolchain = to_vcvarsall_toolchain(pre_build_info.target_architecture, toolset); const auto target = to_vcvarsall_target(pre_build_info.cmake_system_name); return Strings::format(R"("%s" %s %s %s %s 2>&1 variables = get_cmake_vars(paths, config, triplet, toolset); - const std::string cmd_launch_cmake = System::make_cmake_cmd(cmake_exe_path, paths.ports_cmake, variables); + const std::string cmd_launch_cmake = + System::make_cmake_cmd(cmake_exe_path, paths.ports_cmake, variables, toolset.name); std::string command = make_build_env_cmd(pre_build_info, toolset); + if (!command.empty()) { #ifdef _WIN32 @@ -1167,6 +1151,33 @@ namespace vcpkg::Build pre_build_info.public_abi_override = variable_value.empty() ? nullopt : Optional{variable_value}; break; + case VcpkgTripletVar::SKIP_POST_BUILD_LIB_ARCH_CHECK: + pre_build_info.skip_post_build_lib_arch_check = + variable_value.empty() ? nullopt : Optional{variable_value}; + break; + case VcpkgTripletVar::CMAKE_VS_GENERATOR: + pre_build_info.cmake_vs_generator = + variable_value.empty() ? nullopt : Optional{variable_value}; + break; + case VcpkgTripletVar::FORCE_VCVARS_LOAD: + if (variable_value.empty()) + pre_build_info.force_vcvar_load = false; + else if (Strings::case_insensitive_ascii_equals(variable_value, "1")) + pre_build_info.force_vcvar_load = true; + else if (Strings::case_insensitive_ascii_equals(variable_value, "on")) + pre_build_info.force_vcvar_load = true; + else if (Strings::case_insensitive_ascii_equals(variable_value, "true")) + pre_build_info.force_vcvar_load = true; + else if (Strings::case_insensitive_ascii_equals(variable_value, "0")) + pre_build_info.force_vcvar_load = false; + else if (Strings::case_insensitive_ascii_equals(variable_value, "off")) + pre_build_info.force_vcvar_load = false; + else if (Strings::case_insensitive_ascii_equals(variable_value, "false")) + pre_build_info.force_vcvar_load = false; + else + Checks::exit_with_message( + VCPKG_LINE_INFO, "Unknown setting for VCPKG_FORCE_LOAD_VCVARS_ENV: %s", variable_value); + break; } } else diff --git a/toolsrc/src/vcpkg/postbuildlint.cpp b/toolsrc/src/vcpkg/postbuildlint.cpp index a85d879fe472aa..2caa3b74915149 100644 --- a/toolsrc/src/vcpkg/postbuildlint.cpp +++ b/toolsrc/src/vcpkg/postbuildlint.cpp @@ -395,10 +395,12 @@ namespace vcpkg::PostBuildLint "\n\n"); } } +#endif static LintStatus check_dll_architecture(const std::string& expected_architecture, const std::vector& files) { +#if defined(_WIN32) std::vector binaries_with_invalid_architecture; for (const fs::path& file : files) @@ -421,10 +423,9 @@ namespace vcpkg::PostBuildLint print_invalid_architecture_files(expected_architecture, binaries_with_invalid_architecture); return LintStatus::ERROR_DETECTED; } - +#endif return LintStatus::SUCCESS; } -#endif static LintStatus check_lib_architecture(const std::string& expected_architecture, const std::vector& files) @@ -778,6 +779,7 @@ namespace vcpkg::PostBuildLint if (!pre_build_info.build_type) error_count += check_matching_debug_and_release_binaries(debug_libs, release_libs); + if (!pre_build_info.skip_post_build_lib_arch_check.has_value()) { std::vector libs; libs.insert(libs.cend(), debug_libs.cbegin(), debug_libs.cend()); @@ -815,9 +817,11 @@ namespace vcpkg::PostBuildLint check_outdated_crt_linkage_of_dlls(dlls, toolset.dumpbin, build_info, pre_build_info); } -#if defined(_WIN32) - error_count += check_dll_architecture(pre_build_info.target_architecture, dlls); -#endif + if (!pre_build_info.skip_post_build_lib_arch_check.has_value()) + { + error_count += check_dll_architecture(pre_build_info.target_architecture, dlls); + } + break; } case Build::LinkageType::STATIC: diff --git a/toolsrc/src/vcpkg/vcpkgpaths.cpp b/toolsrc/src/vcpkg/vcpkgpaths.cpp index 078121fcc2e4b0..a6ef4b3873cbf8 100644 --- a/toolsrc/src/vcpkg/vcpkgpaths.cpp +++ b/toolsrc/src/vcpkg/vcpkgpaths.cpp @@ -182,17 +182,19 @@ namespace vcpkg const Toolset& VcpkgPaths::get_toolset(const Build::PreBuildInfo& prebuildinfo) const { - if (prebuildinfo.external_toolchain_file || + const auto host_arch = System::get_host_processor(); + const auto target_arch = System::to_cpu_architecture(prebuildinfo.target_architecture).value_or(host_arch); + + if ((prebuildinfo.external_toolchain_file && !prebuildinfo.force_vcvar_load) || (!prebuildinfo.cmake_system_name.empty() && prebuildinfo.cmake_system_name != "WindowsStore")) { - static Toolset external_toolset = []() -> Toolset { + static Toolset external_toolset = [&]() -> Toolset { Toolset ret; ret.dumpbin = ""; - ret.supported_architectures = { - ToolsetArchOption{"", System::get_host_processor(), System::get_host_processor()}}; + ret.arch = {ArchOption{"", host_arch, target_arch}}; ret.vcvarsall = ""; ret.vcvarsall_options = {}; - ret.version = "external"; + ret.vsversion = "external"; ret.visual_studio_root_path = ""; return ret; }(); @@ -208,15 +210,34 @@ namespace vcpkg std::vector candidates = Util::fmap(vs_toolsets, [](auto&& x) { return &x; }); const auto tsv = prebuildinfo.platform_toolset.get(); auto vsp = prebuildinfo.visual_studio_path.get(); + + // Filter by host and target architecture + Util::erase_remove_if(candidates, [&](const Toolset* t) { + return t->arch.host_arch != host_arch || t->arch.target_arch != target_arch; + }); + if (!vsp && !default_vs_path.empty()) { vsp = &default_vs_path; } + // Filter by CMake VS Generator (Allows to overwrite our preferences! -> Makes triplets like: x86-windows-vs2012 + // possible) + if (const auto cmake_vs_gen = prebuildinfo.cmake_vs_generator.get(); cmake_vs_gen) + { + Util::erase_remove_if(candidates, [&](const Toolset* t) { return t->cmake_generator != *cmake_vs_gen; }); + Checks::check_exit(VCPKG_LINE_INFO, + !candidates.empty(), + "Could not find Visual Studio instance at %s with %s toolset.", + vsp->u8string(), + *tsv); + } + + // Filter by toolset and VS path => Should only ever return a single toolset if (tsv && vsp) { Util::erase_remove_if( - candidates, [&](const Toolset* t) { return *tsv != t->version || *vsp != t->visual_studio_root_path; }); + candidates, [&](const Toolset* t) { return *tsv != t->name || *vsp != t->visual_studio_root_path; }); Checks::check_exit(VCPKG_LINE_INFO, !candidates.empty(), "Could not find Visual Studio instance at %s with %s toolset.", @@ -227,13 +248,17 @@ namespace vcpkg return *candidates.back(); } + // Filter by toolset (Allows triplets like x86-windows-llvm or triplets like x86-windows-v141_xp) + // If used together with cmake_vs_gen x86-windows-vs120_xp should be possible if (tsv) { - Util::erase_remove_if(candidates, [&](const Toolset* t) { return *tsv != t->version; }); + Util::erase_remove_if(candidates, [&](const Toolset* t) { return *tsv != t->name; }); Checks::check_exit( VCPKG_LINE_INFO, !candidates.empty(), "Could not find Visual Studio instance with %s toolset.", *tsv); + return *candidates.front(); } + // Filter by Path if (vsp) { const fs::path vs_root_path = *vsp; @@ -246,7 +271,24 @@ namespace vcpkg } Checks::check_exit(VCPKG_LINE_INFO, !candidates.empty(), "No suitable Visual Studio instances were found"); - return *candidates.front(); + + // Last but not least: filter by preferred toolset selection. + // Requires candidates to be sorted in: a) major version b) toolset versions. (newer > older) + // Maybe candidates should be sorted that way to make sure it is sorted. + // Currently the code relies on the fact that VisualStudio::find_toolset_instances_preferred_first + // pushes it back in that way (hoepfully; not fully tested <- please make better) + auto preferred_pred = [](const Toolset* set, const CStringView prename) noexcept + { + return (set->name == prename.c_str()); + }; + const auto preferred = std::find_first_of(candidates.begin(), + candidates.end(), + VisualStudio::get_preferred_toolset_names().cbegin(), + VisualStudio::get_preferred_toolset_names().cend(), + preferred_pred); + Checks::check_exit( + VCPKG_LINE_INFO, preferred != candidates.cend(), "Could not find a preferred Visual Studio toolset!"); + return **preferred; #endif } diff --git a/toolsrc/src/vcpkg/visualstudio.cpp b/toolsrc/src/vcpkg/visualstudio.cpp index df3c70de2170a4..6af05da6d1809e 100644 --- a/toolsrc/src/vcpkg/visualstudio.cpp +++ b/toolsrc/src/vcpkg/visualstudio.cpp @@ -16,6 +16,30 @@ namespace vcpkg::VisualStudio static constexpr CStringView V_141 = "v141"; static constexpr CStringView V_142 = "v142"; + static constexpr std::array preferred_toolsets{V_142, V_141, V_140, V_120}; + + static constexpr CStringView cmake_V_120_x86 = "Visual Studio 12 2013"; + static constexpr CStringView cmake_V_120_x64 = "Visual Studio 12 2013 Win64"; + static constexpr CStringView cmake_V_120_ARM = "Visual Studio 12 2013 ARM"; + + static constexpr CStringView cmake_V_140_x86 = "Visual Studio 14 2015"; + static constexpr CStringView cmake_V_140_x64 = "Visual Studio 14 2015 Win64"; + static constexpr CStringView cmake_V_140_ARM = "Visual Studio 14 2015 ARM"; + + static constexpr CStringView cmake_V_141_x86 = "Visual Studio 15 2017"; + static constexpr CStringView cmake_V_141_x64 = "Visual Studio 15 2017 Win64"; + static constexpr CStringView cmake_V_141_ARM = "Visual Studio 15 2017 ARM"; + static constexpr CStringView cmake_V_141_ARM64 = "Visual Studio 15 2017"; + + static constexpr CStringView cmake_V_142_x86 = "Visual Studio 16 2019;-A;Win32"; //CMake needs to properly parse this string on the command line + static constexpr CStringView cmake_V_142_x64 = "Visual Studio 16 2019"; + static constexpr CStringView cmake_V_142_ARM = "Visual Studio 16 2019;-A;ARM"; + static constexpr CStringView cmake_V_142_ARM64 = "Visual Studio 16 2019;-A;ARM64"; + + static constexpr CStringView unknown = "unknown"; + + const std::array& get_preferred_toolset_names() noexcept { return preferred_toolsets; } + struct VisualStudioInstance { enum class ReleaseType @@ -184,7 +208,7 @@ namespace vcpkg::VisualStudio if (!fs.exists(vcvarsall_bat)) continue; // Get all supported architectures - std::vector supported_architectures; + std::vector supported_architectures; if (fs.exists(vcvarsall_dir / "vcvars32.bat")) supported_architectures.push_back({"x86", CPU::X86, CPU::X86}); if (fs.exists(vcvarsall_dir / "vcvars64.bat")) @@ -202,6 +226,76 @@ namespace vcpkg::VisualStudio if (fs.exists(vcvarsall_dir / "vcvarsamd64_arm64.bat")) supported_architectures.push_back({"amd64_arm64", CPU::X64, CPU::ARM64}); + // Discover available platform toolsets + for (ArchOption& arch : supported_architectures) + { + const auto vs_arch = [](const ArchOption& arch) noexcept + { + switch (arch.target_arch) + { + case CPU::X86: return "Win32"; + case CPU::X64: return "x64"; + case CPU::ARM: return "ARM"; + case CPU::ARM64: return "ARM64"; + default: return unknown.c_str(); //<- Please update if you see that; + }; + }; + const auto vs15_cmake = [](const ArchOption& arch) noexcept + { + switch (arch.target_arch) + { + case CPU::X86: return cmake_V_141_x86; + case CPU::X64: return cmake_V_141_x64; + case CPU::ARM: return cmake_V_141_ARM; + case CPU::ARM64: return cmake_V_141_ARM64; + default: return unknown; //<- Please update if you see that; + }; + }; + const auto vs16_cmake = [](const ArchOption& arch) noexcept + { + switch (arch.target_arch) + { + case CPU::X86: return cmake_V_142_x86; + case CPU::X64: return cmake_V_142_x64; + case CPU::ARM: return cmake_V_142_ARM; + case CPU::ARM64: return cmake_V_142_ARM64; + default: return unknown; //<- Please update if you see that; + }; + }; + + // Should probably create a map of lambdas with all those paths using major_version as a key + const fs::path platformpath = [&]() { + if (major_version > "15") + { + return vs_instance.root_path / "MSBuild" / "Microsoft" / "VC" / "v160" / "Platforms" / + vs_arch(arch) / "PlatformToolsets"; + } + else + { + return vs_instance.root_path / "Common7" / "IDE" / "VC" / "VCTargets" / "Platforms" / + vs_arch(arch) / "PlatformToolsets"; + } + }(); + + if (fs.exists(platformpath)) + { + std::vector platformsubdirs = fs.get_files_non_recursive(platformpath); + Util::erase_remove_if(platformsubdirs, + [&fs](const fs::path& path) { return !fs.is_directory(path); }); + + for (const fs::path& platform : platformsubdirs) + { + const auto tmp = platform.filename(); + + const ToolsetMinimal Toolmin{tmp.u8string(), + major_version, + major_version > "15" ? vs16_cmake(arch).c_str() + : vs15_cmake(arch).c_str()}; + arch.supported_toolsets.push_back(Toolmin); + } + } + } + // Locate the "best" MSVC toolchain version const fs::path msvc_path = vc_dir / "Tools" / "MSVC"; std::vector msvc_subdirectories = fs.get_files_non_recursive(msvc_path); @@ -225,6 +319,11 @@ namespace vcpkg::VisualStudio // unknown toolset continue; } + else if (toolset_version_prefix[3] == '0') + { + toolset_version = V_140; + vcvars_option = "-vcvars_ver=14.0"; + } else if (toolset_version_prefix[3] == '1') { toolset_version = V_141; @@ -240,42 +339,40 @@ namespace vcpkg::VisualStudio // unknown toolset minor version continue; } - const fs::path dumpbin_path = subdir / "bin" / "HostX86" / "x86" / "dumpbin.exe"; - paths_examined.push_back(dumpbin_path); - if (fs.exists(dumpbin_path)) + for (const ArchOption& arch : supported_architectures) { - Toolset toolset{vs_instance.root_path, - dumpbin_path, - vcvarsall_bat, - {vcvars_option}, - toolset_version, - supported_architectures}; - - const auto english_language_pack = dumpbin_path.parent_path() / "1033"; + const std::string Host_arch = "Host" + System::to_string(arch.host_arch); + const fs::path dumpbin_path = subdir / "bin" / Host_arch.c_str() / + System::to_string(arch.target_arch).c_str() / "dumpbin.exe"; - if (!fs.exists(english_language_pack)) + paths_examined.push_back(dumpbin_path); + if (fs.exists(dumpbin_path)) { - excluded_toolsets.push_back(std::move(toolset)); - continue; - } - - found_toolsets.push_back(std::move(toolset)); + for (const ToolsetMinimal& MinTool : arch.supported_toolsets) + { + const auto english_language_pack = dumpbin_path.parent_path() / "1033"; + const bool english_language_pack_available = fs.exists(english_language_pack); - if (v140_is_available) - { - found_toolsets.push_back({vs_instance.root_path, + const Toolset toolset{vs_instance.root_path, dumpbin_path, vcvarsall_bat, - {"-vcvars_ver=14.0"}, - V_140, - supported_architectures}); + {vcvars_option}, + MinTool.name, + MinTool.vsversion, + MinTool.cmake_generator, + arch}; + + if (!english_language_pack_available) + { + excluded_toolsets.push_back(toolset); + break; + } + + found_toolsets.push_back(toolset); + } } - - continue; } } - - continue; } if (major_version == "14" || major_version == "12") @@ -289,7 +386,7 @@ namespace vcpkg::VisualStudio paths_examined.push_back(vs_dumpbin_exe); const fs::path vs_bin_dir = vcvarsall_bat.parent_path() / "bin"; - std::vector supported_architectures; + std::vector supported_architectures; if (fs.exists(vs_bin_dir / "vcvars32.bat")) supported_architectures.push_back({"x86", CPU::X86, CPU::X86}); if (fs.exists(vs_bin_dir / "amd64\\vcvars64.bat")) @@ -305,22 +402,39 @@ namespace vcpkg::VisualStudio if (fs.exists(vs_dumpbin_exe)) { - const Toolset toolset = {vs_instance.root_path, - vs_dumpbin_exe, - vcvarsall_bat, - {}, - major_version == "14" ? V_140 : V_120, - supported_architectures}; - - const auto english_language_pack = vs_dumpbin_exe.parent_path() / "1033"; - - if (!fs.exists(english_language_pack)) + for (const auto& arch : supported_architectures) { - excluded_toolsets.push_back(toolset); - break; + const bool is_vs_14{major_version == "14"}; + const auto vs12or14_cmake = [&is_vs_14](const ArchOption& arch) noexcept + { + switch (arch.target_arch) + { + case CPU::X86: return is_vs_14 ? cmake_V_140_x86 : cmake_V_120_x86; + case CPU::X64: return is_vs_14 ? cmake_V_140_x64 : cmake_V_120_x64; + case CPU::ARM: return is_vs_14 ? cmake_V_140_ARM : cmake_V_120_ARM; + default: return unknown; //<- Please update if you see that; + }; + }; + + const Toolset toolset = {vs_instance.root_path, + vs_dumpbin_exe, + vcvarsall_bat, + {}, + is_vs_14 ? V_140.c_str() : V_120.c_str(), + major_version, + vs12or14_cmake(arch).c_str(), + arch}; + + const auto english_language_pack = vs_dumpbin_exe.parent_path() / "1033"; + + if (!fs.exists(english_language_pack)) + { + excluded_toolsets.push_back(toolset); + break; + } + + found_toolsets.push_back(toolset); } - - found_toolsets.push_back(toolset); } } } diff --git a/triplets/x64-windows-clang.cmake b/triplets/x64-windows-clang.cmake new file mode 100644 index 00000000000000..3ad3f651820f13 --- /dev/null +++ b/triplets/x64-windows-clang.cmake @@ -0,0 +1,23 @@ +set(VCPKG_TARGET_ARCHITECTURE x64) +set(VCPKG_CRT_LINKAGE static) +set(VCPKG_LIBRARY_LINKAGE static) +set(VCPKG_PLATFORM_TOOLSET v142) +set(VCPKG_SKIP_POST_BUILD_LIB_ARCH_CHECK "ON") # Skips post build architecture checks of libs and dlls. Only works with VS link.exe +set(LLVM_BINDIR "C:\\Program Files\\LLVM\\bin") +set(ENV{Path} "${LLVM_BINDIR};$ENV{Path}") +set(VCPKG_C_COMPILER "clang") +set(VCPKG_CXX_COMPILER "clang++") +set(VCPKG_LINKER "lld-link") +set(VCPKG_AR "llvm-ar.exe") +set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${CMAKE_CURRENT_LIST_DIR}/../toolchain/win-clang-toolchain.cmake") +set(VCPKG_DEFAULT_CMAKE_GENERATOR Ninja) +#set(VCPKG_LOAD_ENVIROMNENT_BATCH "C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Community\\VC\\Auxiliary\\Build\\vcvars64.bat") +set(VCPKG_FORCE_LOAD_VCVARS_ENV "true") +#set(ENV{VCPKG_KEEP_ENV_VARS} "Path;INCLUDE;LIB") # start building this triplet from a dev cmd with vcvars loaded. Needs to be set manually for some reason +#set(VCPKG_C_FLAGS) # Injects additional C build flags +#set(VCPKG_CXX_FLAGS) # Injects additional C++ build flags +#set(VCPKG_C_FLAGS_DEBUG) # Injects additional C build flags in debug mode +#set(VCPKG_CXX_FLAGS_DEBUG) # Injects additional C++ build flags in debug mode +#set(VCPKG_C_FLAGS_RELEASE) # Injects additional C build flags in release mode +#set(VCPKG_CXX_FLAGS_RELEASE) # Injects additional C++ build flags in release mode +#set(VCPKG_LINKER_FLAGS) # Injects additional Linker Flags \ No newline at end of file diff --git a/triplets/x64-windows-intel19.cmake b/triplets/x64-windows-intel19.cmake new file mode 100644 index 00000000000000..54732bd10ff5e2 --- /dev/null +++ b/triplets/x64-windows-intel19.cmake @@ -0,0 +1,13 @@ +set(VCPKG_TARGET_ARCHITECTURE x64) +set(VCPKG_CRT_LINKAGE dynamic) +set(VCPKG_LIBRARY_LINKAGE dynamic) +set(VCPKG_PLATFORM_TOOLSET "Intel C++ Compiler 19.0") +set(VCPKG_SKIP_POST_BUILD_LIB_ARCH_CHECK "ON") # Skips post build architecture checks of libs and dlls. Only works with VS link.exe +set(VCPKG_USE_NINJA OFF) +#set(VCPKG_C_FLAGS) # Injects additional C build flags +#set(VCPKG_CXX_FLAGS) # Injects additional C++ build flags +#set(VCPKG_C_FLAGS_DEBUG) # Injects additional C build flags in debug mode +#set(VCPKG_CXX_FLAGS_DEBUG) # Injects additional C++ build flags in debug mode +#set(VCPKG_C_FLAGS_RELEASE) # Injects additional C build flags in release mode +#set(VCPKG_CXX_FLAGS_RELEASE) # Injects additional C++ build flags in release mode +#set(VCPKG_LINKER_FLAGS) # Injects additional Linker Flags diff --git a/triplets/x64-windows-llvm.cmake b/triplets/x64-windows-llvm.cmake new file mode 100644 index 00000000000000..57917890cd2ac3 --- /dev/null +++ b/triplets/x64-windows-llvm.cmake @@ -0,0 +1,12 @@ +set(VCPKG_TARGET_ARCHITECTURE x64) +set(VCPKG_CRT_LINKAGE dynamic) +set(VCPKG_LIBRARY_LINKAGE dynamic) +set(VCPKG_PLATFORM_TOOLSET llvm) +set(VCPKG_SKIP_POST_BUILD_LIB_ARCH_CHECK "ON") # Skips post build architecture checks of libs and dlls. Only works with VS link.exe +#set(VCPKG_C_FLAGS) # Injects additional C build flags +#set(VCPKG_CXX_FLAGS) # Injects additional C++ build flags +#set(VCPKG_C_FLAGS_DEBUG) # Injects additional C build flags in debug mode +#set(VCPKG_CXX_FLAGS_DEBUG) # Injects additional C++ build flags in debug mode +#set(VCPKG_C_FLAGS_RELEASE) # Injects additional C build flags in release mode +#set(VCPKG_CXX_FLAGS_RELEASE) # Injects additional C++ build flags in release mode +#set(VCPKG_LINKER_FLAGS) # Injects additional Linker Flags \ No newline at end of file