Arquitectura de Computadores y Sistemas Operativos I Manual del 80386

Departamento de Arquitectura de Computadores

M. Jimnez, G. Utrera Curso 2008-2009 (Q1)

ndice
1 El microprocesador Intel 80386.......................................................................................................... 3 1.1 Organizacin de la memoria...................................................................................................... 3 1.2 Registros ......................................................................................................................................... 3 1.2.1 Registros Generales ............................................................................................................... 4 1.2.2 Registros de Segmento ......................................................................................................... 5 1.2.3 Registros especiales ............................................................................................................... 5 1.3 Tipos de datos y almacenamiento ............................................................................................ 6 1.4 Modos de direccionamiento ...................................................................................................... 8 1.4.1 Operandos inmediatos ......................................................................................................... 9 1.4.2 Operandos en registros ......................................................................................................... 9 1.4.3 Operandos en memoria ....................................................................................................... 9 1.5 Repertorio de instrucciones....................................................................................................... 12 1.5.1 Instrucciones de transferencia de datos.......................................................................... 12 1.5.2 Instrucciones aritmticas .................................................................................................... 15 1.5.3 Instrucciones lgicas............................................................................................................ 18 1.5.4 Instrucciones de control de flujo........................................................................................ 22 1.5.5 Instrucciones de control del procesador ......................................................................... 24 1.5.6 Instrucciones de acceso a perifricos de Entrada/Salida............................................. 25

1 El microprocesador Intel 80386

El i80386, tambin conocido como i386, es un microprocesador de 32 bits de propsito general. Para realizar un programa en lenguaje ensamblador del i80386 es necesario conocer previamente los siguientes aspectos de la arquitectura: Organizacin de la memoria Registros Tipos de datos y almacenamiento Modos de direccionamiento Repertorio de instrucciones En este captulo detallamos cada uno de estos aspectos.

1.1 Organizacin de la memoria

En un espacio lineal de direcciones, la memoria se ve como una sucesin de palabras numeradas desde 0 hasta un valor mximo determinado por el tamao del bus de direcciones. Para acceder a cualquiera de estas palabras, hay que generar la direccin asociada a dicha palabra. El i80386 tiene un bus de direcciones de 32 bits y, por lo tanto, puede acceder hasta 4 Gigabytes (232 bytes) de memoria. El i80386 ofrece varios modelos de organizacin de la memoria que varan entre los siguientes extremos:

El modelo plano: donde el espacio de direcciones consiste en un nico espacio

lineal de hasta 4 gigabytes. En este modelo, una direccin de memoria a nivel ensamblador se identifica con una simple tira de 32 bits.

El modelo segmentado: donde el espacio de direcciones consiste en una

coleccin de hasta 16383 espacios lineales de direcciones de hasta 4 gigabytes cada uno. En este modelo, una direccin de memoria a nivel ensamblador consta de dos componentes: un segmento (tira de 16 bits que identifican un segmento) y un desplazamiento (tira 32 bits que identifican un byte dentro de un segmento). En esta asignatura usaremos siempre el modelo plano de memoria.

1.2 Registros
El i80386 dispone en total de 16 registros, divididos en las tres siguientes categoras bsicas (ver Figura 1):

Registros generales. Dispone de 8 registros generales de 32 bits cada uno. Estos

registros se usan bsicamente para almacenar operandos de operaciones aritmticas y lgicas.

Registros de segmento. Dispone de 6 registros de segmento de 16 bits cada uno.

Estos registros solamente se usan en modelos segmentados de memoria. Estos registros permiten determinar, en un instante dado, qu segmento de memoria se est direccionando.

Registros especiales. Dispone de 2 registros especiales de 32 bits cada uno. Estos registros se usan para almacenar y modificar ciertos aspectos del estado del procesador.
%EAX 0..31 %EBX 0..31 %ECX 0..31 %EDX 0..31 %EBP 0..31 %ESP 0..31 %ESI 0..31 %EDI 0..31 %AH 8..15 %BH 8..15 %CH 8..15 %DH 8..15 %AL 0..7 %BL 0..7 %CL 0..7 %DL 0..7 %AX 0..15 %BX 0..15 %CX 0..15 %DX 0..15 %BP 0..15 %SP 0..15 %SI 0..15 %DI 0..15

%CS 0..15 %SS 0..15 %DS 0..15 %ES 0..15 %FS 0..15 %GS 0..15 %EFLAGS
0..31
O F D F I F T F S F Z F A F P F C F

%FLAGS 0..15 %IP 0..15

%EIP 0..31
Figura 1: Registros del i30386

1.2.1 Registros Generales Los registros generales del i80386 son de 32 bits y se llaman %EAX, %EBX, %ECX, %EDX, %ESP, %EBP, %ESI y %EDI. Cualquiera de estos registros se puede utilizar para almacenar operandos de instrucciones lgicas y aritmticas y para almacenar direcciones de memoria donde se encuentran los operandos (excepto el %ESP que no puede ser usado con esta segunda finalidad). La parte baja (los 16 bits bajos) de cada uno de estos registros tiene un nombre diferente (en concreto, %AX, %BX, %CX, %DX, %SP, %BP, %SI y %DI) y puede ser usada como un registro de 16 bits. Esta caracterstica es til para manejar datos de 16 bits y para compatibilidad con los procesadores 8086 y 80286. Adems, cada byte de los registros %AX, %BX, %CX y %DX tambin tiene un nombre diferente y puede ser usado como un registro de 8 bits. Esta caracterstica es til para manejar caracteres y datos de 8 bits. Los nombres de estos registros son %AH, %BH, %CH y %DH para el byte alto y %AL, %BL, %CL y %DL para el byte bajo. Todos los registros generales se pueden usar como punteros a memoria, como operandos de operaciones aritmticas y lgicas y para almacenar resultados. Adems algunos de estos registros se usan de forma implcita en algunas instrucciones (%AX y %DX en la multiplicacin y divisin, %SI y %DI en instrucciones de manipulacin de string, etc.).

