Comment générer un graphe appelant pour le code C ++

J'essaie de générer un graphe d'appel avec lequel découvrir tous les chemins d'exécution possibles qui frappent une fonction particulière (pour ne pas avoir à comprendre tous les chemins manuellement, car il existe de nombreux chemins qui mènent à cette fonction ). Par exemple:

path 1: A -> B -> C -> D  
path 2: A -> B -> X -> Y -> D  
path 3: A -> G -> M -> N -> O -> P -> S -> D  
...  
path n: ...

J'ai essayé Codeviz et Doxygen, d'une manière ou d'une autre, les deux résultats ne montrent rien d'autre que des noms de fonction cible, D. Dans mon cas, D est une fonction membre d'une classe dont l'objet sera enveloppé dans un pointeur intelligent. Les clients obtiendront toujours l'objet pointeur intelligent via une fabrique afin d'appeler D.

Est-ce que quelqu'un sait comment y parvenir?

static void D() { }
static void Y() { D(); }
static void X() { Y(); }
static void C() { D(); X(); }
static void B() { C(); }
static void S() { D(); }
static void P() { S(); }
static void O() { P(); }
static void N() { O(); }
static void M() { N(); }
static void G() { M(); }
static void A() { B(); G(); }

int main() {
  A();
}

ensuite

$ clang++ -S -emit-llvm main1.cpp -o - | opt -analyze -dot-callgraph
$ dot -Tpng -ocallgraph.png callgraph.dot

Donne une image brillante (il y a un "nœud externe", car il maina un lien externe et peut également être appelé de l'extérieur de cette unité de traduction):

Vous souhaiterez peut-être post-traiter cela avec c++filt, afin de pouvoir obtenir les noms non mélangés des fonctions et des classes impliquées. Comme dans ce qui suit

#include <vector>

struct A { 
  A(int);
  void f(); // not defined, prevents inlining it!
};

int main() {
  std::vector<A> v;
  v.push_back(42);
  v[0].f();
}

$ clang++ -S -emit-llvm main1.cpp -o - |
   opt -analyze -std-link-opts -dot-callgraph
$ cat callgraph.dot | 
   c++filt | 
   sed 's,>,\\>,g; s,-\\>,->,g; s,<,\\<,g' | 
   gawk '/external node/{id=$1} $1 != id' | 
   dot -Tpng -ocallgraph.png    

Donne cette beauté (oh mon Dieu, la taille sans optimisations activées était trop grande!)

Cette fonction mystique sans nom Node0x884c4e0, est un espace réservé supposé être appelé par toute fonction dont la définition n'est pas connue.

Vous pouvez y parvenir en utilisant doxygen (avec l'option d'utiliser le point pour la génération de graphiques).

Avec Johannes Schaub - litb main.cpp, il génère ceci:

doxygen / dot sont probablement plus faciles que clang / opt à installer et à exécuter. Je n'ai pas réussi à l'installer moi-même et c'est pourquoi j'ai essayé de trouver une solution alternative!

Le calcul statique d'un graphe d'appel C ++ précis est difficile, car vous avez besoin d'un analyseur de langage précis, d'une recherche de nom correcte et d'un bon analyseur de points à respecter qui honore correctement la sémantique du langage. Doxygen n'en a aucun, je ne sais pas pourquoi les gens prétendent l'aimer pour C ++; il est facile de construire un exemple C ++ de 10 lignes que Doxygen analyse par erreur).

Vous feriez peut-être mieux d'exécuter un profileur de synchronisation qui collecte un graphe d'appel de manière dynamique (cela décrit le nôtre) et d'exercer simplement de nombreux cas. Ces profileurs vous montreront le graphique d'appel réel exercé.

EDIT: Je me suis soudainement souvenu de Comprendre pour C ++ , qui prétend construire des graphes d'appels. Je ne sais pas ce qu'ils utilisent pour un analyseur, ou s'ils font correctement l'analyse détaillée; Je n'ai aucune expérience spécifique avec leur produit.

Je suis impressionné par la réponse de Schaub, utilisant Clang; Je m'attendrais à ce que Clang ait tous les éléments correctement.

Vous pouvez utiliser CppDepend , il peut générer de nombreux types de graphiques

• Graphique de dépendance
• Graphique d'appel
• Graphique d'héritage de classe
• Graphique de couplage
• Graphique de chemin
• Graphique de tous les chemins
• Graphique de cycle

Pour que la clang++commande trouve des fichiers d'en-tête standard comme mpi.hdeux options supplémentaires doivent être utilisées -### -fsyntax-only, c'est-à-dire que la commande complète doit ressembler à:

clang++ -### -fsyntax-only -S -emit-llvm main1.cpp -o - | opt -analyze -dot-callgraph

"C ++ Bsc Analyzer" peut afficher des graphiques d'appels - en lisant le fichier généré par l'utilitaire bscmake.

doxygen + graphviz pourrait résoudre la plupart des problèmes lorsque nous voulons générer un graphe d'appel, ensuite confié à la main-d'œuvre.

Scitools Understanding est un outil fantastique , meilleur que tout ce que je connais pour la rétro-ingénierie , et génère des graphiques de haute qualité .

Mais notez que c'est assez cher et que la version d'essai a son graphique d'appel papillon limité à un seul niveau d'appel (à mon humble avis, je crois qu'ils ne s'aident pas à le faire ...)