Seltene, aber nützliche GCC-Befehlszeilenoptionen

Software-Tools bieten in der Regel mehrere Funktionen, aber – wie die meisten von Ihnen zustimmen werden – nicht alle ihre Funktionen werden von jedem genutzt. Im Allgemeinen ist das kein Problem, da jeder Benutzer seine eigenen Anforderungen hat und die Werkzeuge nur in diesem Bereich verwendet werden. Es ist jedoch immer gut, die Tools, die Sie verwenden, weiter zu erforschen, da Sie nie wissen, wann eine ihrer Funktionen nützlich sein könnte, was Ihnen etwas von Ihrer kostbaren Zeit im Prozess spart.

Beispiel: Compiler. Ein guter Compiler für Programmiersprachen bietet immer eine Fülle von Optionen, aber Benutzer kennen und verwenden im Allgemeinen nur ein begrenztes Set. Insbesondere, wenn Sie C-Sprachenentwickler sind und Linux als Entwicklungsplattform verwenden, ist es sehr wahrscheinlich, dass Sie den gcc-Compiler verwenden, der eine endlose Liste von Befehlszeilenoptionen bietet.

Weißt du, dass du, wenn du willst, gcc bitten kannst, die Ausgabe in jeder Phase des Kompilierungsprozesses zu speichern? Kennen Sie die Option -Wall, die Sie zum Erzeugen von Warnungen verwenden, die einige bestimmte Warnungen nicht abdeckt? Es gibt viele Kommandozeilen-Gcc-Optionen, die nicht häufig verwendet werden, aber in bestimmten Szenarien sehr nützlich sein können, z.B. beim Debuggen des Codes.

In diesem Artikel werden wir daher einige dieser Optionen behandeln, alle erforderlichen Details anbieten und sie durch leicht verständliche Beispiele erklären, wo immer dies erforderlich ist.

Aber bevor wir vorankommen, denken Sie bitte daran, dass alle in diesem Tutorial genannten Beispiele, Befehle und Anweisungen auf Ubuntu 16.04 LTS getestet wurden und die von uns verwendete gcc-Version 5.4.0 ist.

Siehe Zwischenausgabe während jeder Kompilierungsphase.

Wusstest du, dass es im Großen und Ganzen insgesamt vier Phasen gibt, die dein C-Code durchläuft, wenn du ihn mit dem gcc-Compiler kompilierst? Dies sind Vorverarbeitung, Kompilierung, Montage und Verknüpfung. Nach jeder Stufe erstellt gcc eine temporäre Ausgabedatei, die an die nächste Stufe übergeben wird. Nun, das sind alles temporäre Dateien, die produziert werden, und deshalb bekommen wir sie nicht zu sehen – alles, was wir sehen, ist, dass wir den Kompilierungsbefehl ausgegeben haben und es produziert die Binärdatei, die wir ausführen können.

Aber nehmen wir an, wenn beim Debuggen eine Anforderung besteht, um zu sehen, wie der Code aussah, z.B. in der Vorverarbeitungsphase. Was würdest du dann tun? Nun, das Gute ist, dass der gcc-Compiler eine Befehlszeilenoption anbietet, die Sie in Ihrem Standard-Kompilierungsbefehl verwenden können, und Sie erhalten diese Zwischendateien, die andernfalls vom Compiler gelöscht werden. Die Option, über die wir hier sprechen, ist -save-temps.

Hier ist, was die gcc-Manualseite über diese Option sagt:

           Store the usual "temporary" intermediate files permanently; place
           them in the current directory and name them based on the source
           file.  Thus, compiling foo.c with -c -save-temps produces files
           foo.i and foo.s, as well as foo.o.  This creates a preprocessed
           foo.i output file even though the compiler now normally uses an
           integrated preprocessor.

When used in combination with the -x command-line option,
-save-temps is sensible enough to avoid over writing an input
source file with the same extension as an intermediate file.  The
corresponding intermediate file may be obtained by renaming the
source file before using -save-temps.