1.2.2 Registros de Segmento Los registros de segmento del i80386 son de 16 bits y se llaman %CS, %SS, %DS, %ES, %FS y %GS. Estos registros solamente se usan en modelos segmentados de memoria y permiten identificar cada uno de los seis segmentos accesibles en un instante concreto de la ejecucin de un programa. En un modelo plano de memoria, que es el que usaremos en nuestra asignatura, estos registros de segmento no se usan. 1.2.3 Registros especiales Los dos registros especiales de los que dispone el i80386 son de 32 bits cada uno y se llaman %EFLAGS y %EIP. A continuacin comentamos con ms detalle cada uno de estos registros. %EFLAGS El registro %EFLAGS controla ciertas operaciones e indica el estado del procesador. La parte baja (los 16 bits de peso bajo) del %EFLAGS se llama %FLAGS y puede ser usado por el procesador como una unidad. Esta caracterstica es til cuando ejecutamos cdigos que fueron diseados para los procesadores 8086 o 80286. Los 16 bits de peso bajo del %EFLAGS pueden ser accedidos como una unidad y se llaman %FLAGS. Cada bit (tambin llamado flag) del %EFLAGS nos proporciona algn tipo de informacin. Estos flags se pueden clasificar en tres grupos: flags de estado, flags de control y flags de sistema. Los flags de sistema no sern discutidos en esta publicacin. Los flags de estado almacenan informacin sobre el estado del procesador despus de ejecutar la ltima instruccin. De esta forma, el resultado de una instruccin puede influenciar la ejecucin de una instruccin posterior. Los flags de estado son los siguientes: Acarreo. CF (Carry Flag, bit 0): Este flag se activa cuando se produce un acarreo en el bit de mayor peso en el resultado de la ltima instruccin. En otro caso, CF se pone a cero. Paridad. PF (Parity Flag, bit 2): Se activa si el nmero de bits a 1 del byte bajo del resultado de la ltima instruccin es par. En otro caso, PF se pone a cero. Ajuste. AF (Adjust Flag, bit 4): Se activa si se produce acarreo en el bit 3 (cuarto bit de menor peso) del resultado de la ltima instruccin. Este flags se usa en operaciones aritmticas decimal (dgitos BCD). En otro caso, AF se pone a cero. Cero. ZF (Zero Flag, bit 6): Se activa si el resultado de la ltima instruccin es cero. En otro caso, ZF se pone a cero. Signo. SF (Sign Flag, bit 7): Se activa si el bit de mayor peso del resultado de la ltima instruccin es 1 (resultado negativo). En otro caso, SF se pone a cero (resultado positivo). Desbordamiento. OF (Overflow Flag, bit 11): El desbordamiento en una operacin aritmtica se produce cuando el resultado de la operacin excede la capacidad de representacin del operando destino. El flag OF se activa cuando se produce desbordamiento en la ltima instruccin. En otro caso, OF se pone a cero.

Los flags de control almacenan informacin de control del procesador. Estos flags son los siguientes: Trap. TF (Trap Flag, bit 8): Si este bit est activo, despus de la ejecucin de cada instruccin pasa a ejecutarse una rutina especial. Esta rutina podra ser el ncleo de un depurador de programas o debugger. Permiso de interrupcin. IF (Interrupt Flag, bit 9): Si este bit est activo el procesador puede ser interrumpido despus de la ejecucin de la instruccin en curso. Direccin. DF (Direction Flag, bit 10): Las instrucciones de tratamiento de strings incrementan y decrementan automticamente los punteros de los operandos (registros ESI y/o EDI) despus de cada operacin elemental. Si este bit est activo, los registros ESI y/o EDI se autoincrementan. En caso contrario, se autodecrementan.

En el lenguaje mquina del i80386 existen instrucciones que permiten modificar algunos de los flags, leerlos, preguntar por ellos, etc. La posicin relativa de cada flag dentro del EFLAGS se muestra en la Figura 1. %EIP El registro %EIP (contador de programa) siempre almacena la direccin de memoria donde se encuentra la siguiente instruccin a ejecutar. Este registro no puede ser manipulado de forma explcita; se modifica implcitamente con las instrucciones de control de flujo (CALL, JMP, etc.). La parte baja (los 16 bits de peso bajo) del %EIP se llama %IP y puede ser usado por el procesador como una unidad. Esta caracterstica es til cuando ejecutamos instrucciones que fueron diseadas para los procesadores 8086 o 80286.

1.3 Tipos de datos y almacenamiento

El i80386 tiene tres tipos de datos fundamentales: bytes, words y doublewords. Un byte est compuesto por 8 bits consecutivos almacenados en una determinada direccin de memoria. Los bits estn enumerados del 0 al 7, siendo el bit cero el bit menos significativo. Un word est compuesto por dos bytes consecutivos, por lo tanto contiene 16 bits. Los bits de un word estn enumerados del 0 al 15, siendo el bit cero el menos significativo. El byte que contiene el bit cero es el byte bajo y el byte que contiene el bit 15 del word es el byte alto. Cada byte de un word tiene su propia direccin de memoria y estn almacenados consecutivamente en memoria; si el byte bajo est almacenado en la direccin n, el byte alto est en la direccin n+1 (ver Figura 2). Un doubleword est compuesto por dos words consecutivos, por lo tanto tiene 32 bits. Los bits de un doubleword estn enumerados del 0 al 31, siendo el bit cero el menos significativo. El word que contiene el bit cero es el word bajo y el word que contiene el bit 31 es el word alto. Cada uno de los cuatro bytes que forman un doubleword tiene su propia direccin de memoria y estn almacenados consecutivamente en memoria; si el byte bajo del word bajo est almacenado en la direccin n, entonces el byte alto del word bajo est en la direccin n+1, el byte bajo del word alto est en n+2 y el byte alto del word alto est en n+3.

