Lenguaje ensamblador - Procesamiento de números
En el lenguaje ensamblador, el procesamiento de números implica la combinación de conversión de bases, conversión ASCII y operaciones aritméticas. Este capítulo explica en detalle cómo ingresar y generar números en diferentes bases en un programa.
Representación de números
Internamente, todos los números en una computadora se almacenan en binario, pero en un programa se pueden representar en diferentes bases:
| Sistema numérico | Base | Sintaxis en NASM | Rango de números (32 bits) |
|---|---|---|---|
| Binario | 2 | 0b10101010o10101010b | 0 y 1 |
| Octal | 8 | 0o52o52o | 0-7 |
| Decimal | 10 | 42 | 0-9 |
| Hexadecimal | 16 | 0x2Ao2Ah | 0-9, A-F |
Relación entre ASCII y números
Lo que se ingresa y se muestra en pantalla soncaracteres ASCII, no valores binarios.
Comprender la conversión entre caracteres y valores numéricos es el núcleo del procesamiento de números en ensamblador:
| Carácter | Valor ASCII | Valor numérico correspondiente |
|---|---|---|
| '0' | 0x30(48) | 0 |
| '1' | 0x31(49) | 1 |
| '9' | 0x39(57) | 9 |
| 'A' | 0x41(65) | 10 (hexadecimal) |
| 'F' | 0x46(70) | 15 (hexadecimal) |
| 'a' | 0x61(97) | 10 (hexadecimal) |
Conversión de carácter a número:数值 = ASCII码 - '0'(es decir,ASCII码 - 0x30)
Conversión de número a carácter:ASCII码 = 数值 + '0'(es decir,数值 + 0x30)
Entrada de números (conversión de cadena a valor numérico)
El usuario ingresa una secuencia de caracteres, que debe convertirse a un valor binario para poder usarse en cálculos:
Ejemplo
; Convierte una cadena de dígitos decimales a un valor entero
section .data
input_str db '12345', 0 ; Cadena de entrada "12345"
input_len dd 5 ; Longitud de la cadena
section .bss
result_val resd 1 ; Almacena el valor convertido
section .text
global _start
_start:
; Algoritmo de conversión: result = 0
; result = result * 10 + (carácter actual - '0')
mov esi, input_str ; esi apunta a la cadena de entrada
mov ecx, [input_len] ; ecx = número de iteraciones
mov eax, 0 ; eax = resultado acumulado
convert_loop:
mov ebx, 10
mul ebx ; eax = eax * 10
; mul ebx: edx:eax = eax * ebx
mov bl, [esi] ; Lee el carácter actual
sub bl, '0' ; Convierte a valor numérico: carácter - '0'
movzx ebx, bl ; Extiende con ceros ebx (bl -> ebx)
add eax, ebx ; eax = eax + valor del dígito actual
inc esi ; Avanza al siguiente carácter
loop convert_loop
; eax ahora = 12345
mov [result_val], eax ; Guarda el resultado
mov eax, 1
mov ebx, 0
int 0x80
Análisis del algoritmo: tomando "12345" como ejemplo:
Iteración 1: result = 0×10 + 1 = 1
Iteración 2: result = 1×10 + 2 = 12
Iteración 3: result = 12×10 + 3 = 123
...finalmente se obtiene 12345.
Salida de números (conversión de valor numérico a cadena)
Convierte un valor binario a una cadena decimal visible:
Ejemplo
; Convierte un valor entero a una cadena decimal para su salida
section .data
number dd 12345 ; Número a mostrar
newline db 0xA
section .bss
output_buf resb 12 ; Búfer de salida (el entero de 32 bits máximo es 10 dígitos + signo + null)
section .text
global _start
_start:
mov eax, [number] ; Carga el número
mov edi, output_buf + 11 ; edi apunta al final del búfer
mov byte [edi], 0 ; Terminador null (para facilitar la depuración)
dec edi
mov ebx, 10 ; Divisor = 10
mov ecx, 0 ; Contador de dígitos
convert_digit:
mov edx, 0 ; Pon edx a cero (div requiere edx:eax)
div ebx ; eax = eax/10, edx = eax%10
add dl, '0' ; Convierte el resto a carácter
mov [edi], dl ; Almacena en el búfer (de atrás hacia adelante)
dec edi ; Mueve el puntero del búfer hacia adelante
inc ecx ; Dígitos +1
cmp eax, 0 ; ¿Es el cociente 0?
jne convert_digit ; No, continúa el bucle
; Ahora edi+1 apunta al primer dígito significativo
inc edi ; Ajusta el puntero para que apunte al inicio de la cadena
; Calcula la longitud de los caracteres significativos
; output_buf + 11 - edi es la longitud efectiva
; Muestra el número
mov eax, 4
mov ebx, 1
mov ecx, edi ; Apunta a la cadena convertida
; Calcula la longitud
mov edx, output_buf + 11
sub edx, edi ; edx = final del búfer - inicio de la cadena
int 0x80
; Muestra un salto de línea
mov eax, 4
mov ebx, 1
mov ecx, newline
mov edx, 1
int 0x80
mov eax, 1
mov ebx, 0
int 0x80
Resultado de la ejecución:
$ nasm -f elf32 int_to_string.asm -o int_to_string.o $ ld -m elf_i386 int_to_string.o -o int_to_string $ ./int_to_string 12345
Entrada y salida hexadecimal
El procesamiento hexadecimal requiere manejar la conversión de 0-9 y A-F/a-f:
Ejemplo
; Muestra el valor en formato hexadecimal
section .data
number dd 0x1A2B3C4D ; Valor a mostrar
hex_prefix db '0x'
hex_prefix_len equ $ - hex_prefix
newline db 0xA
section .bss
hex_buf resb 10 ; 8 dígitos hexadecimales + prefijo + null
section .text
global _start
_start:
; Muestra el prefijo "0x"
mov eax, 4
mov ebx, 1
mov ecx, hex_prefix
mov edx, hex_prefix_len
int 0x80
mov eax, [number] ; Valor a convertir
mov edi, hex_buf + 8 ; Final del búfer (8 dígitos hexadecimales)
mov ecx, 8 ; Bucle 8 veces (32 bits = 8 dígitos hexadecimales)
hex_loop:
mov edx, 0 ; Prepara la división
mov ebx, 16 ; Divide entre 16
div ebx ; Ahora: eax dividido por ebx
; Nota: aquí div ebx en realidad es edx:eax / ebx
; El resto está en edx (0-15), el cociente en eax
mov ebx, eax ; Guarda el cociente
; Convierte el resto a carácter hexadecimal
mov al, dl
cmp al, 10
jl digit_09 ; 0-9
add al, 'A' - 10 ; A-F
jmp store_char
digit_09:
add al, '0' ; 0-9
store_char:
dec edi
mov [edi], al
mov eax, ebx ; Recupera el cociente
loop hex_loop
; Se eliminó el bucle, se usa decremento directamente
; Muestra los dígitos hexadecimales (8 dígitos)
mov eax, 4
mov ebx, 1
mov ecx, hex_buf
mov edx, 8
int 0x80
; Muestra un salto de línea
mov eax, 4
mov ebx, 1
mov ecx, newline
mov edx, 1
int 0x80
mov eax, 1
mov ebx, 0
int 0x80
Ejemplo completo: calculadora de suma simple
Ingresa dos números de un dígito desde el teclado, calcula su suma y la muestra:
Ejemplo
; Ingresa dos números de un dígito (0-9), calcula la suma y la muestra
section .data
prompt1 db 'Enter first number (0-9): '
prompt1_len equ $ - prompt1
prompt2 db 'Enter second number (0-9): '
prompt2_len equ $ - prompt2
result_msg db 'Sum = '
result_msg_len equ $ - result_msg
newline db 0xA
section .bss
num1 resb 2 ; Entrada del primer número (1 dígito + salto de línea)
num2 resb 2 ; Entrada del segundo número
result_str resb 3 ; Cadena de resultado (máximo 2 dígitos + salto de línea)
section .text
global _start
_start:
; Solicita el primer número
mov eax, 4
mov ebx, 1
mov ecx, prompt1
mov edx, prompt1_len
int 0x80
; Lee el primer número
mov eax, 3
mov ebx, 0
mov ecx, num1
mov edx, 2
int 0x80
; Solicita el segundo número
mov eax, 4
mov ebx, 1
mov ecx, prompt2
mov edx, prompt2_len
int 0x80
; Lee el segundo número
mov eax, 3
mov ebx, 0
mov ecx, num2
mov edx, 2
int 0x80
; Calcula la suma
mov al, [num1] ; Lee el primer número (carácter ASCII)
sub al, '0' ; Convierte a valor numérico
mov bl, [num2] ; Lee el segundo número
sub bl, '0' ; Convierte a valor numérico
add al, bl ; Suma
; Convierte el resultado a cadena
mov ah, 0 ; Prepara la división
mov bl, 10 ; Divide entre 10
div bl ; al = dígito de las decenas, ah = dígito de las unidades
; Guarda el resultado
add al, '0' ; Convierte la decena a carácter
mov [result_str], al ; Almacena la decena
add ah, '0' ; Convierte la unidad a carácter
mov [result_str + 1], ah ; Almacena la unidad
mov byte [result_str + 2], 0xA ; Salto de línea
; Muestra el mensaje de resultado
mov eax, 4
mov ebx, 1
mov ecx, result_msg
mov edx, result_msg_len
int 0x80
; Muestra el resultado del cálculo (puede ser de 1 o 2 dígitos)
mov eax, 4
mov ebx, 1
mov ecx, result_str
cmp byte [result_str], '0'
je output_one_digit ; Si la decena es '0', muestra solo la unidad
mov edx, 3 ; 2 dígitos + salto de línea
jmp do_output
output_one_digit:
inc ecx ; Omite el '0' de las decenas
mov edx, 2 ; 1 dígito + salto de línea
do_output:
int 0x80
mov eax, 1
mov ebx, 0
int 0x80
Resultado de la ejecución:
$ nasm -f elf32 simple_calc.asm -o simple_calc.o $ ld -m elf_i386 simple_calc.o -o simple_calc $ ./simple_calc Enter first number (0-9): 7 Enter second number (0-9): 8 Sum = 15
Otras extensionesEn ensamblador, manejar la entrada y salida de números requiere una comprensión clara de la codificación ASCII y la conversión de bases. La conversión de número a cadena (int to string) y de cadena a número (string to int) son las dos funciones de utilidad más básicas. Se recomienda guardarlas como plantilla después de escribirlas, para poder reutilizarlas directamente más adelante.