Przejdź do treści

make

make buduje pliki według reguł zapisanych w pliku Makefile. Przy kolejnym uruchomieniu buduje tylko to, co się zmieniło od poprzedniego razu.

Przykład na tej stronie to program nwd, który wypisuje największy wspólny dzielnik i najmniejszą wspólną wielokrotność dwóch liczb (nwd.tar.gz):

curl -LO https://srodowisko.tcs.uj.edu.pl/build/nwd.tar.gz
tar xzf nwd.tar.gz && cd nwd
nwd/
├── include/
│   ├── nwd.h        int nwd(int a, int b);
│   └── nww.h        int nww(int a, int b);
└── src/
    ├── main.c       #include "nwd.h", "nww.h"
    ├── nwd.c        #include "nwd.h"
    └── nww.c        #include "nwd.h", "nww.h"

Reguły

Makefile składa się z reguł:

target: prerequisites
    recipe
  • target: plik, który reguła tworzy;
  • prerequisites: pliki, z których target powstaje;
  • recipe: polecenia powłoki, które tworzą target. Każda linia recipe musi zaczynać się tabulatorem, nie spacjami.
nwd: src/main.c src/nwd.c src/nww.c
    gcc -Iinclude src/main.c src/nwd.c src/nww.c -o nwd

Tabulator

Przykłady skopiowane z tej strony mają wcięcia ze spacji, bo strona zamienia tabulatory na spacje. W Makefile zamień je z powrotem na tabulator, ręcznie albo poleceniem sed -i 's/^ /\t/' Makefile (cztery spacje na początku linii zamienia na tabulator).

make bez argumentów buduje pierwszy target w pliku, make nazwa wskazany. Recipe jest wykonywana tylko wtedy, gdy target nie istnieje albo któryś z prerequisites jest od niego nowszy: make porównuje czasy modyfikacji plików.

$ make
gcc -Iinclude src/main.c src/nwd.c src/nww.c -o nwd
$ make
make: 'nwd' is up to date.
$ touch src/nwd.c          # czas modyfikacji = teraz, jakbyśmy edytowali plik
$ make
gcc -Iinclude src/main.c src/nwd.c src/nww.c -o nwd

make wypisuje każde polecenie przed wykonaniem. Jeśli któreś się nie powiedzie (kod wyjścia różny od 0), make przerywa pracę.

Pliki obiektowe

Kompilacja dużego projektu trwa długo. Jeśli każdy plik .c kompilujemy do osobnego pliku obiektowego, po zmianie jednego pliku wystarczy skompilować tylko jego i zlinkować program od nowa.

nwd: src/main.o src/nwd.o src/nww.o
    gcc src/main.o src/nwd.o src/nww.o -o nwd

src/main.o: src/main.c
    gcc -Iinclude -c src/main.c -o src/main.o

src/nwd.o: src/nwd.c
    gcc -Iinclude -c src/nwd.c -o src/nwd.o

src/nww.o: src/nww.c
    gcc -Iinclude -c src/nww.c -o src/nww.o

Prerequisite jednej reguły może być targetem innej. Żeby zbudować nwd, make najpierw sprawdza (rekurencyjnie) każdy plik .o:

$ touch src/nwd.c
$ make
gcc -Iinclude -c src/nwd.c -o src/nwd.o
gcc src/main.o src/nwd.o src/nww.o -o nwd

Nagłówki

src/main.c dołącza nww.h. Po zmianie nww.h plik src/main.o jest więc nieaktualny. make o tym nie wie, bo nie czyta kodu w C, tylko porównuje czasy plików z prerequisites. Dlatego nagłówki dopisujemy do prerequisites:

src/main.o: src/main.c include/nwd.h include/nww.h
    gcc -Iinclude -c src/main.c -o src/main.o

src/nwd.o: src/nwd.c include/nwd.h
    gcc -Iinclude -c src/nwd.c -o src/nwd.o

src/nww.o: src/nww.c include/nwd.h include/nww.h
    gcc -Iinclude -c src/nww.c -o src/nww.o
$ touch include/nww.h
$ make
gcc -Iinclude -c src/main.c -o src/main.o
gcc -Iinclude -c src/nww.c -o src/nww.o
gcc src/main.o src/nwd.o src/nww.o -o nwd

clean i .PHONY

Reguła nie musi tworzyć pliku. Target clean to nazwa czynności: usuwa wszystko, co zbudował make.

clean:
    rm -f nwd src/main.o src/nwd.o src/nww.o

.PHONY: clean
  • rm -f: brak błędu, gdy plików już nie ma.
  • make traktuje każdy target jak nazwę pliku. Gdyby istniał plik clean, a reguła nie ma prerequisites, make uznałby target za aktualny: make: 'clean' is up to date.
  • .PHONY wymienia targety, które nie są plikami. Ich recipe wykonują się zawsze. Typowe: all, clean, test, install.

Zmienne

CC = gcc
CPPFLAGS = -Iinclude
CFLAGS = -Wall -Wextra -g

nwd: src/main.o src/nwd.o src/nww.o
    $(CC) src/main.o src/nwd.o src/nww.o -o nwd

src/main.o: src/main.c include/nwd.h include/nww.h
    $(CC) $(CPPFLAGS) $(CFLAGS) -c src/main.c -o src/main.o

Zmienną odczytujemy przez $(NAZWA). Programy i ich opcje trzymamy w zmiennych, żeby każdy mógł je zmienić bez edycji pliku. Wartość podana w wierszu poleceń zastępuje tę z Makefile:

make CC=clang
make CFLAGS="-O2 -Wall"

