web-dev-qa-db-fra.com

Comment compiler l'ASM généré par GCC?

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 problème suivant est vraiment, comment compiler cette sortie et puis-je faire en sorte que GCC le fasse pour moi?

cgcccompiler-constructionassembly
54
Martin Kristiansen

Oui, vous pouvez utiliser gcc pour compiler votre code asm. Utilisez -c pour la compilation comme ceci:

gcc -c file.S -o file.o

Cela donnera un fichier de code objet nommé fichier.o. Pour appeler l'éditeur de liens, exécutez les commandes suivantes après:

gcc file.o -o file
71
cyber_raj

gcc peut utiliser un fichier Assembly en tant qu'entrée et appeler l'assembleur si nécessaire. Il y a une subtilité, cependant:

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

Donc, de manière générale, vous voulez faire les choses suivantes:

gcc -S file.c -o file.s
gcc -c file.s
43
Thomas Pornin

Vous pouvez intégrer le code d'assemblage dans un programme C normal. Voici une bonne introduction . En utilisant la syntaxe appropriée, vous pouvez également indiquer à GCC que vous souhaitez interagir avec les variables déclarées en C. Le programme ci-dessous indique à gcc que:

  • eax sera foo 
  • ebx doit être bar
  • la valeur dans eax doit être stockée dans foo après l'exécution du code d'assemblage

\ 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;
}
8
Johannes Rudolph

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

3
zvrba

Vous pouvez utiliser GAS, l’assembleur principal de gcc:

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

3
Brian Gordon

Si vous avez le fichier main.s . Vous pouvez générer un fichier objet par GCC et aussi as

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

vérifiez ce lien, il vous aidera à apprendre certains binutils de GCC http://www.thegeekstuff.com/2017/01/gnu-binutils-commands/ _

2
Srinivas Achary
nasm -f bin -o 2_hello 2_hello.asm
0
Hassan Maher