Byte:
7 byte @n 0

Word:
15 byte alto @n+1 8 7 byte bajo @n 0

Doubleword:
31 byte alto @n+3 word alto 24 23 byte bajo @n+2 16 15 word bajo 8 7 byte alto byte bajo @n+1 @n 0

Quadword:
63 byte H @n+7 56 55 byte L @n+6 48 47 byte H @n+5 40 39 byte L @n+4 32 31 byte H @n+3 24 23 byte L @n+2 16 15 byte H @n+1 8 7 byte L @n 0

Figura 2: Tipos de datos y almacenamiento en el i80386

A nivel lenguaje ensamblador, el tamao del resultado de una instruccin se especifica mediante un sufijo (b (byte), w (word) l (doubleword)) en el cdigo de operacin de la propia instruccin. Ejemplos: ADDB %AH,%AL
# suma el valor de los registros %AH y %AL. El resultado es de tamao byte.

ADDW %AX,%BX
# suma el valor de los registros %AX y %BX. El resultado es de tamao word.

ADDL %EAX,%EBX
# suma el valor de los registros %EAX y %EBX. El resultado es de tamao # doubleword.

Aunque bytes, word y doublewords son los tipos fundamentales de los operandos, el i80386 tambin soporta interpretaciones adicionales de estos operandos. En concreto, el i80386 ofrece instrucciones a nivel lenguaje mquina para manipular y operar con los siguientes tipos de datos:

Naturales, codificados en binario puro con: - 8 bits (byte): rango de representacin 0 <= x <= 255 - 16 bits (word): rango de representacin 0 <= x <= 65535 - 32 bits (doubleword): rango de representacin 0<= x <= 232-1

Enteros, codificados en complementa a 2 con: - 8 bits (byte): rango de representacin -128 <= x <= 127 - 16 bits (word): rango de representacin -32768 <= x <= 32767 - 32 bits (doubleword): rango de representacin -231 <= x<= 231-1 Punteros a memoria - 32 bits (doubleword): asumimos un modelo plano de memoria. Bits. El lenguaje mquina ofrece instrucciones para manipular bits dentro de bytes, words o doublewords (operaciones lgicas, desplazamientos y rotaciones). Strings. Cada elemento del string puede ser un byte, word o doubleword. Dgitos BCD. Un dgito BCD ocupa 4 bits. Se puede utilizar dos formatos para almacenarlos: - desempaquetados: cada dgito BCD se almacena en la parte baja de un byte - empaquetados: se almacenan dos dgitos BCD en cada byte.

Finalmente, cabe comentar que la transferencia de datos entre procesador y memoria en el i80386 se lleva a cabo en unidades de 32 bits (4 bytes) empezando siempre en direcciones de memoria divisibles entre 4. Por ello, es conveniente (pero no necesario) que los words y doublewords estn alineados en direcciones pares y divisibles entre 4, respectivamente. Si los datos no estuvieran alineados, el procesador convierte las peticiones de datos desalineados en la correspondiente secuencia de peticiones a memoria. Este desalineamiento reduce el rendimiento del procesador debido a que se necesitan ms ciclos en los accesos a memoria. Para conseguir mximo rendimiento, las estructuras de datos (incluyendo la pila) deben de ser diseadas de tal manera que los words queden almacenados en direcciones pares de memoria y los doublewords en direcciones divisibles entre 4.

1.4 Modos de direccionamiento

Los modos de direccionamiento indican la localizacin de los operandos involucrados en una instruccin. En el i386, un operando puede estar en una de estas localizaciones: En la propia instruccin (operando inmediato) En un registro En memoria

El acceso a operandos inmediatos o que estn en registros es ms rpido que el acceso a operandos en memoria. Las instrucciones del i386 pueden tener explcitamente uno o dos operandos. Instrucciones con dos operandos, tales como MOV, ADD, XOR, generalmente dejan el resultado sobre uno de los operandos de la propia instruccin, perdiendo as el valor original del operando. Por lo tanto, en este tipo de instrucciones podemos hacer una distincin entre el operando fuente (que no se ve modificado por la operacin) y el operando destino (que es sobrescrito con el resultado). A nivel lenguaje ensamblador, el destino se coloca a la derecha y el fuente a la izquierda.

Ejemplo: ADDW %AX, %BX # suma el valor de los registros %AX y %BX, dejando el # resultado en %bx. El resultado es de tamao word. En la mayora de las instrucciones, uno de los dos operandos (tanto el fuente como el destino) puede estar en memoria o en registro. El otro operando tiene que estar en registro o ser un inmediato. Por lo tanto, las instrucciones de dos operandos del i386 solamente permiten operaciones con los siguientes tipos de operandos: registro - registro registro - memoria memoria - registro inmediato - registro inmediato memoria

1.4.1 Operandos inmediatos Algunas instrucciones usan datos de la propia instruccin como operandos. Estos operandos se llaman inmediatos y pueden ser de 32, 16 8 bits. A nivel lenguaje ensamblador, los valores inmediatos llevan el prefijo $. Ejemplo: ADDW $4, %AX # suma 4 al valor del registro %ax.

1.4.2 Operandos en registros Los operandos tambin pueden estar localizados en uno de los registros generales de 32 bits (%EAX, %EBX, %ECX, %EDX, %ESP, %EBP, %ESI y %EDI), en uno de los registros generales de 16 bits (%AX, %BX, %CX, %DX, %SP, %BP, %SI y %DI) o en uno de los registros generales de 8 bits (%AH, %BH, %CH, %DH, %AL, %BL, %CL y %DL). El i386 tambin tiene instrucciones que manipulan los registros de segmento (%CS,%DS,%ES, %FS, %SS, %GS). Estas instrucciones solamente se usan en modelos segmentados de memoria. 1.4.3 Operandos en memoria Los operandos tambin pueden estar localizados en memoria. Para el clculo de la direccin efectiva de memoria se suman los siguientes componentes (ver Figura 3): Un desplazamiento que se encuentra en la propia instruccin. Este desplazamiento puede ser de 8 32 bits. Un registro base Un registro ndice que puede estar multiplicado por un factor de escala que puede ser 2, 4 8.

