Programación en ensamblador (x86-64)

mov rbx, var       ;se carga en rbx la dirección de la variable var
mov rax, [rbx+4]   ;el segundo operando utiliza direccionamiento relativo
                   ;4 es el desplazamiento respecto a esta dirección
mov [rbx+16], rcx  ;rbx contiene la dirección base, 16 es el
                   ;desplazamiento respecto a esta dirección.

• mov destino, fuente: instrucción genérica para mover un dato desde un origen a un destino.

• push fuente: instrucción que mueve el operando de la instrucción a la cima de la pila.

• pop destino: mueve el dato que se encuentra en la cima de la pila al operando destino.

• xchg destino, fuente: intercambia contenidos de los operandos.

• add destino, fuente: suma aritmética de los dos operandos.

• adc destino, fuente: suma aritmética de los dos operandos considerando el bit de transporte.

• sub destino, fuente: resta aritmética de los dos operandos.

• sbb destino, fuente: resta aritmética de los dos operandos considerando el bit de transporte.

• inc destino: incrementa el operando en una unidad.

• dec destino: decrementa el operando en una unidad.

• mul fuente: multiplicación entera sin signo.

• imul fuente: multiplicación entera con signo.

• div fuente: división entera sin signo.

• idiv fuente: división entera con signo.

• neg destino: negación aritmética en complemento a 2.

• cmp destino, fuente: comparación de los dos operandos; hace una resta sin guardar el resultado.

• and destino, fuente: operación 'y' lógica.

• or destino, fuente: operación 'o' lógica.