Im Folgenden finden Sie ein Beispiel für einen Befehl, der Ihnen eine Vorstellung davon vermittelt, wie Sie diese Option verwenden können:

gcc -Wall -save-temps test.c -o test-exec

Und so habe ich überprüft, ob alle Zwischendateien tatsächlich erzeugt wurden, nachdem der oben genannte Befehl ausgeführt wurde:

Wie Sie also im obigen Screenshot sehen können, wurden die Dateien test.i, test.s und test.o mit der Option -save-temps erzeugt. Diese Dateien entsprechen den Vorverarbeitungs-, Kompilierungs- bzw. Verknüpfungsschritten.

Machen Sie Ihr Code Debugging und Profiling bereit.

Es gibt spezielle Tools, mit denen Sie Ihren Quellcode debuggen und profilieren können. Beispielsweise wird gdb für Debuggingzwecke verwendet, während gprof ein beliebtes Werkzeug für Profilingzwecke ist. Aber weißt du, dass es spezifische Befehlszeilenoptionen gibt, die gcc anbietet, um dein Code Debugging und Profiling vorzubereiten?

Beginnen wir mit dem Debugging. Um gdb für das Code-Debugging verwenden zu können, müssen Sie Ihren Code mit der Option -g der Kommandozeile des gcc-Compilers kompilieren. Diese Option ermöglicht es gcc grundsätzlich, Debugging-Informationen zu erzeugen, die der gdb benötigt, um Ihr Programm erfolgreich zu debuggen.

Falls du vorhast, diese Option zu nutzen, solltest du die Details durchgehen, die die gcc-Manualseite zu dieser Option bietet – einige davon können sich in einigen Fällen als wichtig erweisen. Im Folgenden finden Sie beispielsweise einen Auszug aus der Manpage:

           GCC allows you to use -g with -O.  The shortcuts taken by optimized
           code may occasionally produce surprising results: some variables
           you declared may not exist at all; flow of control may briefly move
           where you did not expect it; some statements may not be executed
           because they compute constant results or their values are already
           at hand; some statements may execute in different places because
           they have been moved out of loops.

Nevertheless it proves possible to debug optimized output.  This
makes it reasonable to use the optimizer for programs that might
have bugs.

Die Kompilierung Ihres Codes mit der Option -g eröffnet nicht nur gdb, sondern auch die Möglichkeit, das memcheck-Tool von Valgrind vollständig zu nutzen. Für diejenigen, die es nicht wissen, wird memcheck von Programmierern verwendet, um nach Speicherlecks (falls vorhanden) in ihrem Code zu suchen. Mehr über dieses Tool erfahren Sie hier.

Um gprof für die Codeprofilierung verwenden zu können, müssen Sie Ihren Code mit der Kommandozeilenoption -pg kompilieren. Es erlaubt gcc, zusätzlichen Code zu generieren, um Profilinformationen zu schreiben, die von gprof für die Codeanalyse benötigt werden. „Du musst diese Option verwenden, wenn du die Quelldateien kompilierst, über die du Daten willst, und du musst sie auch beim Verlinken verwenden“, sagt die gcc-Manualseite. Um mehr darüber zu erfahren, wie Sie Codeprofiling mit gprof durchführen können, besuchen Sie dieses spezielle Tutorial auf unserer Website.

Hinweis: Die Verwendung der Optionen -g und -pg ist ähnlich wie die Verwendung der Option -save-temps im vorherigen Abschnitt.

Fazit

Es sei denn, du bist ein Gcc-Profi, ich bin sicher, du hast mit diesem Artikel etwas Neues gelernt. Probieren Sie diese Optionen aus und sehen Sie, wie sie funktionieren. In der Zwischenzeit warten Sie auf den nächsten Teil dieser Tutorial-Serie, in dem wir weitere so interessante und nützliche gcc-Befehlszeilenoptionen diskutieren werden.