comment puis-je compiler l'asm généré par gcc

Question

Je joue avec du code asm et quelque chose me dérange.

Je compile ceci:

 #include <stdio.h>

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

avec gcc file.c -S -o file.S cela génère un joli petit morceau de code 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
 

mon prochain problème est vraiment, comment puis-je compiler cette sortie, et puis-je faire gcc le faire pour moi?

Answer 1

Oui, vous pouvez utiliser gcc pour compiler votre code asm. Utilisez -c pour une compilation comme celle-ci:

 gcc -c file.S -o file.o
 

Cela donnera un fichier de code objet nommé file.o. Pour appeler l'éditeur de liens, procédez comme suit après la commande ci-dessus:

 gcc file.o -o file
 

Answer 2

gcc pouvez utiliser un fichier d'assemblage: entrée, et invoquer l'assembleur en tant que de besoin. Il y a une subtilité, mais:

• Si le nom de fichier se termine par ".s" (en minuscule 's'), alors gcc des appels de l'assembleur.
• Si le nom de fichier se termine par ".S" (en majuscules "S"), alors gcc s'applique le préprocesseur C sur le fichier source (c'est à dire qu'il reconnaît des directives telles que #if et remplace les macros), et puis les appels de l'assembleur sur le résultat.

Donc, sur une base générale, vous voulez faire les choses comme ceci:

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

Answer 3

Vous pouvez intégrer le code assembleur dans un programme C. Voici une bonne introduction. À l'aide de la syntaxe appropriée, vous pouvez également demander à GCC vous souhaitez interagir avec les variables déclarées dans C. Le programme ci-dessous indique gcc:

• eax est foo
• ebx est bar
• la valeur de eax doit être stocké dans foo après l'assemblée du code exécuté

\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 4

Vous pouvez utiliser GAS, qui est l'assembleur backend de gcc:

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

Answer 5

Oui, gcc peut également compiler le code source de l'assembly. Alternativement, vous pouvez appeler as , qui est l'assembleur. (gcc est juste un programme "pilote" qui utilise l'heuristique pour appeler le compilateur C, le compilateur C ++, l'assembleur, l'éditeur de liens, etc.)