Utiliser GCC pour produire un assemblage lisible?

Je me demandais comment utiliser GCC sur mon fichier source C pour vider une version mnémonique du code machine afin que je puisse voir dans quoi mon code était compilé. Vous pouvez le faire avec Java mais je n'ai pas réussi à trouver un moyen avec GCC.

J'essaie de réécrire une méthode C dans l'assemblage et voir comment GCC le fait serait d'une grande aide.

Si vous compilez avec des symboles de débogage, vous pouvez utiliser objdumppour produire un désassemblage plus lisible.

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

objdump -drwC -Mintel est sympa:

• -raffiche les noms des symboles lors des délocalisations (comme vous pouvez le voir putsdans les callinstructions ci-dessous)
• -R affiche les relocalisations de liens dynamiques / noms de symboles (utile sur les bibliothèques partagées)
• -C démêle les noms des symboles C ++
• -w est un mode "large": il n'encapsule pas les octets de code machine
• -Mintel: utilisez GAS / binutils comme une .intel_syntax noprefixsyntaxe MASM au lieu d'AT & T
• -S: entrelacer les lignes source avec démontage.

Vous pourriez mettre quelque chose comme alias disas="objdump -drwCS -Mintel"dans votre~/.bashrc

Exemple:

> 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

Si vous donnez le drapeau à GCC-fverbose-asm , il

Mettez des informations supplémentaires dans le code d'assembly généré pour le rendre plus lisible.

[...] Les commentaires ajoutés comprennent:

• des informations sur la version du compilateur et les options de ligne de commande,
• les lignes de code source associées aux instructions d'assemblage, sous la forme FILENAME: LINENUMBER: CONTENT OF LINE,
• des conseils sur les expressions de haut niveau qui correspondent aux différents opérandes d'instructions d'assemblage.

Utilisez le commutateur -S (note: S majuscule) vers GCC, et il émettra le code assembleur dans un fichier avec une extension .s. Par exemple, la commande suivante:

gcc -O2 -S foo.c

laissera le code assembleur généré dans le fichier foo.s.

Extrait directement de http://www.delorie.com/djgpp/v2faq/faq8_20.html (mais en supprimant les erreurs -c)

L'utilisation du -Scommutateur vers GCC sur les systèmes x86 produit un vidage de la syntaxe AT&T, par défaut, qui peut être spécifié avec le -masm=attcommutateur, comme ceci:

gcc -S -masm=att code.c

Alors que si vous souhaitez produire un vidage dans la syntaxe Intel, vous pouvez utiliser le -masm=intelcommutateur, comme ceci:

gcc -S -masm=intel code.c

(Les deux produisent des vidages de code.cdans leurs différentes syntaxes, code.srespectivement dans le fichier )

Afin de produire des effets similaires avec objdump, vous voudriez utiliser le commutateur --disassembler-options= intel/ att, un exemple (avec des vidages de code pour illustrer les différences de syntaxe):

 $ 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

et

$ 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 est un outil très utile, ils ne contiennent que des compilateurs C ++ mais vous pouvez utiliser -x cflag pour le faire traiter le code comme C. Il générera ensuite une liste d'assembly pour votre code côte à côte et vous pouvez utiliser l' Colouriseoption pour générer des barres colorées pour indiquer visuellement quel code source correspond à l'assembly généré. Par exemple le code suivant:

#include <stdio.h>

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

en utilisant la ligne de commande suivante:

-x c -std=c99 -O3

et Colourisegénérerait ce qui suit:

Avez-vous essayé de gcc -S -fverbose-asm -O source.cregarder le source.sfichier assembleur généré ?

Le code assembleur généré va dans source.s(vous pouvez remplacer cela avec -o assembler-filename ); l' -fverbose-asmoption demande au compilateur d'émettre des commentaires d'assembleur "expliquant" le code assembleur généré. L' -Ooption demande au compilateur d'optimiser un peu (il pourrait optimiser davantage avec -O2ou -O3).

Si vous voulez comprendre ce qui gccse passe, essayez de passer -fdump-tree-allmais soyez prudent: vous obtiendrez des centaines de fichiers de vidage.

BTW, GCC est extensible via des plugins ou avec MELT (un langage spécifique de domaine de haut niveau pour étendre GCC; que j'ai abandonné en 2017)

Vous pouvez utiliser gdb pour cela comme objdump.

Cet extrait est tiré de http://sources.redhat.com/gdb/current/onlinedocs/gdb_9.html#SEC64

Voici un exemple montrant un assemblage source + mixte pour Intel x86:

  (gdb) disas / m principal
Dump du code assembleur pour la fonction main:
5 {
0x08048330: pousser% ebp
0x08048331: mov% esp,% ebp
0x08048333: sous $ 0x8,% esp
0x08048336: et $ 0xfffffff0,% esp
0x08048339: sous $ 0x10,% esp

6 printf ("Bonjour. \ N");
0x0804833c: movl $ 0x8048440, (% esp)
0x08048343: appelez 0x8048284 

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

Fin du vidage de l'assembleur.

Utilisez le commutateur -S (note: S majuscule) vers GCC, et il émettra le code assembleur dans un fichier avec une extension .s. Par exemple, la commande suivante:

gcc -O2 -S -c foo.c

Je n'ai pas donné de chance à gcc, mais dans le cas de g ++. La commande ci-dessous fonctionne pour moi. -g pour la version de débogage et -Wa, -adhln est passé à l'assembleur pour être répertorié avec le code source

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

utilisez -Wa, -adhln comme option sur gcc ou g ++ pour produire une sortie de listage vers stdout.

-Wa, ... est pour les options de ligne de commande pour la partie assembleur (exécuter dans gcc / g ++ après la compilation C / ++). Il appelle en interne (as.exe dans Windows). Voir

> comme --help

comme ligne de commande pour voir plus d'aide pour l'outil d'assemblage dans gcc