Nazwy są umowne, ale używa ich każdy (także wbudowane reguły make):

Zmienna Znaczenie Przykład
CC kompilator C gcc
CPPFLAGS opcje preprocessora -Iinclude -DNDEBUG
CFLAGS opcje kompilatora -Wall -Wextra -g -O2
LDFLAGS opcje linkera -Llib
LDLIBS biblioteki -lm

-I i -D to opcje preprocessora, więc należą do CPPFLAGS. Tak robią wbudowane reguły make i ./configure.

Wartość z wiersza poleceń zastępuje całą zmienną: make CPPFLAGS=-DDEBUG usunęłoby -Iinclude i kompilator nie znalazłby nagłówków. Dlatego opcje, bez których projekt się nie zbuduje, można trzymać w osobnej zmiennej, a CPPFLAGS i CFLAGS zostawić użytkownikowi:

ALL_CPPFLAGS = -Iinclude $(CPPFLAGS)

src/main.o: src/main.c include/nwd.h include/nww.h
    $(CC) $(ALL_CPPFLAGS) $(CFLAGS) -c src/main.c -o src/main.o

Rodzaje przypisań:

A = $(B) x       # rozwijane przy każdym użyciu (B może być zdefiniowane później)
A := $(B) x      # rozwijane raz, w tym miejscu
A ?= x           # tylko jeśli A nie ma jeszcze wartości
A += y           # dopisanie na końcu

Przykład różnicy między = i :=:

nazwa = main.c
plik = src/$(nazwa)       # przy użyciu: src/nwd.c
plik2 := src/$(nazwa)     # od razu:     src/main.c
nazwa = nwd.c

$(shell polecenie) wstawia to, co polecenie wypisało, np. TODAY = $(shell date +%F). Zmienne powłoki w recipe piszemy z podwójnym $$, bo pojedynczy $ należy do make:

show:
    for f in src/*.c; do echo "$$f"; done

Pattern rules

Trzy reguły dla plików .o różnią się tylko nazwą. Zastępuje je jedna pattern rule:

CC = gcc
CPPFLAGS = -Iinclude
CFLAGS = -Wall -Wextra -g
OBJS = src/main.o src/nwd.o src/nww.o

nwd: $(OBJS)
    $(CC) $^ -o $@

src/%.o: src/%.c
    $(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

src/main.o: include/nwd.h include/nww.h
src/nwd.o: include/nwd.h
src/nww.o: include/nwd.h include/nww.h

clean:
    rm -f nwd $(OBJS)

.PHONY: clean

% pasuje do dowolnego tekstu, takiego samego po obu stronach: src/nwd.o powstaje z src/nwd.c. Reguły bez recipe tylko dopisują prerequisites.

Automatic variables, dostępne w recipe:

Zmienna Znaczenie W regule src/%.o: src/%.c dla src/nwd.o
$@ target src/nwd.o
$< pierwszy prerequisite src/nwd.c
$^ wszystkie prerequisites (bez powtórzeń) src/nwd.c include/nwd.h
$? prerequisites nowsze od targetu
$* tekst dopasowany do % nwd

Kilka funkcji do list plików:

SRCS = $(wildcard src/*.c)            # pliki pasujące do wzorca
OBJS = $(SRCS:.c=.o)                  # zamiana końcówki: src/main.o ...
OBJS = $(patsubst src/%.c,build/%.o,$(SRCS))   # zamiana według wzorca

make ma też reguły wbudowane, m.in. %.o: %.c z recipe $(CC) $(CPPFLAGS) $(CFLAGS) -c. Dlatego warto trzymać się nazw zmiennych z tabeli powyżej. Wszystkie reguły i zmienne wypisuje make -p.

Automatyczne zależności

Listy nagłówków może pisać kompilator:

CC = gcc
CPPFLAGS = -Iinclude -MMD -MP
CFLAGS = -Wall -Wextra -g
OBJS = src/main.o src/nwd.o src/nww.o
DEPS = $(OBJS:.o=.d)

nwd: $(OBJS)
    $(CC) $^ -o $@

src/%.o: src/%.c
    $(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

clean:
    rm -f nwd $(OBJS) $(DEPS)

.PHONY: clean

-include $(DEPS)

-MMD: kompilując src/nww.c, gcc zapisuje też src/nww.d, czyli regułę w składni make. -MP dopisuje puste reguły dla nagłówków (dwie ostatnie linie):

src/nww.o: src/nww.c include/nwd.h include/nww.h
include/nwd.h:
include/nww.h:
  • Bez -MP, po usunięciu nagłówka, make zatrzyma się z błędem No rule to make target 'include/nww.h'.
  • -include: wczytaj pliki .d. Minus oznacza brak błędu, gdy plików jeszcze nie ma, czyli przy pierwszym budowaniu. Wtedy i tak kompiluje się wszystko.
  • Nowy #include w kodzie trafi do pliku .d przy najbliższej kompilacji. Makefile nie wymaga zmian.

Przydatne opcje

Polecenie Działanie
make -n wypisz polecenia, nie wykonuj ich
make -B zbuduj wszystko od nowa
make -j8 do 8 poleceń naraz
make -s nie wypisuj poleceń
make -C katalog uruchom make w innym katalogu
make -f plik użyj innego pliku niż Makefile

W recipe: @ na początku linii ukrywa ją (@echo Gotowe), - każe zignorować jej błąd (-rm plik).

make nie zauważa zmian w samym Makefile. Po zmianie opcji kompilacji zbuduj wszystko od nowa: make clean && make albo make -B.