Verwenden Sie GCC, um eine lesbare Baugruppe zu erstellen?

Ich habe mich gefragt, wie man GCC benutzt in meiner C-Quelldatei verwenden soll, um eine mnemonische Version des Maschinencodes zu sichern, damit ich sehen kann, in was mein Code kompiliert wird. Sie können dies mit Java tun, aber ich konnte mit GCC keinen Weg finden.

Ich versuche, eine C-Methode in Assembly neu zu schreiben, und zu sehen, wie GCC dies tut, wäre eine große Hilfe.

Wenn Sie mit Debug-Symbolen kompilieren, können Sie objdumpeine besser lesbare Demontage erstellen.

>objdump --help
[...]
-S, --source             Intermix source code with disassembly
-l, --line-numbers       Include line numbers and filenames in output

objdump -drwC -Mintel ist nett:

• -rZeigt Symbolnamen bei Umzügen an (so wie putsin der folgenden callAnleitung dargestellt).
• -R zeigt dynamisch verknüpfte Verschiebungen / Symbolnamen (nützlich für gemeinsam genutzte Bibliotheken)
• -C entwirrt C ++ - Symbolnamen
• -w ist der "breite" Modus: Die Maschinencode-Bytes werden nicht in Zeilenumbruch gebracht
• -Mintel: Verwenden Sie GAS / binutils MASM-ähnliche .intel_syntax noprefixSyntax anstelle von AT & T.
• -S: Verschachteln Sie die Quellleitungen mit der Demontage.

Sie könnten so etwas alias disas="objdump -drwCS -Mintel"in Ihre setzen~/.bashrc

Beispiel:

> gcc -g -c test.c
> objdump -d -M intel -S test.o

test.o:     file format elf32-i386


Disassembly of section .text:

00000000 <main>:
#include <stdio.h>

int main(void)
{
   0:   55                      push   ebp
   1:   89 e5                   mov    ebp,esp
   3:   83 e4 f0                and    esp,0xfffffff0
   6:   83 ec 10                sub    esp,0x10
    puts("test");
   9:   c7 04 24 00 00 00 00    mov    DWORD PTR [esp],0x0
  10:   e8 fc ff ff ff          call   11 <main+0x11>

    return 0;
  15:   b8 00 00 00 00          mov    eax,0x0
}
  1a:   c9                      leave  
  1b:   c3                      ret

Wenn Sie GCC die Flagge geben -fverbose-asm, wird es

Fügen Sie zusätzliche Kommentarinformationen in den generierten Assemblycode ein, um ihn besser lesbar zu machen.

[...] Die hinzugefügten Kommentare umfassen:

• Informationen zur Compilerversion und zu den Befehlszeilenoptionen,
• die mit der Montageanleitung verknüpften Quellcodezeilen in der Form FILENAME: LINENUMBER: CONTENT OF LINE,
• Hinweise, welche übergeordneten Ausdrücke den verschiedenen Assembler-Anweisungsoperanden entsprechen.

Verwenden Sie den Schalter -S (Hinweis: Großbuchstabe S) zu GCC, und der Assemblycode wird an eine Datei mit der Erweiterung .s ausgegeben. Zum Beispiel der folgende Befehl:

gcc -O2 -S foo.c

belässt den generierten Assemblycode in der Datei foo.s.

Direkt von http://www.delorie.com/djgpp/v2faq/faq8_20.html gerippt (aber fehlerhaft entfernt -c)

Die Verwendung des -SWechsels zu GCC auf x86-basierten Systemen erzeugt standardmäßig einen Speicherauszug der AT & T-Syntax, der mit dem -masm=attSchalter wie folgt angegeben werden kann:

gcc -S -masm=att code.c

Wenn Sie dagegen einen Speicherauszug in Intel-Syntax erstellen möchten, können Sie den -masm=intelSchalter folgendermaßen verwenden:

gcc -S -masm=intel code.c

(Beide erzeugen Dumps von code.cin ihre verschiedenen Syntax, jeweils in die Datei code.s)

Um ähnliche Effekte mit objdump zu erzielen, sollten Sie den Schalter --disassembler-options= intel/ attswitch verwenden, ein Beispiel (mit Code-Dumps, um die Unterschiede in der Syntax zu veranschaulichen):

 $ objdump -d --disassembler-options=att code.c

 080483c4 <main>:
 80483c4:   8d 4c 24 04             lea    0x4(%esp),%ecx
 80483c8:   83 e4 f0                and    $0xfffffff0,%esp
 80483cb:   ff 71 fc                pushl  -0x4(%ecx)
 80483ce:   55                      push   %ebp
 80483cf:   89 e5                   mov    %esp,%ebp
 80483d1:   51                      push   %ecx
 80483d2:   83 ec 04                sub    $0x4,%esp
 80483d5:   c7 04 24 b0 84 04 08    movl   $0x80484b0,(%esp)
 80483dc:   e8 13 ff ff ff          call   80482f4 <puts@plt>
 80483e1:   b8 00 00 00 00          mov    $0x0,%eax
 80483e6:   83 c4 04                add    $0x4,%esp 
 80483e9:   59                      pop    %ecx
 80483ea:   5d                      pop    %ebp
 80483eb:   8d 61 fc                lea    -0x4(%ecx),%esp
 80483ee:   c3                      ret
 80483ef:   90                      nop

