Jak skompilować asm generowany przez GCC?

Question

Gram z jakimś kodem asm i coś mnie dręczy.

skompilować to:

#include <stdio.h> 

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

z gcc file.c -S -o file.S ten generuje ładny mały kawałek kodu 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 

Moim następnym problemem jest naprawdę, jak mogę skompilować to wyjście, i mogę sprawić, że GCC zrobi to za mnie?

Answer 1

Tak, możesz użyć gcc do kompilacji swojego kodu asm. Użyj opcji -c do kompilacji w następujący sposób:

gcc -c file.S -o file.o 

Spowoduje to podanie pliku kodu obiektu o nazwie plik.o. Aby wywołać łącznik wykonywania następujących po powyższym polecenia:

gcc file.o -o file 

Answer 2

Tak, gcc może również kompilować kod źródłowy zespołu. Alternatywnie możesz wywołać as, która jest asemblerem. (Gcc jest właśnie program "kierowca", który używa heurystyki zadzwonić C kompilatora, kompilator C++, asembler, linker, itp ..)

Answer 3

Można użyć gazu, który jest gcc backend asemblera:

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

Answer 4

można umieścić kod montaż w normalnym programie C. Oto dobry introduction. Stosując odpowiednią składnię, można również powiedzieć GCC chcesz interakcji z zmiennych zadeklarowanych w C poniżej Program instruuje gcc że:

• eax będzie foo
• ebx będzie prętem
• wartości w eax przechowuje się foo po kodzie montaż wykonywany

\ 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 może użyć pliku zespołu jako danych wejściowych i wywołać asembler w razie potrzeby. Jest subtelność, choć:

• Jeśli nazwa pliku kończy się ".s" (mała litera 's'), a następnie gcc nazywa asemblera.
• Jeśli nazwa pliku kończy się „.S” (wielka litera „S”), a następnie gcc dotyczy preprocesora C na pliku źródłowym (czyli uznaje dyrektyw takich jak #if i zastępuje makra) i następnie wywołuje asemblera na wynik.

Tak, na zasadach ogólnych, chcesz robić rzeczy tak:

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

Answer 6

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

Answer 7

Jeśli masz main.s pliku. można wygenerować plik obiektu przez GCC a także as

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

Sprawdź ten link, to pomoże Ci nauczyć się binutils GCC http://www.thegeekstuff.com/2017/01/gnu-binutils-commands/