Salta al contenuto principale

make: automatizzare la compilazione e ricostruire solo ciò che è cambiato

Inviato da tuxsa il

Un progetto con più file sorgente si compila a mano con una serie di comandi. Se modifichi un solo file, vorresti ricompilare solo quello e non tutto il resto. make si occupa proprio di questo: guarda cosa è cambiato, ricostruisce il minimo necessario e lo fa nell'ordine giusto.

Cos'è

make è un programma che legge un file di istruzioni, il Makefile, e lo usa per costruire dei target (i file da produrre) a partire dalle loro dipendenze (i file da cui derivano). Nasce per compilare programmi in C, ma funziona con qualsiasi lavoro che trasformi dei file in altri file: documenti, immagini, pacchetti, o anche semplici sequenze di comandi da lanciare con un nome breve. Su Debian e Ubuntu si installa con sudo apt install make (spesso c'è già, con build-essential).

Cosa fa

Per ogni target make confronta la data di modifica del file con quella delle sue dipendenze. Se il target non esiste, o se una dipendenza è più recente, esegue i comandi della regola. Altrimenti lo salta. Per questo, dopo aver modificato un solo .c, ricompila solo quel file e rifà il collegamento finale.

Come si usa

$ make [opzioni] [target...]

Senza target, make costruisce il primo definito nel Makefile della cartella corrente. Una regola ha questa forma:

target: dipendenze
    comando

Attenzione alla tabulazione. Le righe dei comandi devono iniziare con un carattere TAB, non con spazi. In questa pagina le righe sono rientrate con spazi (per via del formato): se copi un esempio, nel tuo editor sostituisci quel rientro con un TAB. Se usi gli spazi, make si ferma con *** missing separator. Stop.: l'ho verificato.

Gli esempi usano un progetto di prova: main.c, util.c e util.h (con la funzione doppio). Gli output sono reali, con GNU Make 4.3 su Ubuntu 24.04. Sul tuo sistema i messaggi possono essere tradotti, se il locale è italiano.

Esempio 1: un Makefile minimo e la prima compilazione

CC = gcc
CFLAGS = -Wall -O2
OBJ = main.o util.o

prog: $(OBJ)
    $(CC) -o prog $(OBJ)

%.o: %.c util.h
    $(CC) $(CFLAGS) -c $<

.PHONY: clean
clean:
    rm -f prog $(OBJ)
$ make
gcc -Wall -O2 -c main.c
gcc -Wall -O2 -c util.c
gcc -o prog main.o util.o
$ ./prog
42

Le prime tre righe definiscono delle variabili (si usano con $(NOME)). La regola prog dice che il programma dipende dai file oggetto. La regola %.o: %.c util.h è una regola generica: ogni .o si ottiene dal .c con lo stesso nome (e dipende anche da util.h), e $< è la prima dipendenza. make mostra i comandi che esegue prima di lanciarli.

Esempio 2: ricostruire solo il necessario

$ make
make: 'prog' is up to date.

$ touch util.c
$ make
gcc -Wall -O2 -c util.c
gcc -o prog main.o util.o

$ touch util.h
$ make
gcc -Wall -O2 -c main.c
gcc -Wall -O2 -c util.c
gcc -o prog main.o util.o

Con nulla di modificato non fa niente. Dopo aver "toccato" util.c (touch ne aggiorna la data) ricompila solo quello e rifà il collegamento. Dopo aver toccato l'intestazione util.h ricompila tutto, perché l'abbiamo indicata come dipendenza di ogni .o. Dimenticare le intestazioni tra le dipendenze è un errore classico: make non si accorge delle modifiche e il programma resta con codice vecchio.

Esempio 3: vedere cosa farebbe, senza farlo

$ touch main.c
$ make -n
gcc -Wall -O2 -c main.c
gcc -o prog main.o util.o

$ make -q; echo $?
1
$ make
gcc -Wall -O2 -c main.c
gcc -o prog main.o util.o
$ make -q; echo $?
0

-n (dry run) stampa i comandi senza eseguirli: è il modo per controllare un Makefile prima di lanciarlo. -q (question) non stampa nulla e comunica solo con il codice di uscita: 0 se il target è aggiornato, 1 se andrebbe ricostruito, 2 in caso di errore.

Esempio 4: variabili automatiche e funzioni

SRC = $(wildcard *.c)
OBJS = $(SRC:.c=.o)
elenco: $(OBJS)
    @echo "target=$@ prima=$< tutti=$^"
%.o: %.c
    @echo "compilo $< -> $@"
    @touch $@
$ make -f V.mk
compilo main.c -> main.o
compilo util.c -> util.o
target=elenco prima=main.o tutti=main.o util.o

$@ è il nome del target, $< la prima dipendenza e $^ tutte. $(wildcard *.c) espande l'elenco dei .c presenti e $(SRC:.c=.o) sostituisce l'estensione. Il @ davanti a un comando impedisce a make di stamparlo. Con -f file si sceglie un Makefile con un nome diverso da quello di default. In questo esempio i comandi simulano la compilazione con echo e touch, per mostrare il meccanismo.

Esempio 5: target "finti" con .PHONY

$ touch clean
$ make -f P.mk clean
make: 'clean' is up to date.

$ make -f P2.mk clean      # con la riga ".PHONY: clean"
echo pulisco
pulisco

Un target come clean non produce un file: è solo un nome per un'azione. Se per caso nella cartella esiste un file con quel nome, make lo considera aggiornato e non fa nulla (primo caso). Dichiararlo con .PHONY dice a make di eseguirlo sempre (secondo caso). Per questo si mette in .PHONY ogni target che non corrisponde a un file: clean, all, install, test.

Esempio 6: variabili da riga di comando, parallelismo, errori

$ make CFLAGS="-O0" -n | head -3
gcc -O0 -c main.c
gcc -O0 -c util.c
gcc -o prog main.o util.o

$ make clean; make -j2
rm -f prog main.o util.o
gcc -Wall -O2 -c main.c
gcc -Wall -O2 -c util.c
gcc -o prog main.o util.o

$ make -k a b      # K.mk: 'a' fallisce, 'b' no
false
make: *** [K.mk:4: x] Error 1
make: Target 'a' not remade because of errors.
echo ok
ok

Una variabile data sulla riga di comando vince su quella nel Makefile: qui CFLAGS="-O0" sostituisce -Wall -O2 (ho aggiunto -n per non ricompilare davvero e head -3 per accorciare). Una variabile impostata nell'ambiente (X=env make) invece non sostituisce quella del file, a meno di usare -e. Con -jN make lancia fino a N comandi in parallelo, utile sui progetti grandi: nel mio test il progetto è così piccolo che non c'è differenza visibile (output uguale a quello seriale). -k (keep going) continua con i target indipendenti anche dopo un errore. Nel test il target b è stato eseguito nonostante il fallimento di a, e make ha comunque restituito codice 2.

Esempio 7: messaggi d'errore tipici

$ make nonce
make: *** No rule to make target 'nonce'.  Stop.

$ make                      # in una cartella senza Makefile
make: *** No targets specified and no makefile found.  Stop.

$ make -f S.mk              # comando indentato con spazi
S.mk:2: *** missing separator.  Stop.

In tutti e tre i casi make esce con codice 2. Se un comando di una regola fallisce (ad esempio un errore del compilatore), make si ferma e lo segnala con un messaggio del tipo make: *** [Bad.mk:2: bad.o] Error 1.

Esempio 8: uso negli script

#!/bin/bash
# Dice se un target di make e' aggiornato, senza compilare nulla
[ $# -ge 1 ] || { echo "Uso: $0 cartella [target]" >&2; exit 2; }
command -v make >/dev/null || { echo "make non trovato" >&2; exit 3; }
[ -d "$1" ] || { echo "$1: cartella inesistente" >&2; exit 2; }
dir=$1; target=${2:-}
make -C "$dir" -q ${target:+"$target"} >/dev/null 2>&1
case $? in
    0) echo "${target:-default}: aggiornato" ;;
    1) echo "${target:-default}: da ricostruire"; exit 1 ;;
    *) echo "${target:-default}: errore (target o Makefile non validi)" >&2; exit 4 ;;
