van C naar montage

Kan iemand mij uitleggen, ik heb een programma op C, kan ik het converteren naar assembly? zo ja, hoe?

Antwoord 1, autoriteit 100%

Als je gcc gebruikt, kun je gcc -O2 -S -c foo.cdoen volgens dezepagina om de output assembly in een voor mensen leesbare vorm te krijgen.

Antwoord 2, autoriteit 22%

Met gcc kunt u de optie -Sgebruiken:

gcc -O2 -S myfile.c

De meeste andere opties (zoals de -O2) kunnen hier ook worden gebruikt om te bepalen wat voor soort assemblagecode wordt geproduceerd.

Houd er echter rekening mee dat dit eenvoudigweg een tussenstap blootlegt die de compiler toch doorloopt (niet het genereren van een assembly-bronbestand, dat wil zeggen, maar de machinecode die het vertegenwoordigt). Het eindresultaat, na het doorgeven van deze code door een assembler, zal op geen enkele manier verschillen van gewoon direct compileren naar machinecode.

Antwoord 3, autoriteit 13%

Je compiler zou een optie moeten hebben om dat te doen. Voor gcc kunt u bijvoorbeeld de optie -S gebruiken. Een kort voorbeeld:

// test.c
#include <stdio.h>
int
main ()
{
  printf ("hello, world\n");
  return 0;
}

Compileer het met de optie -S. Dit zal een test.s bestand produceren dat de assembly zal bevatten:

.file   "test.c"
    .section    .rodata
.LC0:
    .string "hello, world"
    .text
.globl main
    .type   main, @function
main:
    leal    4(%esp), %ecx
    andl    $-16, %esp
    pushl   -4(%ecx)
    pushl   %ebp
    movl    %esp, %ebp
    pushl   %ecx
    subl    $4, %esp
    movl    $.LC0, (%esp)
    call    puts
    movl    $0, %eax
    addl    $4, %esp
    popl    %ecx
    popl    %ebp
    leal    -4(%ecx), %esp
    ret
    .size   main, .-main
    .ident  "GCC: (Ubuntu 4.3.3-5ubuntu4) 4.3.3"
    .section    .note.GNU-stack,"",@progbits

Antwoord 4, autoriteit 13%

Dat is wat uw compiler doet.

De compiler compileert uw C-programma naar machinetaal, wat een binaire weergave is van het machineprogramma. Wanneer een mens machinetaal wil schrijven, schrijft hij/zij dit in assembler, dat wordt vertaald naar de binaire machinetaal.

De assembler-code is gewoon een door mensen leesbare vorm van de binaire machinetaal.

Het C-programma:

$ cat test.c 
#include <stdio.h>
int main(int argc, char **argv) {
    int a = 11+12;
    printf("a = %d\n", a);
    return 0;
}

compileer het

$ gcc -c test.c

demonteer het:

$ objdump -d test.o
test.o:     file format elf32-i386
Disassembly of section .text:
00000000 <main>:
   0:   55                      push   %ebp
   1:   89 e5                   mov    %esp,%ebp
   3:   83 e4 f0                and    $0xfffffff0,%esp
   6:   83 ec 20                sub    $0x20,%esp
   9:   c7 44 24 1c 17 00 00    movl   $0x17,0x1c(%esp)
  10:   00 
  11:   b8 00 00 00 00          mov    $0x0,%eax
  16:   8b 54 24 1c             mov    0x1c(%esp),%edx
  1a:   89 54 24 04             mov    %edx,0x4(%esp)
  1e:   89 04 24                mov    %eax,(%esp)
  21:   e8 fc ff ff ff          call   22 <main+0x22>
  26:   b8 00 00 00 00          mov    $0x0,%eax
  2b:   c9                      leave  
  2c:   c3                      ret    

Antwoord 5, Autoriteit 4%

De meeste compilers hebben een optie om montagellijstjes samen met de binaire bestanden te genereren.
In Visual Studio kunt u het vinden onder de sectie “Code Generation” in de bestandseigenschappen.
Met GCC kunt u -S -S-schakelaar (hoofdstad) gebruiken
Eindelijk als u een binary hebt, kunt u objdump -s (hoofdstad) gebruiken.

Antwoord 6, Autoriteit 4%

Aangezien u Dev-C++ noemde, is het de moeite waard om te vermelden dat de -S-vlag daar ook werkt. Actieve Windows, Dev-C++ noemt de output .exe nog steeds, maar het resultaat is niet een uitvoerbaar bestand, dus verander gewoon de extensie naar .txt of wat dan ook, zodat het kan worden gelezen in de redacteur van uw keuze. Opties / vlaggen toevoegen onder Project & GT; Projectopties & GT; Parameters & GT; Compiler of Extra & GT; Compiler-opties.