und

$ objdump -d --disassembler-options=intel code.c

 080483c4 <main>:
 80483c4:   8d 4c 24 04             lea    ecx,[esp+0x4]
 80483c8:   83 e4 f0                and    esp,0xfffffff0
 80483cb:   ff 71 fc                push   DWORD PTR [ecx-0x4]
 80483ce:   55                      push   ebp
 80483cf:   89 e5                   mov    ebp,esp
 80483d1:   51                      push   ecx
 80483d2:   83 ec 04                sub    esp,0x4
 80483d5:   c7 04 24 b0 84 04 08    mov    DWORD PTR [esp],0x80484b0
 80483dc:   e8 13 ff ff ff          call   80482f4 <puts@plt>
 80483e1:   b8 00 00 00 00          mov    eax,0x0
 80483e6:   83 c4 04                add    esp,0x4
 80483e9:   59                      pop    ecx
 80483ea:   5d                      pop    ebp
 80483eb:   8d 61 fc                lea    esp,[ecx-0x4]
 80483ee:   c3                      ret    
 80483ef:   90                      nop

godbolt ist ein sehr nützliches Tool. Die Liste enthält nur C ++ - Compiler. Sie können jedoch das -x cFlag verwenden, um den Code als C zu behandeln. Anschließend wird nebeneinander eine Assembly-Liste für Ihren Code erstellt, und Sie können die ColouriseOption zum Generieren verwenden Farbige Balken zeigen visuell an, welcher Quellcode der generierten Assembly zugeordnet ist. Zum Beispiel der folgende Code:

#include <stdio.h>

void func()
{
  printf( "hello world\n" ) ;
}

Verwenden Sie die folgende Befehlszeile:

-x c -std=c99 -O3

und Colourisewürde Folgendes erzeugen:

Haben Sie gcc -S -fverbose-asm -O source.cdann versucht , in die generierte source.sAssembler-Datei zu schauen ?

Der generierte Assembler-Code geht in source.s(Sie können diesen mit -o Assembler-Dateinamen überschreiben ); Die -fverbose-asmOption fordert den Compiler auf, einige Assembler-Kommentare auszugeben, die den generierten Assembler-Code "erklären". Die -OOption fordert den Compiler auf, ein wenig zu optimieren (es könnte mit -O2oder mehr optimieren -O3).

Wenn Sie verstehen möchten, was gccpassiert -fdump-tree-all, versuchen Sie es, aber seien Sie vorsichtig: Sie erhalten Hunderte von Dump-Dateien.

Übrigens ist GCC durch Plugins oder mit MELT (einer domänenspezifischen Hochsprache zur Erweiterung von GCC, die ich 2017 aufgegeben habe) erweiterbar.

Sie können dafür gdb wie objdump verwenden.

Dieser Auszug stammt aus http://sources.redhat.com/gdb/current/onlinedocs/gdb_9.html#SEC64

Hier ist ein Beispiel für eine gemischte Quelle + Assembly für Intel x86:

  (gdb) disas / m main
Speicherauszug des Assembler-Codes für die Funktion main:
5 {
0x08048330:% ebp drücken
0x08048331: mov% esp,% ebp
0x08048333: sub $ 0x8,% esp
0x08048336: und $ 0xfffffff0,% esp
0x08048339: sub $ 0x10,% esp

6 printf ("Hallo. \ N");
0x0804833c: movl $ 0x8048440, (% esp)
0x08048343: Rufen Sie 0x8048284 an 

7 return 0;
8}
0x08048348: mov $ 0x0,% eax
0x0804834d: verlassen
0x0804834e: ret

Ende des Assembler-Dumps.

Verwenden Sie den Schalter -S (Hinweis: Großbuchstabe S) zu GCC, und der Assemblycode wird an eine Datei mit der Erweiterung .s ausgegeben. Zum Beispiel der folgende Befehl:

gcc -O2 -S -c foo.c

Ich habe gcc keinen Versuch gegeben, aber im Fall von g ++. Der folgende Befehl funktioniert für mich. -g für Debug-Build und -Wa, -adhln wird an Assembler zur Auflistung mit Quellcode übergeben

g ++ -g -Wa, -adhln src.cpp

Verwenden Sie -Wa, -adhln als Option für gcc oder g ++, um eine Listenausgabe an stdout zu erstellen.

-Wa, ... steht für Befehlszeilenoptionen für den Assembler-Teil (nach der C / ++ - Kompilierung in gcc / g ++ ausführen). Es wird als intern aufgerufen (as.exe in Windows). Sehen

> als --help

als Befehlszeile, um weitere Hilfe für das Assembler-Tool in gcc anzuzeigen