gcc - compilar - inline assembly code in c

¿Puede gcc compilar el ensamblado x86 o simplemente enlazarlo?

Question

gcc puede producir ensamblados, pero ¿cómo compilo ensamblados puros con gcc u otro compilador? Sé que el ensamblaje de x86 es difícil y hay otro conjunto de instrucciones distinto al MIPS y Nios que estaba viendo, pero ahora quiero intentar compilar el asm directo de x86. Hay instrucciones sobre cómo hacerlo, pero hay un archivo C incluido y no necesito un archivo C para mi primera compilación más básica.

gcc -o test_asm asm_functions.S test_asm.c

Hay un paso para crear archivos .o .

gcc -c asm_functions.S
gcc -c test_asm.c
gcc -o test_asm asm_functions.o test_asm.o

Pero no veo el paso donde puedo compilar directamente x86 asm con gcc. Hay otro programa llamado GNU as (GNU Assembler), ¿se puede usar para traducir el ensamblado x86 al código de máquina?

Prueba

Código (32.s)

.globl  _start

.text
_start:
        movl    $len, %edx
        movl    $msg, %ecx
        movl    $1, %ebx
        movl    $4, %eax
        int     $0x80

        movl    $0, %ebx
        movl    $1, %eax
        int     $0x80
.data
msg:
        .ascii  "Hello, world!/n"
        len =   . - msg

Pasos

$ gcc -c 32.s 
$ ls 32*
32.o  32.s
$ gcc -o 32 32.o 
32.o: In function `_start'':
(.text+0x0): multiple definition of `_start''
/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../x86_64-linux-gnu/crt1.o:(.text+0x0): first defined here
/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../x86_64-linux-gnu/crt1.o: In function `_start'':
(.text+0x20): undefined reference to `main''

Por lo que parece que puede haber mezclado 32 y 64 bits, ¿debo decirle al complaciente si el ensamblaje tiene instrucciones de 32 o 64 bits?

Actualizar

Esta prueba funcionó con gcc.

$ cat hello.s
.data
.globl hello
hello:
.string "Hi World/n"

.text
.global main
main:
    pushq   %rbp
    movq    %rsp,       %rbp
    movq    $hello,     %rdi
    call    puts
    movq    $0,         %rax
    leave
    ret
$ gcc hello.s -o hello
$ ./hello 
Hi World

Answer 1

Aunque la actualización funciona, el código original podría haber sido compilado simplemente usando gcc -nostdlib . Por ejemplo,

gcc -nostdlib 32.s -o 32 DarrylW

Answer 2

Ya lo estas haciendo

gcc -c asm_functions.S

Ese paso produce un archivo objeto, asm_functions.o . El archivo objeto es un archivo "vinculable" (a diferencia de "cargable") que contiene el código de la máquina, con algunas instrucciones adicionales sobre cómo el vinculador debe modificar el código al vincular. El programa gcc sí mismo es solo un controlador, se ejecuta detrás de la escena para que produzca asm_functions.o . Así que tienes la opción de ejecutar directamente, pero a menudo es más fácil ejecutar la interfaz gcc .