Cada uno de estos componentes de la direccin efectiva puede tener un valor positivo o negativo. Si la suma de los componentes excede de 232, la direccin efectiva es truncada a 32 bits. La componente desplazamiento, que est codificada en la propia instruccin, es til para los aspectos fijos de la direccin de memoria, por ejemplo: Localizacin de operandos escalares. Direccin base de vectores y matrices. Desplazamientos de campos dentro de una estructura.

Las componentes base e ndice tienen funciones similares. Ambas usan el mismo conjunto de registros generales (excepto que %ESP no se puede usar como registro ndice) y ambas se usan para aspectos de la direccin de memoria que son determinados dinmicamente, por ejemplo: Localizacin de parmetros y variables locales en las subrutinas. El inicio de una estructura dentro de un vector/matriz de estructuras. El inicio de una dimensin en vectores de varias dimensiones.

El factor de escala permite un acceso eficiente a vectores/matrices cuando los elementos del vector/matriz son de tamao 2, 4 8 bytes. La multiplicacin del registro ndice por el factor de escala la realiza el procesador en el mismo instante en que se calcula la direccin efectiva del operando. De esta forma se elimina la necesidad de aadir instrucciones que realicen esta multiplicacin. A nivel lenguaje ensamblador, los operandos en memoria se especifican con la siguiente sintaxis:

DESPLAZAMIENTO (BASE, INDICE, FACTOR ESCALA)

BASE NDICE * FACTOR DE ESCALA DESPLAZAMIENTO %EAX %EAX 1 %ECX %ECX %EDX %EDX 2 SIN DESPLAZAMIENTO %EBX %EBX DESPLAZAMIENTO 8 BITS %ESP --4 DESPLAZAMIENTO 32 BITS %EBP %EBP %ESI %ESI 8 %EDI %EDI
Figura 3: Clculo de la direccin efectiva

Las componentes desplazamiento, base e ndice se pueden usar en cualquier combinacin; todas las componentes son opcionales. El factor de escala solamente se puede usar cuando se usa la componente ndice. Cada una de las posibles combinaciones es til para la implementacin de estructuras de datos usadas comnmente en los lenguajes de alto nivel o lenguaje ensamblador. A continuacin se muestran posibles usos para algunas de las combinaciones de las componentes de una direccin:

10

DESPLAZAMIENTO: El desplazamiento nicamente indica la direccin efectiva del operando. Esta combinacin se usa para acceso a variables escalares o a direcciones fijas de memoria. Ejemplo: ADDW var, %AX # Suma la variable var con el contenido del registro %AX. El # resultado es de tamao word y queda almacenado en %AX.

BASE: la direccin del operando est almacenada en un registro general. Esta combinacin es til para acceso a vectores. Ejemplo: ADDW (%EBX), %AX # Suma el dato almacenado en la direccin especificada por # %ebx con el registro %AX. El resultado es de tamao word y # queda almacenado en %AX.

BASE + DESPLAZAMIENTO: El operando est en la direccin de memoria que resulta de sumar un registro base general y un desplazamiento. Esta combinacin es til para el acceso a estructuras. Ejemplo: ADDW -4(%EBX), %AX # Suma el dato almacenado en la direccin especificada por # %EBX - 4 con el registro %AX. El resultado es de tamao # word y queda almacenado en %AX.

(ndice * FACTOR ESCALA) + DESPLAZAMIENTO: Esta combinacin es til para acceder de forma eficiente a vectores cuyos elementos son de tamao 2, 4 o 8 bytes. La componente desplazamiento almacena la direccin base del vector y el registro ndice (multiplicado por el factor de escala) indexa el vector. Ejemplo: ADDW tab(,%EBX,4), %AX # Suma el dato almacenado en la direccin especificada por # tab + %EBX * 4 con el registro %AX. tab es la direccin base # de una variable. El resultado es de tamao word y queda # almacenado en %AX.

BASE + ndice + DESPLAZAMIENTO: Esta combinacin es til para el acceso a matrices o a vectores de estructuras. Ejemplo: ADDW tab(%EAX,%EBX), %AX # suma el dato almacenado en la direccin especificada # por tab + %EAX + %EBX con el registro %AX. tab es la # direccin base de una variable. El resultado es de tamao # word y queda almacenado en %AX.

BASE + (ndice * FACTOR ESCALA) + DESPLAZAMIENTO: Permite el acceso eficientes a matrices cuyos elementos son de 2, 4 8 bytes. Ejemplo: ADDW tab(%EAX,%EBX,2), %AX # suma el dato almacenado en la direccin especificada # por tab + %EAX + %EBX * 2 con el registro %AX. tab es la # direccin base de una variable. El resultado es de tamao # word y queda almacenado en %AX.

11

1.5 Repertorio de instrucciones

El repertorio de instrucciones del i386 puede dividirse en los siguientes grupos: Instrucciones de transferencia de datos Instrucciones aritmticas Instrucciones lgicas Instrucciones de control de flujo Instrucciones de control del procesador Instrucciones de acceso a perifricos de Entrada/Salida Instrucciones en coma flotante Instrucciones multimedia Instrucciones de manipulacin de strings Instrucciones de aritmtica BCD

A continuacin se describe brevemente algunas de las instrucciones incluidas en el repertorio de instrucciones del i386 (las instrucciones relacionadas con la manipulacin de strings y aritmtica BCD no se detallarn en este documento).

