Usando o GCC para produzir montagem legível?

Eu queria saber como usar o GCC no meu arquivo de origem C para despejar uma versão mnemônica do código da máquina para que eu pudesse ver em que meu código estava sendo compilado. Você pode fazer isso com Java, mas não consegui encontrar uma maneira com o GCC.

Estou tentando reescrever um método C em assembly e ver como o GCC faz isso seria uma grande ajuda.

Se você compilar com símbolos de depuração, poderá usar objdumppara produzir uma desmontagem mais legível.

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

objdump -drwC -Mintel é legal:

• -rmostra os nomes dos símbolos nas realocações (você verá putsna callinstrução abaixo)
• -R mostra realocações de vinculação dinâmica / nomes de símbolos (útil em bibliotecas compartilhadas)
• -C desmarca os nomes dos símbolos C ++
• -w é o modo "amplo": ele não quebra os bytes de código de máquina
• -Mintel: use a .intel_syntax noprefixsintaxe semelhante a GAS / binutils MASM em vez da AT&T
• -S: intercalar linhas de origem com desmontagem.

Você poderia colocar algo como alias disas="objdump -drwCS -Mintel"no seu~/.bashrc

Exemplo:

> 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

Se você der a bandeira ao GCC-fverbose-asm , ela será

Coloque informações adicionais de comentários no código de montagem gerado para torná-lo mais legível.

[...] Os comentários adicionados incluem:

• informações sobre a versão do compilador e as opções da linha de comando,
• as linhas de código-fonte associadas às instruções de montagem, no formato FILENAME: LINENUMBER: CONTENT OF LINE,
• dicas nas quais expressões de alto nível correspondem aos vários operandos de instruções de montagem.

Use a opção -S (observação: maiúscula S) para GCC e ela emitirá o código do assembly para um arquivo com extensão .s. Por exemplo, o seguinte comando:

gcc -O2 -S foo.c

deixará o código de montagem gerado no arquivo foo.s.

Extraído diretamente de http://www.delorie.com/djgpp/v2faq/faq8_20.html (mas removendo erros -c)

Usar o -Sswitch para o GCC em sistemas baseados em x86 produz um dump da sintaxe da AT&T, por padrão, que pode ser especificada com o -masm=attswitch, da seguinte maneira:

gcc -S -masm=att code.c

Considerando que, se você quiser produzir um dump na sintaxe da Intel, poderá usar o -masm=intelswitch da seguinte maneira:

gcc -S -masm=intel code.c

(Ambos produzem despejos code.cem suas várias sintaxes, no arquivo, code.srespectivamente)

Para produzir efeitos semelhantes com o objdump, você deseja usar a opção --disassembler-options= intel/ att, um exemplo (com despejos de código para ilustrar as diferenças na sintaxe):

 $ 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

e

$ 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 é uma ferramenta muito útil, eles listam apenas compiladores C ++, mas você pode usar -x cflag para fazer com que ele trate o código como C. Ele gerará uma lista de montagem para o seu código lado a lado e você pode usar a Colouriseopção para gerar barras coloridas para indicar visualmente qual código-fonte é mapeado para o assembly gerado. Por exemplo, o seguinte código:

#include <stdio.h>

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

usando a seguinte linha de comando:

-x c -std=c99 -O3

e Colourisegeraria o seguinte:

Você tentou gcc -S -fverbose-asm -O source.cexaminar o source.sarquivo assembler gerado ?

O código do assembler gerado entra source.s(você pode substituí-lo pelo -o assembler-filename ); a -fverbose-asmopção solicita que o compilador emita alguns comentários do assembler "explicando" o código do assembler gerado. A -Oopção solicita que o compilador otimize um pouco (ele pode otimizar mais com -O2ou -O3).

Se você quiser entender o que gccestá fazendo, tente passar, -fdump-tree-allmas tenha cuidado: você receberá centenas de arquivos de despejo.

BTW, o GCC é extensível através de plugins ou com MELT (uma linguagem específica de domínio de alto nível para estender o GCC; que eu abandonei em 2017)

Você pode usar o gdb para isso, como o objdump.

Este trecho foi retirado de http://sources.redhat.com/gdb/current/onlinedocs/gdb_9.html#SEC64

Aqui está um exemplo mostrando fonte mista + assembly para Intel x86:

  (gdb) disas / m principal
Despejo do código do assembler para a função main:
5 {
0x08048330: push% ebp
0x08048331: mov% esp,% ebp
0x08048333: sub $ 0x8,% esp
0x08048336: e $ 0xfffffff0,% esp
0x08048339: sub $ 0x10,% esp

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

7 retorna 0;
8}
0x08048348: mov $ 0x0,% eax
0x0804834d: licença
0x0804834e: ret

Fim do despejo do montador.

Use a opção -S (observação: maiúscula S) para GCC e ela emitirá o código do assembly para um arquivo com extensão .s. Por exemplo, o seguinte comando:

gcc -O2 -S -c foo.c

Eu não dei uma chance ao gcc, mas no caso do g ++. O comando abaixo funciona para mim. -g para depuração e -Wa, -adhln é passado para o assembler para listar com o código fonte

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

use -Wa, -adhln como opção no gcc ou g ++ para produzir uma saída de listagem para o stdout.

-Wa, ... é para opções de linha de comando para a parte do montador (execute no gcc / g ++ após a compilação do C / ++). Invoca como internamente (as.exe no Windows). Vejo

> como --help

como linha de comando para ver mais ajuda para a ferramenta assembler dentro do gcc