Wie kann ich mein Makefile für Debug- und Release-Builds konfigurieren?

Ich habe das folgende Makefile für mein Projekt und möchte es für Release- und Debug-Builds konfigurieren. In meinem Code sind viele #ifdef DEBUGMakros vorhanden. Es geht also nur darum, dieses Makro zu setzen und -g3 -gdwarf2den Compilern die Flags hinzuzufügen . Wie kann ich das machen?

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

Um zu verdeutlichen, wenn ich Release- / Debug-Builds sage, möchte ich in der Lage sein, einfach makeeinen Release-Build oder make debugeinen Debug-Build einzugeben und abzurufen, ohne die Dinge im Makefile manuell auskommentieren zu müssen.

Sie können zielspezifische Variablenwerte verwenden . Beispiel:

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

Denken Sie daran, in all Ihren Kompilierungsbefehlen $ (CXX) oder $ (CC) zu verwenden.

Dann hat 'make debug' zusätzliche Flags wie -DDEBUG und -g, während 'make' dies nicht tut.

Nebenbei bemerkt, Sie können Ihr Makefile viel prägnanter gestalten, als andere Beiträge vorgeschlagen hatten.

Diese Frage ist häufig bei der Suche nach einem ähnlichen Problem aufgetreten, daher halte ich eine vollständig implementierte Lösung für gerechtfertigt. Zumal ich (und ich würde andere annehmen) Schwierigkeiten hatte, all die verschiedenen Antworten zusammenzusetzen.

Unten finden Sie ein Beispiel für ein Makefile, das mehrere Build-Typen in separaten Verzeichnissen unterstützt. Das abgebildete Beispiel zeigt Debug- und Release-Builds.

Unterstützt ...

• separate Projektverzeichnisse für bestimmte Builds
• Einfache Auswahl eines Standard-Ziel-Builds
• stilles Vorbereitungsziel zum Erstellen von Verzeichnissen, die zum Erstellen des Projekts benötigt werden
• Build-spezifische Compiler-Konfigurationsflags
• Die natürliche Methode von GNU Make, um festzustellen, ob ein Projekt neu erstellt werden muss
• Musterregeln anstelle der veralteten Suffixregeln

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

Wenn Sie mit configure release / build nur eine Konfiguration pro Makefile benötigen, ist dies einfach eine Frage der Entkopplung von CC und CFLAGS:

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

Abhängig davon, ob Sie gnu makefile verwenden können, können Sie bedingt verwenden, um dies ein bisschen schicker zu machen, und es über die Befehlszeile steuern:

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

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

und dann benutze:

make DEBUG=0
make DEBUG=1

Wenn Sie beide Konfigurationen gleichzeitig steuern müssen, ist es meiner Meinung nach besser, Build-Verzeichnisse und ein Build-Verzeichnis / Konfiguration zu haben.

Beachten Sie, dass Sie gleichzeitig Ihr Makefile vereinfachen können:

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

Jetzt müssen Sie Dateinamen nicht mehr überall wiederholen. Alle .l-Dateien werden über flex und gcc übertragen, alle .y-Dateien werden über Bison und g ++ und alle .cpp-Dateien nur über g ++ weitergeleitet.

Listen Sie einfach die .o-Dateien auf, mit denen Sie voraussichtlich enden werden, und Make wird herausfinden, welche Regeln die Anforderungen erfüllen können ...

für die Aufzeichnung:

• $@ Der Name der Zieldatei (die vor dem Doppelpunkt)

• $< Der Name der ersten (oder einzigen) vorausgesetzten Datei (die erste nach dem Doppelpunkt)

• $^ Die Namen aller erforderlichen Dateien (durch Leerzeichen getrennt)

• $*Der Stamm (das Bit, das mit dem %Platzhalter in der Regeldefinition übereinstimmt .

Sie können eine Variable haben

DEBUG = 0

dann können Sie eine bedingte Anweisung verwenden

  ifeq ($(DEBUG),1)

  else

  endif

Vervollständigen der Antworten von früher ... Sie müssen auf die Variablen verweisen, die Sie in Ihren Befehlen definieren ...

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

Sie können Ihrem Makefile auch etwas Einfaches hinzufügen, z

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

Kompilieren Sie es dann zum Debuggen

make DEBUG=1