¿Cómo se obtiene la salida del ensamblador de la fuente C / C ++ en gcc?

¿Cómo hace uno esto?

Si quiero analizar cómo se está comstackndo algo, ¿cómo obtendré el código ensamblador emitido?

Use la opción -S para gcc (o g ++).

 gcc -S helloworld.c 

Esto ejecutará el preprocesador (cpp) sobre helloworld.c, realizará la comstackción inicial y luego se detendrá antes de que se ejecute el ensamblador.

Por defecto esto dará como resultado un archivo helloworld.s . El archivo de salida aún se puede establecer utilizando la opción -o .

 gcc -S -o my_asm_output.s helloworld.c 

Por supuesto, esto solo funciona si tienes la fuente original. Una alternativa si solo tiene el archivo de objeto resultante es usar objdump , configurando la opción --disassemble (o -d para la forma abreviada).

 objdump -S --disassemble helloworld > helloworld.dump 

Esta opción funciona mejor si la opción de depuración está habilitada para el archivo de objeto ( -g en tiempo de comstackción) y el archivo no se ha eliminado.

La ejecución del file helloworld le dará alguna indicación sobre el nivel de detalle que obtendrá al usar objdump.

Esto generará el asm con el código C + números de línea entrelazados para ver más fácilmente qué líneas generan qué código.

 # create assembler code: c++ -S -fverbose-asm -g -O2 test.cc -o test.s # create asm interlaced with source lines: as -alhnd test.s > test.lst 

Se encuentra en Algoritmos para progtwigdores , página 4.

La siguiente línea de comando es del blog de Christian Garbin

 g++ -g -O -Wa,-aslh horton_ex2_05.cpp >list.txt 

Ejecuté G ++ desde una ventana DOS en Win-XP, contra una rutina que contiene un molde implícito

 c:\gpp_code>g++ -g -O -Wa,-aslh horton_ex2_05.cpp >list.txt horton_ex2_05.cpp: In function `int main()': horton_ex2_05.cpp:92: warning: assignment to `int' from `double' 

La salida se ensambla con el código generado iterspersed con el código C ++ original (el código C ++ se muestra como comentarios en la secuencia asm generada)

  16:horton_ex2_05.cpp **** using std::setw; 17:horton_ex2_05.cpp **** 18:horton_ex2_05.cpp **** void disp_Time_Line (void); 19:horton_ex2_05.cpp **** 20:horton_ex2_05.cpp **** int main(void) 21:horton_ex2_05.cpp **** { 164 %ebp 165 subl $128,%esp ?GAS LISTING C:\DOCUME~1\CRAIGM~1\LOCALS~1\Temp\ccx52rCc.s 166 0128 55 call ___main 167 0129 89E5 .stabn 68,0,21,LM2-_main 168 012b 81EC8000 LM2: 168 0000 169 0131 E8000000 LBB2: 169 00 170 .stabn 68,0,25,LM3-_main 171 LM3: 172 movl $0,-16(%ebp) 

Use el interruptor -S

 g++ -S main.cpp 

o también con gcc

 gcc -S main.c 

Ver también esto

Si lo que desea ver depende de la vinculación de la salida, entonces objdump en el archivo de objeto de salida / ejecutable también puede ser útil además de la gcc -S mencionada anteriormente. Aquí hay un guión muy útil de Loren Merritt que convierte la syntax de objdump por defecto en la syntax de nasm más legible:

 #!/usr/bin/perl -w $ptr='(BYTE|WORD|DWORD|QWORD|XMMWORD) PTR '; $reg='(?:[er]?(?:[abcd]x|[sd]i|[sb]p)|[abcd][hl]|r1?[0-589][dwb]?|mm[0-7]|xmm1?[0-9])'; open FH, '-|', '/usr/bin/objdump', '-w', '-M', 'intel', @ARGV or die; $prev = ""; while(){ if(/$ptr/o) { s/$ptr(\[[^\[\]]+\],$reg)/$2/o or s/($reg,)$ptr(\[[^\[\]]+\])/$1$3/o or s/$ptr/lc $1/oe; } if($prev =~ /\t(repz )?ret / and $_ =~ /\tnop |\txchg *ax,ax$/) { # drop this line } else { print $prev; $prev = $_; } } print $prev; close FH; 

Sospecho que esto también se puede usar en la salida de gcc -S.

Como todos han señalado, use la opción -S para GCC. También me gustaría añadir que los resultados pueden variar (¡salvajemente!) Dependiendo de si agrega o no opciones de optimización ( -O0 para ninguno, -O2 para una optimización agresiva).

En architectures RISC en particular, el comstackdor a menudo transformará el código casi más allá del reconocimiento al hacer la optimización. ¡Es impresionante y fascinante ver los resultados!

Bueno, como todos dijeron, usa la opción -S. Si usa la opción -save-temps, también puede obtener el archivo preprocesado ( .i), el archivo de ensamblaje ( .s) y el archivo de objeto (*. O). (obtenga cada uno de ellos usando -E, -S y -c)

Use la opción -S:

 gcc -S program.c 

Como se mencionó anteriormente, mire la bandera -S.

También vale la pena mirar la familia de banderas ‘-fdump-tree’, en particular ‘-fdump-tree-all’, que te permite ver algunas de las formas intermedias de gcc. A menudo, estos pueden ser más legibles que el ensamblador (al menos para mí), y le permiten ver cómo se desempeñan las operaciones de optimización.

Si estás buscando ensamblaje LLVM:

 llvm-gcc -emit-llvm -S hello.c 

De: http://www.delorie.com/djgpp/v2faq/faq8_20.html

gcc -c -g -Wa, -a, -ad [otras opciones de GCC] foo.c> foo.lst

en alternativa a la respuesta de PhirePhly O simplemente usa -S como todos dijeron.

No veo esta posibilidad entre las respuestas, probablemente porque la pregunta es de 2008, pero en 2018 puede usar el sitio web en línea de Matt Goldbolt https://godbolt.org

También puedes clonar localmente git y ejecutar su proyecto https://github.com/mattgodbolt/compiler-explorer

Salida de estos commnads

Estos son los pasos para ver / imprimir el código ensamblador de cualquier progtwig C en su Windows

consola / terminal / símbolo del sistema:

  1. Escriba un progtwig C en un editor de código C como bloques de código y guárdelo con una extensión .c

  2. Comstackr y ejecutarlo.

  3. Una vez que se ejecuta con éxito, vaya a la carpeta donde ha instalado su comstackdor gcc y proporcione el

    siguiendo el comando para obtener un archivo ‘.s’ del archivo ‘.c’

    C: \ gcc> gcc -S ruta completa del archivo C ENTER

    Un comando de ejemplo (como en mi caso)

    C: \ gcc> gcc -SD: \ Aa_C_Certified \ alternate_letters.c

    Esto genera un archivo ‘.s’ del archivo original ‘.c’

4. Después de esto, escriba el siguiente comando

C; \ gcc> cpp nombre de archivo.s ENTER

Ejemplo de comando (como en mi caso)

C; \ gcc> cpp alternate_letters.s

Esto imprimirá / dará como resultado el código de idioma de conjunto de su progtwig C.

Use “-S” como una opción. Muestra la salida de ensamblaje en el terminal.