¿Cómo puedo configurar mi makefile para compilaciones de depuración y lanzamiento?

Si por configurar release / build, quiere decir que solo necesita una configuración por makefile, entonces es simplemente una cuestión y desacoplar CC y CFLAGS:

CFLAGS=-DDEBUG
#CFLAGS=-O2 -DNDEBUG
CC=g++ -g3 -gdwarf2 $(CFLAGS)

Dependiendo de si puedes usar gnu makefile, puedes usar condicional para hacer esto un poco más elegante, y controlarlo desde la línea de comandos:

DEBUG ?= 1
ifeq ($(DEBUG), 1)
    CFLAGS =-DDEBUG
else
    CFLAGS=-DNDEBUG
endif

.o: .c
    $(CC) -c $< -o $@ $(CFLAGS)

Y luego use:

make DEBUG=0
make DEBUG=1

Si necesita controlar ambas configuraciones al mismo tiempo, creo que es mejor tener directorios de compilación, y un directorio de compilación / config.

Esta pregunta ha aparecido a menudo cuando se busca un problema similar, por lo que siento que se justifica una solución completamente implementada. Especialmente porque yo (y asumiría que otros) he luchado juntando todas las diversas respuestas.

A continuación se muestra un Makefile de ejemplo que soporta múltiples tipos de compilación en directorios separados. El ejemplo ilustrado muestra compilaciones de depuración y liberación.

Soporta ...

• directorios de proyectos separados para compilaciones específicas
• fácil selección de una compilación de destino predeterminada
• objetivo de preparación silenciosa para crear los directorios necesarios para construir el proyecto
• banderas de configuración del compilador específicas de compilación
• El método natural de GNU Make para determinar si el proyecto requiere una reconstrucción
• reglas de patrón en lugar del sufijo obsoleto reglas

#
# Compiler flags
#
CC     = gcc
CFLAGS = -Wall -Werror -Wextra

#
# Project files
#
SRCS = file1.c file2.c file3.c file4.c
OBJS = $(SRCS:.c=.o)
EXE  = exefile

#
# Debug build settings
#
DBGDIR = debug
DBGEXE = $(DBGDIR)/$(EXE)
DBGOBJS = $(addprefix $(DBGDIR)/, $(OBJS))
DBGCFLAGS = -g -O0 -DDEBUG

#
# Release build settings
#
RELDIR = release
RELEXE = $(RELDIR)/$(EXE)
RELOBJS = $(addprefix $(RELDIR)/, $(OBJS))
RELCFLAGS = -O3 -DNDEBUG

.PHONY: all clean debug prep release remake

# Default build
all: prep release

#
# Debug rules
#
debug: $(DBGEXE)

$(DBGEXE): $(DBGOBJS)
    $(CC) $(CFLAGS) $(DBGCFLAGS) -o $(DBGEXE) $^

$(DBGDIR)/%.o: %.c
    $(CC) -c $(CFLAGS) $(DBGCFLAGS) -o $@ $<

#
# Release rules
#
release: $(RELEXE)

$(RELEXE): $(RELOBJS)
    $(CC) $(CFLAGS) $(RELCFLAGS) -o $(RELEXE) $^

$(RELDIR)/%.o: %.c
    $(CC) -c $(CFLAGS) $(RELCFLAGS) -o $@ $<

#
# Other rules
#
prep:
    @mkdir -p $(DBGDIR) $(RELDIR)

remake: clean all

clean:
    rm -f $(RELEXE) $(RELOBJS) $(DBGEXE) $(DBGOBJS)

Tenga en cuenta que también puede simplificar su Makefile, al mismo tiempo:

DEBUG ?= 1
ifeq (DEBUG, 1)
    CFLAGS =-g3 -gdwarf2 -DDEBUG
else
    CFLAGS=-DNDEBUG
endif

CXX = g++ $(CFLAGS)
CC = gcc $(CFLAGS)

EXECUTABLE = output
OBJECTS = CommandParser.tab.o CommandParser.yy.o Command.o
LIBRARIES = -lfl

all: $(EXECUTABLE)

$(EXECUTABLE): $(OBJECTS)
    $(CXX) -o $@ $^ $(LIBRARIES)

%.yy.o: %.l 
    flex -o $*.yy.c $<
    $(CC) -c $*.yy.c

%.tab.o: %.y
    bison -d $<
    $(CXX) -c $*.tab.c

%.o: %.cpp
    $(CXX) -c $<

clean:
    rm -f $(EXECUTABLE) $(OBJECTS) *.yy.c *.tab.c

Ahora no tienes que repetir nombres de archivo por todas partes. Cualquier .los archivos l se pasarán a través de flex y gcc, cualquiera .los archivos y pasarán a través de bison y g++, y any .archivos cpp a través de just g++.

Simplemente enumere el.o archivos que espera terminar con, y Make hará el trabajo de averiguar qué reglas pueden satisfacer las necesidades...

Para que conste:

• $@ Las nombre del archivo de destino (el anterior a los dos puntos)

• $< El nombre del primer (o único) archivo de prerrequisitos (el primero después de los dos puntos)

• $^ Los nombres de todos los archivos de prerrequisitos (separados por espacio)

• $* La raíz (el bit que coincide con el comodín % en la definición de la regla.

Puede tener una variable

DEBUG = 0

Entonces puedes usar una sentencia condicional

  ifeq ($(DEBUG),1)

  else

  endif

Completando las respuestas anteriores... Necesita hacer referencia a las variables que define info en sus comandos...

DEBUG ?= 1
ifeq (DEBUG, 1)
    CFLAGS =-g3 -gdwarf2 -DDEBUG
else
    CFLAGS=-DNDEBUG
endif

CXX = g++ $(CFLAGS)
CC = gcc $(CFLAGS)

all: executable

executable: CommandParser.tab.o CommandParser.yy.o Command.o
    $(CXX) -o output CommandParser.yy.o CommandParser.tab.o Command.o -lfl

CommandParser.yy.o: CommandParser.l 
    flex -o CommandParser.yy.c CommandParser.l
    $(CC) -c CommandParser.yy.c

CommandParser.tab.o: CommandParser.y
    bison -d CommandParser.y
    $(CXX) -c CommandParser.tab.c

Command.o: Command.cpp
    $(CXX) -c Command.cpp

clean:
    rm -f CommandParser.tab.* CommandParser.yy.* output *.o