Allowing users to override CFLAGS, CXXFLAGS and friends

Question

Typical makefiles often use the built-in variables CFLAGS, CXXFLAGS, CPPFLAGS and so on¹ to set the flags passed to the C, C++ or other compilers/tools. In principle, this sometimes even lets you avoid writing a compilation recipe entirely since the various built-in rules use these flags.

In general, a makefile might add things to the FLAGS variables that are required for the code to compile, such as include directories, arguments indicating which language standard to use and so on. The variables might also include "optional" or "default" arguments, such as optimization level, warning level and other settings that might validly be altered or removed.

Since CFLAGS and fields are "well known" variables, they are also apparently a configuration point for end users. For example, if a project compiles without debug information by default, it is expected that CFLAGS=-g on the make command line causes -g to be added to the $(CC) compiler command line and hence cause debug info to be produced. Similarly for other options the end user might want to control, such as the optimization level, the -march setting on gcc, and so on.

However, these two uses seem incompatible to me. If the user overrides $(CFLAGS) they will obliterate any internal "required" flags as described above, and the project either may not compile or may compile incorrectly.

Is there a best practice for handling this? The same problem doesn't really arise for "single value" variables like $(CC) since they generally have exactly one value: in this example, the C compiler to use. If the user overrides it, you use their value. Things like $(CFLAGS) are in principle a list of values, some of which are internal and shouldn't be overridden, an others which a user may want to override.

Intuitively, a solution seems to be to leave $(CFLAGS) and friends empty and unused in your makefile, preferring say CFLAGS_INTERNAL for in-makefile arguments, and then put both on the command line. I'm curious, however, if there is a best practice around this or if I'm missing something obvious.

---

¹ For the rest of this question I will often simply refer to $(CFLAGS) with the understanding that this is simply a convenient representative of the whole family of well known compiler flag variables such as $(CPPFLAGS), $(CXXFLAGS) and so on.

Answer 1

The approach I prefer is to provide sensible default values to these common variables, but let users provide their own - overriding the default values.

include $(wildcard makefile.in Makefile.in)

BUILD ?= build
CFLAGS ?= -O2 -fPIC -pedantic -Wall -Wextra -Wconversion

This can be done by either environment variables, command line parameters like make CFLAGS=-g or persistently in a makefile.in.

I am aware that this doesn't exactly pick up the issue you described in the questions, but I found use cases in which users want to compile a project with non-default flags should be able to

1. Define these variables to their needs
2. Check their defaults, preferably at the top of the makefile
3. Maybe adjust the definitions in accordance to the defaults

If someone wants to build with some special flags and is incapable of these steps, there will be some more serious problems anyhow.

This approach will not scale well when the build becomes more involved and the defaults are set across a larger makefile and dependent on other conditions.

Answer 2

I am faced with the same problem. For the time being my solution is to provide "non-standard" flags such as OPTIMS, WARNINGS, MODENV which will be appended to the "standard" CXXFLAGS internally.

If the user defines CXXFLAGS from the command-line it is assumed that he wants to override it, and if that's what he wants, that's what he should get: an override. Ironically this means I'm not using override CXXFLAGS += ... in the Makefile.

I don't want advanced users to pull their hairs out because I insist on appending/prepending my stuff to their flags, so in my opinion the final situation is like this:

• GOOD: require advanced users to pass intricate custom flags
• BAD: require advanced users to patch the Makefile

Answer 3

Just stumbled upon the same question while building an RPM with debuginfo package.

The requirement for debuginfo generation is to pass -g in CFLAGS while preserving whatever CFLAGS the software has in its Makefile.

So if you want to add some extra bits to CFLAGS, without overwriting the ones present in Makefile, you can simply use CFLAGS as an environment variable. But only as long as the Makefile in question uses CFLAGS += ... notation.

Example, suppose that you have software with Makefile having:

CFLAGS += $(ARCH) -O3 -std=gnu11 -Wall ...

To have it build with all those flags and -g, you will do:

CFLAGS='-g' make 

Note that passing it as an argument to make won't work, as in: make CFLAGS='-g' is wrong, because it will overwrite internal CFLAGS.

More on the solution to pass -g for building debuginfo packages properly

Here's reference on make: appending to variables.

Answer 4

The override directive may be what you are looking for:

$ cat Makefile
override CFLAGS += -foobar

all:
    $(info CFLAGS = $(CFLAGS))

$ make
CFLAGS = -foobar
make: 'all' is up to date.

$ make CFLAGS=-g
CFLAGS = -g -foobar
make: 'all' is up to date.

Note that you can also use:

$ make CFLAGS+=-g

on the command line but it behaves just like:

$ make CFLAGS=-g