GCC dépendance génération pour un autre répertoire de sortie

Je suis en utilisant GCC de générer un fichier de dépendance, mais mon élaborer des règles de mettre la sortie dans un sous-répertoire. Est-il un moyen de demander à GCC de mettre mon préfixe de sous-répertoire dans le fichier de dépendance qu'il génère pour moi?

gcc $(INCLUDES) -E -MM $(CFLAGS) $(SRC) >>$(DEP)

InformationsquelleAutor KPexEA | 2008-09-18

c++dependencies gcc makefile

18

La réponse est dans la Manuel de GCC: utiliser le -MT drapeau.
-MT target

Changer la cible de la règle émise par la dépendance en génération. Par défaut RPC prend le nom de la principale entrée de fichier, supprime le répertoire de composants et de n'importe quel fichier de suffixe comme .c, et ajoute la plate-forme de l'objet usuel suffixe. Le résultat en est la cible.

Un -MT option vous permet de définir la cible à être exactement la chaîne de caractères que vous spécifiez. Si vous souhaitez avoir plusieurs cibles, vous pouvez spécifier qu'un seul argument à -MT, ou en utiliser plusieurs -MT options.

Par exemple, -MT '$(objpfx)foo.o' pourrait donner
```
$(objpfx)foo.o: foo.c
```
- -MT n'est pas disponible pour mon gcc 2.9.5, invité devrait être disponible 3.x.x au-dessus de
- n'était pas 2.9.5 a été publié >il y a 14 ans?
- Yup, j'ai constaté que lors de l'entretien de l'héritage de code de date de construction de plate-forme. 😐 Il est encore en utilisant 2.9.1.57 (c'était l'appel d'egcs au lieu de gcc) et la bonne chose est qu'il possède un minimum de dépendance avec 4 fichiers seulement et moins de 700 ko. 🙂 La mauvaise, c'est qu'il n'a pas de -MT de soutien. 🙁
InformationsquelleAutor bk1e
39

Je suis en supposant que vous êtes à l'aide de GNU Make et GCC. Tout d'abord ajouter une variable pour contenir la liste de vos fichiers de dépendance. En supposant que vous avez déjà un qui répertorie l'ensemble de nos sources:
```
SRCS = \
        main.c \
        foo.c \
        stuff/bar.c

DEPS = $(SRCS:.c=.d)
```
Alors inclure les dépendances générées dans le fichier makefile:
```
include $(DEPS)
```
Puis ajouter ce modèle à la règle:
```
# automatically generate dependency rules

%.d : %.c
        $(CC) $(CCFLAGS) -MF"$@" -MG -MM -MP -MT"$@" -MT"$(<:.c=.o)" "$<"

# -MF  write the generated dependency rule to a file
# -MG  assume missing headers will be generated and don't stop with an error
# -MM  generate dependency rule for prerequisite, skipping system headers
# -MP  add phony target for each header to prevent errors when header is missing
# -MT  add a target to the generated dependency
```
"$@" est la cible (le truc sur le côté gauche de l' : ), "$<" est la condition préalable (le truc sur le côté droit de l' : ). L'expression "$(<:.c=.o)" remplace le .c extension avec la .o.

L'astuce ici est de générer la règle avec deux objectifs par l'ajout d'-MT à deux reprises, ce qui en fait à la fois l' .o fichier et le .d fichier dépend de la source du fichier et de ses en-têtes, de cette façon, le fichier de dépendance est automatiquement régénéré à chaque fois que le correspondant .c ou .h fichiers sont modifiés.

La MG et MP options de garder de faire de paniquer si un en-tête de fichier est manquant.
- Pour moi, sur gcc 4.1.2, gmake 3.8.1, si un fichier d'en-tête n'existe pas de recette "$(CC) $(CCFLAGS) -MF"$@" -MG -MM -MP-MT"$@" -MT"$(<:.c=.o)" "$<"' les boucles infinies. // Suppression de l'-MP option s'arrête la boucle infinie.
InformationsquelleAutor Don McCaughey
10

Vous aimerez cette version plus courte de Ne McCaughey réponse:
```
SRCS = \
    main.c \
    foo.c \
    stuff/bar.c
```
DEPS = $(SRCS:.c=.d)

Ajouter -include $(DEPS) note le - préfixe, qui fait taire les erreurs si le .d fichiers n'existent pas encore.

Il n'y a pas besoin d'un autre modèle de règle pour générer les fichiers de dépendance. Ajoutez simplement -MD ou -MMD à la normale de votre ligne de la compilation, et le .d les fichiers sont générés dans le même temps, votre source, les fichiers sont compilés. Par exemple:
```
%.o: %.c
     gcc $(INCLUDE) -MMD -c $< -o $@

# -MD can be used to generate a dependency output file as a side-effect of the compilation process.
```
- Par la voie, assurez-vous d'éviter de placer les "inclure" au-dessus de votre première cible. Il est donc logique de le placer au bas du Makefile, parce que cela a toujours été le lieu traditionnel de mettre les dépendances, à l'époque où ils devaient être fabriquées à la main!
InformationsquelleAutor Steve Pitchers
3

De détails sur DGentry réponse, ce qui a bien fonctionné pour moi:
```
.depend: $(SOURCES)
    $(CC) $(CFLAGS) -MM $(SOURCES) | sed 's|[a-zA-Z0-9_-]*\.o|$(OBJDIR)/&|' > ./.depend
```
Cela fonctionne aussi dans le cas où il y a seulement un fichier de dépendance qui contient les règles de dépendances pour tous les fichiers source.

InformationsquelleAutor rsp1984
1

Ok, juste pour s'assurer que j'ai le droit de la question: je suis en supposant que vous avez test.c qui comprend test.h, et vous voulez générer subdir/test.d (alors que pas générer subdir/test.o) où subdir/test.d contient
```
subdir/test.o: test.c test.h
```
plutôt que
```
test.o: test.c test.h
```
qui est ce que vous obtenez dès maintenant. Est ce que le droit?

Je n'étais pas en mesure de venir avec un moyen facile de faire exactement ce que vous demandez. Cependant, en regardant La Dépendance De La Génération Des Améliorations, si vous souhaitez créer le .d fichier alors que vous générer l' .o fichier, vous pouvez utiliser:
```
gcc $(INCLUDES) -MMD $(CFLAGS) $(SRC) -o $(SUBDIR)/$(OBJ)
```
(Donnée SRC=test.c, SUBDIR=subdir, et OBJ=test.o.) Cela va créer deux subdir/test.o et subdir/test.d, où subdir/test.d contient la sortie désirée comme ci-dessus.

InformationsquelleAutor
0

Si il y a un argument de GCC pour ce faire, je ne sais pas ce que c'est. Nous finissons la tuyauterie de la dépendance de sortie à travers la sed à réécrire toutes les occurrences de <blah>.o comme ${OBJDIR}/<blah>.o.

InformationsquelleAutor DGentry
0
1. [GNU] s'obtient en colère si vous ne placez pas la sortie dans le répertoire courant. Vous devriez vraiment se faire à partir du répertoire de construction, et d'utiliser le VPATH rendre variable de trouver le code source. Si vous mentez à un compilateur, tôt ou tard, il va prendre sa revanche.
2. Si vous insistez sur la production de vos objets et dépendances dans un autre répertoire, vous devez utiliser le -o argument, comme répondu par Emile.
InformationsquelleAutor florin

Vous devez vous connecter pour publier un commentaire.