[windows|toolchain] Try using /Zi

.gitignore

@@ -297,6 +297,7 @@ __pycache__/
 !/triplets/x64-uwp.cmake
 !/triplets/x64-windows-static.cmake
 !/triplets/x64-windows.cmake
+!/triplets/move_pdb_files.cmake
 !/triplets/x86-windows.cmake
 
 !/triplets/community

ports/boost-modular-build-helper/CMakeLists.txt

@@ -9,7 +9,7 @@ set(USER_CONFIG_TOOLSET_OPTIONS "")
 set(USER_CONFIG_EXTRA_LINES "")
 set(USER_CONFIG_REQUIREMENTS "")
 
-set(B2_OPTIONS)
+set(B2_OPTIONS "")
 
 include("${VCPKG_CMAKE_VARS_FILE}")
 
@@ -106,7 +106,7 @@ if(VCPKG_DETECTED_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
     list(JOIN libpath_args " " libpath_arg)
     string(APPEND COMPILEFLAGS " ${libpath_arg} /D_WIN32_WINNT=0x0A00")
     list(APPEND B2_OPTIONS windows-api=store)
-    list(APPEND B2_OPTIONS linkflags=WindowsApp.lib)
+    list(APPEND B2_OPTIONS linkflags=WindowsApp.lib) # TODO: Fix this; Probably should use a VCPKG_DETECTED_ variable and also be applied in the !store case
 endif()
 
 set(USER_CONFIG_TOOLSET_INVOCATION_COMMAND "\"${VCPKG_DETECTED_CMAKE_CXX_COMPILER}\"")
@@ -117,10 +117,23 @@ string(APPEND CFLAGS "${COMPILEFLAGS}")
 foreach(var CXXFLAGS CFLAGS LDFLAGS ARFLAGS)
     string(REPLACE [[\]] [[\\]] ${var} "${${var}}")
     string(REPLACE [["]] [[\"]] ${var} "${${var}}")
+    if(WIN32)
+        # env variables need extra %<var>% to be not expanded early
+        string(REGEX REPLACE [[(%[^%]+%)]] [[%\1%]] ${var} "${${var}}")
+        # remove PDB flag, until the pdb install rule of boost-build can be deactivated. 
+        string(REGEX REPLACE "-PDB:[^ ]+" "" ${var} "${${var}}") 
+    endif()
     string(REGEX REPLACE "[ \t\r\n]+" " " ${var} "${${var}}")
     string(STRIP "${${var}}" ${var})
 endforeach()
 
+if(CFLAGS MATCHES "-Zi" OR CXXFLAGS MATCHES "-Zi")
+    list(APPEND B2_OPTIONS
+            debug-store=database
+            pch=off
+        )
+endif()
+
 if(USER_CONFIG_TOOLSET STREQUAL "msvc")
     file(TO_CMAKE_PATH "${CMAKE_CURRENT_LIST_DIR}/nothing.bat" NOTHING_BAT)
     string(APPEND USER_CONFIG_TOOLSET_OPTIONS

ports/boost-modular-build-helper/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "name": "boost-modular-build-helper",
   "version": "1.79.0",
-  "port-version": 5,
+  "port-version": 6,
   "description": "Internal vcpkg port used to build Boost libraries",
   "license": "MIT",
   "dependencies": [

ports/openssl/windows/portfile.cmake

@@ -18,12 +18,16 @@ set(ENV{CXX} "${VCPKG_DETECTED_CMAKE_CXX_COMPILER}")
 set(ENV{AR} "${VCPKG_DETECTED_CMAKE_AR}")
 set(ENV{LD} "${VCPKG_DETECTED_CMAKE_LINKER}")
 
-# OpenSSL's buildsystem hardcodes certain PDB manipulations, so we cannot use Z7
+# OpenSSL's buildsystem hardcodes certain PDB manipulations, so we cannot use Z7 (These are mainly install rules for PDBs....)
 string(REGEX REPLACE "(^| )-Z7($| )" " " VCPKG_COMBINED_C_FLAGS_RELEASE "${VCPKG_COMBINED_C_FLAGS_RELEASE}")
 string(REGEX REPLACE "(^| )-Z7($| )" " " VCPKG_COMBINED_C_FLAGS_DEBUG "${VCPKG_COMBINED_C_FLAGS_DEBUG}")
 string(REGEX REPLACE "(^| )-Z7($| )" " " VCPKG_COMBINED_CXX_FLAGS_RELEASE "${VCPKG_COMBINED_CXX_FLAGS_RELEASE}")
 string(REGEX REPLACE "(^| )-Z7($| )" " " VCPKG_COMBINED_CXX_FLAGS_DEBUG "${VCPKG_COMBINED_CXX_FLAGS_DEBUG}")
 
+string(REGEX REPLACE "(^| )(-|/)PDB(STRIPPED)?:[^ ]+($| )" " " VCPKG_COMBINED_SHARED_LINKER_FLAGS_RELEASE "${VCPKG_COMBINED_SHARED_LINKER_FLAGS_RELEASE}")
+string(REGEX REPLACE "(^| )(-|/)PDB(STRIPPED)?:[^ ]+($| )" " " VCPKG_COMBINED_SHARED_LINKER_FLAGS_DEBUG "${VCPKG_COMBINED_SHARED_LINKER_FLAGS_DEBUG}")
+
+
 set(CONFIGURE_OPTIONS
     enable-static-engine
     enable-capieng

scripts/azure-pipelines/azure-pipelines.yml

@@ -13,61 +13,9 @@ parameters:
     default: 'use default'
 
 jobs:
-- template: windows/azure-pipelines.yml
-  parameters:
-    triplet: x86-windows
-    jobName: x86_windows
-    poolName: $(windows-pool)
-    vcpkgToolSha: ${{ parameters.vcpkgToolSha }}
-
 - template: windows/azure-pipelines.yml
   parameters:
     triplet: x64-windows
     jobName: x64_windows
     poolName: $(windows-pool)
     vcpkgToolSha: ${{ parameters.vcpkgToolSha }}
-
-- template: windows/azure-pipelines.yml
-  parameters:
-    triplet: x64-windows-static
-    jobName: x64_windows_static
-    poolName: $(windows-pool)
-    vcpkgToolSha: ${{ parameters.vcpkgToolSha }}
-
-- template: windows/azure-pipelines.yml
-  parameters:
-    triplet: x64-windows-static-md
-    jobName: x64_windows_static_md
-    poolName: $(windows-pool)
-    vcpkgToolSha: ${{ parameters.vcpkgToolSha }}
-
-- template: windows/azure-pipelines.yml
-  parameters:
-    triplet: x64-uwp
-    jobName: x64_uwp
-    poolName: $(windows-pool)
-    vcpkgToolSha: ${{ parameters.vcpkgToolSha }}
-
-- template: windows/azure-pipelines.yml
-  parameters:
-    triplet: arm64-windows
-    jobName: arm64_windows
-    poolName: $(windows-pool)
-    vcpkgToolSha: ${{ parameters.vcpkgToolSha }}
-
-- template: windows/azure-pipelines.yml
-  parameters:
-    triplet: arm-uwp
-    jobName: arm_uwp
-    poolName: $(windows-pool)
-    vcpkgToolSha: ${{ parameters.vcpkgToolSha }}
-
-- template: osx/azure-pipelines.yml
-  parameters:
-    poolName: $(osx-pool)
-    vcpkgToolSha: ${{ parameters.vcpkgToolSha }}
-
-- template: linux/azure-pipelines.yml
-  parameters:
-    poolName: $(linux-pool)
-    vcpkgToolSha: ${{ parameters.vcpkgToolSha }}

scripts/cmake/vcpkg_build_nmake.cmake

@@ -35,10 +35,9 @@ function(vcpkg_build_nmake)
     find_program(NMAKE nmake REQUIRED)
     get_filename_component(NMAKE_EXE_PATH ${NMAKE} DIRECTORY)
     # Load toolchains
-    if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
-        set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/windows.cmake")
-    endif()
-    include("${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}")
+    z_vcpkg_get_cmake_vars(cmake_vars_file)
+    debug_message("Including cmake vars from: ${cmake_vars_file}")
+    include("${cmake_vars_file}")
     # Set needed env
     set(ENV{PATH} "$ENV{PATH};${NMAKE_EXE_PATH}")
     set(ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include;$ENV{INCLUDE}")
@@ -57,7 +56,7 @@ function(vcpkg_build_nmake)
         set(project_subpath "")
     endif()
 
-    vcpkg_backup_env_variables(VARS CL)
+    vcpkg_backup_env_variables(VARS CL LINK)
     cmake_path(NATIVE_PATH CURRENT_PACKAGES_DIR NORMALIZE install_dir_native)
     foreach(build_type IN ITEMS debug release)
         if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL build_type)
@@ -70,7 +69,8 @@ function(vcpkg_build_nmake)
                     vcpkg_list(APPEND make_opts "INSTALLDIR=${install_dir_native}\\debug")
                 endif()
                 vcpkg_list(APPEND make_opts ${arg_OPTIONS} ${arg_OPTIONS_DEBUG})
-                set(ENV{CL} "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}")
+                set(ENV{CL} "$(VCPKG_DETECTED_CMAKE_CXX_FLAGS_DEBUG}")
+                set(ENV{LINK} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
 
                 set(prerun_variable_name arg_PRERUN_SHELL_DEBUG)
             else()
@@ -82,7 +82,8 @@ function(vcpkg_build_nmake)
                 endif()
                 vcpkg_list(APPEND make_opts ${arg_OPTIONS} ${arg_OPTIONS_RELEASE})
 
-                set(ENV{CL} "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}")
+                set(ENV{CL} "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_RELEASE}")
+                set(ENV{LINK} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_RELEASE}")
                 set(prerun_variable_name arg_PRERUN_SHELL_RELEASE)
             endif()
 

scripts/cmake/vcpkg_configure_meson.cmake

@@ -404,6 +404,16 @@ function(vcpkg_configure_meson)
     vcpkg_list(APPEND arg_OPTIONS_DEBUG -Ddebug=true --prefix "${CURRENT_PACKAGES_DIR}/debug" --includedir ../include)
     vcpkg_list(APPEND arg_OPTIONS_RELEASE -Ddebug=false --prefix "${CURRENT_PACKAGES_DIR}")
 
+    if(DEFINED VCPKG_MESON_CONFIGURE_OPTIONS)
+        vcpkg_list(APPEND arg_OPTIONS ${VCPKG_MESON_CONFIGURE_OPTIONS})
+    endif()
+    if(DEFINED VCPKG_MESON_CONFIGURE_OPTIONS_DEBUG)
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG ${VCPKG_MESON_CONFIGURE_OPTIONS_DEBUG})
+    endif()
+    if(DEFINED VCPKG_MESON_CONFIGURE_OPTIONS_RELEASE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE ${VCPKG_MESON_CONFIGURE_OPTIONS_RELEASE})
+    endif()
+
     # select meson cmd-line options
     if(VCPKG_TARGET_IS_WINDOWS)
         vcpkg_list(APPEND arg_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/share']")

scripts/cmake/vcpkg_copy_pdbs.cmake

@@ -1,49 +1,6 @@
 function(vcpkg_copy_pdbs)
     cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "" "BUILD_PATHS")
 
-    if(DEFINED arg_UNPARSED_ARGUMENTS)
-        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
-    endif()
-
-    if(NOT DEFINED arg_BUILD_PATHS)
-        set(arg_BUILD_PATHS
-            "${CURRENT_PACKAGES_DIR}/bin/*.dll"
-            "${CURRENT_PACKAGES_DIR}/debug/bin/*.dll"
-        )
-    endif()
-
-    set(dlls_without_matching_pdbs "")
-
-    if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic" AND VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
-        file(GLOB_RECURSE dlls ${arg_BUILD_PATHS})
-
-        set(vslang_backup "$ENV{VSLANG}")
-        set(ENV{VSLANG} 1033)
-
-        foreach(dll IN LISTS dlls)
-            execute_process(COMMAND dumpbin /PDBPATH "${dll}"
-                            COMMAND findstr PDB
-                OUTPUT_VARIABLE pdb_line
-                ERROR_QUIET
-                RESULT_VARIABLE error_code
-            )
-
-            if(error_code EQUAL "0" AND pdb_line MATCHES "PDB file found at.*'(.*)'")
-                set(pdb_path "${CMAKE_MATCH_1}")
-                cmake_path(GET dll PARENT_PATH dll_dir)
-                file(COPY "${pdb_path}" DESTINATION "${dll_dir}")
-            else()
-                list(APPEND dlls_without_matching_pdbs "${dll}")
-            endif()
-        endforeach()
-
-        set(ENV{VSLANG} "${vslang_backup}")
-
-        if(NOT dlls_without_matching_pdbs STREQUAL "")
-            list(JOIN dlls_without_matching_pdbs "\n    " message)
-            message(WARNING "Could not find a matching pdb file for:
-    ${message}\n")
-        endif()
-    endif()
+    message(STATUS "${CMAKE_CURRENT_FUNCTION} is deprecated. Please remove the call from the portfile!")
 
 endfunction()

scripts/ports.cmake

@@ -144,7 +144,18 @@ if(CMD STREQUAL "BUILD")
     set(Z_VCPKG_ERROR_LOG_COLLECTION_FILE "${CURRENT_BUILDTREES_DIR}/error-logs-${TARGET_TRIPLET}.txt")
     file(REMOVE "${Z_VCPKG_ERROR_LOG_COLLECTION_FILE}")
 
+    foreach(z_pre_portfile_include IN LISTS VCPKG_PRE_PORTFILE_INCLUDES)
+        include("${z_pre_portfile_include}")
+    endforeach()
+    unset(z_pre_portfile_include)
+
     include("${CURRENT_PORT_DIR}/portfile.cmake")
+
+    foreach(z_post_portfile_include IN LISTS VCPKG_POST_PORTFILE_INCLUDES)
+        include("${z_post_portfile_include}")
+    endforeach()
+    unset(z_post_portfile_include)
+
     if(DEFINED PORT)
         if(VCPKG_FIXUP_ELF_RPATH)
             include("${SCRIPTS}/cmake/z_vcpkg_fixup_rpath.cmake")

scripts/toolchains/windows.cmake

@@ -51,22 +51,86 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
         set(CHARSET_FLAG)
     endif()
 
-    set(CMAKE_CXX_FLAGS " /nologo /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} /GR /EHsc /MP ${VCPKG_CXX_FLAGS}" CACHE STRING "")
-    set(CMAKE_C_FLAGS " /nologo /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} /MP ${VCPKG_C_FLAGS}" CACHE STRING "")
+    set(CMAKE_CXX_FLAGS " /nologo /Brepro /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} /GR /EHsc /MP ${VCPKG_CXX_FLAGS}" CACHE STRING "")
+    set(CMAKE_C_FLAGS " /nologo /Brepro /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} /MP ${VCPKG_C_FLAGS}" CACHE STRING "")
     set(CMAKE_RC_FLAGS "-c65001 /DWIN32" CACHE STRING "")
 
     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 "")
-    set(CMAKE_C_FLAGS_RELEASE "${VCPKG_CRT_LINK_FLAG_PREFIX} /O2 /Oi /Gy /DNDEBUG /Z7 ${VCPKG_C_FLAGS_RELEASE}" CACHE STRING "")
+    if(BUILD_SHARED_LIBS)
+        set(VCPKG_DBG_FLAGS "/Zi /FS")
+    else()
+        set(VCPKG_DBG_FLAGS "/Z7")
+    endif()
+
+    set(CMAKE_CXX_FLAGS_DEBUG "/D_DEBUG ${VCPKG_CRT_LINK_FLAG_PREFIX}d ${VCPKG_DBG_FLAGS} /Ob0 /Od /RTC1 ${VCPKG_CXX_FLAGS_DEBUG}" CACHE STRING "")
+    set(CMAKE_C_FLAGS_DEBUG "/D_DEBUG ${VCPKG_CRT_LINK_FLAG_PREFIX}d ${VCPKG_DBG_FLAGS} /Ob0 /Od /RTC1 ${VCPKG_C_FLAGS_DEBUG}" CACHE STRING "")
+    set(CMAKE_CXX_FLAGS_RELEASE "${VCPKG_CRT_LINK_FLAG_PREFIX} /O2 /Oi /Gy /DNDEBUG ${VCPKG_DBG_FLAGS} ${VCPKG_CXX_FLAGS_RELEASE}" CACHE STRING "")
+    set(CMAKE_C_FLAGS_RELEASE "${VCPKG_CRT_LINK_FLAG_PREFIX} /O2 /Oi /Gy /DNDEBUG ${VCPKG_DBG_FLAGS} ${VCPKG_C_FLAGS_RELEASE}" CACHE STRING "")
+
+    get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )
+    if(NOT _CMAKE_IN_TRY_COMPILE)
+        string(APPEND CMAKE_SHARED_LINKER_FLAGS " /PDBALTPATH:%_PDB%")
+        string(APPEND CMAKE_EXE_LINKER_FLAGS " /PDBALTPATH:%_PDB%")
 
+        function(z_vcpkg_install_pdbs)
+            # from https://stackoverflow.com/questions/37434946/how-do-i-iterate-over-all-cmake-targets-programmatically/62311397#62311397
+            # changed to not add an empty element add the end of the list and adjusted to vcpkg policies. 
+            function(get_all_targets var)
+                set(targets "")
+                get_all_targets_recursive(targets "${CMAKE_CURRENT_SOURCE_DIR}")
+                set("${var}" "${targets}" PARENT_SCOPE)
+            endfunction()
+
+            macro(get_all_targets_recursive targets dir)
+                get_property(subdirectories DIRECTORY "${dir}" PROPERTY SUBDIRECTORIES)
+                foreach(subdir IN LISTS subdirectories)
+                    get_all_targets_recursive("${targets}" "${subdir}")
+                endforeach()
+                get_property(current_targets DIRECTORY "${dir}" PROPERTY BUILDSYSTEM_TARGETS)
+                if(current_targets)
+                    list(APPEND "${targets}" "${current_targets}")
+                endif()
+            endmacro()
+
+            get_all_targets(build_targets)
+            #get_directory_property(build_targets DIRECTORY "${CMAKE_SOURCE_DIR}" BUILDSYSTEM_TARGETS)
+            message(STATUS "BUILDSYSTEM_TARGETS: ${build_targets}")
+            foreach(target IN LISTS build_targets)
+                get_target_property(type "${target}" TYPE)
+                if(type MATCHES "(SHARED_LIBRARY|EXECUTABLE|MODULE_LIBRARY)")
+                    #message(STATUS "Toolchain shared pdb install: ${target}")
+                    #install(FILES "$<TARGET_PDB_FILE:${target}>" TYPE BIN OPTIONAL)
+                elseif(type MATCHES "(STATIC_LIBRARY|OBJECT_LIBRARY)")
+                    get_target_property(sources "${target}" SOURCES)
+                    if("${sources}" MATCHES "(\\\.asm|\\\.s)")
+                    else()
+                        target_compile_options("${target}" PRIVATE "/Z7")
+                    endif()
+                   # message(STATUS "Toolchain static pdb install: ${target}")
+                   # set(pdb_filename "$<PATH:REPLACE_EXTENSION,LAST_ONLY,$<TARGET_FILE_NAME:${target}>,*.pdb>")
+                    #get_target_property(pdb_name "${target}" PDB_NAME)
+                   # install(FILES "$<TARGET_FILE_DIR:${target}>/${pdb_filename}" DESTINATION "pdb" OPTIONAL)
+                #elseif(type MATCHES "(OBJECT_LIBRARY)")
+                    #set(z_vcpkg_has_obj_libs ON)
+                    #message(STATUS "Toolchain object libraries pdb install: ${target}")
+                    #set_target_properties("${target}" PROPERTIES 
+                    #                        COMPILE_PDB_NAME "${VCPKG_PORT_NAME}_${target}_obj.pdb"
+                    #                        COMPILE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+                    #                        )
+                    #install(FILES "${CMAKE_BINARY_DIR}/${VCPKG_PORT_NAME}_${target}_obj.pdb" DESTINATION "pdb" OPTIONAL)
+                else()
+                    message(STATUS "Toolchain no pdb installed: ${target}|${type}")
+                endif()
+            endforeach()
+        endfunction()
+        cmake_language(DEFER CALL z_vcpkg_install_pdbs)
+    endif()
     string(APPEND CMAKE_STATIC_LINKER_FLAGS_RELEASE_INIT " /nologo ")
     set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "/nologo /DEBUG /INCREMENTAL:NO /OPT:REF /OPT:ICF ${VCPKG_LINKER_FLAGS} ${VCPKG_LINKER_FLAGS_RELEASE}" CACHE STRING "")
     set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/nologo /DEBUG /INCREMENTAL:NO /OPT:REF /OPT:ICF ${VCPKG_LINKER_FLAGS} ${VCPKG_LINKER_FLAGS_RELEASE}" CACHE STRING "")
 
-    string(APPEND CMAKE_STATIC_LINKER_FLAGS_DEBUG_INIT " /nologo ")
+    string(APPEND CMAKE_STATIC_LINKER_FLAGS_DEBUG_INIT " /nologo")
     string(APPEND CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT " /nologo ${VCPKG_LINKER_FLAGS} ${VCPKG_LINKER_FLAGS_DEBUG} ")
     string(APPEND CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT " /nologo ${VCPKG_LINKER_FLAGS} ${VCPKG_LINKER_FLAGS_DEBUG} ")
 endif()