esac

Lo script usa make -q per sapere se un target è aggiornato, senza compilare nulla: utile in un controllo periodico o prima di un rilascio. -C cartella fa entrare make nella cartella indicata. Esce con 0 se il target è aggiornato, 1 se serve ricostruirlo, 4 se il target o il Makefile non sono validi, 2 per argomenti o cartella sbagliati e 3 se make manca. Nei miei test ha risposto correttamente con il target di default aggiornato e poi, dopo un touch util.c, da ricostruire; con un target inesistente e con una cartella senza Makefile ha dato l'errore (codice 4). Ha restituito 2 con una cartella inesistente e senza argomenti, e 3 con make assente dal PATH.

Opzioni utili

  • -n: mostra i comandi senza eseguirli. -q: solo codice di uscita (0 aggiornato, 1 da ricostruire).
  • -f file: usa un Makefile con un altro nome. -C cartella: entra nella cartella prima di fare qualsiasi cosa.
  • -j N: esegue fino a N comandi in parallelo.
  • -k: continua sui target indipendenti dopo un errore.
  • -s: silenzioso, non stampa i comandi.
  • -e: le variabili d'ambiente hanno la precedenza su quelle del Makefile.
  • VAR=valore: imposta una variabile da riga di comando (ha la precedenza sul file).
  • -B: ricostruisce tutto a prescindere dalle date. Non l'ho provato.

Attenzione a

  • TAB, non spazi. È l'errore più comune: la riga del comando deve iniziare con una tabulazione, altrimenti missing separator. Gli editor che convertono le tabulazioni in spazi lo causano senza che te ne accorga.
  • Dipendenze incomplete. Se un .o non dipende dalle intestazioni che include, make non ricompila dopo una loro modifica e il programma resta incoerente (esempio 2).
  • Si basa sulle date dei file. Se un orologio è sfasato (file copiati da un'altra macchina, ad esempio) make può saltare file da ricostruire o ricostruire tutto. touch forza la data.
  • Dichiara i target finti come .PHONY. Altrimenti un file con lo stesso nome li fa saltare.
  • Il primo target è quello di default. Mettilo in cima, di solito con il nome all. Nel mio test, con due regole, make senza argomenti ha eseguito solo la prima.
  • Parallelo e dipendenze. Con -j, una dipendenza dimenticata può produrre errori intermittenti che con la compilazione seriale non compaiono. Non l'ho riprodotto: è un consiglio generale.
  • Un Makefile è codice eseguibile. Ogni comando gira con i tuoi permessi: non lanciare make su un progetto scaricato da una fonte che non conosci senza averlo letto.

Riepilogo

ComandoCosa fa
makeCostruisce il primo target del Makefile
make targetCostruisce il target indicato
make -nMostra i comandi senza eseguirli
make -q; echo $?0 se aggiornato, 1 se da ricostruire
make -f file.mkUsa un Makefile con un altro nome
make -C cartellaEsegue make in un'altra cartella
make -j4Fino a 4 comandi in parallelo
make CFLAGS="-O0"Sovrascrive una variabile del Makefile
make cleanDi solito rimuove i file generati (se definito)