¿Usando GCC para producir un ensamblaje legible?

Me preguntaba cómo usar GCC en mi archivo fuente C para volcar una versión mnemónica del código de máquina para poder ver en qué se estaba compilando mi código. Puede hacer esto con Java, pero no he podido encontrar una manera con GCC.

Estoy tratando de reescribir un método C en ensamblador y ver cómo funciona GCC sería de gran ayuda.

Si compila con símbolos de depuración, puede usar objdumppara producir un desmontaje más legible.

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

objdump -drwC -Mintel es bueno:

• -rmuestra los nombres de los símbolos en las reubicaciones (por lo que vería putsen las callinstrucciones a continuación)
• -R muestra reubicaciones de enlace dinámico / nombres de símbolos (útil en bibliotecas compartidas)
• -C demanda los nombres de símbolos de C ++
• -w es el modo "ancho": no ajusta en línea los bytes del código de máquina
• -Mintel: use la .intel_syntax noprefixsintaxis similar a MASM de GAS / binutils en lugar de AT&T
• -S: intercalar líneas de origen con desmontaje.

Podrías poner algo como alias disas="objdump -drwCS -Mintel"en tu~/.bashrc

Ejemplo:

> 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 le das la bandera a GCC-fverbose-asm , será

Ponga información adicional de comentarios en el código de ensamblado generado para que sea más legible.

[...] Los comentarios agregados incluyen:

• información sobre la versión del compilador y las opciones de línea de comandos,
• las líneas del código fuente asociadas con las instrucciones de ensamblaje, en el formato FILENAME: LINENUMBER: CONTENT OF LINE,
• insinúa en qué expresiones de alto nivel corresponden a los diversos operandos de instrucciones de ensamblaje.

Use el interruptor -S (nota: S mayúscula) a GCC, y emitirá el código de ensamblaje a un archivo con una extensión .s. Por ejemplo, el siguiente comando:

gcc -O2 -S foo.c

dejará el código de ensamblaje generado en el archivo foo.s.

Extraído directamente de http://www.delorie.com/djgpp/v2faq/faq8_20.html (pero eliminando erróneamente -c)

El uso del -Scambio a GCC en sistemas basados ​​en x86 produce un volcado de sintaxis de AT&T, por defecto, que se puede especificar con el -masm=attcambio, de la siguiente manera:

gcc -S -masm=att code.c

Mientras que si desea generar un volcado en la sintaxis de Intel, puede usar el -masm=intelconmutador de esta manera:

gcc -S -masm=intel code.c

(Ambos producen volcados de code.csus diversas sintaxis, en el archivo code.srespectivamente)

Para producir efectos similares con objdump, querrás usar el modificador --disassembler-options= intel/ att, un ejemplo (con volcados de código para ilustrar las diferencias en la sintaxis):

 $ 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

y

$ 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 es una herramienta muy útil, la lista solo tiene compiladores de C ++, pero puede usar -x cflag para que trate el código como C. Luego generará una lista de ensamblaje para su código de lado a lado y puede usar la Colouriseopción para generar barras de colores para indicar visualmente qué código fuente se asigna al ensamblaje generado. Por ejemplo el siguiente código:

#include <stdio.h>

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

usando la siguiente línea de comando:

-x c -std=c99 -O3

y Colourise generaría lo siguiente:

¿Intentó gcc -S -fverbose-asm -O source.cluego buscar en el source.sarchivo ensamblador generado ?

El código de ensamblador generado entra source.s(puede anularlo con -o assembler-filename ); la -fverbose-asmopción le pide al compilador que emita algunos comentarios del ensamblador "explicando" el código del ensamblador generado. La -Oopción le pide al compilador que optimice un poco (podría optimizar más con -O2o -O3).

Si desea comprender lo que gccestá haciendo, intente pasar, -fdump-tree-allpero tenga cuidado: obtendrá cientos de archivos de volcado.

Por cierto, GCC es extensible a través de complementos o con MELT (un lenguaje específico de dominio de alto nivel para extender GCC; que abandoné en 2017)

Puede usar gdb para esto como objdump.

Este extracto está tomado de http://sources.redhat.com/gdb/current/onlinedocs/gdb_9.html#SEC64

Aquí hay un ejemplo que muestra fuente mixta + ensamblaje para Intel x86:

  (gdb) disas / m principal
Volcado del código del ensamblador para la función main:
5 {
0x08048330: push% ebp
0x08048331: mov% esp,% ebp
0x08048333: sub $ 0x8,% esp
0x08048336: y $ 0xfffffff0,% esp
0x08048339: sub $ 0x10,% esp

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

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

Fin del volcado del ensamblador.

Use el interruptor -S (nota: S mayúscula) a GCC, y emitirá el código de ensamblaje a un archivo con una extensión .s. Por ejemplo, el siguiente comando:

gcc -O2 -S -c foo.c

No le he dado una inyección a gcc, pero en el caso de g ++. El siguiente comando funciona para mí. -g para la compilación de depuración y -Wa, -adhln se pasa al ensamblador para que aparezca con el código fuente

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

use -Wa, -adhln como opción en gcc o g ++ para producir una salida de listado a stdout.

-Wa, ... es para las opciones de línea de comandos para la parte del ensamblador (ejecutar en gcc / g ++ después de la compilación C / ++). Se invoca como internamente (as.exe en Windows). Ver

> como --ayuda

como línea de comando para ver más ayuda sobre la herramienta ensambladora dentro de gcc