📌 Demostración: División de dos números mostrando cociente y residuo en ARM64 Assembly

💻 Lenguajes de Interfaz en TECNM Campus ITT
👨‍💻 Autor: Alejandro Suarez Sandoval
📅 Fecha: 2025/04/08

🎯 Descripción

Este programa divide dos números mostrando el resultado en la terminal junto al residuo.
La implementación se realiza en:

✅ Assembly ARM64 para RaspbianOS en Raspberry Pi

🔧 Compilación en Raspberry Pi (ARM64)

as division.s -o division.o  
ld division.o -o division

▶️ Ejecución

./division

👀 Código fuente

🔗 Código fuente en Gist: Programa 20 Division de dos numeros Código Assembly ARM64 para RaspbianOS

/*
 ______  ____               ____  __ __      
/\  _  \/\  _`\   /'\_/`\  /'___\/\ \\ \     
\ \ \L\ \ \ \L\ \/\      \/\ \__/\ \ \\ \    
 \ \  __ \ \ ,  /\ \ \__\ \ \  _``\ \ \\ \_  
  \ \ \/\ \ \ \\ \\ \ \_/\ \ \ \L\ \ \__ ,__\
   \ \_\ \_\ \_\ \_\ \_\\ \_\ \____/\/_/\_\_/
    \/_/\/_/\/_/\/ /\/_/ \/_/\/___/    \/_/  
                                             
♡ ∩_∩ 
(„• ֊ •„)♡
|￣U U￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣| 
| • Lenguajes de Interfaz en TECNM Campus ITT                            |   
| • Autor: Alejandro Suarez Sandoval                                     | 
| • Fecha: 2025/04/08                                                    | 
| • Descripción: Programa que divide dos numeros                         | 
|   en Go y Assembly ARM64 para RaspbianOS.                              | 
| • Demostración:                                                        |
|   https://asciinema.org/a/713384                                       |
| • Compilación (Raspberry Pi ARM64):                                    |  
|     as division.s -o division.o                                        |  
|     ld division.o -o division                                          |  
| • Ejecución: ./division                                                |  
￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣                                        

⠂⠄⠄⠂⠁⠁⠂⠄⠄⠂⠁⠁⠂⠄⠄⠂ ⠂⠄⠄⠂☆
═════════•°• Demostración Código en lenguaje Go •°•═══════

package main

import "fmt"

func main() {
    // Definimos los números a dividir (puedes cambiar estos valores)
    dividendo := 25
    divisor := 4
    
    // Realizamos la división
    cociente := dividendo / divisor
    residuo := dividendo % divisor
    
    // Mostramos el resultado
    fmt.Printf("Resultado: Cociente = %d, Residuo = %d\n", cociente, residuo)
}

════════════════════•°• ☆ •°•══════════════════════════════
/*

/* ⠂⠄⠄⠂⠁⠁⠂⠄⠄⠂⠁⠁⠂⠄⠄⠂ ⠂⠄⠄⠂☆
═════════════•°• Código en ARM64 Assembly •°•═════════════ */

.global _start
.align 4

.data
result_msg:  .asciz "Resultado: Cociente = "
remain_msg:  .asciz ", Residuo = "
newline:     .asciz "\n"

.text
_start:
    // Definimos los números a dividir (valores de ejemplo)
    mov x19, #25       // Dividendo
    mov x20, #4        // Divisor
    
    // Realizamos la división
    udiv x21, x19, x20 // Cociente en x21
    msub x22, x21, x20, x19 // Residuo en x22
    
    // Mostrar mensaje de resultado
    ldr x0, =result_msg
    bl print_string
    
    // Mostrar cociente
    mov x0, x21
    bl print_number
    
    // Mostrar mensaje de residuo
    ldr x0, =remain_msg
    bl print_string
    
    // Mostrar residuo
    mov x0, x22
    bl print_number
    
    // Nueva línea
    ldr x0, =newline
    bl print_string
    
    // Salir correctamente
    mov x0, #0         // Código de retorno 0
    mov x8, #93        // syscall exit
    svc #0

// Función para imprimir string (dirección en x0)
print_string:
    mov x2, #0         // Inicializa contador de longitud
1:
    ldrb w1, [x0, x2]  // Carga byte
    cbz w1, 2f         // Si es cero, termina
    add x2, x2, #1
    b 1b
2:
    mov x1, x0         // Dirección del string
    mov x0, #1         // stdout
    mov x8, #64        // syscall write
    svc #0
    ret

// Función para imprimir número (valor en x0)
print_number:
    // Reservamos espacio en el stack (32 bytes para asegurar alineación)
    sub sp, sp, #32    // Reservamos espacio extra
    
    mov x1, #30        // Posición inicial en buffer (empezamos desde el final)
    mov x2, #10        // Divisor
    
1:
    udiv x3, x0, x2    // x3 = x0 / 10
    msub x4, x3, x2, x0 // x4 = x0 % 10
    add x4, x4, #'0'   // Convertir a ASCII
    sub x1, x1, #1     // Decrementar posición
    strb w4, [sp, x1]  // Almacenar dígito
    mov x0, x3         // Actualizar x0
    cbnz x0, 1b        // Repetir si x0 != 0
    
    // Calcular longitud
    mov x2, #30
    sub x2, x2, x1
    
    // Imprimir
    add x0, sp, x1     // Dirección del string
    mov x1, x0
    mov x0, #1         // stdout
    mov x8, #64        // syscall write
    svc #0
    
    // Restaurar stack
    add sp, sp, #32
    ret