Explication del primer programa
Explicación Paso a Paso
1. Sección de Datos ( section .data )
section .data
msg db 'Hola, mundo!', 0xA ; Define el mensaje
len equ $ - msg ; Calcula su longitud
section .data :
Es como un pizarrón donde escribimos información que el programa usará (como
variables).
msg db 'Hola, mundo!', 0xA :
msg : Es el nombre de nuestra variable (como una etiqueta en una caja).
db : Significa "define bytes" (guardamos letras y números en la memoria).
'Hola, mundo!' : El texto que queremos mostrar.
0xA : Es el código para un salto de línea (como presionar Enter).
len equ $ - msg :
len : Otra variable que guarda la longitud del mensaje.
$ : Representa la posición actual (como un puntero).
$ - msg : Resta la posición actual del inicio de msg , dando la longitud del texto.
2. Sección de Código ( section .text )
section .text
global _start
section .text :
Aquí van las instrucciones que la CPU ejecutará (como los pasos de una receta).
global _start :
Le dice al sistema: "¡El programa empieza aquí!" (como el punto de partida en un mapa).
3. Etiqueta _start (Inicio del Programa)
_start:
Es como decir: "Paso 1: Comenzar".
4. Mostrar el Mensaje en Pantalla
mov eax, 4 ; sys_write (escribir)
mov ebx, 1 ; stdout (pantalla)
mov ecx, msg ; dirección del mensaje
mov edx, len ; longitud del mensaje
int 0x80 ; llamada al sistema
mov eax, 4 :
eax : Es un "registro" (una caja donde guardamos datos).
4 : Es el código para "escribir en pantalla" (como pedirle a la computadora que muestre
algo).
mov ebx, 1 :
ebx : Otro registro.
1 : Significa "pantalla" (stdout).
mov ecx, msg :
ecx : Guarda la dirección de memoria donde está el mensaje.
mov edx, len :
edx : Guarda la longitud del mensaje (para saber cuánto mostrar).
== int 0x80 :==
Es como tocar un timbre para llamar al sistema operativo y decirle: "¡Ejecuta lo que
pedí!".
5. Terminar el Programa
mov eax, 1 ; sys_exit (salir)
int 0x80 ; llamada al sistema
mov eax, 1 :
1 : Es el código para "terminar el programa".
int 0x80 :
Otra llamada al sistema para decir: "¡Termina el programa!".
Resumen en Pasos Sencillos
1. Preparamos el mensaje ( msg ) y su longitud ( len ) en la sección .data .
2. Iniciamos el programa en _start .
3. Configuramos los registros para decirle al sistema:
"Quiero escribir ( eax=4 )"
"En la pantalla ( ebx=1 )"
"Este texto ( ecx=msg )"
"De esta longitud ( edx=len )"
4. Llamamos al sistema ( int 0x80 ) para que lo muestre.
5. Terminamos el programa ( eax=1 + int 0x80 ).
¿Qué hace el programa al final?
Simplemente muestra "Hola, mundo!" en la pantalla y luego se cierra.
🔹 Si esto fuera una receta de cocina:
.data = Lista de ingredientes.
.text = Pasos para cocinar.
mov = Poner ingredientes en tazones (registros).
int 0x80 = Pedirle al chef (sistema operativo) que cocine.
¿Hay alguna parte que quieras que explique con más detalle? 😊
los codices para escribir o Mostar en pantalla por ejemplo 1 y 4, cuales mas existen y que hace
cada uno
¡Excelente pregunta! En ensamblador para Linux (x86), los códigos de llamadas al sistema
(como 1 para salir y 4 para escribir) están definidos por el kernel. Aquí te dejo una tabla con
los más importantes y su función:
📜 Llamadas al Sistema Básicas (x86 Linux)
(Se usan con int 0x80 y el código en EAX )
Código Nombre Uso Parámetros (EBX, ECX, EDX...)
(EAX)
1 sys_exit Termina el EBX = Código de salida (0 = éxito)
programa
2 sys_fork Crea un proceso -
hijo
3 sys_read Lee entrada EBX = File descriptor (0 = teclado),
(teclado/archivo) ECX = Buffer (donde guardar datos),
EDX = Longitud máxima
4 sys_write Escribe en EBX = File descriptor (1 = pantalla),
pantalla/archivo ECX = Mensaje a mostrar, EDX =
Longitud del mensaje
5 sys_open Abre un archivo EBX = Nombre del archivo, ECX =
Modo (lectura/escritura), EDX =
Permisos
6 sys_close Cierra un archivo EBX = File descriptor
11 sys_execve Ejecuta un EBX = Ruta al programa, ECX =
programa Argumentos
12 sys_chdir Cambia de EBX = Ruta del directorio
directorio
🖥️ Ejemplos Prácticos
1. Leer entrada del teclado ( sys_read )
section .bss
input resb 32 ; Reserva 32 bytes para la entrada
section .text
global _start
_start:
mov eax, 3 ; sys_read
mov ebx, 0 ; 0 = teclado (stdin)
mov ecx, input ; Buffer donde se guarda lo leído
mov edx, 32 ; Máximo 32 caracteres
int 0x80
; (Luego podrías mostrar 'input' con sys_write)
2. Abrir y leer un archivo ( sys_open + sys_read )
section .data
archivo db "mi_archivo.txt", 0
section .bss
contenido resb 1024
section .text
global _start
_start:
; Abrir archivo
mov eax, 5 ; sys_open
mov ebx, archivo ; Nombre del archivo
mov ecx, 0 ; 0 = solo lectura
int 0x80
; Leer archivo (EAX ahora tiene el file descriptor)
mov ebx, eax ; File descriptor a EBX
mov eax, 3 ; sys_read
mov ecx, contenido ; Buffer
mov edx, 1024 ; Bytes a leer
int 0x80
; Cerrar archivo
mov eax, 6 ; sys_close
int 0x80
🔍 ¿Cómo encontrar más llamadas al sistema?
1. En Linux x86:
Ejecuta en terminal:
cat /usr/include/asm/unistd_32.h | grep "__NR_"
O consulta esta tabla completa.
2. En x86-64:
Los códigos son diferentes (ej: sys_write es 1 en vez de 4 ).
Se usa syscall en vez de int 0x80 .
📌 Key Points
int 0x80 es la interrupción para llamar al kernel en x86 (32 bits).
Los parámetros van en registros ( EBX , ECX , EDX , etc.).
En x86-64 se usa syscall y los códigos cambian (ej: sys_write es 1 ).