Ejercicio resuelto: suma y máximo de un vector en ensamblador x86-64

La solución tiene tres partes: un prólogo que guarda registros y deja la pila alineada, un bucle que lee los n elementos en vec, y un bucle que recorre el vector acumulando la suma y buscando el máximo. El caso n = 0 se desvía al principio a la etiqueta vacio.

Los valores que deben sobrevivir a las llamadas a libc van en registros callee-saved: rbx guarda n, r12 el índice de lectura y luego la suma, r13 el máximo y r14 la base del vector y luego la posición del máximo.

    .intel_syntax noprefix

    .section .rodata
fmt_in:     .string "%ld"
fmt_suma:   .string "Suma: %ld\n"
fmt_max:    .string "Maximo: %ld (posicion %ld)\n"
msg_vacio:  .string "Vector vacio\n"

    .bss
    .align 8
n:      .skip 8             # numero de elementos
vec:    .skip 8000          # 1000 enteros de 64 bits

    .text
    .globl main
main:
    push rbp                # rsp queda alineado a 16
    mov rbp, rsp
    push rbx                # 4 pushes de 8 bytes = 32 bytes:
    push r12                # la alineacion a 16 se mantiene
    push r13
    push r14

    # scanf("%ld", &n)
    lea rdi, [rip + fmt_in]
    lea rsi, [rip + n]
    xor eax, eax
    call scanf
    cmp eax, 1
    jne vacio
    mov rbx, [rip + n]      # rbx = n
    test rbx, rbx
    jle vacio

    # Bucle de lectura: for (i = 0; i < n; i++) scanf("%ld", &vec[i])
    xor r12d, r12d          # r12 = i = 0
leer:
    cmp r12, rbx
    jge fin_leer
    lea rdi, [rip + fmt_in]
    lea rax, [rip + vec]
    lea rsi, [rax + r12*8]  # rsi = &vec[i]
    xor eax, eax
    call scanf
    inc r12
    jmp leer
fin_leer:

    # Bucle de recorrido: suma y maximo
    lea r14, [rip + vec]    # r14 = &vec[0]
    mov r12, [r14]          # suma = vec[0]
    mov r13, r12            # maximo = vec[0]
    xor edx, edx            # posmax = 0
    mov ecx, 1              # i = 1
recorrer:
    cmp rcx, rbx
    jge fin_recorrer
    mov rax, [r14 + rcx*8]  # rax = vec[i]
    add r12, rax            # suma += vec[i]
    cmp rax, r13
    jle no_max              # con signo; estricto: primera aparicion
    mov r13, rax            # maximo = vec[i]
    mov rdx, rcx            # posmax = i
no_max:
    inc rcx
    jmp recorrer
fin_recorrer:
    mov r14, rdx            # posmax a un registro que sobrevive a printf

    # printf("Suma: %ld\n", suma)
    lea rdi, [rip + fmt_suma]
    mov rsi, r12
    xor eax, eax
    call printf

    # printf("Maximo: %ld (posicion %ld)\n", maximo, posmax)
    lea rdi, [rip + fmt_max]
    mov rsi, r13
    mov rdx, r14
    xor eax, eax
    call printf
    jmp salir

vacio:
    lea rdi, [rip + msg_vacio]
    xor eax, eax
    call printf

salir:
    xor eax, eax            # return 0
    pop r14
    pop r13
    pop r12
    pop rbx
    pop rbp
    ret

    .section .note.GNU-stack,"",@progbits

Datos. En .rodata están las cadenas de formato. fmt_in es "%ld" porque cada elemento es un long de 8 bytes. En .bss se reservan n (8 bytes) y vec (1000 × 8 = 8000 bytes), que el sistema inicializa a cero sin ocupar espacio en el ejecutable. La directiva .align 8 garantiza que cada elemento empiece en una dirección múltiplo de 8.

Prólogo y alineación. Al entrar en main, el call que nos invocó ha apilado la dirección de retorno, así que rsp vale 8 módulo 16. Con push rbp pasa a 0 módulo 16. Los cuatro push siguientes suman 32 bytes y mantienen esa alineación, de modo que todas las llamadas posteriores se hacen con la pila alineada sin necesidad de sub rsp. Esos cuatro registros se apilan porque la ABI obliga a main a devolverlos intactos.

Lectura de n. Se pasa el formato en rdi y la dirección de n en rsi, calculada con lea relativo a rip. xor eax, eax indica a la función variádica que no se pasan argumentos en registros vectoriales. Si scanf no devuelve 1 (entrada vacía) o si n ≤ 0, el flujo salta a vacio. Así se cubre el test «vector vacío», que imprime Vector vacio.

Bucle leer. Es un for con la condición al principio: cmp r12, rbx y jge fin_leer. La instrucción clave es lea rsi, [rax + r12*8], que calcula &vec[i] sin acceder a memoria. El índice está en r12 y n en rbx, y ambos sobreviven a las sucesivas llamadas a scanf. Si se usara rcx como contador, cualquier llamada podría destruirlo.

Bucle recorrer. La suma y el máximo empiezan en vec[0], la posición en 0 y el índice en 1. En cada vuelta se carga vec[i] en rax y se acumula en r12. Después se compara con el máximo en r13. El salto jle no_max es con signo y deja pasar solo los valores estrictamente mayores. Por eso, en el ejemplo, donde el 9 aparece en las posiciones 2 y 4, se informa la posición 2. Aquí sí se pueden usar rcx y rdx, porque dentro del bucle no hay ninguna llamada.

Escritura. Antes del primer printf, la posición se copia de rdx a r14, ya que printf puede machacar rdx. La base del vector ya no hace falta, así que r14 queda libre. Luego se hacen dos llamadas con los argumentos en rdi, rsi y rdx, siempre en el orden de la ABI. El epílogo restaura los registros en orden inverso y devuelve 0 en eax.

Casos de prueba. El test con todos los valores negativos (máximo −3) comprueba que no se ha inicializado el máximo a 0. El de un solo elemento comprueba que el bucle de recorrido no ejecuta ninguna vuelta y aun así se imprime vec[0]. El de valores grandes produce una suma de 3999999999, que no cabe en 32 bits con signo: confirma que se usan registros de 64 bits y el formato %ld. El último caso sitúa el máximo en la posición 4 para comprobar que se procesa el último elemento.