Erste Control-Flow-Graph von ANSI-C-code

Für den control-flow-graph eines C-Programms kann man sich an den bestehenden Python-Parser für C:

• PyCParser
• pycparser
• pyclibrary (Gabel pyclibrary )
• joern
• CoFlo C/C++ - control-flow-graph-generator und analyzer

Call Graphen sind eng verknüpft mit dem Konstrukt kontrollflußgraphen.
Es gibt mehrere Ansätze zur Verfügung, erstellen call-Graphen (Funktion Abhängigkeiten) für C-code.
Dies könnte sich als Hilfe für fortgeschrittene mit control flow graph generation.
Möglichkeiten zum erstellen von dependency Graphen in C:

• Mit cflow:

  • cflow +pycflow2dot +dot (GPL, BSD) cflow ist robust, denn es kann mit code, der nicht kompiliert, z.B. fehlende enthält. Wenn Präprozessor-Direktiven sind so stark genutzt wird, müssen Sie möglicherweise die --cpp option Vorverarbeitung der code.
  • cflow + cflow2dot + dot (GPL v2, GPL, Version 3, Eclipse Public License (EPL) v1) (beachten Sie, dass cflow2dot braucht einige Weg die Befestigung, bevor es funktioniert)
  • cflow +cflow2dot.bash (GPL v2, ?)
  • cflow +cflow2vcg (GPL v2 , GPL v2)
  • verbesserte cflow (GPL v2) mit Liste ausschließen Symbole Graphen

• Mit cscope:

  • cscope (BSD)
  • cscope +callgraphviz +dot +xdot
  • cscope +vim CCTree (C Call-Tree-Explorer)
  • cscope +ccglue
  • cscope +CodeQuery für C, C++, Python & Java
  • cscope +Python-html-Produzent
  • cscope +calltree.sh

• ncc (wie cflow)

• KCachegrind (KDE dependency viewer)
• Calltree

Den folgenden tools leider verlangen Sie, dass der code kompilierbar sein, da es davon abhängt Ausgabe von gcc:

• CodeViz (GPL v2) (Schwachpunkt: muss kompilierbar Quelle, denn es verwendet gcc-dump cdepn Dateien)
• gcc +ägypten +dot (GPL v*, Perl = GPL | Artistic license, EPL v1) (egypt verwendet gcc zu produzieren RTL, so fällt für alle buggy-source-code, oder sogar, wenn Sie nur wollen, um den Fokus auf eine einzelne Datei aus einem größeren Projekt. Daher ist es nicht sehr nützlich, im Vergleich zu den robusteren cflow-basierten Werkzeugketten. Beachten Sie, dass ägypten hat standardmäßig eine gute Unterstützung für den Ausschluss der Bibliothek Anrufe aus dem Diagramm, um es sauberer.

Auch, Datei-dependency-Graphen für C/C++ erstellt werden können, mit crowfood.

Dynamische Analyse-Methoden

In dieser Antwort, die ich beschreiben, ein paar dynamische Analyse-Methoden.

Dynamische Methoden wirklich das Programm ausführen, um zu bestimmen, die call-graph.

Das Gegenteil von dem, dynamische Methoden statische Methoden, die versuchen zu bestimmen, es von der Quelle allein, ohne das Programm läuft.

Vorteile der dynamischen Methoden:

• Fänge Funktion Zeiger und virtuelle C++ - Aufrufe. Diese sind in großer Zahl vorhanden in jeder nicht-trivialen software.

Nachteile der dynamischen Methoden:

• Sie haben, um das Programm auszuführen, die möglicherweise zu langsam sein, oder Sie benötigen ein setup, dass Sie nicht haben, z.B. die cross-Kompilierung
• nur Funktionen die tatsächlich aufgerufen werden, wird sich zeigen. E. g., einige Funktionen können aufgerufen werden oder nicht, abhängig von der Befehl Linie Argumente.

KcacheGrind

https://kcachegrind.github.io/html/Home.html

Test-Programm:

int f2(int i) { return i + 2; }
int f1(int i) { return f2(2) + i + 1; }
int f0(int i) { return f1(1) + f2(2); }
int pointed(int i) { return i; }
int not_called(int i) { return 0; }

int main(int argc, char **argv) {
    int (*f)(int);
    f0(1);
    f1(1);
    f = pointed;
    if (argc == 1)
        f(1);
    if (argc == 2)
        not_called(1);
    return 0;
}

Verwendung:

sudo apt-get install -y kcachegrind valgrind

# Compile the program as usual, no special flags.
gcc -ggdb3 -O0 -o main -std=c99 main.c

# Generate a callgrind.out.<PID> file.
valgrind --tool=callgrind ./main

# Open a GUI tool to visualize callgrind data.
kcachegrind callgrind.out.1234

Sind Sie nun mit der linken Innenseite eine tolle GUI-Programm, das enthält eine Vielzahl von interessanten Leistungsdaten.

Rechts unten, wählen Sie die "Call graph" - tab. Dies zeigt eine interaktive call-graph bezieht sich auf performance-Metriken in anderen Fenstern, wie Sie auf die Funktionen.

Um die Grafik zu exportieren, klicken Sie rechts und wählen Sie "Export Graph". Die exportierte PNG sieht wie folgt aus:

Aus, dass wir sehen können, dass:

• der root-Knoten ist _start, ist die tatsächliche ELF Einstiegspunkt, und enthält glibc Initialisierung boilerplate
• f0, f1 und f2 sind aufgerufen, wie erwartet von einem anderen
• pointed wird auch gezeigt, obwohl wir nannten es eine Funktion, mit pointer. Es könnte nicht aufgerufen, wenn passierten wir ein command line argument.
• not_called ist nicht dargestellt, da es nicht aufgerufen werden, in der Flucht, weil wir nicht bestanden hat, eine zusätzliche command-line-argument.

Die kühle Sache über valgrind ist, dass es erfordert keine speziellen Kompilations-Optionen.

Daher, Sie können es verwenden, auch wenn Sie nicht den Quellcode zu haben, nur die ausführbare Datei.

valgrind schafft dies, indem Sie mit dem code durch ein leichtes "virtuelle Maschine".

Getestet auf Ubuntu 18.04.

gcc -finstrument-functions + etrace

https://github.com/elcritch/etrace

-finstrument-functions fügt Rückrufe, etrace analysiert die ELF-Datei und implementiert alle Rückrufe.

Konnte ich nicht, es funktioniert aber leider nicht: Warum nicht `-finstrument-Funktionen` für mich arbeiten?

Behauptete Ausgabe von format:

\-- main
|   \-- Crumble_make_apple_crumble
|   |   \-- Crumble_buy_stuff
|   |   |   \-- Crumble_buy
|   |   |   \-- Crumble_buy
|   |   |   \-- Crumble_buy
|   |   |   \-- Crumble_buy
|   |   |   \-- Crumble_buy
|   |   \-- Crumble_prepare_apples
|   |   |   \-- Crumble_skin_and_dice
|   |   \-- Crumble_mix
|   |   \-- Crumble_finalize
|   |   |   \-- Crumble_put
|   |   |   \-- Crumble_put
|   |   \-- Crumble_cook
|   |   |   \-- Crumble_put
|   |   |   \-- Crumble_bake

Wahrscheinlich die effizienteste Methode, neben speziellen hardware-tracing-Unterstützung, hat aber den Nachteil, dass Sie den code neu kompilieren.