Come si compila l'asm generato da GCC?

Question

Sto giocando con qualche codice asm, e qualcosa mi dà fastidio.

compilo questo:

#include <stdio.h> 

int main(int argc, char** argv){ 
    printf("Hello World\n"); 
    return 0; 
} 

con gcc file.c -S -o file.S questo genera un bel pezzo di codice asm:

.cstring 
LC0: 
    .ascii "Hello World\0" 
    .text 
.globl _main 
_main: 
LFB3: 
    pushq %rbp 
LCFI0: 
    movq %rsp, %rbp 
LCFI1: 
    subq $16, %rsp 
LCFI2: 
    movl %edi, -4(%rbp) 
    movq %rsi, -16(%rbp) 
    leaq LC0(%rip), %rdi 
    call _puts 
    movl $0, %eax 
    leave 
    ret 
LFE3: 
    .section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support 
EH_frame1: 
    .set L$set$0,LECIE1-LSCIE1 
    .long L$set$0 
LSCIE1: 
    .long 0x0 
    .byte 0x1 
    .ascii "zR\0" 
    .byte 0x1 
    .byte 0x78 
    .byte 0x10 
    .byte 0x1 
    .byte 0x10 
    .byte 0xc 
    .byte 0x7 
    .byte 0x8 
    .byte 0x90 
    .byte 0x1 
    .align 3 
LECIE1: 
.globl _main.eh 
_main.eh: 
LSFDE1: 
    .set L$set$1,LEFDE1-LASFDE1 
    .long L$set$1 
LASFDE1: 
    .long LASFDE1-EH_frame1 
    .quad LFB3-. 
    .set L$set$2,LFE3-LFB3 
    .quad L$set$2 
    .byte 0x0 
    .byte 0x4 
    .set L$set$3,LCFI0-LFB3 
    .long L$set$3 
    .byte 0xe 
    .byte 0x10 
    .byte 0x86 
    .byte 0x2 
    .byte 0x4 
    .set L$set$4,LCFI1-LCFI0 
    .long L$set$4 
    .byte 0xd 
    .byte 0x6 
    .align 3 
LEFDE1: 
    .subsections_via_symbols 

Il mio prossimo problema è in realtà, come faccio a compilare questa uscita, e posso far fare a GCC questo per me?

Answer 1

Sì, puoi usare gcc per compilare il tuo codice asm. Utilizzare -c per la compilazione in questo modo:

gcc -c file.S -o file.o 

Questo darà file di codice oggetto denominato file.o. Per richiamare linker eseguire seguente dopo il comando di cui sopra:

gcc file.o -o file 

Answer 2

Sì, gcc può anche compilare il codice sorgente dell'assembly. In alternativa, puoi invocare as, che è l'assemblatore. (Gcc è solo un programma "driver" che utilizza l'euristica per chiamare compilatore C, C++, assemblatore, linker, ecc ..)

Answer 3

È possibile utilizzare GAS, che è di gcc assembler backend:

http://linux.die.net/man/1/as

Answer 4

è possibile incorporare il codice assembly in un normale programma C. Ecco un buon introduction. Utilizzando la sintassi appropriata, si può anche dire GCC si desidera interagire con le variabili dichiarate in C. Il programma di seguito istruisce gcc che:

• EAX sarà foo
• EBX deve essere bar
• il valore in eax deve essere conservato in foo dopo che il codice assembly eseguito

\ n

int main(void) 
{ 
     int foo = 10, bar = 15; 
     __asm__ __volatile__("addl %%ebx,%%eax" 
          :"=a"(foo) 
          :"a"(foo), "b"(bar) 
          ); 
     printf("foo+bar=%d\n", foo); 
     return 0; 
} 

Answer 5

gcc può utilizzare un file assembly come input e richiamare l'assembler secondo necessità. C'è una sottigliezza, però:

• Se il nome del file termina con ".s" ('s' minuscola), quindi gcc chiama l'assembler.
• Se il nome del file termina con ".S" (maiuscolo 'S'), poi gcc applica il preprocessore C sul file sorgente (cioè riconosce le direttive quali #if e sostituisce le macro), e poi chiama l'assemblatore su il risultato.

Così, in via generale, si vuole fare le cose in questo modo:

gcc -S file.c -o file.s 
gcc -c file.s 

Answer 6

nasm -f bin -o 2_hello 2_hello.asm 

Answer 7

Se si dispone di file di main.s. è possibile generare file oggetto da GCC e anche as

# gcc -c main.s 
# as main.s -o main.o 

controllare questo link, che vi aiuterà a imparare alcune binutils di GCC http://www.thegeekstuff.com/2017/01/gnu-binutils-commands/