Como posso configurar meu makefile para compilações de depuração e lançamento?

Eu tenho o seguinte makefile para o meu projeto e gostaria de configurá-lo para versões de lançamento e depuração. No meu código, eu tenho muitas #ifdef DEBUGmacros, então é simplesmente uma questão de definir essa macro e adicionar os -g3 -gdwarf2sinalizadores aos compiladores. Como posso fazer isso?

$(CC) = g++ -g3 -gdwarf2
$(cc) = gcc -g3 -gdwarf2

all: executable

executable: CommandParser.tab.o CommandParser.yy.o Command.o
    g++ -g -o output CommandParser.yy.o CommandParser.tab.o Command.o -lfl

CommandParser.yy.o: CommandParser.l 
    flex -o CommandParser.yy.c CommandParser.l
    gcc -g -c CommandParser.yy.c

CommandParser.tab.o: CommandParser.y
    bison -d CommandParser.y
    g++ -g -c CommandParser.tab.c

Command.o: Command.cpp
    g++ -g -c Command.cpp

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

Apenas para esclarecer, quando digo compilações de liberação / depuração, quero poder digitar makee obter uma compilação de liberação ou make debugobter uma compilação de depuração, sem comentar manualmente as coisas no makefile.

Você pode usar valores variáveis ​​específicos do destino . Exemplo:

CXXFLAGS = -g3 -gdwarf2
CCFLAGS = -g3 -gdwarf2

all: executable

debug: CXXFLAGS += -DDEBUG -g
debug: CCFLAGS += -DDEBUG -g
debug: 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

Lembre-se de usar $ (CXX) ou $ (CC) em todos os seus comandos de compilação.

Então, 'make debug' terá sinalizadores extras como -DDEBUG e -g onde 'make' não terá.

Em uma nota lateral, você pode tornar seu Makefile muito mais conciso, como outras postagens sugeriram.

Essa pergunta apareceu com frequência ao procurar um problema semelhante, portanto, acho que uma solução totalmente implementada é necessária. Especialmente porque eu (e eu diria que outros) lutam para reunir todas as várias respostas.

Abaixo está um Makefile de amostra que suporta vários tipos de compilação em diretórios separados. O exemplo ilustrado mostra compilações de depuração e lançamento.

Apoia ...

• diretórios de projeto separados para construções específicas
• seleção fácil de uma construção de destino padrão
• destino de preparação silenciosa para criar diretórios necessários para a construção do projeto
• Sinalizadores de Configuração do Compilador Específicos de Construção
• O método natural do GNU Make para determinar se o projeto requer uma reconstrução
• regras padrão em vez das regras obsoletas de sufixo

#
# 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)

Se por configurar release / build, você quer dizer que você só precisa de uma configuração por makefile, é simplesmente uma questão e desacoplar CC e CFLAGS:

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

Dependendo se você pode usar o gnu makefile, é possível usar o condicional para tornar isso um pouco mais sofisticado e controlá-lo na linha de comando:

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

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

e então use:

make DEBUG=0
make DEBUG=1

Se você precisar controlar as duas configurações ao mesmo tempo, acho melhor ter diretórios de construção e um diretório de configuração / configuração.

Observe que você também pode tornar seu Makefile mais simples, ao mesmo tempo:

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

Agora você não precisa repetir os nomes de arquivos em todo o lugar. Quaisquer arquivos .l serão passados ​​pelo flex e gcc, quaisquer arquivos .y serão passados ​​pelo bison e g ++, e quaisquer arquivos .cpp apenas pelo g ++.

Basta listar os arquivos .o que você espera que acabem, e o Make fará o trabalho de descobrir quais regras podem satisfazer as necessidades ...

para o registro:

• $@ O nome do arquivo de destino (aquele antes dos dois pontos)

• $< O nome do primeiro (ou único) arquivo de pré-requisito (o primeiro após os dois pontos)

• $^ Os nomes de todos os arquivos de pré-requisito (separados por espaço)

• $*A raiz (o bit que corresponde ao %curinga na definição de regra.

você pode ter uma variável

DEBUG = 0

então você pode usar uma declaração condicional

  ifeq ($(DEBUG),1)

  else

  endif

Concluindo as respostas anteriores ... Você precisa fazer referência às variáveis ​​que definem informações em seus 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

Você também pode adicionar algo simples ao seu Makefile, como

ifeq ($(DEBUG),1)
   OPTS = -g
endif

Em seguida, compile-o para depuração

make DEBUG=1