assembler - ¿Usando GCC para producir ensamblajes legibles?

use assembler in c

Question

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

Estoy tratando de volver a escribir un método C en ensamblado y ver cómo GCC lo hace sería una gran ayuda.

Answer 1

Use el conmutador -S (nota: mayúscula S) a GCC, y emitirá el código de ensamblaje a un archivo con la 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.

Arrancado directamente desde http://www.delorie.com/djgpp/v2faq/faq8_20.html (pero eliminando el error -c )

Answer 2

¿ gcc -S -fverbose-asm -O source.c luego gcc -S -fverbose-asm -O source.c en el archivo ensamblador de source.s generado?

El código del ensamblador generado va a source.s (puede anularlo con -o assembler-filename ); La opción -fverbose-asm le pide al compilador que emita algunos comentarios del ensamblador "explicando" el código del ensamblador generado. La opción -O le pide al compilador que optimice un poco (podría optimizar más con -O2 o -O2 ).

Si quieres entender qué está haciendo gcc intenta pasar -fdump-tree-all pero ten cuidado: obtendrás cientos de archivos de volcado.

Por cierto, GCC es extensible a través de complementos o con MELT (un lenguaje de alto nivel específico del dominio para extender GCC).

Answer 3

El uso del conmutador -S a GCC en sistemas basados ​​en x86 produce un volcado de la sintaxis de AT&T, de forma predeterminada, que se puede especificar con el -masm=att , así:

gcc -S -masm=att code.c

Mientras que si deseas producir un volcado en la sintaxis de Intel, puedes usar el -masm=intel , así:

gcc -S -masm=intel code.c

(Ambos producen volcados de code.c en su sintaxis, en el archivo code.s respectivamente)

Para producir efectos similares con objdump, querría usar el --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

Answer 4

Me gustaría agregar a estas respuestas que si le da a gcc la -fverbose-asm , el ensamblador que emite será mucho más claro de leer.

Answer 5

No le he dado una inyección a gcc, pero en 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 su listado con código fuente

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

Answer 6

Puedes usar gdb para esto como objdump.

Este extracto se toma de http://sources.redhat.com/gdb/current/onlinedocs/gdb_9.html#SEC64

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

(gdb) disas /m main Dump of assembler code for function main: 5 { 0x08048330 : push %ebp 0x08048331 : mov %esp,%ebp 0x08048333 : sub $0x8,%esp 0x08048336 : and $0xfffffff0,%esp 0x08048339 : sub $0x10,%esp 6 printf ("Hello./n"); 0x0804833c : movl $0x8048440,(%esp) 0x08048343 : call 0x8048284 7 return 0; 8 } 0x08048348 : mov $0x0,%eax 0x0804834d : leave 0x0804834e : ret End of assembler dump.

Answer 7

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

gcc -O2 -S -c foo.c

Answer 8

gcc.godbolt.org es una herramienta muy útil, ya que solo tienen compiladores de C ++, pero puedes usar el indicador -xc para tratar el código como C. Luego generará una lista de ensamblados para tu código en paralelo y puedes usar Colourise Opció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:

Answer 9

Si compila con símbolos de depuración, puede usar objdump para producir un desensamblaje 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:

• -r muestra los nombres de los símbolos en las reubicaciones (para que vea las instrucciones de call continuación)
• -R muestra relocalizaciones de enlaces dinámicos / nombres de símbolos (útiles en bibliotecas compartidas)
• -C desmangle los nombres de los símbolos de C ++
• -w es el modo "ancho": no envuelve los bytes del código de la máquina
• -Mintel : use la sintaxis de .intel_syntax noprefix GAS / binutils tipo MASM .intel_syntax noprefix lugar de AT&T
• -S : entrelazar lineas fuente con desmontaje.

Puedes 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