I've been doing a lot of work on CMake for Eclipse OMR
for the last little while.
CMake is a really ambitious project that accomplishes so much with such simplicity it's like magic... so long as you stay on the well trodden road. Once you start wandering into the woods, because your project has peculiar needs or requirements, things can get hairy pretty quickly.
There's a pretty steep ramp from "This is amazing, a trivial
CMakeLists.txt builds my project" to "How do I do this slightly odd thing?"
We'll see how much I end up talking about CMake, but I'll start with a quick discussion of variables and scopes in CMake.
Variables and scopes in CMake
First, a quick note of caution: Variables exist in an entirely separate universe from properties, and so what I say about variables may well not apply to properties, which I am much less well versed in.
Variables are set in CMake using
The key to understanding variables in CMake in my mind is to understand where these variables get set.
Variables are set in a particular scope. I am aware of two places where new scopes are created:
add_subdirectory is used to add a new directory to the CMake source tree and
- When invoking a
Each scope when created maintains a link to its parent scope, and so you can think of all the scopes in a project as a tree.
Here's the trick to understanding scopes in CMake: Unlike other languages, where name lookup would walk up the tree of scopes, each new scope is a copy by value of the parent scope at that point. This means
function inherit the scope from the point where they're called, but modification will not be reflected in the parent scope.
This actually can be put to use to simplify your
CMakeLists.txt. A surprising amount of CMake configuration is still done only through what seem to be 'global' variables -- despite the existence of more modern forms. i.e despite the existence of
target_compile_options, if you need to add compiler options only to a C++ compile, you'll still have to use
If you don't realize, as i didn't, that scopes are copied-by-value, you may freak out at contaminating the build flags of other parts of a project. The trick is realizing that the scope copying limits the impact of the changes you make to these variables
Given that a scope has a reference to the scope it was copied from, it maybe isn't surprising that there's a way in CMake to affect the parent scope:
set(FOO <foo value> PARENT_SCOPE)
FOO in the parent scope... but not the current scope! So if you're going to want to read
FOO back again, and see the updated value, you'll want to write to
PARENT_SCOPE as well.
Cache variables are special ones that persist across runs of CMake. They get written to a special file called
There's a little bit different about cache variables. They're typed, as they interact with CMake's configuration GUI system), as well they tend to override normal variables (which makes a bit of sense). Mostly though, on the subject, I'll defer to the documentation!
There's a couple other random notes related to scoping I'd like to share.
It appears that not all scopes are created equal. In particular, it appears that targets will always use target-affecting variables from the contained directory scope, not function scopes.
It's been my experience that the above doesn't work as expected, because the
add_library call doesn't seem to see the modification of the CXX flags.
Pro Tip: If anything has gone wrong in your CMakeLists.txt, try looking in the cache! It's just a text file, but can be crazy helpful to figure out what's going on.