Make building with cmake verbose 20 March 2017 in Programming tagged cmake / make / verbose by Tux Ever wanted to get more information out of a build process controlled by CMake? Jun 13, 2019 How to build debug in CMake. If you want to build an executable / library with debug symbols in CMake, run. Cmake -DCMAKEBUILDTYPE=Debug. Conversely, if you want to build an executable / library in release mode, run. Cmake -DCMAKEBUILDTYPE=Release. First off Debug/Release are called configurations in cmake (nitpick). If you are using a single configuration generator (Ninja/Unix-Makefiles) Then you need a build folder for each configuration. Add this to CMakeLists.txt (the one in the project source directory; don't touch anything in the build directory): SET (CMAKECXXFLAGSDEBUG '-O0') SET (CMAKECFLAGSDEBUG '-O0').
at the request of a friend i’ve decided to dump some of my basic cmake knowledge. this isinformation i’ve picked up from supercollider, personal projects, and tutorial videos, but itdoesn’t seem to be immediately accessible unless you know what you’re looking for.
for each bit i’ll be using the most recent notation available, as far as i know it. i’m alsointentionally keeping this post short so it can serve as a cheat sheet - that’s why, for instance,i’m not listing every possible compiler id or command variation.
config and build steps
most usage of cmake will consist of two types of commands: configuration and building. i don’t thinkthese are exactly the official names, but what i mean is:
to figure out what compiler CMake is using, check
CMAKE_CXX_COMPILER_ID or use a
<CXX_COMPILER_ID:Foo> generator expression (see below)
|clang (Apple) - this is what comes with XCode||AppleClang|
with CMake you can have several build types. the most important thing to know is that if you use anIDE project generator (like Visual Studio or XCode) you specify this in the build step, but forMakefiles you specify it in the config step.
each build type passes different flags to your compiler. for some ungodly reason it’s hard to findout what those are, so i’m listing them here. the only other place i can find this is on a stackoverflow answer. these are the flags for AppleClang,others should be similar.
you can find out what they are for your compiler by creating a minimum CMake project, running
cmake., and reading CMakeCache.txt.
|build type||what it means||flags (AppleClang, GCC)||flags (MSVC 2017)|
|you didn’t pass a build type to a makefile generator|
|debug build, no optimization|
|release build, full optimization|
|“release with debug info”. keeps debugging symbols and does optimization|
|“minimum size release”. optimized for small binary size|
the ‘none’ flags will be passed for all build types.
don’t develop on Windows and don’t know what those flags mean? i looked them up for you:
FOOin the preprocessor
/EHsc- catch C++ exceptions, assume
extern 'C'functions never throw C++ exceptions
/GR- enable RTTI
/MD- make a multithreaded DLL
/MDd- make a debug multithreaded DLL
/O1- optimize for size
/O2- optimize for speed
/Ob0- no auto-inlining
/Ob1- only inline functions that are marked inline, and C++ member functions defined in a classdeclaration
/Ob2- let compiler inline freely
/Od- no optimization
/RTC1- run-time checking: report when a variable is used without being initialized, and stackframe run-time error checking. See theirsite for more details.
/W3- use warning level 3 (out of 4), “production quality”
/Zi- generate “complete debugging information”, like
Cmake Make Debug Button
passing flags to the compiler or linker
sometimes you want to force a flag to be passed to the compiler or linker. while some compilersalso let you specify these using environment variables, other times you just want to test outwhether adding a flag does what you want it to do. the following configuration-step flags are goodfor that:
CMAKE_CXX_FLAGS- used by the compiler
CMAKE_EXE_LINKER_FLAGS- used by the linker when linking executables
CMAKE_SHARED_LINKER_FLAGS- used by linker when linking shared object libraries
CMAKE_MODULE_LINKER_FLAGS- used by linker when linking modules (i don’t know what this means)
CMAKE_STATIC_LINKER_FLAGS- used by linker when linking static object libraries
you can also edit the cache directly to set these if you don’t want to go through an entireconfiguration step again.
you can also use the environment variables
LDFLAGS, but those only workon the first configuration and are therefore useless in my opinion.
find_package will take care of everything else for you: include directories, finding thelibraries, etc.
you can set some variables pre-command to configure what libs are linked. some of interest may be:
Boost_USE_MULTITHREADED- ON by default, set to OFF to use non-multithreaded libs
Boost_STATIC_LIBS- OFF by default, set to ON to force-use static libraries
Boost_DEBUG- get debug output from the
enable_testing add_test CTest manual
after building, you can now you can execute
ctest in the build directory to run the tests.
for a more sophisticated project you will want to hide this behind a flag so that end users don’thave to build your tests if they don’t want to.
Php array diff. Creates an array containing variables and their values. For each of these, compact looks for a variable with that name in the current symbol table and adds it to the output array such that the variable name becomes the key and the contents of the variable become the value for that key.
setting compiler options
target_compile_definitions for preprocessor definitions,
target_compile_options for actualcompiler options.
these are close to real commands i’ve used:
using generator expressions
i think the docs here are quite good actually, and the list is too long to go over here.
generator expressions are fantastic; they let you succinctly write informational messages andconditional expressions. take the example i gave in the previous section:
Cmake Generate Debug Information
the inner expression evaluates to either 1 or 0, and a generic expression like
$<X:STR> will onlyevaulate to
X is 1. overall, this evaluates to the flag
-Wno-psabi iff the compiler isgcc; otherwise it evaluates to nothing.
this is a lot simpler and clearer than writing:
note: unlike most of CMake, you can’t just coerce things on the left hand side of one of thesethings to true or false; it has to be exactly 0 or 1. there’s a special expression,
$<BOOL:foo>,for just that purpose.
Cmake Make Debug Screen
setting the c++ standard
note: added in cmake 3.1.
Cmake Debug Mode
putting it all together
a sample cmake file for a project using the boost unit testing lib: