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 .