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éricoBaseSintaxis en NASMRango de números (32 bits)
Binario20b10101010o10101010b0 y 1
Octal80o52o52o0-7
Decimal10420-9
Hexadecimal160x2Ao2Ah0-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ácterValor ASCIIValor 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

; Ruta del archivo: string_to_int.asm
; 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

; Ruta del archivo: int_to_string.asm
; 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

; Ruta del archivo: hex_output.asm
; 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

; Ruta del archivo: simple_calc.asm
; 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

En 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.

Otras extensiones