Problème

Je veux voir les dépendances pour une ou plusieurs cibles d'un makefile. Je recherche donc un programme qui peut analyser les makefiles et représenter ensuite les dépendances dans un format arborescent (indentation, ascii-art, ...) ou sous forme de graphique (point, ...).

Similaire

Il existe des programmes qui le font pour d'autres situations:

• pactree ou debtree peuvent afficher les dépendances des packages logiciels au format respectif dans une arborescence comme le format ascii ou sous forme de dotgraphique,
• gcc -M source_file.c affiche les dépendances du fichier source C en tant que règle de création,
• pstree affiche une représentation ascii de l'arbre de processus.

Le progrès

En cherchant sur le Web, j'ai trouvé peu d'aide . Cela m'a amené à essayer

make --always-make --silent --dry-run some_target | \
  grep --extended-regexp 'Considering target file|Trying rule prerequisite'

mais il semble que je doive pirater un peu plus de code d'analyse en perl ou en python afin de le représenter comme un joli arbre / graphique. Et je ne sais pas encore si je vais vraiment obtenir le graphique complet et correct de cette façon.

Exigences

Ce serait bien de limiter le graphique à certains égards (pas de règle intégrée, seulement une cible donnée, seulement une certaine profondeur) mais pour la plupart je cherche juste un outil qui me donnera les dépendances dans certains "raisonnables", humains -Format visible (comme le font les programmes sous "Similaire").

Des questions

• Y a-t-il des programmes qui peuvent le faire?
• Vais-je obtenir les informations complètes et correctes de make -dnq ...?
• Existe-t-il un meilleur moyen d'obtenir ces informations?
• Des scripts / tentatives d'analyse de ces informations existent-ils déjà?

Essayez makefile2graph du même auteur, il existe un outil similaire MakeGraphDependencies écrit à la javaplace de c.

make -Bnd | make2graph | dot -Tsvg -o out.svg

Utilisez ensuite un éditeur de graphiques vectoriels pour mettre en évidence les connexions dont vous avez besoin.

J'ai trouvé une sorte de hack pour produire au moins des informations clairement structurées sur quelle cible dépend de quelles conditions préalables. L'inconvénient est que c'est assez intrusif. En d'autres termes, vous devez modifier votre makefile pour encapsuler les recettes de construction de toutes vos cibles dans une petite fonction conditionnelle. Je posterai un bref exemple:

getRecipe = $(if $(DEPENDENCY_GRAPH),@echo Target $@ depends on prerequisites "$^",$(1))


VARIABLE_TARGET_NAME = foobar.txt

all : TopLevelTarget

TopLevelTarget : Target_A Target_D
    $(call getRecipe,\
        @echo Building target $@)

Target_A : Target_B
    $(call getRecipe,\
        @echo Building target $@)

Target_D : Target_C
    $(call getRecipe,\
        @echo Building target $@)

Target_B : $(VARIABLE_TARGET_NAME)
    $(call getRecipe,\
        @echo Building target $@)

Target_C :
    $(call getRecipe,\
        @echo Building target $@)

$(VARIABLE_TARGET_NAME) :
    $(call getRecipe,\
        @echo Building target $@)

Dans cet exemple, j'utilise la fonction getRecipe roulée à la main pour encapsuler la recette de chaque cible individuelle, puis décider s'il faut réellement exécuter cette recette ou simplement afficher la cible en cours de construction et les conditions préalables dont elle dépend. Cette dernière ne se produit que si la variable DEPENDENCY_GRAPHest définie (par exemple en tant que variable d'environnement). Dans l'exemple, la recette de construction n'est rien de plus qu'un écho disant que la cible est en cours de construction, mais vous pouvez évidemment la remplacer par une commande de votre choix.

Avec DEPENDENCY_GRAPH1, cela donne la sortie:

Target foobar.txt depends on prerequisites ""
Target Target_B depends on prerequisites "foobar.txt"
Target Target_A depends on prerequisites "Target_B"
Target Target_C depends on prerequisites ""
Target Target_D depends on prerequisites "Target_C"
Target TopLevelTarget depends on prerequisites "Target_A Target_D"

qui devrait être assez facile à analyser puis à convertir en un graphique à points.

Avec DEPENDENCY_GRAPHpas du tout défini ou réglé sur 0, la sortie est:

Building target foobar.txt
Building target Target_B
Building target Target_A
Building target Target_C
Building target Target_D
Building target TopLevelTarget

ou, en d'autres termes, la recette de construction normale est utilisée à la place. Je n'ai pas encore testé si cela fonctionne de manière fiable avec des recettes compliquées. Un problème que j'ai déjà rencontré est qu'il ne fonctionne pas du tout avec des recettes multi-lignes.

Par exemple, dans la recette de construction de la dernière cible, si en plus de dire que la cible est en cours de construction, je voulais en fait touchle fichier:

$(VARIABLE_TARGET_NAME) :
    $(call getRecipe,\
        @echo Building target $@\
        touch $@)

makesemble penser que la touch $@partie fait simplement partie de l'écho de la ligne précédente:

Building target foobar.txt touch foobar.txt

Si je laisse la barre oblique inverse à la ligne précédente, se makeplaint l' *** unterminated call to functionappel ': manquant )'. Stop.Si quelqu'un a une idée de comment makejouer gentiment, je suis à l'écoute. :)

EDIT: L'autre problème avec cette approche est que cela ne fonctionnera que si aucun résultat de build n'existe déjà, car makeévidemment n'exécute pas la recette de build d'une cible qu'il considère à jour.

J'ai utilisé remake --profile (un remplacement pour make), il a généré un arbre de dépendance au format callgrind.

alors gprof2dot peut générer une image de l'arborescence cible.