1.5.1 Instrucciones de transferencia de datos Estas instrucciones permiten mover bytes, words o doublewords entre memoria y registros del procesador. Se pueden distinguir tres clases diferentes en instrucciones de transferencia de datos: (1) instrucciones de transferencia de datos de propsito general, (2) instrucciones para el manejo de la pila e (3) instrucciones para conversin de tipo.

Instrucciones de propsito general

Cada instruccin cuando corresponda tiene asociado el tipo de datos que manipula y en ste documento se indicar de la siguiente forma: nombre_instruccion[B|W|L] operandos Significa que segn si la instruccion opera sobre bytes, words o doublewords deber aadirse al final de nombre_instruccion: B, W L respectivamente.

MOV. Copiar MOV[B|W|L] fuente, destino destino:=fuente # Copia byte, word doubleword desde destino a fuente # Flags que se modifican: ninguna Ejemplo: Copiar el valor 3 (doubleword) al registro %EAX. MOVL $3,%EAX

12

XCHG. Intercambiar XCHG[B|W|L] operando1, operando2 tmp:=operando1 operando1:=operando2 operando2:=tmp # Intercambia el contenido de operando1 y operando2 # Flags que se modifican: ninguna Ejemplo: Intercambiar los valores de los registros %EAX y %EBX. XCHGL %EAX,%EBX

LEA. Cargar direccin efectiva LEA[B|W|L] fuente, destino destino:=direccin efectiva (fuente) destino &fuente # Interpreta la expresin fuente como una direccin a # memoria, cargando el resultado de dicha expresin a # destino. # Flags que se modifican: ninguna Ejemplo: Cargar la direccin %6 + %EAX en el registro %EDX. LEAL 6(%EAX),%EDX

LAHF. Cargar en AH las flags LAHF %AH:=%EFLAGS(SF, ZF, xx, AF, xx, PF, xx, CF) # Copia los bits 0-7 del registro de flags al registro AH # (sto incluye: AF, CF, PF, SF y ZF) # Flags que se modifican: ninguna

SAHF. Cargar las flags a partir de AH SAHF %EFLAGS(SF, ZF, xx, AF, xx, PF, xx, CF):=%AH # Guarda el contenido del registro AH en el registro de # flags. # Flags que se modifican: AF CF PF SF ZF

Instrucciones para el manejo de la pila

PUSH. Poner en la pila PUSH[B|W|L] fuente %ESP:=%ESP - tamao_operando_fuente_en_bytes (%ESP):=fuente # Copia en la pila el contenido del operando fuente. # Decrementa el registro %ESP segn el tamao del operando # fuente (2 o 4 bytes). # Flags que se modifican: Ninguna

13

POP. Coger de la pila POP[B|W|L] destino destino:=(%ESP) %ESP:=%ESP + tamao_operando_destino_en_bytes # Copia el contenido de lo que se encuentra en el tope de # la pila en operando destino. Incrementa el registro %ESP # segn el tamao del operando destino (2 o 4 bytes). # Flags que se modifican: Ninguna

PUSHF. Poner en la pila registro de flags PUSHF[W|L] %ESP:=%ESP-tamao_registro_de_flags (%ESP):=registro_de_flags # %EFLAGS %FLAGS # Copia el contenido del registro de flags en la pila (2 o # 4 bytes) # Flags que se modifican: Ninguna

POPF. Coger de la pila registro de flags POPF[W|L] registro_de_flags :=(%ESP) %ESP:=%ESP + tamao_registro_de_flags # Copia el contenido de lo que se encuentra en el tope de # la pila en el registro de flags. Incrementa el registro # %ESP segn el tamao del operando destino (2 o 4 bytes). # Flags que se modifican: Todas

Instrucciones para conversin de tipo

CBW. Convertir un byte en word con extensin de signo CBW %AX:=%AL (con extensin de signo) # Convierte el byte en %AL en un word (dos bytes) en %AX # extendiendo el signo de %AL en %AH # Flags que se modifican: Ninguna CWDE. Convertir un word en doubleword con extensin de signo CWDE %EAX:=%AX (con extensin de signo) # Convierte un word (2 bytes) en %AX en un double word (4 # bytes) en %EAX, extendiendo el signo de %AX en %EAX # Flags que se modifican: Ninguna CWD. Convertir un word en doubleword con extensin de signo CWD %DX:%AX:=%AX (con extensin de signo) # Convierte un word (2 bytes) en %AX en un double word (4 # bytes) en %DX:%AX, extendiendo el signo de %AX en %DX # Flags que se modifican: Ninguna

14

CDQ. Convertir un doubleword en quadword (64 bits) con extensin de signo CDQ %EDX:%EAX:=%EAX (con extensin de signo) # Convierte un double word (4 bytes) en %EAX en una quad # word (4 bytes) en %DX:%AX, extendiendo el signo de %EAX # en %EDX # Flags que se modifican: Ninguna

MOVSX. Copiar y convertir un byte/word en word/doubleword CON extensin de signo MOVSX fuente, destino destino:=fuente (con extensin de signo) # Copia el contenido del operando fuente en el destino # extendiendo el signo. # Flags que se modifican: Ninguna

MOVZX. Copiar y convertir un byte/word en word/doubleword SIN extensin de signo MOVZX fuente, destino destino:=fuente (sin extensin de signo, aade ceros) # Copia el contenido del operando fuente en el destino # extendiendo ceros. # Flags que se modifican: Ninguna

1.5.2 Instrucciones aritmticas Estas instrucciones manipulan datos numricos codificados en binario. Estas instrucciones ofrecen las operaciones standard de sumar, restar, multiplicar y dividir, as como incrementar, decrementar, comparar y cambiar de signo. Estas instrucciones aritmticas operan con enteros con y sin signo. Las instrucciones modifican los flags ZF, CF, SF y OF de tal forma que instrucciones posteriores puedan interpretar el resultado como un entero con o sin signo. CF contiene informacin relevante para enteros sin signo; SF y OF contienen informacin relevante para enteros con signo; y ZF contiene informacin relevante para enteros con y sin signo. ADD. Sumar ADD[B|W|L] fuente, destino destino:= destino + fuente # Suma el contenido del operando fuente al de destino, # reemplazando el contenido de ste ltimo con el resultado. # Flags que se modifican: AF CF OF PF SF ZF

