No se puede vincular el archivo de ensamblaje en Mac OS X usando ld

Question

Estoy tratando de ejecutar un archivo de ensamblaje básico utilizando 64 Bit Mac OS X Lion, usando nasm y ld que están instalados por defecto con Xcode.

He escrito un archivo de ensamblaje, que imprime un personaje, y lo tengo para construir usando nasm.

nasm -f elf -o program.o main.asm

Sin embargo, cuando voy a vincularlo con dificultades de aprendizaje, se produce un error con un buen número de errores/advertencias:

ld -o program program.o

ld: warning: -arch not specified 
ld: warning: -macosx_version_min not specificed, assuming 10.7 
ld: warning: ignoring file program.o, file was built for unsupported file format which is not the architecture being linked (x86_64) 
ld: warning: symbol dyld_stub_binder not found, normally in libSystem.dylib 
ld: entry point (start) undefined. Usually in crt1.o for inferred architecture x86_64 

tanto, he intentado rectificar algunos de estos problemas, y no llegó a ninguna parte.

He aquí una de las cosas que he intentado:

ld -arch i386 -e _start -o program program.o

que pensé que trabajar, pero estaba equivocado.

¿Cómo se hace que el archivo objeto sea una arquitectura compatible con la que nasm y ld estarán de acuerdo?

Además, ¿cómo definiría el punto de entrada en el programa (en este momento estoy usando global _start en .section text, que está por encima _start, lo que no parece hacer mucho bien.)

Soy una Estaba un poco confundido en cuanto a cómo vincularía con éxito un archivo objeto a un archivo binario usando ld, y creo que me falta un código (o argumento para nasm o ld) que los hará estar de acuerdo.

Cualquier ayuda apreciada.

Answer 1

Probablemente sea más fácil simplemente dejar que gcc haga el trabajo pesado por usted, en lugar de tratar de conducir ld directamente, p. Ej.

$ gcc -m32 program.o -o program 

Answer 2

OK, mirando a sus muestras supongo que sea utilizado un nasm o montaje Linux genérica tutorial.
Lo primero que debe tener en cuenta es el formato binario creado por nasm.
tu post estados:

ld: warning: ignoring file program.o, file was built for unsupported file format which is not the architecture being linked (x86_64) 

Eso es el resultado de la 'Elf -f' parámetro que le dice nasm desea que un objeto de 32 bits ELF (que sería el caso de, por ejemplo, Linux). Pero dado que estás en OSX, lo que quieres es un objeto Mach-O.

Pruebe lo siguiente:

nasm -f macho64 -o program.o main.asm 
gcc -o program program.o 

O si quieres probar para crear un binario de 32 bits:

nasm -f macho32 -o program.o main.asm 
gcc -m32 -o program program.o 

---

En cuanto al símbolo _start - si quieres probar a cree un programa simple que podrá para usar las funciones proporcionadas del sistema libc, entonces no debería usar _start at al. Es el punto de entrada predeterminado ld buscará y normalmente se proporciona en su libc/libsystem.

que sugieren intenta reemplazar el _start en su código por algo así como '_main' y vincularlo como el ejemplo anterior estados.

Una plantilla de montaje a base de libc genérico para nasm podría tener este aspecto:

;--------------------------------------------------- 
.section text 
;--------------------------------------------------- 
use32    ; use64 if you create 64bit code 
global _main  ; export the symbol so ld can find it 

_main: 
    push ebp 
    mov ebp, esp ; create a basic stack frame 

    [your code here] 

    pop ebp  ; restore original stack 
    mov eax, 0 ; store the return code for main in eax 
    ret   ; exit the program 

---

Además de esto debería mencionar que cualquier llamada 's que haces en OSX necesitan utilizar una marco alineado de la pila o su código simplemente se bloqueará.
Hay algunos buenos tutoriales sobre eso también: intente buscar la guía de ensamblaje OSX.

Answer 3

Es necesario utilizar global start y start:, sin subrayan. Además, no debe usar elf como arco. Aquí es un script bash que utilizo para montar mis programas NASM x86-64 en Mac OS X:

#!/bin/bash 

if [[ -n "$1" && -f "$1" ]]; then 
    filename="$1" 
    base="${filename%%.*}" 
    ext="${filename##*.}" 

    nasm -f macho64 -Ox "$filename" \ 
    && ld -macosx_version_min 10.7 "${base}.o" -o "$base" 
fi 

Si usted tiene un archivo llamado foo.s, este script se ejecutará primero

nasm -f macho64 -Ox foo.s 

que creará foo.o. La bandera -Ox hace que NASM realice una optimización extra con saltos (es decir, hacerlos cortos, cercanos o lejanos) para que no tenga que hacerlo usted mismo. Estoy usando x86-64, entonces mi código es de 64 bits, pero parece que estás intentando ensamblar 32 bits. En ese caso, usaría -f macho32. Consulte nasm -hf para obtener una lista de formatos de salida válidos.

Ahora, el fichero objeto se vinculará:

ld -macosx_version_min 10.7 foo.o -o foo 

He establecido la opción -macosx_version_min NASM para calmar abajo y prevenir una advertencia. No tiene que configurarlo para Lion (10.7). Esto creará un ejecutable llamado foo. Con un poco de suerte, escribir ./foo y presionar return debería ejecutar su programa.

Con respecto a la advertencia ld: warning: symbol dyld_stub_binder not found, normally in libSystem.dylib, lo consigo cada vez que lo hago y no estoy seguro de por qué, pero todo parece estar bien cuando ejecuto el ejecutable.

Answer 4

El compilador mac gcc no enlazará los objetos elf. Necesitas un compilador cruzado ...

http://crossgcc.rts-software.org/doku.php?id=compiling_for_linux

A continuación, puede proceder con algo similar a esto ...

/usr/local/gcc-4.8.1-for-linux32/bin/i586-pc-linux-ld -m elf_i386 -T link.ld -o kernel kasm.o kc.o