Come generare un grafico di chiamata per il codice C ++

Sto cercando di generare un grafico di chiamata con il quale scoprire tutti i possibili percorsi di esecuzione che stanno colpendo una particolare funzione (in modo da non dover calcolare manualmente tutti i percorsi, poiché ci sono molti percorsi che portano a questa funzione ). Per esempio:

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: ...

Ho provato Codeviz e Doxygen, in qualche modo entrambi i risultati non mostrano altro che chiamate della funzione di destinazione, D. Nel mio caso, D è una funzione membro di una classe il cui oggetto sarà racchiuso in un puntatore intelligente. I client otterranno sempre l'oggetto puntatore intelligente tramite una factory per richiamare D.

Qualcuno sa come ottenere questo risultato?

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();
}

Poi

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

Restituisce un'immagine brillante (c'è un "nodo esterno", perché mainha un collegamento esterno e potrebbe essere chiamato anche dall'esterno dell'unità di traduzione):

Potresti voler postelaborare questo con c++filt, in modo da poter ottenere i nomi non confusi delle funzioni e delle classi coinvolte. Come nel seguito

#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    

Resa questa bellezza (oh mio, la dimensione senza ottimizzazioni attivate era troppo grande!)

Quella funzione mistica senza nome,, Node0x884c4e0è un segnaposto che si presume venga chiamato da qualsiasi funzione la cui definizione non è nota.

Puoi ottenerlo usando doxygen (con l'opzione di usare il punto per la generazione di grafici).

Con Johannes Schaub - litb main.cpp, genera questo:

doxygen / dot sono probabilmente più facili da installare ed eseguire rispetto a clang / opt. Non sono riuscito a installarlo da solo ed è per questo che ho provato a trovare una soluzione alternativa!

Calcolare staticamente un grafico delle chiamate C ++ accurato è difficile, perché è necessario un parser di linguaggio preciso, una ricerca del nome corretta e un buon analizzatore di punti che onori adeguatamente la semantica del linguaggio. Doxygen non ha nessuno di questi, non so perché la gente afferma di apprezzarlo per C ++; è facile costruire un esempio C ++ di 10 righe che Doxygen analizza erroneamente).

Potrebbe essere meglio eseguire un profiler di temporizzazione che raccoglie dinamicamente un grafico di chiamata (questo descrive il nostro) ed esercita semplicemente un sacco di casi. Tali profiler ti mostreranno il grafico delle chiamate effettive esercitato.

EDIT: improvvisamente mi sono ricordato di Understand per C ++ , che afferma di costruire grafici di chiamata. Non so cosa usano per un parser o se eseguono correttamente l'analisi dettagliata; Non ho esperienza specifica con il loro prodotto.

Sono impressionato dalla risposta di Schaub, usando Clang; Mi aspetto che Clang abbia tutti gli elementi giusti.

Puoi usare CppDepend , può generare molti tipi di grafici

• Grafico delle dipendenze
• Chiama grafico
• Grafico dell'ereditarietà delle classi
• Grafico di accoppiamento
• Grafico del percorso
• Grafico di tutti i percorsi
• Grafico del ciclo

Affinché il clang++comando trovi i file di intestazione standard mpi.h, è necessario utilizzare due opzioni aggiuntive -### -fsyntax-only, ovvero il comando completo dovrebbe avere il seguente aspetto:

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

L '"C ++ Bsc Analyzer" può visualizzare i grafici delle chiamate - leggendo il file generato dall'utilità bscmake.

doxygen + graphviz potrebbe risolvere la maggior parte dei problemi quando vogliamo generare il grafico delle chiamate, il prossimo passo alla manodopera.

Scitools Understand è uno strumento fantastico , migliore di tutto ciò che so per il reverse engineering e genera grafici di alta qualità .

Ma nota che è piuttosto costoso e che la versione di prova ha il suo grafico a farfalla limitato a un solo livello di chiamata (IMHO credo che non si aiutino a farlo ...)