Makefile中的Cflags用法

Question

I wanted to know the use of C FLAGS.In make file what does the below snippet means ?

CFLAGS=-00 -g 
${PROG}: ${OBJS}
${CC} ${CFLAGS} -o ${PROG} ${OBJS} ${LDFLAGS}

what does -00 defines ?

############# Target type (Debug/Release) ##################
############################################################
TARGET_NAME=telematics

CFLAGS=-O0 -g
LinkDebug=-g -Xlinker -Map=$(TARGET_NAME)debug.map
LinkRelease=-O -s -Xlinker -Map=$(TARGET_NAME).map
SUPPRESS_WARNINGS=-Wno-write-strings -Wno-builtin-macro-redefined
COMMON_DEFINES = -DA5N2 -DLINUX_SYSTEM -DCT_2
C___DEFINES =
CPP_DEFINES = -std=c++11 -D_GLIBCXX_USE_C99 -DUSE_IOSTREAM -DOM_NO_TEMPLATES_USAGE -DOM_NO_FRAMEWORK_MEMORY_MANAGER
ConfigurationCPPCompileSwitches= $(SUPPRESS_WARNINGS) $(COMMON_DEFINES) $(CPP_DEFINES) $(INCLUDE_PATH) $(CFLAGS) -c
ConfigurationCCompileSwitches=   $(SUPPRESS_WARNINGS) $(COMMON_DEFINES) $(C___DEFINES) $(INCLUDE_PATH) $(CFLAGS) -c

###### Commands & Flags ################
RM=/bin/rm -rf
MD=/bin/mkdir -p
CC=arm-linux-gcc
LIB_CMD=arm-linux-ar
LINK_CMD=$(CC)
LIB_FLAGS=rvu

######### Context macros ##################

My question here is to basically understand whether that -00 is for static analysis ? From make file i thinks its -00(two Zero )

Answer 1

You probably are using GCC as your C compiler (perhaps as a cross compiler ), and your compilation commands are run by make . So read the chapter about Invoking GCC . -O0 (that is a 0 digit at last) is for an optimize option which:

reduce compilation time and make debugging produce the expected results. This is the default

I strongly recommend also enabling all warnings so put

CFLAGS= -Wall -Wextra -O0 -g3

in your Makefile (if you want more optimizations , eg for benchmarking purposes, replace -O0 by -O2 or -O3 ). The -g3 is a debugging option (to emit DWARF debugging information for the gdb debugger , which you should use).

Notice that -00 is not for static analysis! You could consider using specialized external static source analysis tools , like Frama-C or Clang Analyzer . These tools typically run much slower than a classical compilation (but of course any compiler is doing some static analysis internally for optimization purposes).

Take also time to read the documentation of make (and probably of binutils , for your linker). I am not sure you want to keep your SUPPRESS_WARNINGS line (it smells bad). You might perhaps also use remake (also here ) to debug your Makefile . Be aware that GNU make has a lot of builtin rules that you could see with make -p and that you should use. BTW, CFLAGS is known to some of these rules (so is a convention in Makefile -s about compilation flags passed for compiling C files).

Notice that you might, with great care and parsimony, add (rarely) some pragmas or function attributes in your source code, for example to disable specific warnings or force optimizations (only on some very few functions ).

Answer 2

In addition to the answer by Basile Starynkevitch , I'd like to add:

In make file what does the below snippet means ?

CFLAGS=-00 -g

The above assigns -O0 -g (make debugging information work as expected, and add debugging information, respectively) to the CFLAGS variable.

${PROG}: ${OBJS}
        ${CC} ${CFLAGS} -o ${PROG} ${OBJS} ${LDFLAGS}

The above creates a compilation recipe for the file named in the variable PROG , with the files named in variable OBJS as prerequisites. Note that the indentation uses TAB s, not spaces. (This forum converts tabs to spaces in code snippets, that's why you get spaces if you copy+paste the above to an editor.)

The way make interprets this, is as follows: First, all of the files listed in variable OBJS must be created (and new enough). Then, the command named in variable CC needs to be run, with parameters ${CFLAGS} -o ${PROG} ${OBJS} ${LDFLAGS}$ .

For example, if CC=arm-linux-gcc , PROG=foobar , OBJS=foobar.o , and LDFLAGS=-lm , then to generate foobar , make needs to first ensure foobar.o exists and is new enough, and then run arm-linux-gcc -o foobar foobar.o -lm .