Conceptos básicos
Comentarios
La pista 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
Una constante en tiempo de ensamblado se puede definir en NASM con 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 (GPRs)
En ensamblador, en lugar de variables, normalmente usamos registros para almacenar valores.
Un registro de CPU es una porción 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 variedad de cálculos distintos y se llaman registros de propósito general (GPRs).
Otros tienen propósitos especiales o dedicados.
En x86-64 hay 16 registros de propósito general (GPRs) de 64 bits, a los que también se puede acceder como 32 bits, 16 bits u 8 bits.
Los GPRs se describen a continuación, donde n en rn va del 8 al 15: r8, r9, r10, r11, r12, r13, r14 y r15.
| 64 bits |
32 bits |
16 bits |
8 bits |
| rax |
eax |
ax |
ah/al |
| rbx |
ebx |
bx |
bh/bl |
| rcx |
ecx |
cx |
ch/cl |
| rdx |
edx |
dx |
dh/dl |
| rsi |
esi |
si |
sil |
| rdi |
edi |
di |
dil |
| rbp |
ebp |
bp |
bpl |
| rsp |
esp |
sp |
spl |
| rn |
rnd |
rnw |
rnb |
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 preservarse a través de las llamadas a funciones: rbp, rsp, rbx, r12, r13, r14 y r15.
No preservarlos puede provocar un error o un comportamiento indefinido.
Los demás no se preservan y se pueden usar libremente: rax, rcx, rdx, rdi, rsi, r8, r9, r10 y r11.
Más adelante en el temario aprenderás a preservar registros.
Por ahora, usa solo el segundo tipo de registros: rax, rcx, rdx, rdi, rsi, r8, r9, r10 y r11.
Instrucciones
Las instrucciones son fragmentos de cálculo que una CPU puede realizar.
Normalmente tienen la siguiente forma:
name destination, source
Entonces, primero se coloca el nombre de la instrucción, luego al menos un espacio en blanco, después el operando destino, una coma (,) y por último un operando fuente.
Por lo general, una instrucción no modifica el operando fuente, solo el operando destino.
Ambos operandos deben tener el mismo tamaño, a menos que se indique lo contrario.
Por ejemplo, el operando destino también debe tener 16 bits si el operando fuente tiene 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 fuente, a los 64 bits de rax, que es el operando destino de la instrucción.
En la mayoría de las instrucciones es posible usar números enteros constantes como operandos fuente (pero no como operandos 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 es cierto para los registros de 16 bits y de 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.
La declaración de una función consta de:
- Una etiqueta con el nombre de la función, seguida de un
:.
- Las instrucciones que definen la función.
- La instrucción de retorno,
ret.
Esta pista usa la convención de llamadas 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 parte del mismo archivo fuente.
Para que una función sea visible desde otros archivos fuente, se debe 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
Ejercicio de aprendizaje