15

ADC. Sumar con acarreo ADC[B|W|L] fuente, destino destino:=destino + fuente + CF # Suma el contenido del operando fuente al de destino, # reemplazando el contenido de ste ltimo con el resultado. Si # CF est en 1, se suma 1 al resultado. Con esta instruccin se # puede implementar sumas de nmeros de ms de 32 bits. # Flags que se modifican: AF CF OF PF SF ZF

INC. Incrementar INC[B|W|L] destino destino:=destino+1 # Suma 1 al contenido del operando destino, reemplazando el # contenido de ste ltimo con el resultado. # Flags que se modifican: AF OF PF SF ZF

SUB. Restar SUB[B|W|L] fuente, destino destino:=destino fuente # Resta el contenido del operando fuente al de destino, # reemplazando el contenido de ste ltimo con el resultado. # Flags que se modifican: AF CF OF PF SF ZF

SBB. Restar con acarreo SBB[B|W|L] fuente, destino destino:=destino-fuente-CF # Resta el contenido del operando fuente al de destino, # reemplazando el contenido de ste ltimo con el resultado. Si # CF est en 1, se resta 1 al resultado. # Flags que se modifican: AF CF OF PF SF ZF

DEC. Decrementar DEC[B|W|L] destino destino:=destino-1 # Resta 1 al contenido del operando destino, reemplazando el # contenido de ste ltimo con el resultado. # Flags que se modifican: AF OF PF SF ZF

NEG. Cambiar signo en complemento a 2 NEG[B|W|L] destino destino:= - destino # Resta el operando destino a 0, y le aplica complemento a 2, # reemplazando el operando destino con el resultado. # Flags que se modifican: AF CF OF PF SF ZF

16

CMP. Comparar CMP[B|W|L] operando1, operando2 operando2 operando1 # Resta el contenido del operando1 al contenido del operando1 # sin almacenar el resultado. # Flags que se modifican: AF CF OF PF SF ZF

MUL. Multiplicar enteros sin signo MUL[B|W|L] fuente si fuente es un byte entonces %AX:=%AL * fuente fsi si fuente es un word entonces %DX:%AX:= %AX * fuente fsi si fuente es un doubleword entonces %EDX:%EAX:= %EAX* fuente fsi # # # # # Multiplica el contenido del operando fuente por el contenido de %AL, %AX %EAX almacenando el resultado en %AX, %DX %EDX:%EAX dependiendo de si el operando fuente es un byte, word o double word respectivamente. Flags que se modifican: CF OF (AF, PF, SF, ZF indefinidas)

IMUL. Multiplicar enteros con signo IMUL[B|W|L] fuente si fuente es un byte entonces %AX:=%AL * fuente fsi si fuente es un word entonces %DX:%AX:= %AX * fuente fsi si fuente es un doubleword entonces %EDX:%EAX:= %EAX* fuente fsi destino:=destino * fuente # Multiplica el contenido del operando fuente por el contenido # de %AL, %AX %EAX almacenando el resultado en %AX, %DX # %EDX:%EAX dependiendo de si el operando fuente es un byte, # word o double word respectivamente. IMUL[B|W|L] fuente, destino destino:=destino * fuente IMUL[B|W|L] fuente1, fuente2, destino destino:=fuente1 * fuente2 # Flags que se modifican: CF OF (AF, PF, SF, ZF indefinidas)

17

DIV. Dividir enteros sin signo DIV[B|W|L] fuente si fuente es un byte entonces %AL:= cociente (%AX / fuente) %AH:= resto (%AX / fuente) fsi si fuente es un word entonces %AX:= cociente (%DX:%AX / fuente) %DX:= resto (%DX:%AX / fuente) fsi si fuente es un doubleword entonces %EAX:= cociente (%EDX:%EAX / fuente) %EDX:= resto (%EDX:%EAX / fuente) fsi # # # # # Divide el contenido %AL, %AX %EAX por el contenido del operando fuente almacenando el cociente y resto en %AL y %AH en %AX y %DX en %EAX y %EDX dependiendo de si el operando fuente es un byte, word o double word respectivamente. Flags que se modifican: (AF, CF, OF, PF, SF, ZF indefinidas)

IDIV. Dividir enteros con signo IDIV[B|W|L] fuente si fuente es un byte entonces %AL:= cociente (%AX / fuente) %AH:= resto (%AX / fuente) fsi si fuente es un word entonces %AX:= cociente (%DX:%AX / fuente) %DX:= resto (%DX:%AX / fuente) fsi si fuente es un doubleword entonces %EAX:= cociente (%EDX:%EAX / fuente) %EDX:= resto (%EDX:%EAX / fuente) fsi # # # # # Divide el contenido %AL, %AX %EAX por el contenido del operando fuente almacenando el cociente y resto en %AL y %AH en %AX y %DX en %EAX y %EDX dependiendo de si el operando fuente es un byte, word o double word respectivamente. Flags que se modifican: (AF, CF, OF, PF, SF, ZF indefinidas)

1.5.3 Instrucciones lgicas El grupo de instrucciones lgicas operan a nivel de bits e incluyen operaciones de tipo booleano, desplazamientos y rotaciones. NOT. Negacin lgica NOT[B|W|L] destino destino:= NOT destino # Realiza el complemento a 1 del contenido del operando destino. # Flags que se modifican: Ninguna

18

