Discussion :

[Roland Chastain]

Bonjour !

Je souhaiterais modifier le Makefile d'un projet existant pour pouvoir compiler au choix en 32 ou 64 bits. Apparemment la modification que j'ai faite n'est pas bonne. On dirait que les fichiers *.o sont toujours compilés en 64 bits, ce qui me donne l'erreur suivante quand je veux compiler en 32 bits :

Code X :

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
[roland@portable source]$ LC_ALL=C make sachy32
gcc -Wall   -c -o main.o main.c
gcc -Wall   -c -o inic.o inic.c
gcc -Wall   -c -o interf.o interf.c
gcc -Wall   -c -o movegen.o movegen.c
gcc -Wall   -c -o value.o value.c
gcc -Wall   -c -o rules.o rules.c
gcc -Wall   -c -o makemove.o makemove.c
gcc -Wall   -c -o search.o search.c
gcc -Wall   -c -o test.o test.c
gcc -Wall   -c -o sort.o sort.c
gcc -Wall   -c -o book.o book.c
gcc -o sachy32 main.o inic.o interf.o movegen.o value.o rules.o makemove.o search.o test.o sort.o book.o -m32
/usr/bin/ld: i386:x86-64 architecture of input file `main.o' is incompatible with i386 output
/usr/bin/ld: i386:x86-64 architecture of input file `inic.o' is incompatible with i386 output
/usr/bin/ld: i386:x86-64 architecture of input file `interf.o' is incompatible with i386 output
/usr/bin/ld: i386:x86-64 architecture of input file `movegen.o' is incompatible with i386 output
/usr/bin/ld: i386:x86-64 architecture of input file `value.o' is incompatible with i386 output
/usr/bin/ld: i386:x86-64 architecture of input file `rules.o' is incompatible with i386 output
/usr/bin/ld: i386:x86-64 architecture of input file `makemove.o' is incompatible with i386 output
/usr/bin/ld: i386:x86-64 architecture of input file `search.o' is incompatible with i386 output
/usr/bin/ld: i386:x86-64 architecture of input file `test.o' is incompatible with i386 output
/usr/bin/ld: i386:x86-64 architecture of input file `sort.o' is incompatible with i386 output
/usr/bin/ld: i386:x86-64 architecture of input file `book.o' is incompatible with i386 output
collect2: error: ld returned 1 exit status
make: *** [Makefile:12: sachy32] Error 1
[roland@portable source]$

Voici mon Makefile :

Code Makefile :

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
# Makefile pro SACHY
 
CC = gcc
CFLAGS = -Wall
 
objects = main.o inic.o interf.o movegen.o value.o rules.o makemove.o search.o test.o sort.o book.o
 
sachy:  $(objects)
	$(CC) -o sachy $(objects)
 
sachy32:  $(objects)
	$(CC) -o sachy32 $(objects) -m32
 
sachy64:  $(objects)
	$(CC) -o sachy64 $(objects)
 
$(objects): data.h 
 
.PHONY: clean
 
clean:
	rm sachy $(objects)

Mais je ne vois pas la commande pour les fichiers *.o...

[WhiteCrow]

Bonjour,

les fichiers objets sont compilés avec la règle par défaut :

Code Makefile :

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

1
2
3
4
5
COMPILE.c = $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c
 
%.o: %.c
#  recette à exécuter (commande interne)*:
        $(COMPILE.c) $(OUTPUT_OPTION) $<

Tu peux afficher ça avec l'option -p (ou --print-data-base si tu aimes les longopt).

Pour ce qui est de l'édition des liens :

Code Makefile :

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

1
2
3
4
5
LINK.o = $(CC) $(LDFLAGS) $(TARGET_ARCH)
 
%: %.o
#  recette à exécuter (commande interne)*:
        $(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -o $@

Le plus simple est sans doute d'utiliser la variable TARGET_ARCH.

Attention cependant à ne pas oublier qu'une fois le fichier objet créé, il ne le sera plus tant que le timestamp du source sera antérieur à celui de l'objet … Cela signifie que si tu pars d'un répertoire ne contenant que des sources, une fois compilés pour une architecture il faudra effacer tous les objets avant de relancer un build pour une autre architecture.

Tu as aussi la possibilité d'utiliser les fonctionnalités multi répertoire de make. Une autre possibilité serait de différentier les objets 32 et 64 bits avec une extension différente.

Tu as aussi la possibilité de changer de builder pour prendre quelque chose de plus moderne comme Meson ou CMake qui eux vont gérer tout ça un peu mieux et peuvent même utiliser make comme backend.

Edit: typo

[Roland Chastain]

les fichiers objets sont compilés avec la règle par défaut :

Tu peux afficher ça avec l'option -p (ou --print-data-base si tu aimes les longopt).

Ah, d'accord, je comprends mieux. Je note l'information sur l'option -p.

Le plus simple est sans doute d'utiliser la variable TARGET_ARCH.

Attention cependant à ne pas oublier qu'une fois le fichier objet créé, il ne le sera plus tant que le timestamp du source sera antérieur à celui de l'objet … Cela signifie que si tu pars d'un répertoire ne contenant que des sources, une fois compilés pour une architecture il faudra effacer tous les objets avant de relancer un build pour une autre architecture.

Tu as aussi la possibilité d'utiliser les fonctionnalités multi répertoire de make. Une autre possibilité serait de différentier les objets 32 et 64 bits avec une extension différente.

Je n'avais pas remarqué que make vérifiait la date du code source.

Mais, du coup, je ne sais toujours pas comment faire concrètement. Si ce n'est pas trop demander, tu n'aurais pas un exemple ?

Tu as aussi la possibilité de changer de builder pour prendre quelque chose de plus moderne comme Meson ou CMake qui eux vont gérer tout ça un peu mieux et peuvent même utiliser make comme backend.

Bon, là, je suis en train de me familiariser tout doucement avec make, qui est largement utilisé dans les projets que je consulte. J'aimerais mieux utiliser cet outil.

[WhiteCrow]

Ah, d'accord, je comprends mieux. Je note l'information sur l'option -p.

Attention, ce sont des règles par défaut en l'absence de règles explicites dans le makefle.

Je n'avais pas remarqué que make vérifiait la date du code source.

Oui, la règle d'une cible n'est lancée que lorsqu'un des fichiers listé en dépendance est antérieur (ou inexistant) à la cible.
C'est aussi le pourquoi de l'existence d'une cible comme `.phony`, car en général les dépendances ne sont pas des fichiers et ne crée pas de fichiers. Si par mégarde un fichier de ce nom était créé alors la règle ne s'appliquerait plus.

Mais, du coup, je ne sais toujours pas comment faire concrètement. Si ce n'est pas trop demander, tu n'aurais pas un exemple ?

Alors à main levée sans tests je peux te proposer ça :

Code Makefile :

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# compilateur & options de base
CC = gcc
CFLAGS = -Wall
 
# la liste des sources
SOURCES = main.c inic.c interf.c movegen.c value.c rules.c makemove.c search.c test.c sort.c book.c
# ici on crée deux listes, une pour chaque architecture
# elles sont créées en remplaçant l'extension `.c` de la liste de sources par `.o32`/`.o64`
OBJ32 = $(SOURCES:.c=.o32)
OBJ64 = $(SOURCES:.c=.o64)
 
# première cible, par défaut on essaye de construire les deux exécutables
all: sachy32 sachy64 sachy
 
# les cibles par architectures
# $@ est le nom de la cible, $^ est la totalité des dépendances
sachy32: $(OBJ32)
	$(CC) $(LDFLAGS) -m32 $(LDLIBS) -o $@ $^
 
sachy64: $(OBJ64)
	$(CC) $(LDFLAGS) -m64 $(LDLIBS) -o $@ $^
 
# par défaut, sans indication on préfèrera la version 64 bits
sachy: sachy64
	cp $< $@
 
# on rajoute une dépendance vers `data.h` sur tous les fichiers objets
$(OBJ32): data.h
 
$(OBJ64): data.h
 
# cibles inconditionnelles de maintenance
.phony: clean clean32 clean64
 
clean: clean32 clean64
	$(RM) sachy
 
clean32:
	$(RM) sachy32 $(OBJ32)
 
clean64:
	$(RM) sachy64 $(OBJ64)
 
# Les règles par défaut pour produire des objets 32 bits
# $< est le fichier source concerné par la compilation
%.o32: %.c
	$(CC) $(CFLAGS) $(CPPFLAGS) -m32 -o $@ $<
 
# Idem pour une architecture 64 bits
%.o64: %.c
	$(CC) $(CFLAGS) $(CPPFLAGS) -m64 -o $@ $<

Dis-moi si ça convient …

[Roland Chastain]

Bon, j'ai essayé ceci

Code Makefile :

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

1
2
3
sachy32: TARGET_ARCH += -m32
sachy32:  $(objects)
	$(CC) -o sachy32 $(objects)

puis ceci

Code Makefile :

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

1
2
3
4
sachy32: CFLAGS += -m32
sachy32: LDFLAGS += -m32
sachy32:  $(objects)
	$(CC) -o sachy32 $(objects)

sans succès.

[Roland Chastain]

Dis-moi si ça convient …

Nos messages se sont croisés. J'essaie tout de suite et je reviens.

[Roland Chastain]

Bon, ça ne marche point... Aucun fichier n'est créé.

Code X :

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

1
2
3
4
5
6
7
8
9
10
[roland@localhost makefile]$ make
gcc -Wall  -m32 -o main.o32 main.c
/usr/bin/ld*: /tmp/ccsxj4Su.o*: dans la fonction «*main*»*:
main.c:(.text+0x9e)*: référence indéfinie vers «*InitGame*»
/usr/bin/ld*: main.c:(.text+0xb0)*: référence indéfinie vers «*openbook*»
/usr/bin/ld*: main.c:(.text+0xd6)*: référence indéfinie vers «*IsStaleMate*»
/usr/bin/ld*: main.c:(.text+0x104)*: référence indéfinie vers «*IsMate*»
...
collect2: error: ld a retourné le statut de sortie 1
make: *** [Makefile:47: main.o32] Error 1

À moins que j'aie fait une fausse manipulation, mais il ne me semble pas.

Mais merci quand même pour l'exemple, qui montre pas mal de petits trucs. Je regarde si j'arrive à comprendre ce qui se passe...

[Roland Chastain]

Au cas où, voici le code source.

[kaitlyn]

Salut,

Quand je faisais des opérations de genre, je m'efforçais de bien séparer les binaires produits de la source, en m'aidant d'un script shell, cela me permettait de conserver un makefile simple et épuré. Dans les grandes lignes, mon dossier projet :

build.sh
source/

dans le shell, en se plaçant dans projet, un build, un build 32, build 64 ou un build all suffisait à la construction, les dossiers de sortie étaient générés automatiquement, à la fin :

build.sh
source/
workspace/ (avec sous-dossier(s) 32, et 64 )
bin/ (avec sous-dossier(s) 32, et 64 )

le principe, c'était que build.sh "s'autoplace" dans workspace, qu'il exporte une variable target=-m32 ou 64 (utilisée par makefile dans cflags et ldflags) qu'il appelle make et que l'installation se fasse dans bin.

ça devrait être simple à reproduire, mais avec mon téléphone je ne peux pas

[WhiteCrow]

Bon, ça ne marche point... Aucun fichier n'est créé.

Code X :

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

1
2
3
4
5
6
7
8
9
10
[roland@localhost makefile]$ make
gcc -Wall  -m32 -o main.o32 main.c
/usr/bin/ld*: /tmp/ccsxj4Su.o*: dans la fonction «*main*»*:
main.c:(.text+0x9e)*: référence indéfinie vers «*InitGame*»
/usr/bin/ld*: main.c:(.text+0xb0)*: référence indéfinie vers «*openbook*»
/usr/bin/ld*: main.c:(.text+0xd6)*: référence indéfinie vers «*IsStaleMate*»
/usr/bin/ld*: main.c:(.text+0x104)*: référence indéfinie vers «*IsMate*»
...
collect2: error: ld a retourné le statut de sortie 1
make: *** [Makefile:47: main.o32] Error 1

À moins que j'aie fait une fausse manipulation, mais il ne me semble pas.

Mais merci quand même pour l'exemple, qui montre pas mal de petits trucs. Je regarde si j'arrive à comprendre ce qui se passe...

J'ai oublié l'option -c pour que gcc crée des fichiers objets … remplace la fin du makefile par :

Code Makefile :

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

1
2
3
4
5
6
7
8
# Les règles par défaut pour produire des objets 32 bits
# $< est le fichier source concerné par la compilation
%.o32: %.c
	$(CC) $(CFLAGS) $(CPPFLAGS) -m32 -c -o $@ $<
 
# Idem pour une architecture 64 bits
%.o64: %.c
	$(CC) $(CFLAGS) $(CPPFLAGS) -m64 -c -o $@ $<

[Roland Chastain]

J'ai oublié l'option -c pour que gcc crée des fichiers objets … remplace la fin du makefile par :

Oui, ça marche ! Merci.

@kaitlyn
Merci pour ta réponse. Je retiens l'idée.