appel d'un mauvais compilateur avec make

Bonjour. Je débute dans l’écriture de makefile. Mon problème est qu’avec ce code

CC=clang++
FLAGS=-Wall -Wextra -Weffc++ -pedantic
LDFLAGS=-lvulkan -lglfw
DFLAGS=-O0 -g
RFLAGS=-O2 -DNDEBUG
EXE=vktests
SRC=main.cpp
OBJ=$(SRC:.cpp=.o)

all:build

build:$(OBJ)
    $(CC) $(OBJ) $(LDFLAGS) -o $(EXE)

$(OBJ):release

release:$(SRC)
    $(CC) $(SRC) $(FLAGS) $(RFLAGS) -c && echo release

debug:$(SRC)
    $(CC) $(SRC) $(FLAGS) $(DFLAGS) -c && echo debug

clean:
    rm $(OBJ) $(EXE)

Le résultat est

clang++ main.cpp -Wall -Wextra -Weffc++ -pedantic -O2 -DNDEBUG -c && echo release
Can't read /proc/cpuinfo: No such file or directory
Can't read /proc/cpuinfo: No such file or directory
main.cpp:34:16: warning: unused variable 'test' [-Wunused-variable]
    auto const test { matrix * vector };
               ^
1 warning generated.
release
g++    -c -o main.o main.cpp
clang++ main.o -lvulkan -lglfw -o vktests
Can't read /proc/cpuinfo: No such file or directory

Comme vous pouvez le voir, g++ est appelé alors que j’ai demandé à mon makefile d’appeler clang++! Quel est le problème de ce code?

Bon, pour les Can't read /proc/cpuinfo: No such file or directory, ça doit venir du fait que mon environnement de développement est dans un chroot.

Merci de vos réponses!

Merci pour ta réponse.

Je ne savais pas que le nommage respectait une convention et que CC correspondait à un compilateur particulier. Par contre, je ne comprend pas pourquoi est-ce que les valeurs par défaut sont utilisées au lieu des instructions décrites dans ce fichier.

Parce que tu ne décris pas tout dans ton Makefile, en l’occurrence tu fais appel à une règle implicite pour la génération des fichiers .o à partir des .cpp. Et cette règle implicite doit faire référence à CXX.

Ce n’est pas ce que fait la ligne $(OBJ):release ? Je peux me tromper (d’ailleurs c’est certain car ça marche pas) mais je la lis comme "Pour la génération des .o, ne fait rien. Par contre tu as besoin que la routine release soit exécutée. Qu’est ce qui ne va pas dans ce raisonnement?

$(OBJ):release

Dit seulement que l’ensemble des éléments de la variable OBJ dépend de release.

Un makefile plus correct serait

CC=clang
CXX=clang++
CXXFLAGS=-Wall -Wextra -Weffc++ -pedantic
LDFLAGS=-lvulkan -lglfw
DFLAGS=-O0 -g
RFLAGS=-O2 -DNDEBUG
EXE=vktests
SRC=main.cpp
OBJ=$(SRC:.cpp=.o)

all:$(EXE)

$(EXE):$(OBJ)
    $(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -o $@

debug release: $(EXE)
debug: CXXFLAGS += $(DFLAGS)
release: CXXFLAGS += $(RFLAGS)

clean:
    rm -rf $(OBJ) $(EXE)

et attention, cela ne gère pas les dépendances vis à vis des headers (qu’il faut générer avec clang++)

edit: correction de quelques erreurs

Alors cette ligne indique simplement que les fichiers .o de ta variable OBJ dépendent de la règle release. C’est bien pour cela qu’on voit ta ligne avec le echo release être appelée.

Mais ça ne remplace pas la règle implicite %.o: %.cpp. Ainsi quand tu exécutes make, ta règle build est appelée qui dépend des règles présentes dans $(OBJ).
Ces règles dépendent de release, donc elle est appelée et compile les fichiers sources.

Mais surtout, chaque .o dépend toujours du .cpp associé, donc la règle implicite est ensuite appelée pour chaque fichier, c’est la ligne que tu vois apparaître avec g++.

Vos explications étaient un peu compliquées vu le peu que je connais en makefiles, mais je vais utiliser make -dp pour mieux comprendre ce qu’il se passe exactement.

Si ça peu te rassurer BorisD, j’utilise souvent make et je ne savais même pas qu’il possédait des règles pas défaut.

C’est déjà relativement pénible à écrire, alors si en plus il fallait toutes les écrire…

Je commence à comprendre un peu mieux le principe.

Par contre, j’ai testé un nouveau makefile dont voici un extrait (bugué évidemment)

release: $(EXE) CXXFLAGS += $(RFLAGS)
        echo release

Comment puis-je le faire dépendre de $(EXE) tout en modifiant CXXFLAGS comme l’a fait @unidan dans son exemple?

Ah oui, merci beaucoup! Pour CMake, j’avais déjà utilisé, mais j’y arrivait pas du tout (encore moins que les makefile) donc j’ai laissé tomber. Je crois que j’avais utilisé ça.

Edit : lien changé

En 2019, comme en 2018 et surtout pour le C++, on n’écrit pas de makefile à la main.

Tout comme en 2018, ça dépend des use cases. Si tu as un fichier à compiler et que tu es sous linux, c’est parfaitement viable.

Si tu as un fichier appelle le directement sans makefile.

Si tu fait un projet avec plus d’un fichier, CMake est bon.

Pourquoi ?