linux - que - Error al intentar ejecutar el archivo.asm en NASM en Ubuntu

nasm rpm

Question

Estoy usando ubuntu de 64 bits e intento ejecutar un archivo .asm en NASM. Pero devuelve este error cuando intento ejecutar el siguiente código. Lo que trato de hacer es construir un ejecutable compilando (o ensamblando) un archivo de objeto desde el origen $ nasm -f elf hello.asm , y luego de creado el archivo hello.o está produciendo el archivo ejecutable mismo desde el archivo objeto invocando el enlazador

$ ld -s -o hello hello.o

Esto finalmente construirá hello ejecutable.

Estoy siguiendo este tutorial http://www.faqs.org/docs/Linux-HOWTO/Assembly-HOWTO.html

Error:

La arquitectura i386 del archivo de entrada `hello.o ''no es compatible con i386: salida x86-64

Código:

     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

Cómo compilar, vincular y ejecutar una aplicación nasm en Ubuntu 64 bit.

Instalar nasm:

sudo apt-get install nasm

Guarde un archivo con el nombre de archivo 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

Compilarlo:

nasm -f elf64 hello.asm

Vincularlo:

ld -s -o hello hello.o

Ejecutarlo

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

¡Funciona! ¿Ahora que? Solicite que su compilador favorito genere el código de ensamblaje que normalmente se hubiera pasado para convertirlo a código de máquina. Búsqueda en Google: "convertir el programa php / java / python / c ++ al ensamblado"

Perspectiva: con todas las personas que hoy intentan derribar y deshacerse de la computación de propósito general para el público en general, es imperativo que enseñemos a los nuevos estudiantes los conceptos de cómo construir una máquina de turing de uso general a partir de principios básicos, en adelante a través del bare metal, luego finalmente ensambladores y lenguajes de programación.

¿Cómo ayuda aprender a ensamblar en la programación? El 99% de los programas de computación disponibles son de 10 a 100 veces más lentos de lo que podrían haber optimizado, solo porque los programadores no saben qué retrasos les están imponiendo su compilador o intérprete de alto nivel favorito.

Una comprensión completa de la pila completa aquí significa que puede obligar a sus programas a tener esa propiedad codiciada de solo tomar nanosegundos para hacer el trabajo a mano. Tiempo == dinero. Así que este conocimiento de cómo evitar algo que lleva más de unos pocos nanosegundos para completar ahorra tiempo y, por lo tanto, dinero.

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

Answer 2

Necesita decirle al vinculador que produzca un archivo de salida i386, ya que está escribiendo el ensamblaje i386:

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

Answer 3

Parece que puede tratarse de un desajuste simple entre lo que produce nasm y lo que intenta hacer:

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

En otras palabras, nasm ha producido un archivo de objetos de 32 bits hello.o y ld quiere tomar eso y crear un archivo ejecutable de 64 bits.

El comando nasm -hf debería darle los formatos de salida 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

Veo que su tutorial vinculado le pide que ejecute:

nasm -f elf hello.asm

Intenta usar:

nasm -f elf64 hello.asm

en cambio, y puede encontrar que ld deja de quejarse del archivo de entrada.