Discussion :

[Realc]

Bonjour tout le monde, un problème se pose lors de l’exécution de mon script make, j'ai un recipe for target (je pense que cela viens de l'organisation de mes dossiers).
En fait mon dossier racine est composé de la sorte :
|_makefile
|_src / foo.c bar.c azerty.h
|_build

Lors de la compilation je souhaite placer mes objets et mon exécutable dans le dossier build, hors quand je lance mon make je me retrouve avec cette hiérarchie :
|_makefile
|_foo.o
|_bar.o
|_src / foo.c bar.c azerty.h
|_build

Et l'erreur me dit de ce fait que exécutable ne peut être compilé.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
CC=gcc
SRC=src
BLD=build
 
.PHONY: clean
 
all: $(BLD)/foo.o $(BLD)/bar.o
 
$(BLD)/foo.o: $(SRC)/foo.c $(SRC)/azerty.h
	$(CC) -c $^
 
$(BLD)/bar.o: $(SRC)/bar.c $(SRC)/azerty.h
	$(CC) -c $^
 
$(BLD)/executable: $(BLD)/foo.o $(BLD)/bar.o
	$(CC) -o $@ $^
 
clean:
	rm $(BLD)/executable $(BLD)/foo.o $(BLD)/bar.o

Pourriez vous me dire ce qui ne permet pas aux .o d'aller se placer dans le /build ?
Merci de votre future réponse.

[ekieki]

Pourriez vous me dire ce qui ne permet pas aux .o d'aller se placer dans le /build ?
Merci de votre future réponse.

1. Dans la commande $(CC) -c $^ du Makefile, rien ne dit au compilateur d'aller placer le fichier objet à l'endroit voulu

Une solution quick'n'dirty serait de compléter la commande par un "mv" qui va déplacer le fichier au bon endroit

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
$(BLD)/foo.o: $(SRC)/foo.c $(SRC)/azerty.h
	$(CC) -c $^
	mv foo.o $(BLD)

2. Maintenant, c'est crado de faire comme ça. (Déjà c'est mal d'utiliser $(CC) tout seul. Il y a des macros prédéfinies dans make, il faut s'en servir. On verra après.)

Mais bon déjà ça serait mieux de pouvoir utiliser -o $@ pour dire au compilo où il doit mettre foo.o. Mais on ne peut pas, parce que la commande gcc est appelée avec 2 sources. Erreur : il fallait utiliser $< et pas $^. Le fichier azerty.h, c'est une dépendance, pas un source à compiler directement.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
$(BLD)/foo.o: $(SRC)/foo.c $(SRC)/azerty.h
	$(CC) -c $<  -o $@

3. Ensuite, c'est chiant de réécrire toujours la même chose : les machins de BLD sont fabriqués à partir de ceux de SRC. Alors on fait une règle "générique"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
$(BLD)/%.o: $(SRC)/%.c
	$(CC) -c $< -o $@

et on écrit les dépendances supplémentaires plus loin.

4. Ensuite, on utilise les macros COMPILE.c et LINK.c, parce qu'elles savent se servir des variables CC, CFLAGS, etc. Ce qui nous donne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#Makefile amélioré
CC  = gcc
SRC = src
BLD = build
 
# Les options indispensables à toutes les compilations
CFLAGS = -Wall -Wextra -std=c11
 
# modules et exécutables à fabriquer
modules    =  $(BLD)/foo.o $(BLD)/bar.o
executable = $(BLD)/executable
 
 
all: $(executable)
 
# -----------------------------------------------
 
.PHONY: clean
 
# Comment compiler les modules
$(BLD)/%.o: $(SRC)/%.c
	$(COMPILE.c) -c $< -o $@
 
$(executable): $(modules)
	$(LINK.c) $(modules) -o $(executable);
 
# Dépendances supplémentaires
$(BLD)/foo.o: $(SRC)/azerty.h
$(BLD)/bar.o: $(SRC)/azerty.h
 
clean:
	$(RM)$(modules) -o $(executable)

Une autre fois : comment générer automatiquement les dépendances.

-----
Note : les macros utilisées sont prédéfinies comme ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
COMPILE.c = $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c
LINK.c       = $(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)
RM      = rm -f