AND. Y lgico AND[B|W|L] fuente, destino destino:= destino AND fuente # Realiza el AND bit a bit entre los operandos fuente y destino, # reemplazando el contenido de ste ltimo con el resultado. # Flags que se modifican: CF OF PF SF ZF (AF indefinida)

OR. O lgico OR[B|W|L] fuente, destino destino:= destino OR fuente # Realiza el OR bit a bit entre los operandos fuente y destino, # reemplazando el contenido de ste ltimo con el resultado. # Flags que se modifican: CF OF PF SF ZF (AF indefinida)

XOR. O exclusivo lgico XOR[B|W|L] fuente, destino destino:= destino XOR fuente # Realiza el XOR bit a bit entre los operandos fuente y destino, # reemplazando el contenido de ste ltimo con el resultado. # Flags que se modifican: CF OF PF SF ZF (AF indefinida)

TEST. Y lgico TEST[B|W|L] fuente, destino destino AND fuente # Realiza el AND bit a bit entre los operandos fuente y destino, # sin almacenar el resultado. # Flags que se modifican: CF OF PF SF ZF (AF indefinida)

SAL / SHL. Desplazamiento (aritmtico / lgico) a la izquierda SAL[B|W|L] contador, destino SHL[B|W|L] contador, destino for j:=1 to contador do CF:=destino (bit tamao_destino_en_bits-1) for i:=tamao_destino_en_bits-1 downto 1 do destino (bit i):=destino(bit i-1) destino (bit 0):=0 endfor endfor # # # # # # Mueve hacia la izquiera los bits de operando destino tantas posiciones como indique el operando contador. Por la derecha entran ceros. La flag de Carry contiene el ltimo bit que queda fuera del operando destino. El operando contador debe ser: %CL o un operando inmediato. Flags que se modifican: CF OF PF SF ZF (AF indefinida)

19

SHR. Desplazamiento (lgico) a la derecha SHR[B|W|L] contador, destino for j:=1 to contador do CF:=destino (bit 0) for i:=0 to tamao_operando_en_bits-2 do destino (bit i):=destino(bit i+1) destino (bit tamao_operando_en_bits-1):=0 endfor endfor # # # # # # Mueve hacia la derecha los bits de operando destino tantas posiciones como indique el operando contador. Por la izquierda entran ceros. La flag de Carry contiene el ltimo bit que queda fuera del operando destino. El operando contador debe ser: %CL o un operando inmediato. Flags que se modifican: CF OF PF SF ZF (AF indefinida)

SAR. Desplazamiento (aritmtico) a la derecha SAR[B|W|L] contador, destino for j:=1 to contador do CF:=destino (bit 0) for i:=0 to to tamao_operando_en_bits-2 do destino (bit i):=destino(bit i+1) destino(bit tamao_operando_en_bits-1):= destino(bit tamao_operando_en_bits-2) endfor endfor # # # # # # Mueve hacia la derecha los bits de operando destino tantas posiciones como indique el operando contador. Por la izquierda se replica el bit de signo. La flag de Carry contiene el ltimo bit que queda fuera del operando destino. El operando contador debe ser: %CL o un operando inmediato. Flags que se modifican: CF OF PF SF ZF (AF indefinida)

ROL. Rotacin a la izquierda ROL[B|W|L] contador, destino for j:=1 to contador do tmp:=destino (bit tamao_operando_en_bits-1) for i:=tamao_operando_en_bits-1 downto 1 do destino (bit i):=destino(bit i-1) destino (bit 0):=tmp endfor endfor # # # # # # Rota hacia la izquierda los bits de operando destino tantas posiciones como indique el operando contador. Los bits que salen por la izquierda re-entran por la derecha. La flag de Carry contiene el valor del ltimo bit rotado. El operando contador debe ser: %CL o un operando inmediato. Flags que se modifican: CF OF

20

ROR. Rotacin a la derecha ROR[B|W|L] contador, destino for j:=1 to contador do tmp:=destino (bit 0) for i:=0 to tamao_operando_en_bits-2 destino (bit i):=destino(bit i+1) destino (bit tamao_operando_en_bits-1):=tmp endfor endfor # Rota hacia la derecha los bits de operando destino tantas # posiciones como indique el operando contador. Los bits que # salen por la derecha re-entran por la izquierda. La flag de # Carry contiene el valor del ltimo bit rotado. # El operando contador debe ser: %CL o un operando inmediato. # Flags que se modifican: CF OF

RCL. Rotacin a la izquierda con acarreo RCL[B|W|L] contador, destino for j:=1 to contador do tmp:=CF CF=destino (bit tamao_operando_en_bits-1) for i:=tamao_operando_en_bits-1 downto 1 do destino (bit i):=destino(bit i-1) destino (bit 0):=tmp endfor endfor # # # # # # Rota hacia la izquierda los bits de operando destino tantas posiciones como indique el operando contador. Los bits que salen por la izquierda re-entran por la derecha, pasando por la flag de Carry. El operando contador debe ser: %CL o un operando inmediato. Flags que se modifican: CF OF

RCR. Rotacin a la derecha con acarreo RCR[B|W|L] contador, destino for j:=1 to contador do tmp:=CF CF:=destino (bit 0) for i:=0 to tamao_operando_en_bits-2 destino (bit i):=destino(bit i+1) destino (bit tamao_operando_en_bits-1):=tmp endfor endfor # # # # # # Rota hacia la izquierda los bits de operando destino tantas posiciones como indique el operando contador. Los bits que salen por la izquierda re-entran por la derecha, pasando por la flag de Carry. El operando contador debe ser: %CL o un operando inmediato. Flags que se modifican: CF OF

21

