Erreur lors de la tentative d'exécution du fichier .asm sur NASM sous Ubuntu

Question

J'utilise ubuntu 64 bits et j'essaie d'exécuter un fichier .asm sur MSNA. Mais il renvoie cette erreur lorsque j'essaie d'exécuter le code suivant. Qu'est-ce iM essayer de faire est de construire un exécutable en compilant (ou assemblage) fichier objet à partir de la source $ nasm -f elf hello.asm, puis après a créé le fichier hello.o est la production de fichier exécutable lui-même à partir du fichier objet en invoquant linker

$ ld -s -o hello hello.o 

Cette va enfin construire bonjour exécutable.

que je suis ce tutoriel http://www.faqs.org/docs/Linux-HOWTO/Assembly-HOWTO.html

Erreur:

architecture i386 du fichier d'entrée `hello.o » est incompatible avec i386: sortie x86-64

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 

Answer 1

Cela ressemble à un simple mism atch entre ce qui est produit par nasm et ce que ld tente de faire:

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

En d'autres termes, nasm a produit un fichier objet 32 ​​bits hello.o et ld veut prendre cela et faire un fichier exécutable 64 bits.

La commande nasm -hf 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 votre tutoriel lié vous demande d'exécuter:

nasm -f elf hello.asm 

Essayez d'utiliser:

nasm -f elf64 hello.asm 

à la place, et vous pouvez trouver ld arrêts se plaindre du fichier d'entrée.

Answer 2

Vous devez dire à l'éditeur de liens pour produire un fichier de sortie de i386, puisque vous écrivez ensemble i386:

ld -m elf_i386 -s -o hello hello.o 

Answer 3

Comment compiler, lier et exécuter une application nasm sur bits Ubuntu 64.

Installer nasm:

sudo apt-get install nasm 

Enregistrer un fichier avec le nom de 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 

compiler:

nasm -f elf64 hello.asm 

Faire le lien:

ld -s -o hello hello.o 

Lancez-

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

Il fonctionne! Et maintenant? Demander à votre compilateur favori de générer le code d'assemblage qu'il aurait normalement transmis pour être converti en code machine. Recherche Google: « programme convertir php/java/python/C++ à l'assemblage »

Perspective: Avec tous les gens d'aujourd'hui tentent d'abattre et de se débarrasser de l'informatique à usage général pour le grand public, il est impératif que nous enseignons les nouveaux étudiants les concepts de la façon de construire une machine à turing à usage général à partir des principes de base, à travers le métal nu, puis enfin assembleurs et langages de programmation.

Comment l'apprentissage facilite-t-il la programmation? 99% des programmes informatiques sont 10 à 100 fois plus lents qu'ils ne pourraient l'être parce que les programmeurs ne savent pas quels retards leur sont imposés par leur compilateur ou interpréteur de haut niveau favori.

Une compréhension approfondie de la pile complète ici signifie que vous pouvez contraindre vos programmes à avoir cette propriété convoitée de prendre seulement des nanosecondes pour faire le travail à portée de main. Temps == argent. Donc, cette connaissance de comment éviter tout ce qui prend plus de quelques nanosecondes à compléter permet d'économiser du temps, et donc de l'argent.

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