D'erreur lorsque vous essayez d'exécuter .fichier asm sur MSNA sur Ubuntu

Je suis sur ubuntu 64 bits et en essayant de lancer une .fichier asm sur MSNA. Mais elle renvoie cette erreur lorsque j'essaie d'exécuter le code suivant. Ce Iḿ essayer de faire est de créer un fichier exécutable par la compilation (ou assemblage) fichier de l'objet à partir de la source
$ nasm -f elf hello.asm, et puis après avoir créé le fichier hello.o est la production de fichier exécutable à partir du fichier de l'objet par l'invocation de l'éditeur de liens 

$ ld -s -o hello hello.o

Ce sera de construire, finalement, bonjour exécutable.

Je suis en suivant ce tutoriel http://www.faqs.org/docs/Linux-HOWTO/Assembly-HOWTO.html

Erreur:

architecture i386 de fichier d'entrée " bonjour.o' est incompatible avec i386:x86-64 sortie

Code:

     section .data              ;section declaration

 msg     db      "Hello, world!",0xa    ;our dear string
 len     equ     $ - msg                 ;length of our dear string

 section .text              ;section declaration

             ;we must export the entry point to the ELF linker or
     global _start       ;loader. They conventionally recognize _start as their
             ;entry point. Use ld -e foo to override the default.

 _start:

 ;write our string to stdout

         mov     edx,len ;third argument: message length
         mov     ecx,msg ;second argument: pointer to message to write
         mov     ebx,1   ;first argument: file handle (stdout)
         mov     eax,4   ;system call number (sys_write)
         int     0x80   ;call kernel

  ;and exit

     mov    ebx,0   ;first syscall argument: exit code
         mov     eax,1   ;system call number (sys_exit)
         int     0x80   ;call kernel