• xor destino, fuente: operación `o exclusiva´ lógica.

• not destino: negación lógica bit a bit.

• test destino, fuente: comparación lógica de los dos operandos; hace una 'y' lógica sin guardar el resultado.

• sal destino, fuente / shl destino, fuente: desplazamiento aritmético/lógico a la izquierda.

• sar destino, fuente: desplazamiento aritmético a la derecha.

• shr destino, fuente: desplazamiento lógico a la derecha.

• rol destino, fuente: rotación lógica a la izquierda.

• ror destino, fuente: rotación lógica a la derecha.

• rcl destino, fuente: rotación lógica a la izquierda considerando el bit de transporte.

• rcr destino, fuente: rotación lógica a la derecha considerando el bit de transporte.

• jmp etiqueta: salta de manera incondicional a la etiqueta.

• je etiqueta / jz etiqueta: salta a la etiqueta si igual, si el bit de cero es activo.

• jne etiqueta / jnz etiqueta: salta a la etiqueta si diferente, si el bit de cero no es activo.

• jc etiqueta: salta a la etiqueta si el bit de transporte es activo.

• jnc etiqueta: salta a la etiqueta si el bit de transporte no es activo.

• jo etiqueta: salta a la etiqueta si el bit de desbordamiento es activo.

• jno etiqueta: salta a la etiqueta si el bit de desbordamiento no es activo.

• js etiqueta: salta a la etiqueta si el bit de signo es activo.

• jns etiqueta: salta a la etiqueta si el bit de signo no es activo.

• jb etiqueta / jnae etiqueta: salta a la etiqueta si es más pequeño.

• jbe etiqueta / jna etiqueta: salta a la etiqueta si es más pequeño o igual.

• ja etiqueta / jnbe etiqueta: salta a la etiqueta si es mayor.

• jae etiqueta / jnb etiqueta: salta a la etiqueta si es mayor o igual.

• jl etiqueta / jnge etiqueta: salta si es más pequeño.

• jle etiqueta / jng etiqueta: salta si es más pequeño o igual.

• jg etiqueta / jnle etiqueta: salta si es mayor.

• jge etiqueta / jnl etiqueta: salta si es mayor o igual.

• loop etiqueta: decrementa el registro rcx y salta si rcx es diferente de cero.

• call etiqueta: llamada a subrutina.

• ret: retorno de subrutina.

• iret: retorno de rutina de servicio de interrupción (RSI).

• int servicio: llamada al sistema operativo.

• in destino, fuente: lectura del puerto de E/S especificado en el operando fuente y se guarda en el operando destino.

• out destino, fuente: escritura del valor especificado por el operando fuente en el puerto de E/S especificado en el operando destino.

• caracteres (char),

• enteros (int) y (long) y

• números reales (float) y (double).

/*Una variable de tipo carácter inicializada con el valor 'A'*/
char c='A';
/*Dos variables de tipo entero, una inicializada y otra sin
inicializar*/
int x=0, y;
/*Un número real, expresado en punto fijo*/
float pi=3.1416;

int vector[]={1, 2, 3, 4, 5};         // vector de 5 enteros
char cadena[4]={'H', 'o', 'l', 'a'};  // vector de 4 caracteres
int vector2[3]={1, 2};                // vector de 3 enteros con las dos
                                      // primeras posiciones inicializadas
int vector2[3]={1, 2, 3, 4};          // declaración incorrecta
    int matriz[][]={{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
                                      // matriz de enteros de 3 filas y 4 columnas

;direccionamiento indirecto
mov edx, vec_int             ;Tomamos la dirección del vector
mov DWORD [edx], 0           ;Ponemos a 0 el primer elemento del vector vec_int
add edx, 4                   ;Sumamos 4 para acceder al siguiente elemento del vector
add DWORD [edx], 0           ;Ponemos a 0 el segundo elemento del vector vec_int
add edx, 4                   ;Sumamos 4 para acceder al siguiente elemento del vector
...

;direccionamiento relativo
mov al, byte [vec_char+0]    ;primer elemento del vector, vec_char[0]
mov bl, byte [vec_char+1]    ;segundo elemento del vector, vec_char[1]

mov eax, dword [vec_int+0]   ;primer elemento del vector, vec_int[0]
mov ebx, dword [vec_int+12]  ;cuarto elemento del vector, vec_int[3]

;direccionamiento indexado
   mov esi, 0                ;Inicializamos el índice para acceder al vector.
  inicializa:
mov dword [vec_int+esi],0    ;Ponemos a 0 un elemento del vector
   add esi, 4                ;Sumamos 4 para acceder al siguiente elemento del vector 
   cmp esi, 12               ;Accedemos a vec_int[0], vec_int[1]
   jle inicializa            ;vec_int[2] y vec_int[3]

;combinación indexado y relativo
mov edx, vec_int             ;Tomamos la dirección del vector
mov esi, 0                   ;Inicializamos el índice para acceder al vector.
  inicializa:
mov dword [edx+esi*4],0      ;Ponemos a 0 un elemento del vector
   add esi, 1                ;Sumamos 1 para acceder al siguiente elemento del
                             ;vector porque utilizamos el factor de escala 4
    cmp esi, 3               ;Accedemos a vec_int[0], vec_int[1]  
   jle inicializa            ;vec_int[2] y vec_int[3]

	vec dd 1,2,3,4,5,6
  mat dd 1,2,3
     dd 4,5,6

                                ;recorremos el vector para sumarlo
  mov esi,0                     ;esi será el índice para acceder a los datos
  mov eax,0                     ;eax será donde guardaremos la suma
loop_vec:
  add eax, dword[vec+esi*4]     ;multiplican el índice por 4
  inc esi                       ;porque cada elemento ocupa 4 bytes.
  cmp esi, 6                    ;comparamos con 6 porque es el índice del primer
                                ;elemento fuera del vector.
  jl loop_vec

                                ;recorremos la matriz con un solo índice para sumarla
  mov esi,0                     ;esi será el índice para acceder a los datos
  mov ebx,0                     ;ebx será donde guardaremos la suma
loop_mat:
  add ebx, dword[mat+esi*4]     ;multiplican el índice por 4
  inc esi                       ;porque cada elemento ocupa 4 bytes.
  cmp esi, 6                    ;comparamos con 6 porque es el índice del primer elemento
                                ;fuera de la matriz, la matriz tiene 2*3=6 elementos.
jl loop_mat

                                ;recorremos la matriz con dos índices para sumarla
  mov esi,0                     ;esi será el índice de la columna
  mov edi,0                     ;edi será el índice de la fila
  mov ebx,0                     ;ebx será donde guardaremos la suma
loop_mat2:
  add ebx, dword[mat+edi+esi*4] ;multiplican el índice de la columna
  inc esi                       ;por 4 porque cada elemento ocupa 4 bytes.
  cmp esi, 3                    ;comparamos con 3 porque son los elementos de una fila.
  jl loop_mat2
  mov esi, 0
  add edi, 12                   ;cada fila ocupa 12 bytes, 3 elementos de 4 bytes.
  cmp edi, 24                   ;comparamos con 24 porque es el primer índice
  jl loop_mat2                  ; fuera de la matriz.

  Supongamos que rax = 0102030405060708h (registro de 64 bits),
bx = 0A0Bh (registro de 16 bits) y rsp = 0000000010203050h.

push rax
push bx
pop bx
pop rax

• push rax. Decrementa RSP en 8 unidades y traslada el valor del registro RAX a partir de la posición de memoria indicada por RSP; funcionalmente la instrucción anterior sería equivalente a:

sub rsp, 8
mov qword[rsp], rax

• push bx. Decrementa RSP en 2 unidades y traslada el valor del registro BX a partir de la posición de memoria indicada por RSP; funcionalmente la instrucción anterior sería equivalente a:

sub rsp, 2
mov word[rsp], bx

• pop bx. Traslada hacia BX el valor de 2 bytes almacenado a partir de la posición de memoria indicada por RSP, a continuación se incrementa RSP en 2. Sería equivalente a efectuar:

mov bx, word [rsp]
add rsp, 2

• pop rax. Traslada hacia RAX el valor de 8 bytes almacenado a partir de la posición de memoria indicada por RSP, a continuación se incrementa RSP en 8. Sería equivalente a efectuar:

mov rax, qword [rsp]
add rsp, 8

switch (variable) {
  case valor1:   sentencia1;
                 break;
  case valor2:   sentencia2;
                 ...
                 break;
                 ...
  default:       sentenciaN;
}

switch:  mov rax, qword [var]
         cmp rax, 1
         jne case2
         mov rbx, qword [b]
         add qword [a], rbx
         jmp end_s...
case2:   cmp rax, 2
         jne case3
         mov rbx, qword [b]
         sub qword [a], rbx
         jmp end_s
case3:   cmp rax, 3
         jne default
         mov rbx, qword [b]
         mul qword [a], rbx
         jmp end_s
default: neg qword [a]
end_s:

subrutina:
   ;
   ; Instrucciones de la subrutina
   ;
   ret

• Debemos almacenar los registros modificados dentro de la subrutina para dejarlos en el mismo estado en el que se encontraban en el momento de hacer la llamada a la subrutina, salvo los registros que se utilicen para devolver un valor. Para almacenar los registros modificados utilizaremos la pila.

• Para mantener la estructura de una subrutina y para que el programa funcione correctamente, no se pueden efectuar saltos a instrucciones de la subrutina; siempre finalizaremos la ejecución de la subrutina con la instrucción ret.

subrutina:
   ; Almacenar en la pila
   ; los registros modificados dentro de la subrutina.
   ;
   ; Instrucciones de la subrutina.
   ;
   ; Restaurar el estado de los registros modificados
   ; recuperando su valor inicial almacenado en la pila.
   ret

push rbp       ; Almacenar el registro rbp en la pila  
mov rbp, rsp   ; Asignar a rbp el valor del registro apuntador rsp

...

mov rsp, rbp   ; Restauramos el valor inicial de rsp 
pop rbp        ; Restauramos el valor inicial de rbp

ret

• RAX = 3

• RBX = 0, descriptor correspondiente a la entrada estándar (teclado)

• RCX = dirección de la variable de memoria donde se guardará la cadena leída

• RDX = número máximo de caracteres que se leerán

• RAX = número de caracteres leídos

• La variable indicada se llena con los caracteres leídos.

• RAX = 0

• RDI = 0, descriptor correspondiente a la entrada estándar (teclado)

• RSI = dirección de la variable de memoria donde se guardará la cadena leída

• RDX = número máximo de caracteres que se leerán

• RAX = número de caracteres leídos

section .bss
   buffer resb 10                ;se reservan 10 bytes para hacer la lectura del
teclado

section .text
                                 ;lectura utilizando int 80h
   mov rax, 3
   mov rbx, 0
   mov rcx, buffer               ; se carga la dirección de buffer en rcx
   mov rdx,10                    ; número máximo de caracteres que se leerán
   int 80h                       ; se llama al kernel

                                 ;lectura utilizando syscall
   mov rax, 0
   mov rdi, 0
   mov rsi, buffer               ; se carga la dirección de buffer en rsi
   mov rdx,10                    ; número máximo de caracteres que se leerán
   syscall                       ; se llama al kernel

• RAX = 4

• RBX = 1, descriptor correspondiente a la salida estándar (pantalla)

• RCX = dirección de la variable de memoria que queremos escribir, la variable ha de estar definida con un byte 0 al final

• RDX = tamaño de la cadena que queremos escribir en bytes, incluido el 0 del final

• RAX = número de caracteres escritos

• RAX = 1

• RDI = 1, descriptor correspondiente a la salida estándar (pantalla)

• RSI = dirección de la variable de memoria que queremos escribir, la variable ha de estar definida con un byte 0 al final

• RDX = tamaño de la cadena que queremos escribir en bytes, incluido el 0 del final

• RAX = número de caracteres escritos

Section .data
   msg db "Hola!",0
   msgLen db 6

section .text
                      ; escritura utilizando int 80h
   mov rax,4
   mov rbx,1
   mov rcx, msg       ; se pone la dirección de msg1 en rcx
   mov rdx, msgLen    ; tamaño de msg
   int 80h            ; se llama al kernel

;escritura utilizando syscall
   mov rax, 1
   mov rdi, 1
   mov rsi, msg       ; se carga la dirección de msg en rsi
   mov rdx, msglen    ; tamaño de msg
   syscall            ; se llama al kernel

section .data
  msg db "Hola!",0
  msgLen db equ $ - msg ; $ indica la dirección de la posición actual

• RAX = 1

• RBX = valor de retorno del programa

• RAX = 60

• RDI = valor de retorno del programa

;retorna al sistema operativo utilizando int 80h
mov rax,1
mov rbx,0  ;valor de retorno 0
int 80h   ; se llama al kernel

           ;retorna al sistema operativo utilizando syscall
mov rax,60
mov rbx,0  ;valor de retorno 0
syscall    ;se llama al kernel