VS: Custom MSVC toolchain investigation
We have a custom MSVC toolchain. However, we were getting an issue related to RC files. That only manifested on Ninja dirty builds.
# Here is how the bug will manifest itself:
# "ninja: error: FindFirstFileExA(note: including file: d:/foobar/ms_sdk/n20246/10/include/10.0.20246.0/shared): The filename, directory name, or volume label syntax is incorrect."I've posted about the issue here on the discourse:
cmake_minimum_required(VERSION 3.15)
set(DEVELOPMENT_KIT_ROOT "C:/foobar")
set(FOOBAR_MSVC_VERSION "14.24.28314")
set(FOOBAR_WINDOWS_VERSION "19041")
set(FOOBAR_ARCH "x64")
set(FOOBAR_TOOLSET "x64")
list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
DEVELOPMENT_KIT_ROOT
FOOBAR_MSVC_VERSION
FOOBAR_WINDOWS_VERSION
FOOBAR_ARCH
FOOBAR_TOOLSET
)
# Define the target system and version:
# Only set CMAKE_SYSTEM_NAME when it's different than the host system name.
# Otherwise CMAKE_CROSSCOMPILING will be set to true unneccessarily.
# Which can cause longer builds for developers in some situations.
# https://discourse.cmake.org/t/do-i-need-to-set-the-cmake-system-name-when-making-a-toolchain-file/2861
if (NOT (CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") )
set(CMAKE_SYSTEM_NAME "Windows" CACHE INTERNAL "")
endif()
set(CMAKE_SYSTEM_VERSION "10.0.${FOOBAR_WINDOWS_VERSION}.0" CACHE INTERNAL "")
if(FOOBAR_ARCH STREQUAL "x64")
set(CMAKE_SYSTEM_PROCESSOR AMD64)
elseif(FOOBAR_ARCH STREQUAL "x86")
set(CMAKE_SYSTEM_PROCESSOR x86)
else()
message(FATAL_ERROR "The only supported target architectures are x86 and x64!")
endif()
# Error check toolset
if (FOOBAR_TOOLSET STREQUAL "x64")
elseif (FOOBAR_TOOLSET STREQUAL "x86")
else()
message(FATAL_ERROR "The only supported toolsets are x64 and x86!")
endif()
# Setup FOOBAR DK directories
set(FOOBAR_MSVC_ROOT ${DEVELOPMENT_KIT_ROOT}/vc/${FOOBAR_MSVC_VERSION})
set(FOOBAR_MSVC_BIN_TOOLSET ${FOOBAR_MSVC_ROOT}/bin/Host${FOOBAR_TOOLSET}/${FOOBAR_ARCH})
set(FOOBAR_SDK_ROOT ${DEVELOPMENT_KIT_ROOT}/ms_sdk/n${FOOBAR_WINDOWS_VERSION}/10)
set(FOOBAR_SDK_BIN_TOOLSET ${FOOBAR_SDK_ROOT}/bin/10.0.${FOOBAR_WINDOWS_VERSION}.0/${FOOBAR_TOOLSET})
set(FOOBAR_SDK_LIB ${FOOBAR_SDK_ROOT}/lib/10.0.${FOOBAR_WINDOWS_VERSION}.0)
set(FOOBAR_SDK_INC ${FOOBAR_SDK_ROOT}/include/10.0.${FOOBAR_WINDOWS_VERSION}.0)
set(FOOBAR_WDK_ROOT ${DEVELOPMENT_KIT_ROOT}/ms_wdk/n${FOOBAR_WINDOWS_VERSION})
set(FOOBAR_WDK_LIB ${FOOBAR_WDK_ROOT}/lib/10.0.${FOOBAR_WINDOWS_VERSION}.0)
set(FOOBAR_WDK_INC ${FOOBAR_WDK_ROOT}/include/10.0.${FOOBAR_WINDOWS_VERSION}.0)
# Error checking
# I'm checking if the DEVELOPMENT_KIT_ROOT is defined as an absolute path
# because IS_DIRECTORY is only well defined if the path is absolute
# https://cmake.org/cmake/help/latest/command/if.html?highlight=is_directory#if
if ( IS_ABSOLUTE ${DEVELOPMENT_KIT_ROOT} )
set(FOOBAR_DK_DIRECTORIES_TO_ERROR_CHECK
${FOOBAR_MSVC_ROOT} ${FOOBAR_SDK_ROOT} ${FOOBAR_SDK_LIB}
${FOOBAR_SDK_INC} ${FOOBAR_WDK_ROOT} ${FOOBAR_WDK_LIB} ${FOOBAR_WDK_INC}
${FOOBAR_SDK_BIN_TOOLSET} ${FOOBAR_MSVC_BIN_TOOLSET}
)
# Make sure each directory exists
foreach(dir IN LISTS FOOBAR_DK_DIRECTORIES_TO_ERROR_CHECK)
if (NOT IS_DIRECTORY ${dir})
message(FATAL_ERROR "Include directory is not valid: ${dir}\n"
"Make sure to check your perforce mappings!\n")
endif()
endforeach()
endif()
# Cross Compiler
# In order to pass Visual Studio compiler identification we have to establish these variables
foreach(LANG C CXX)
set(CMAKE_${LANG}_COMPILER "${FOOBAR_MSVC_BIN_TOOLSET}/cl.exe" CACHE FILEPATH "")
set(CMAKE_${LANG}_COMPILER_ID "MSVC" CACHE STRING "")
# Extract the compiler version
execute_process(
# Execute cl.exe on the command line to extract the compiler version
COMMAND ${CMAKE_${LANG}_COMPILER}
# cl.exe outputs some of its output to standard error
# EX:
# Microsoft (R) C/C++ Optimizing Compiler Version 19.16.27032.1 for x64
# Copyright (C) Microsoft Corporation. All rights reserved.
ERROR_VARIABLE cl_exe_ouput
# cl.exe outputs some of its output to standard output
# So just ignore this it isn't important
# EX:
# usage: cl [ option... ] filename... [ /link linkoption... ]
OUTPUT_QUIET
)
# Regex for the compiler version
string(REGEX MATCH ".* Version ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+\).*" out ${cl_exe_ouput})
# If the regex fails then fatal error
if (NOT (${CMAKE_MATCH_COUNT} EQUAL "1"))
message(FATAL_ERROR "MSVC version regex failed")
endif()
# You have to set the compiler version
set(CMAKE_${LANG}_COMPILER_VERSION "${CMAKE_MATCH_1}" CACHE STRING "")
endforeach()
# This variable is neccessary to set for MSVC compilers greater than version 19.0 and greater
#
# Here is my attempt at an explanation (since there is no documentation online):
# VS2015 update 3 and above support language standard level flags, with the default and minimum level
# being C++14. This allows cmake to set variables/compiler-flags much more appropriately.
#
# To see the exact details see this module in your cmake implemenation.
# ...\share\cmake-3.16\Modules\Compiler\MSVC-CXX.cmake
#
# If that still doesn't make sense remove this check/set below
#
# To be honest although I know this logic below fixes the problem and is correct.
# It is still pretty hacky, and is a good argument to not use the DK in the future.
if (${CMAKE_CXX_COMPILER_VERSION} VERSION_GREATER "19.0")
set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "14" CACHE INTERNAL "")
endif()
# Cross Tools
set(CMAKE_RC_COMPILER "${FOOBAR_SDK_BIN_TOOLSET}/rc.exe" CACHE FILEPATH "")
set(CMAKE_MT "${FOOBAR_SDK_BIN_TOOLSET}/mt.exe" CACHE FILEPATH "")
# Generator Tools
if (CMAKE_GENERATOR MATCHES "Visual Studio")
# MSVC_IDE doesn't seem to work in toolchains?
# https://discourse.cmake.org/t/cannot-use-msvc-ide-in-toolchain/2734
set(FOOBAR_MSVC_IDE ON)
endif()
if (FOOBAR_MSVC_IDE)
# Build with Multiple Processes, this is a nice quality of life for VS users
# This is the preferred way of speeding up vs builds.
# Also /MP option enables /FS by default.
set(genFlag "/MP")
else()
# If multiple CL.EXE write to the same .PDB file, please use /FS
# This ensures multi-threads builds like Ninja work properly
set(genFlag "/FS")
endif()
# Set the flags all projects will be forced to use.
# https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_FLAGS_INIT.html
foreach(LANG C CXX)
set(CMAKE_${LANG}_FLAGS_INIT "${genFlag}")
endforeach()
set(FOOBAR_DK_INCLUDE_DIRECTORIES
"${FOOBAR_MSVC_ROOT}/include"
"${FOOBAR_SDK_INC}/ucrt"
"${FOOBAR_SDK_INC}/um"
"${FOOBAR_SDK_INC}/shared"
"${FOOBAR_WDK_INC}/km"
"${FOOBAR_WDK_INC}/um"
"${FOOBAR_WDK_INC}/shared"
)
set(FOOBAR_DK_LIBRARY_DIRECTORIES
"${FOOBAR_MSVC_ROOT}/lib/${FOOBAR_ARCH}"
"${FOOBAR_MSVC_ROOT}/atlmfc/lib/${FOOBAR_ARCH}"
"${FOOBAR_SDK_LIB}/ucrt/${FOOBAR_ARCH}"
"${FOOBAR_SDK_LIB}/um/${FOOBAR_ARCH}"
"${FOOBAR_WDK_LIB}/km/${FOOBAR_ARCH}"
"${FOOBAR_WDK_LIB}/um/${FOOBAR_ARCH}"
)
if (FOOBAR_MSVC_IDE)
string(REGEX MATCHALL "Visual Studio [0-9]+ ([0-9]+)" vsVersions ${CMAKE_GENERATOR})
set(vsYear ${CMAKE_MATCH_1})
if (${vsYear} VERSION_LESS "2010")
message(FATAL_ERROR "CMAKE_VS_SDK_*_DIRECTORIES require at least Visual Studio 2010")
endif()
# Set the appropriate binary directories
set(CMAKE_VS_SDK_EXECUTABLE_DIRECTORIES "")
list(APPEND CMAKE_VS_SDK_EXECUTABLE_DIRECTORIES ${FOOBAR_MSVC_BIN_TOOLSET})
list(APPEND CMAKE_VS_SDK_EXECUTABLE_DIRECTORIES ${FOOBAR_SDK_BIN_TOOLSET})
# Don't allow MSVC defaults
set(CMAKE_VS_SDK_SOURCE_DIRECTORIES "")
set(CMAKE_VS_SDK_LIBRARY_WINRT_DIRECTORIES "")
set(CMAKE_VS_SDK_REFERENCE_DIRECTORIES "")
set(CMAKE_VS_SDK_EXCLUDE_DIRECTORIES "")
# Set include/library directories
set(CMAKE_VS_SDK_LIBRARY_DIRECTORIES ${FOOBAR_DK_LIBRARY_DIRECTORIES})
set(CMAKE_VS_SDK_INCLUDE_DIRECTORIES ${FOOBAR_DK_INCLUDE_DIRECTORIES})
# Platform Selection
# https://cmake.org/cmake/help/latest/generator/Visual%20Studio%2016%202019.html#platform-selection
if ( ${vsYear} VERSION_GREATER_EQUAL "2019")
if(FOOBAR_ARCH STREQUAL "x64")
set(CMAKE_GENERATOR_PLATFORM "x64")
elseif(FOOBAR_ARCH STREQUAL "x86")
set(CMAKE_GENERATOR_PLATFORM "Win32")
else()
message(FATAL_ERROR "Unsupported platform ${FOOBAR_ARCH}")
endif()
endif()
# Toolset Selection
# https://cmake.org/cmake/help/latest/generator/Visual%20Studio%2016%202019.html#toolset-selection
# host=<arch> specifies the host tools architecture as x64 or x86
#
# This is basically a quality of life to avoid cluttering the command line
set(CMAKE_GENERATOR_TOOLSET "host=${FOOBAR_TOOLSET}")
# Work Around:
# This command is only meaningful in the sense that it prevents Cmake from
# choosing a default toolset. 'FOOBAR_DK_TOOLSET' has no instrinsic value
# If you get rid of this, Visual Studio will still build correctly
# However, configuration will give weird output.
# It will list the default MSVC compiler instead of the one we chose.
set(CMAKE_VS_PLATFORM_TOOLSET_VERSION "FOOBAR_DK_TOOLSET")
else()
# Link Directories
foreach(TARGET EXE SHARED STATIC MODULE)
# W/A: CMake doesn't define CMAKE_<LANG>_STANDARD_LINK_DIRECTORIES.
# https://gitlab.kitware.com/cmake/cmake/issues/18222
set(CMAKE_${TARGET}_LINKER_FLAGS_INIT "")
foreach(dir IN LISTS FOOBAR_DK_LIBRARY_DIRECTORIES)
list(APPEND CMAKE_${TARGET}_LINKER_FLAGS_INIT
"/LIBPATH:${dir}"
)
endforeach()
# Neccessary for linker syntax
string(REPLACE ";" " " CMAKE_${TARGET}_LINKER_FLAGS_INIT "${CMAKE_${TARGET}_LINKER_FLAGS_INIT}")
endforeach()
# Include Directories
# NOTE: C/CXX make sense. The tricky one is RC. This is neccessary to support resource files.
foreach(LANG C CXX RC)
set(CMAKE_${LANG}_STANDARD_INCLUDE_DIRECTORIES ${FOOBAR_DK_INCLUDE_DIRECTORIES})
endforeach()
# This is neccessary to ensure RC files compile with our custom toolchain
# Otherwise dirty builds will break. This code basically patches a cmake bug.
#
# Here is the bug will manifest itself:
# "ninja: error: FindFirstFileExA(note: including file: d:/p4/DEVELOPMENT_KIT_ROOT/win/ms_sdk/n20246/10/include/10.0.20246.0/shared): The filename, directory name, or volume label syntax is incorrect."
if (CMAKE_GENERATOR MATCHES "Ninja")
# Compiling RC files needs to set this. The Ninja generator calls cmcldeps.exe to extract dependencies for RC
# files. But it configurates DepType to "gcc" so cmake cannot filter show includes prefix and the dependencies
# are stored in .ninja_deps with the prefix and cause next run of ninja to fail. The DepType cannot be forced
# to "msvc" otherwise the dependency changes won't trigger recompilation of RC files.
# The workaround is to set CMAKE_CL_SHOWINCLUDES_PREFIX to the exact English string "Note: including file: ".
# function CMAKE_DETERMINE_MSVC_SHOWINCLUDES_PREFIX may be used if any locale issue occurs.
set(CMAKE_CL_SHOWINCLUDES_PREFIX "Note: including file: " CACHE INTERNAL "FOOBAR WORKAROUND")
# The Ninja generator relies on the following variables to determine MSVC style PDB names. But these variables
# stored in cmake are only initialized to "" when it is first time run on a project before CMake${lang}Compiler
# .cmake are generated. The next run doesn't initilazed them because CMake${lang}Compiler.cmake are there. So
# they are null and SetMsvcTargetPdbVariable() returns false so ".dbg" suffix is used for PDBs.
# The workaround is to set them to either x64 or x86 (actually "" is enough).
#
# https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_COMPILER_ARCHITECTURE_ID.html?highlight=architecture_id
set(CMAKE_CXX_ARCHITECTURE_ID ${FOOBAR_ARCH} CACHE INTERNAL "FOOBAR WORKAROUND")
set(CMAKE_C_ARCHITECTURE_ID ${FOOBAR_ARCH} CACHE INTERNAL "FOOBAR WORKAROUND")
endif()
endif()
# In conjunction with the variables below this makes all find_* commands
# only look in the DK
set(CMAKE_FIND_ROOT_PATH "${DEVELOPMENT_KIT_ROOT}")
# Make the find_file command only look in the DK
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
# Make the find_package command only look in the DK
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
# Make the find_library command only look in the DK
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
# Make the find_package command only look in the DK
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)I've done my best to sanitize my companies work and still providing a meaningful toolchain to the CMake team.
This toolchain is currently tested against Vs2019/Ninja. However it's only the Ninja path that is having problems.
So currently all 5 of these variables are necessary to compile our project with an MSVC toolchain.
set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "14" CACHE INTERNAL "")
set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "90" CACHE INTERNAL "")
# These are necessary for RC files
set(CMAKE_CL_SHOWINCLUDES_PREFIX "Note: including file: " CACHE INTERNAL "FOOBAR WORKAROUND")
set(CMAKE_CXX_ARCHITECTURE_ID "x64" CACHE INTERNAL "FOOBAR WORKAROUND")
set(CMAKE_C_ARCHITECTURE_ID "x64" CACHE INTERNAL "FOOBAR WORKAROUND")Should CMake toolchain authors be aware of these variables?
To upload designs, you'll need to enable LFS and have an admin enable hashed storage. More information