|
|
Default generator
-----------------
As of CMake 3.26, the default generator (unless set explicitly) is:
* the newest Visual Studio or "NMake Makefiles" on Windows,
* "Unix Makefiles" otherwise.
This is [regardless] of whether any executables like gcc, cl or make are
available.
[regardless]: https://github.com/Kitware/CMake/blob/v3.26.4/Source/cmake.cxx#L2484
Makefile generators
-------------------
CMake has a number of "... Makefiles" generators. "Unix Makefiles" [uses
gmake/make/smake], whichever is found first, and [prefers cc]/[c++] symlinks
for compiler detection. "MinGW Makefiles" [looks for mingw32-make.exe] in a
number of well-known locations instead. In addition, "Unix Makefiles" [uses
/bin/sh] as the SHELL value in the Makefile, while the MinGW version [uses
cmd.exe]. I don't think it matters on Windows though, since the non-existent
/bin/sh is [ignored anyway]. "NMake Makefiles" is similar, except it defaults
to [using cl].
[uses gmake/make/smake]: https://github.com/Kitware/CMake/blob/v3.26.4/Modules/CMakeUnixFindMake.cmake
[prefers cc]: https://github.com/Kitware/CMake/blob/v3.26.4/Modules/CMakeDetermineCCompiler.cmake
[c++]: https://github.com/Kitware/CMake/blob/v3.26.4/Modules/CMakeDetermineCXXCompiler.cmake
[looks for mingw32-make.exe]: https://github.com/Kitware/CMake/blob/v3.26.4/Modules/CMakeMinGWFindMake.cmake
[uses /bin/sh]: https://github.com/Kitware/CMake/blob/v3.26.4/Source/cmLocalUnixMakefileGenerator3.cxx#L651
[uses cmd.exe]: https://github.com/Kitware/CMake/blob/v3.26.4/Source/cmLocalUnixMakefileGenerator3.cxx#L644
[ignored anyway]: https://www.gnu.org/software/make/manual/html_node/Choosing-the-Shell.html
[using cl]: https://github.com/Kitware/CMake/blob/v3.26.4/Source/cmGlobalNMakeMakefileGenerator.cxx#L41
It's important to _not_ use the -A parameter with any of the Makefile
generators - it's an error. This goes for "NMake Makefiles" also. "NMake
Makefiles" [doesn't attempt] to search for installed Visual Studio compilers,
you need to use it from one of the Visual Studio-provided shells.
[doesn't attempt]: https://github.com/Kitware/CMake/blob/v3.26.4/Source/cmGlobalNMakeMakefileGenerator.cxx#L93
Visual Studio generators
------------------------
These are special. They ignore the CMAKE_\<LANG\>_COMPILER parameters and [use
cl by default]. They support specifying the toolset to use via the -T
parameter (the "Platform Toolset" value in the project's properties) [since
3.8]. The toolset list varies between Visual Studio versions, and I'm too lazy
to learn exactly which version supports which toolsets.
[use cl by default]: https://gitlab.kitware.com/cmake/cmake/-/issues/19174
[since 3.8]: https://cmake.org/cmake/help/v3.8/release/3.8.html
`cmake --build` uses msbuild with Visual Studio generators. You can pass the
path to a different cl.exe by doing something like
msbuild ... /p:CLToolExe=another-cl.exe /p:CLToolPath=C:\parent\dir
It's important that the generators for Visual Studio 2017 or older [use Win32]
as the default platform. Because of that, we need to pass the -A parameter.
[use Win32]: https://cmake.org/cmake/help/v3.18/generator/Visual%20Studio%2015%202017.html
mingw32-make vs make
--------------------
No idea what the actual differences are. The [explanation] in the FAQ about
how GNU make "is lacking in some functionality and has modified functionality
due to the lack of POSIX on Win32" isn't terribly helpful.
[explanation]: http://mingw.org/wiki/FAQ
It's important that you can install either on Windows (`choco install make` for
GNU make and `choco install mingw` to install a MinGW-w64 distribution with
mingw32-make.exe included). Personally, I don't see any difference between
using either make.exe or mingw32-make.exe w/ CMake on Windows. But, since
MinGW-w64 distributions do include mingw32-make.exe and not make.exe, we'll try
to detect that.
Cross-compilation
-----------------
If you want to e.g. build x86 binaries on x64 and vice versa, the easiest way
seems to be to make a CMake "toolset file", which initializes the proper
compiler flags (like -m64/-m32, etc.). Such file could look like this:
set(CMAKE_C_COMPILER gcc)
set(CMAKE_C_FLAGS -m32)
set(CMAKE_CXX_COMPILER g++)
set(CMAKE_CXX_FLAGS -m32)
You can then pass the path to it using the CMAKE_TOOLCHAIN_FILE parameter.
If you use the Visual Studio generators, just use the -A parameter: `-A Win32`.
As a side note, if you want to cross-compile between x86 and x64 using GCC on
Ubuntu, you need to install the gcc-multilib package.
Windows & Clang
---------------
Using Clang on Windows is no easy task, of course. Prior to 3.15, there was
[no support] for building things using the clang++.exe executable, only
clang-cl.exe was supported. If you specified `-DCMAKE_CXX_COMPILER=clang++`,
CMake [would still] pass MSVC-style command line options to the compiler (like
`/MD`, `/nologo`, etc.), which clang++ doesn't like.
[no support]: https://cmake.org/cmake/help/v3.15/release/3.15.html#compilers
[would still]: https://github.com/Kitware/CMake/blob/v3.14.7/Modules/Platform/Windows-Clang.cmake
So, in summary, you can only use clang++ since 3.15. clang-cl doesn't work
with Visual Studio generators unless you specify the proper toolset using the
-T parameter. You can set the ClToolExe property using msbuild, but while that
might work in practice, clang-cl.exe needs to map some unsupported options for
everything to work properly. For an example of how this is done, see the
[LLVM.Cpp.Common.* files].
[LLVM.Cpp.Common.* files]: https://github.com/llvm/llvm-project/tree/e408935bb5339e20035d84307c666fbdd15e99e0/llvm/tools/msbuild
I recommend using Clang (either clang-cl or clang++ since 3.15) using the
"NMake Makefiles" generator.
|
