Fundamentos en

Acerca de Fundamentos

Comentarios

El track de x86-64 en Exercism usa NASM (The Netwide Assembler) como ensamblador. En NASM, los comentarios se preceden con un punto y coma (;).

Los comentarios pueden colocarse en cualquier parte del programa y todo lo que viene después de un ; es ignorado por el ensamblador.

Constantes

En NASM se puede definir una constante en tiempo de ensamblado usando equ. Por ejemplo, esto define una constante llamada UNIVERSE con el valor 42:

UNIVERSE equ 42

Las constantes se evalúan una sola vez, cuando se definen, y no se pueden redefinir después.

Registros de propósito general (GPR)

En ensamblador, en lugar de variables, solemos usar registros para almacenar valores. Un registro de CPU es un trozo de memoria rápida dentro del procesador de una computadora. La mayoría de los cálculos se realizan en los registros de la CPU.

Algunos de los registros se usan para una gran variedad de cálculos distintos y se llaman registros de propósito general (GPR). Otros tienen propósitos especiales o dedicados.

En x86-64 hay 16 registros de propósito general (GPR) de 64 bits, a los que también se puede acceder como de 32 bits, 16 bits u 8 bits. Los GPR se describen a continuación, donde n en rn va de 8 a 15: r8, r9, r10, r11, r12, r13, r14 y r15.

Cuando se usan menos de 64 bits, los bits a los que se accede suelen ser de la parte baja del registro. La excepción a esta regla son ah, bh, ch y dh, que acceden a los 8 bits altos de la parte de 16 bits del registro.

Ilustración de cómo se accede a los bits del registro rax:

+--------+---------------------------------------+
| 64-bit |                  rax                  |
+--------+-------------------+-------------------+
| 32-bit |                   |        eax        |
+--------+-------------------+---------+---------+
| 16-bit |                             |    ax   |
+--------+-----------------------------+----+----+
| 8-bit  |                             | ah | al |
+--------+-----------------------------+----+----+

Algunos de esos registros deben conservarse entre llamadas a funciones: rbp, rsp, rbx, r12, r13, r14 y r15. No conservarlos puede provocar un error o un comportamiento indefinido.

Los demás no se conservan y pueden usarse libremente: rax, rcx, rdx, rdi, rsi, r8, r9, r10 y r11.

Instrucciones

Las instrucciones son piezas de cálculo que una CPU puede realizar. Por lo general tienen la siguiente forma:

name destination, source

Así, primero va el nombre de la instrucción, luego al menos un espacio en blanco, después el operando de destino, una coma (,) y finalmente un operando de origen. Por lo general, una instrucción no modifica el operando de origen, solo el operando de destino.

Ambos operandos deben tener el mismo tamaño, salvo que se indique lo contrario. Por ejemplo, si el operando de origen tiene 16 bits, el operando de destino también debe tener 16 bits.

Por ejemplo, para almacenar un valor en un registro, podemos usar la instrucción mov:

mov rax, rdx  ; rax = rdx
              ; mov is the name, rax is the destination operand and rdx is the source operand

El fragmento anterior copia el contenido de los 64 bits de rdx, el operando de origen, a los 64 bits de rax, que es el operando de destino de la instrucción.

En la mayoría de las instrucciones es posible usar números enteros constantes como operandos de origen (pero no como operandos de destino):

mov rcx, 42 ; rcx = 42
            ; rcx is the destination operand and 42 is the source operand

Ten en cuenta que escribir en un registro de 32 bits también borra los bits altos, así que mov eax, 42 es lo mismo que mov rax, 42. Esto no se cumple para los registros de 16 bits y 8 bits.

Para las operaciones aritméticas de suma, resta y multiplicación, podemos usar las instrucciones add, sub e imul:

add rax, rsi ; rax = rax + rsi
imul rax, rdi ; rax = rax * rdi
sub rax, r8 ; rax = rax - r8

Funciones

Las instrucciones se organizan en funciones. Todas las funciones se colocan en la section .text del archivo fuente.

Una declaración de función consta de:

1. Una etiqueta con el nombre de la función, seguida de un :.
2. Las instrucciones que definen la función.
3. La instrucción de retorno, ret.

Existen convenciones específicas sobre cómo se pasan los argumentos a una función y cómo se devuelven. Las dos convenciones de llamada principales son la System V AMD64 ABI y la Microsoft x64.

Este track usa la convención de llamada System V AMD64 ABI y los seis primeros argumentos enteros se pasan a una función en registros. Se pasan en el siguiente orden: rdi, rsi, rdx, rcx, r8 y r9.

Un valor entero se devuelve desde la función en el registro rax.

Para llamar a una función usamos la instrucción call. Se puede llamar a una función desde cualquier lugar del mismo archivo fuente. Para que una función sea visible desde otros archivos fuente, hay que usar la directiva global.

Por ejemplo, esto declara una función sum:

section .text ; functions are placed here

global sum ; sum is visible to other source files

sum:
    ; first argument is passed in rdi
    ; second argument is passed in rsi
    ; return value is placed in rax

    mov rax, rdi ; rax is now equal to rdi
    add rax, rsi ; rax = rax + rsi

    ret ; function return

Y esto llama a nuestra función sum con los argumentos 3 y 5:

mov rdi, 3  ; First argument in rdi
mov rsi, 5  ; Second argument in rsi
call sum

; The rax register now contains the value 8 (3 + 5), after sum returns