InformationsquelleAutor rogcg | 2010-11-23
  1. 37

    Cela ressemble, il peut être un simple décalage entre ce qui est produit par nasm et ce ld essaie de faire:

    i386 architecture of input file 'hello.o' is incompatible with i386:x86-64 output

    En d'autres termes, nasm a produit de 32 bits fichier objet hello.o et ld veut prendre et apporter une 64 bits fichier exécutable.

    La nasm -hf commande devrait vous donner les formats de sortie disponibles:

    valid output formats for -f are (`*' denotes default):
  * bin       flat-form binary files (e.g. DOS .COM, .SYS)
    ith       Intel hex
    srec      Motorola S-records
    aout      Linux a.out object files
    aoutb     NetBSD/FreeBSD a.out object files
    coff      COFF (i386) object files (e.g. DJGPP for DOS)
    elf32     ELF32 (i386) object files (e.g. Linux)
    elf       ELF (short name for ELF32) 
    elf64     ELF64 (x86_64) object files (e.g. Linux)
    as86      Linux as86 (bin86 version 0.3) object files
    obj       MS-DOS 16-bit/32-bit OMF object files
    win32     Microsoft Win32 (i386) object files
    win64     Microsoft Win64 (x86-64) object files
    rdf       Relocatable Dynamic Object File Format v2.0
    ieee      IEEE-695 (LADsoft variant) object file format
    macho32   NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (i386) object files
    macho     MACHO (short name for MACHO32)
    macho64   NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (x86_64) object files
    dbg       Trace of all info passed to output stage

    Je vois que ton liés tutoriel vous demande d'exécuter:

    nasm -f elf hello.asm

    Essayez d'utiliser:

    nasm -f elf64 hello.asm

    au lieu de cela, et vous pouvez trouver ld cesse de se plaindre du fichier d'entrée.

    • Cela fonctionne pour vous?
    • Ce n'est pas vraiment la bonne approche, car l'assemblée que l'OP est écrit devra également être modifié (par exemple, la partie supérieure de 32 bits de %rax, %rbx etc. doivent être effacées avant l'appel système).
    • Oui, @caf, vous avez probablement raison. Moi, je préfère le changement de l'approche de code depuis que je suis en 64 bits, mais je peux voir la création d'un exécutable 32 bits serait préférable, dans certaines circonstances. Votre réponse fournit probablement le minimum d'effort, de la version de l'obtention de la substance de travail de sorte que c'est probablement la meilleure façon d'aller pour un tutoriel. Donc +1 pour l'.
    • J'ai fait comme @paxdiablo dit, et il a bien fonctionné. Alors, est-ce la bonne façon de faire? Car, pour moi, a bien fonctionné! merci.
    • merci à vous, j'ai été en utilisant Sasm comme l'ide, et il avait des options comme -m64 à l'éditeur de liens et aussi -g qui me donnait des ennuis... BTW propre réponse....
    InformationsquelleAutor paxdiablo
  2. 12

    Vous devez dire à l'éditeur de liens pour produire un i386 fichier de sortie, puisque vous avez écrit i386 assemblée:

    ld -m elf_i386 -s -o hello hello.o
    • lorsque j'utilise cette commande, il retourne la même erreur: ld: i386:x86-64 architecture de fichier d'entrée " bonjour.o' est incompatible avec i386 sortie
    • Non, c'est pas de la même erreur, c'est le contraire de l'erreur, parce que vous aussi, dit nasm pour créer x86-64 sortie. Faire un ou de l'autre, pas les deux! (Je vous suggère fortement de créer i386 de sortie, ce qui signifie en invoquant nasm que ce que vous avez fait, et en invoquant ld de cette façon, puisque vous êtes en train d'écrire i386 assembleur et non x86-64).
    InformationsquelleAutor caf
  3. 4

    Comment compiler, lien, et d'exécuter une msna application sur Ubuntu 64 bits.

    Installer msna:

    sudo apt-get install nasm

    Enregistrer un fichier avec le nom du fichier hello.asm:

    section .data
  hello:     db 'Hello world!',10    ; 'Hello world!' plus a linefeed character
  helloLen:  equ $-hello             ; Length of the 'Hello world!' string
                                     ; (I'll explain soon)

section .text
  global _start

_start:
  mov eax,4            ; The system call for write (sys_write)
  mov ebx,1            ; File descriptor 1 - standard output
  mov ecx,hello        ; Put the offset of hello in ecx
  mov edx,helloLen     ; helloLen is a constant, so we don't need to say
                       ;  mov edx,[helloLen] to get it's actual value
  int 80h              ; Call the kernel

  mov eax,1            ; The system call for exit (sys_exit)
  mov ebx,0            ; Exit with return code of 0 (no error)
  int 80h

    Le compiler:

    nasm -f elf64 hello.asm

    Lien:

    ld -s -o hello hello.o

    Exécuter

    el@apollo:~$ ./hello
Hello world!

    Ça marche!!! Que faire maintenant? Demander à ce que votre favori compilateur de générer le code assembleur qu'il aurait été normalement transmis pour être converti en code machine. Recherche Google: "convertir en php/java/python/c++ programme à l'assemblée"

    Point de vue: Avec tous les gens aujourd'hui essayer de détruire et de se débarrasser de l'informatique pour le grand public, il est impératif que nous enseignent les nouveaux étudiants les concepts de la façon de construire un objectif général de machine de turing à partir de principes de base, sur la place grâce à le métal nu, puis, enfin, les monteurs et les langages de programmation.

    Comment l'apprentissage de l'assemblée de l'aide dans la programmation?
    99% des programmes d'ordinateur sont 10 à 100 fois plus lent que ce qu'ils pourraient optimisé pour être seulement parce que les programmeurs ne sais pas ce que les retards sont contraints par leur favori de haut niveau compilateur ou l'interpréteur.

    Une compréhension approfondie de la pile complète ici signifie que vous pouvez forcer votre des programmes qui a convoité la propriété de ne prendre que des nanosecondes pour faire le travail à la main. Temps == de l'argent. Donc, cette connaissance de la façon de fuir tout ce qui prend plus de temps que quelques nanosecondes pour achever de gagner du temps, et donc de l'argent.

    https://softwareengineering.stackexchange.com/questions/156722/how-does-learning-assembly-aid-in-programming

    • merci à vous, j'ai été en utilisant Sasm comme l'ide, et il avait des options comme -m64 à l'éditeur de liens et aussi -g qui me donnait des ennuis... BTW propre réponse....
    InformationsquelleAutor Eric Leschinski