Jak mogę skonfigurować plik Makefile do kompilacji debugowania i wydania?

Question

Mam następujący plik Makefile dla mojego projektu i chciałbym go skonfigurować do wydania i debugowania kompilacji. W moim kodzie mam wiele makr #ifdef DEBUG w miejscu, więc jest to po prostu kwestia ustawienia tego makra i dodania flag do -g3 -gdwarf2 kompilatorów. Jak mogę to zrobić?

$(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 

Właśnie w celu wyjaśnienia, kiedy mówię, uwolnienie/debug buduje, Chcę móc wpisz make i uzyskać kompilacji uwolnienia lub make debug i uzyskać build debugowania, bez ręcznego zakomentowanie rzeczy w makefile.

Answer 1

Można użyć Target-specific Variable Values. Przykład:

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 

Pamiętaj o używaniu $ (CXX) lub $ (CC) we wszystkich komendach kompilacji.

Następnie "make debug" będzie zawierał dodatkowe flagi, takie jak -DDEBUG i -g, gdzie "make" nie będzie.

Na marginesie, możesz zrobić Makefile o wiele bardziej zwięzły, jak sugerowały inne posty.

Answer 2

Jeśli przez configure wydania/build, to znaczy, że wystarczy jeden config za makefile, to jest po prostu kwestia i oddzielenie CC i CFLAGS:

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

W zależności od tego, czy można użyć gnu makefile, ty można użyć warunkowy, aby ta nieco bardziej wyszukane i kontrolować je z wiersza poleceń:

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

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

a następnie użyć:

make DEBUG=0 
make DEBUG=1 

Jeśli potrzebujesz kontrolować obie konfiguracje w tym samym czasie, myślę, że lepiej jest mieć katalogi kompilacji i jeden katalog kompilacji/config.

Answer 3

można mieć zmienną

DEBUG = 0 

następnie można użyć instrukcji warunkowej

ifeq ($(DEBUG),1) 

    else 

    endif 

Answer 4

ukończeniu odpowiedzi od wcześniej ... Trzeba odwoływać się do zmiennych można zdefiniować informacje w twoich poleceń ...

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 

Answer 5

Pamiętaj, że możesz również uprościć Makefile, w tym samym czasie:

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 

Teraz nie trzeba powtarzać nazw plików w każdym miejscu. Wszystkie pliki .l zostaną przekazane za pomocą flex i gcc, wszelkie pliki .y zostaną przekazane przez bison i g ++, a także pliki .cpp za pośrednictwem g ++.

Wystarczy wymienić .o pliki można oczekiwać, aby skończyć z, i Make będzie wykonywać pracę na zastanawianie się, jakie przepisy mogą zaspokoić potrzeby ...

dla przypomnienia:

• $@ nazwa pliku docelowego (jeden przed grubego)

• $< Nazwa pierwszej (lub jedyną) warunkiem pliku (pierwszy po okrężnicy)

• $^ Nazwy wszystkich wstępnych plików (oddzielonych spacjami)

• $* trzpieniu (bit który odpowiada % wieloznaczny w definicji reguły.

Answer 6

Zgadzam się z @davidlin, użyj zmiennych specyficznych dla celu, aby ustawić różne flagi dla każdej konfiguracji. Prawdopodobnie jednak chcesz umieścić pliki wyjściowe w osobnych katalogach, aby można było budować różne konfiguracje bez odbudowywania wszystkiego. Korzystanie @ przykład davidlin jest, można zrobić:

debug: CONFIG=debug 

debug: executable 

executable: output/$(CONFIG)/myprog 

# Always use "$@" when referring to the target file. 
output/$(CONFIG)/myprog: ... 
     $(CXX) ... -o $@ 

Answer 7

Kwestia ta pojawiła się często przy poszukiwaniu podobnego problemu, więc czuję się w pełni wdrożone rozwiązanie jest uzasadnione. Zwłaszcza, że ​​ja (i chciałbym założyć, że inni) zmagali się z różnymi odpowiedziami.

Poniżej znajduje się przykładowy plik Makefile, który obsługuje wiele typów kompilacji w osobnych katalogach. Przedstawiony przykład pokazuje kompilacje debugowania i wydania.

Podpory ...

• oddzielne katalogi projektów dla konkretnych buduje
• łatwy wybór kompilacji domyślny docelowej
• milczy docelową prep do tworzenia katalogów potrzebnych do budowania projektu
• build-specyficzny znaczniki konfiguracji kompilatora
• GNU Make naturalna metoda określania, czy projekt wymaga przebudowy
• zasady wzór zamiast przestarzałych zasad przyrostek

---

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

Answer 8

ifeq (DEBUG, 1) należy zastąpić ifeq ($(DEBUG), 1).