Impossible de lier le fichier d'assemblage sous Mac OS X à l'aide de ld

Je suis en train de lancer un assemblage de base de fichier à l'aide de 64 Bits Mac OS X Lion, à l'aide de msna et ld qui sont installés par défaut avec Xcode.

J'ai écrit un fichier d'assemblage, qui imprime un caractère, et je l'ai eu à construire à l'aide de msna.

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

Cependant, lorsque je vais pour faire le lien avec ld, il échoue avec un certain nombre d'erreurs/avertissements:

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

Donc, j'ai essayé de rectifier quelques-unes de ces questions, et a obtenu nulle part.

Voici l'une des choses que j'ai essayé:

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

Qui me semblait, mais j'avais tort.

La façon dont vous faites l'objet de fichier compatible avec l'architecture de msna et ld seront d'accord avec?

Également, comment pouvez-vous définir le point d'entrée dans le programme (en ce moment je suis en utilisant global _start dans .section textqui est au-dessus de _startqui ne semble pas faire beaucoup de bien.)

Je suis un peu confus quant à la façon dont vous le feriez avec succès lier un objet de fichier pour un fichier binaire à l'aide de ld, et je pense que je manque juste un peu de code (ou de l'argumentation de msna ou ld) qui fera d'eux d'accord.

Toute aide appréciée.

source d'informationauteur Jack Greenhill

5

OK, en regardant vos échantillons, je suppose que vous avez utilisé un générique msna ou linux assemblée tutoriel.

La première chose que vous devez prendre soin de est le format binaire créé par msna.

Votre post unis:
```
ld: warning: ignoring file program.o, file was built for unsupported file format which is not the architecture being linked (x86_64)
```
C'est le résultat de la '-f elf' paramètre qui indique msna vous souhaitez un 32bit objet ELF (ce qui serait le cas, par exemple linux). Mais puisque vous êtes sur OSX ce que vous voulez, c'est un Mach-O de l'objet.

Essayez ce qui suit:
```
nasm -f macho64 -o program.o main.asm
gcc -o program program.o
```
Ou si vous voulez pas créer un binaire 32 bits:
```
nasm -f macho32 -o program.o main.asm
gcc -m32 -o program program.o
```
Concernant la _start symbole - si vous voulez pas créer un programme simple qui sera en mesure
l'utilisation de la condition de la libc fonctions du système, alors vous ne devriez pas utiliser _start de l'al.
C'est la valeur par défaut du point d'entrée ld va chercher et normalement il est fourni dans votre libc /libsystem.

Je vous suggère d'essayer de remplacer le _start dans votre code par quelque chose comme '_main'
et le lien comme dans l'exemple ci-dessus états.

Générique de la libc d'assemblage à base de modèle pour les msna pourrait ressembler à ceci:
```
;---------------------------------------------------
.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
```
En plus de cela, je dois mentionner que tout appel's que vous faites sur OSX besoin d'utiliser l'alignement de trame de pile ou votre code juste crash.

Il y a quelques bons tutoriels sur que là-bas aussi - essayez de rechercher pour OSX guide d'assemblage.
5

Vous devez utiliser global start et start:pas d'underscore. Aussi, vous ne devriez pas utiliser elf que l'arc. Voici un script bash-je utiliser pour monter mon x86-64 MSNA programmes sur 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 vous avez un fichier nommé foo.sce script va d'abord exécuter
```
nasm -f macho64 -Ox foo.s
```
Qui permettra de créer des foo.o. Le -Ox drapeau fait MSNA une optimisation avec des sauts (c'est à dire en les rendant court, de près ou de loin), de sorte que vous n'avez pas à le faire vous-même. Je suis l'aide de x86-64, donc mon code est en 64 bits, mais il semble que vous essayez d'assembler 32 bits. Dans ce cas, vous devez utiliser -f macho32. Voir nasm -hf pour une liste valide de formats de sortie.

Maintenant, le fichier objet sera lié:
```
ld -macosx_version_min 10.7 foo.o -o foo
```
J'ai mis le -macosx_version_min option de calme MSNA vers le bas et éviter un avertissement. Vous n'avez pas à régler pour Lion (10.7). Cela va créer un fichier exécutable appelé foo. Avec un peu de chance, en tapant ./foo et frapper de retour doit exécuter votre programme.

En ce qui concerne la ld: warning: symbol dyld_stub_binder not found, normally in libSystem.dylib avertissement, je reçois à chaque fois trop et je ne sais pas pourquoi, mais tout semble parfait quand je lance l'exécutable.
2

Il est probablement plus facile de laisser gcc faire le gros du travail pour vous, plutôt que d'essayer de conduire ld directement, par exemple
```
$ gcc -m32 program.o -o program
```
0

Le mac gcc compilateur n'a pas de lien elfe objets. Vous avez besoin d'un compilateur croisé...

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

Ensuite, vous pouvez procéder avec quelque chose de semblable à ce...
```
/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
```

Vous devez vous connecter pour publier un commentaire.