1.5.4 Instrucciones de control de flujo El i80386 ofrece instrucciones de control para dirigir el flujo de ejecucin. Estas instrucciones permiten modificar el secuenciamiento implcito de los programas (que ejecutan las instrucciones en el mismo orden en que estn almacenadas en memoria). Las instrucciones de control de flujo pueden ser condicionales o incondicionales. Las instrucciones condicionales consultan los flags del procesador y modifican el secuenciamiento implcito en funcin de sus valores. Las instrucciones incondicionales siempre modifican el secuenciamiento implcito. CALL. Llamada a subrutina CALL etiqueta PUSH %EIP %EIP:=etiqueta # Invoca la subrutina guardando en la pila la direccin de # retorno de la rutina actual. # Flags que modifican: Ninguna RET. Retorno de subrutina RET POP %EIP # # # # Retorna a la instruccin apuntada por el primer valor que se encuentra en la pila en el momento de la ejecucin de esta instruccin. Flags que se modifican: Ninguna

JMP. Salto incondicional JMP etiqueta %EIP:=etiqueta # Salto incondicional a la primera instruccin despus de # etiqueta. # Flags que se modifican: Ninguna

Jxx. Saltos condicionales Jxx etiqueta Si se cumple la condicin especificada en xx entonces: %EIP:=etiqueta # # # # # Salto condicional a etiqueta dependiendo de si la condicin especificada en la instruccin es verdadera. La condicin depender del estado de las flags en el momento de la ejecucin de la instruccin de salto. Flags que se modifican: Ninguna

Ejemplo de instrucciones que relacionan valores sin signo (suponemos que la instruccin anterior al salto es CMP b,a que internamente realiza la resta a-b):

22

JA etiq JAE etiq JB etiq JBE etiq JNBE etiq JNB etiq JNAE etiq JNA etiq

salto si a superior a b salto si a superior o igual a b salto si a inferior a b salto si a inferior o igual a b salto si a superior a b salto si a superior o igual a b salto si a inferior a b salto si a inferior o igual a b

(CF=0 y ZF=0) (CF=0) (CF=1) (CF=1 o ZF =1) (CF=0 y ZF=0) (CF=0) (CF=1) (CF=1 o ZF =1)

Ejemplo de instrucciones que relacionan valores con signo (suponemos que la instruccin anterior al salto es CMP b,a que internamente realiza la resta a-b): JG etiq JGE etiq JL etiq JLE etiq JNLE etiq JNL etiq JNGE etiq JNG etiq salto si a mayor que b salto si a mayor o igual que b salto si a menor que b salto si a inferior o igual que b salto si a mayor que b salto si a mayor o igual que b salto si a menor que b salto si a inferior o igual que b (SF=OF y ZF=0) (SF=OF) (SF!=OF) (SF!= OF o ZF =1) (SF=OF y ZF=0) (SF=OF) (SF!=OF) (SF!= OF o ZF =1)

Ejemplo de instrucciones de salto en funcin de los flags: JE o JZ etiq JNE o JNZ etiq JC etiq JNC etiq JO etiq JNO etiq JS etiq JNS etiq JP o JPE etiq JNP o JPO etiq salto si igual salto si no igual salto si hay acarreo salto si no hay acarreo salto si hay desbordamiento salto si no hay desbordamiento salto si negativo salto si positivo salto si paridad salto si no paridad (ZF=1) (ZF=0) (CF=1) (CF=0) (OF=1) (OF=0) (SF=1) (SF=0) (PF=1) (PF=0)

Ejemplo de instrucciones de salto en funcin de algn registro: JCXZ etiq salto si registro %CX es cero JECXZ etiq salto si registro %ECX es cero INT. Interrupcin software INT n PUSH %EFLAGS TF:=0 IF:=0 PUSH %EIP # # # # Almacena automticamente en la pila el registro de flags (%EFLAGS) y la direccin de retorno (%EIP), deshabilita interrupciones y traps e inicia una interrupcin software. Flags que se modifican: TF IF (se ponen a 0)

23

IRET. Retorno de interrupcin IRET POP %EIP POP %EFLAGS # Restaura el valor de %EIP y el registro de flags (%EFLAGS) # desde la pila y retorna a la instruccin apuntada por %EIP. # Flags que se modifican: AF CF DF IF PF SF TF ZF

1.5.5 Instrucciones de control del procesador El i80386 ofrece instrucciones de control del procesador. Estas instrucciones permiten modificar el estado de los flags de la palabra de estado (%EFLAGS). CLC. Borra flag de acarreo CLC CF:=0 # Pone a 0 la flag de carry. # Flags que se modifican: CF STC. Activa flag de acarreo STC CF:=1 # Pone a 1 la flag de carry # Flags que se modifican: CF CMC. Complementa flag de acarreo CMC CF:= not CF # Cambia flag de carry por su complemento a 1. # Flags que se modifican: CF CLI. Borra flag de interrupcin CLI IF:=0 # Pone a 0 flag de interrupcin # Flags que se modifican: IF STI. Activa flag de interrupcin STI IF:=1 # Pone a 1 flag de interrupcin. # Flags que se modifican: IF

24

1.5.6 Instrucciones de acceso a perifricos de Entrada/Salida El i80386 ofrece instrucciones de acceso a los puertos de Entrada/Salida del procesador para la transferencia de datos entre perifricos y procesador.

IN. Leer un puerto de E/S IN[B|W|L] puerto_E/S, acumulador acumulador:=(puerto_E/S) # # # # # Lee un byte, word o double word desde puerto_E/S y lo almacena en acumulador (%AL, %AX o %EAX respectivamente). Si el nmero de puerto est en el rango 0-255 puede especificarse como un operando inmediato, en caso contrario debe ser especificado en el registro %DX.

OUT. Escribir en un puerto de E/S OUT acumulador, puerto_E/S (puerto_E/S):=acumulador # # # # # El byte, word o double word que est en el acumulador (%AL, %AX o %EAX respectivamente) es escrito en puerto_E/S Si el nmero de puerto est en el rango 0-255 puede especificarse como un operando inmediato, en caso contrario debe ser especificado en el registro %DX.

25