linux - que - Error al intentar ejecutar el archivo.asm en NASM en Ubuntu
nasm rpm (3)
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.
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
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
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.