- 1 -

=============================================================================

TEMA 1 - CONCEPTOS FUNDAMENTALES SOBRE ESTRUCTURA DE COMPUTADORES.

=============================================================================

=============================================================================

1.1 Concepto de computador. =============================================================================

Un computador es una mquina que puede resolver problemas ejecutando una secuencia de instrucciones.

Un programa es la secuencia de instrucciones que describe cmo ejecutar una tarea, tarea que sirve para resolver un problema.

El lenguaje mquina es el conjunto de instrucciones primitivas de un computador. Dichas instrucciones se combinan de una determinada manera para especificar lo que el ordenador debe realizar, y por ello forman un lenguaje, al que se denomina lenguaje mquina. Es un conjunto de relativamente pocas instrucciones. Esas instrucciones son muy sencillas; sirven para expresar acciones simples (por ejemplo, copiar un dato de memoria hacia un registro del procesador, sumar un valor al contenido de un registro, etc.).

Todos los programas a ejecutar por el computador deben ser previamente convertidos a una secuencia de instrucciones de lenguaje mquina.

Es muy incmodo programar un computador en lenguaje mquina. Por ello, para programar se utilizan los lenguajes de alto nivel, que resultan ms cmodos para el programador. Para que un programa escrito en un lenguaje de alto nivel pueda ser ejecutado en un computador, hay que traducirlo a lenguaje mquina; ese trabajo de traduccin lo hacen los compiladores de los lenguajes de alto nivel.

- 2 -

=============================================================================

1.2 Niveles de estudio de un computador. =============================================================================

Primer nivel. Descripcin geomtrica y de componentes. Estructura fsica de la mquina, ubicacin espacial de sus elementos.

Segundo nivel. Descripcin de circuito electrnico. Se estudia cmo los elementos electrnicos estn agrupados formando circuitos lgicos. Est entre la electrnica analgica y la digital.

Tercer nivel. Descripcin de cmo se unen los elementos lgicos simples (puertas lgicas) para formar circuitos que realicen funciones especficas (registros, contadores, etc.). Corresponde a la electrnica digital.

Cuarto nivel. Nivel de transferencia entre registros (o nivel RTL). Un registro es un lugar donde se almacena informacin. Se estudian los flujos de informacin entre los diferentes registros. Es el nivel que nos va a ocupar en esta asignatura.

Quinto nivel. Se describe el computador como una caja negra que realiza funciones recibiendo rdenes del exterior y devolviendo resultados. Nivel al que percibe el computador un usuario con una interfaz de alto nivel.

=============================================================================

1.3 Concepto de arquitectura de computadores y de organizacin de computadores. =============================================================================

Arquitectura de un computador: son los atributos de un sistema computador que son visibles a un programador. Por ejemplo, son aspectos referentes a la arquitectura de un computador el lenguaje mquina, los bits usados para representar los diversos tipos de datos y el modo de direccionar la memoria.

Organizacin de un computador: es la descripcin de las unidades funcionales de un sistema computador y de cmo estn interconectadas. Por ejemplo, son aspectos referentes a la organizacin de computadores las seales de control utilizadas, las interfaces entre el computador y el exterior, la tecnologa utilizada en la construccin de la memoria y cmo son los circuitos que implementan las operaciones aritmticas y lgicas.

Ambos trminos hacen referencia a aspectos que pueden ser estudiados en todos los computadores.

Una familia de computadores es un conjunto de computadores que tienen la misma arquitectura pero diferente organizacin.

Esta asignatura se orienta al estudio de la arquitectura del computador.

- 3 -

=============================================================================

TEMA 2. Componentes y funcionamiento de un computador. La arquitectura IA-32. =============================================================================

=============================================================================

2.1 La arquitectura Von Neumann. =============================================================================

Un computador construido segn la arquitectura Von Neumann se caracteriza porque:

a) Est integrado por tres elementos: la CPU, la memoria y el conjunto de unidades de entrada/salida (E/S).

b) Los datos e instrucciones se almacenan en una memoria sobre la que se puede leer y escribir.

c) Se accede a los contenidos de la memoria utilizando una direccin. Cada dato se almacena en un lugar de la memoria que tiene asociado una direccin, y para acceder al dato se suministra la direccin a la memoria, la cual a su vez devuelve el dato.

d) Las instrucciones de un programa se ejecutan en un orden que coincide con la secuencia de almacenamiento del programa dentro de la memoria.

=============================================================================

2.1.2 La CPU. =============================================================================

La CPU est integrada por un conjunto de componentes lgicos que sirven para almacenar datos y realizar operaciones aritmticas y lgicas con ellos.

- 4 -

Ese conjunto de componentes lgicos est incluido dentro de una configuracin que permite hacer un uso general de las funciones aritmticas y lgicas disponibles. En concreto hay unos circuitos (el "hardware") y esos circuitos pueden realizar funciones diferentes: se selecciona la funcin que van a realizar aplicando unas seales de control sobre ellos.

En conjunto, el funcionamiento es el siguiente: la CPU acepta datos y seales de control y produce resultados.

Dentro de la CPU hay una parte de circuitera encargada de generar las seales de control que a su vez hacen que el resto de circuitos lleven a cabo funciones especficas. Para cada funcin a realizar en la prctica hay que suministrar una secuencia de seales de control al circuito encargado de ejecutarla. Hay una parte de la CPU que genera esas secuencias de seales de control.

Para que la CPU active las seales de control correspondientes a una secuencia concreta (la cual a su vez da lugar a la ejecucin de una operacin en un circuito) dispone de un cdigo especfico asociado a cada una de esas secuencias, y adems hay una parte de la circuitera que es capaz de generar las seales de control cuando reconoce ese cdigo.

Cada uno de los cdigos anteriores es una instruccin mquina. El conjunto de todas ellas forma el lenguaje mquina del computador al que pertenece la CPU, o simplemente se le conoce tambin como el juego de instrucciones del mismo. Una secuencia de esas instrucciones forma un programa, que pertenece as al conjunto del "software" que puede ejecutar el computador.

=============================================================================

2.1.3 La memoria. =============================================================================

En la memoria se almacena la secuencia de instrucciones o programa y los datos que van a ser utilizados en la ejecucin de ese programa.

Su funcionalidad se resume as:

a) En ella se leen las instrucciones que constituyen el programa. b) En ella se leen los datos necesarios para la ejecucin. c) En ella se escriben los resultados de la ejecucin de las instrucciones de la memoria.

Dentro de la memoria hay ubicaciones en las que se puede almacenar informacin. Cada una de ellas tiene asignado un nombre o direccin. Para acceder a esa ubicacin se suministra a la memoria esa direccin. Por ello a veces se dice simplemente que "la CPU accede a la direccin".

=============================================================================

2.1.4 Las unidades de entrada/salida. =============================================================================

Sirven para intercambiar datos entre los dispositivos externos y la memoria del computador, o en ocasiones entre ellos y la CPU directamente. Ese intercambio puede ser de entrada de datos hacia el computador o de salida de los mismos hacia el exterior. A esos dispositivos externos se los denomina dispositivos perifricos del computador o simplemente perifricos.

En general la CPU accede a los dispositivos de entrada/salida anlogamente a como lo hace a la memoria: los dispositivos de entrada/salida tienen asociadas unas ubicaciones especficas sobre las que la CPU puede leer o escribir. Cada ubicacin tiene una direccin. El conjunto de todas ellas es el conjunto de direcciones del sistema de entrada/salida de ese computador. As, la CPU puede

- 5 -

enviar datos hacia un dispositivo de salida o leer datos de un dispositivo de entrada. La diferencia entre las direcciones de memoria y las del sistema de entrada/salida es que estas ltimas estn asociadas a las ubicaciones de lectura o escritura de los dispositivos externos.

=============================================================================

2.2 La arquitectura Intel de 32 bits: IA-32. =============================================================================

=============================================================================

2.2.1 Introduccin. =============================================================================

Estudiaremos las caractersticas de la arquitectura de los computadores sobre un tipo concreto de computador construido segn el concepto arquitectnico de Von Neumann. En concreto, vamos a tomar como referencia computadores tipo PC basados en microprocesadores de Intel actuales (Pentium y Core). La arquitectura de ellos se conoce como la "Arquitectura Intel de 32 bits" o simplemente "IA-32".

Vamos a estudiar los elementos ms bsicos del lenguaje mquina IA-32. se es el lenguaje de todos los microprocesadores IA-32, que son todos los procesadores de Intel actualmente utilizados en los PCs comerciales.

Los procesadores de Intel basados en la arquitectura IA-32 son:

a) El procesador Pentium (1993) b) Los procesadores basados en la microarquitectura P6: el Pentium Pro (1995), el Pentium II (1997) y el Pentium III (1999) c) El procesador Pentium IV, basado en la microarquitectura P7 o "Net-Burst" (2001). d) Los procesadores de microarquitectura Intel Core (2006).

Vamos a comentar los aspectos de la IA-32 apoyndonos sobre las caractersticas de un computador PC tpico basado en cualquiera de los procesadores Intel mencionados. Comentaremos a continuacin los elementos que integran el sistema y sus caractersticas.

=============================================================================

2.2.2 El bus del sistema. =============================================================================

Es el elemento que conecta los distintos componentes de la arquitectura V.N.

En un sistema como el tomado de referencia hay tres buses: el bus de direcciones, el bus de datos y el bus de control. Juntos constituyen lo que se denomina como el bus del sistema.

El bus de datos tiene 64 bits de ancho y permite transferencias de 16, 32 y 64 bits. Sirve para mover informacin entre una posicin particular de la memoria o un dispositivo de E/S y la CPU.

El bus de direcciones sirve para transmitir a la memoria o a un dispositivo de E/S las direcciones de las posiciones a las que la CPU desea acceder (para leer o escribir sobre ellas). El sistema asocia una direccin a cada posicin de la memoria y a cada posicin de los dispositivos de E/S. Si la CPU desea acceder a alguna posicin, coloca su direccin en el bus de direcciones. La circuitera interna de la memoria y de los dispositivos de E/S hace dos cosas: 1) reconoce esa direccin como propia (esto es, que corresponde a una de las ubicaciones a

- 6 -

las que puede acceder), 2) internamente pone en marcha las acciones necesarias para leer el dato y colocar dicho dato en el bus de datos, en una operacin de lectura, o tomar el dato del bus de datos y almacenarlo en la ubicacin que corresponda, en una operacin de escritura. El bus de direcciones tiene 32 bits (salvo extensiones).

El bus de control est integrado por seales que controlan cmo se comunica el procesador con el resto del sistema. Entre estas seales se incluyen: las seales de lectura y escritura sobre la memoria, el reloj del sistema, las lneas de interrupcin y las lneas de estado, y hay otras ms.

El reloj del sistema es una seal elctrica alterna entre dos niveles lgicos. Es la responsable de toda la sincronizacin dentro del computador; su importancia deriva de que la CPU internamente es un complejo sistema lgico sncrono. La frecuencia de esa seal alterna es lo que se denomina la frecuencia de reloj del sistema. A un perodo completo de esa seal es a lo que se denomina el ciclo de reloj del sistema. La ejecucin de cada instruccin mquina consume varios ciclos de reloj (pueden ser menos de 10, decenas, centenas o incluso ms de 1000 ciclos).

=============================================================================

2.2.3 El subsistema de memoria. =============================================================================

La memoria es direccionable a nivel de byte: con una direccin de 32 bits referenciamos una posicin de memoria en la que se almacena 1 byte.

La memoria es equivalente a una array de 4x2^30 posiciones, cada una capaz de almacenar 1 byte, por tanto son 4 Gigabytes. (1 Gigabyte=2^30 bytes).

Para ejecutar "leer el contenido de la direccin X de memoria" cosa que representamos simplemente como:

CPU

- 7 -

pequea que la memoria principal, para ser ms rpida que sta); a ello se le denomina un fallo de la cach. Cuando hay un fallo de la cach, la informacin que necesita el procesador hay que ir a buscarla a la memoria principal. Se tarda mucho menos tiempo en leer o escribir algo en la cach que en hacerlo en la memoria principal del sistema.

=============================================================================

2.2.4 El subsistema de entrada/salida. =============================================================================

Funcionalmente es anlogo al subsistema de memoria. Se direccionan sus posiciones a travs del bus de direcciones. Utiliza direcciones de un ancho de 16 bits, lo que permite un total de 65536 direcciones de entrada/salida.

=============================================================================

2.3 Caractersticas de la CPU en IA-32. =============================================================================

Comentamos a continuacin los elementos ms representativos de la CPU.

=============================================================================

2.3.1. Los registros de la CPU. =============================================================================

Los registros son lugares de almacenamiento de informacin que estn dentro de la CPU.

De ellos se toman datos para las operaciones aritmticas y lgicas de la CPU, y sobre ellos se escriben los resultados. En ocasiones, algunos datos de esas operaciones la CPU los toma directamente de la memoria, o deposita directamente en la memoria los resultados.

Los principales registros de la CPU en IA-32 son:

1) El conjunto de registros de propsito general. Son registros de 32 bits de ancho. Sirven para almacenar datos temporalmente. Los principales son: registro EAX o registro acumulador, EBX o registro de direccin base, ECX o registro contador y EDX o registro de datos.

2) El registro de puntero de instruccin. Es un registro de 32 bits. Contiene la direccin de la memoria a partir de la que est almacenada la siguiente instruccin a ejecutar.

3) El registro de banderas ("flags"). Es un registro de 32 bits. Sus bits informan sobre el estado de funcionamiento del procesador o sobre el resultado de ciertas operaciones.

=============================================================================

2.3.2 La unidad aritmtico-lgica (ALU). =============================================================================

Es la parte de la CPU en la que tienen lugar la mayora de las operaciones ejecutadas por ella.

Por ejemplo, para realizar lo siguiente:

"sumar 5 al contenido del registro EAX"

La CPU hara:

1) Copiar el valor del registro EAX en una entrada de la ALU. 2) Enviar el valor 5 a otra entrada de la ALU. 3) Ordenar a la ALU que sume los valores que tiene depositados en sus entradas.

- 8 -

4) Copiar en EAX el resultado que aparece en la salida de la ALU.

=============================================================================

2.3.3 Unidad de interfaz de bus (BIU). =============================================================================

Se encarga de manejar los buses de datos y direcciones cuando la CPU debe acceder a posiciones de la memoria o del sistema de E/S.

=============================================================================

2.3.4 La unidad de control y el juego de instrucciones. =============================================================================

La CPU internamente posee una unidad de control (UC). Cada una de las instrucciones del juego de instrucciones de la CPU (o del lenguaje mquina) tiene asociado un cdigo numrico, que se denomina "cdigo de operacin" y que se codifica en binario. La UC es capaz de reconocer ese cdigo para que la CPU ejecute una instruccin.

La UC se encarga de hacer que la CPU traiga de la memoria las instrucciones del programa. As, trae el cdigo binario de cada instruccin, y lo trae de la posicin de memoria a la que apunta en cada momento el "puntero de instruccin", que ser el registro que almacena la direccin de memoria a partir de la que se aloja ese cdigo.

Despus, la UC coloca el cdigo en otro registro interno de la CPU denominado "registro de decodificacin". Sobre l realiza el trabajo de identificar la accin a desarrollar. Una vez identificada, comienza la ejecucin de la instruccin.

Los cdigos de operacin tienen un tamao que es mltiplo de 8 bits. En ellos se codifica la operacin a realizar y qu operandos estn involucrados en ella. Esos operandos pueden ser un dato inmediato (un nmero), un registro o una posicin de memoria.

Para referirnos a los cdigos de operacin utilizaremos una notacin simblica. Asociamos a cada cdigo un trmino al que denominamos "mnemnico".

Ejemplos de cdigos de operacin y sus mnemnicos:

a) 11110100 es un cdigo de operacin binario de 8 bits, que se representa por medio del mnemnico "hlt".

b) 10001001:11001000 es un cdigo de operacin de 16 bits, 2 bytes, que se representa por medio de "mov cx,ax".

c) 0x9b:0xdb:0xe1 es un cdigo de operacin de 24 bits, 3 bytes (expresado en hexadecimal) que se representa por "fdisi".

Escribimos programas que puedan ser ejecutados por la CPU utilizando los mnemnicos, en lugar de los cdigos binarios. Los programas as escritos se dice que lo estn en lenguaje ensamblador. Esos programas pueden ser traducidos directamente a lenguaje mquina, cosa que en la prctica se hace por medio de un programa al que se denomina ensamblador.

=============================================================================

2.4 Organizacin fsica de la memoria en IA-32. =============================================================================

Consideraremos siempre un espacio de memoria de 4 Gigabytes.

- 9 -

Por medio de direcciones de 32 bits podemos direccionar cualquier posicin de la memoria.

IA-32 admite el concepto de segmentacin. Un segmento de memoria es una porcin de la memoria que comienza a partir de una determinada direccin.

El direccionamiento en IA-32 puede ser de dos tipos:

a)Lineal o plano: se suministra una sola direccin (32 bits) que sirve para seleccionar una posicin de la memoria.

b)Segmentado: se suministran dos nmeros para especificar una direccin; a esos nmeros se les denomina segmento y desplazamiento. La direccin de memoria se obtiene sumando el desplazamiento al resultado de realizar cierta operacin sobre el nmero de segmento.

En nuestro estudio utilizaremos siempre un direccionamiento lineal o plano sobre un espacio de memoria de 4 Gigabytes. Obsrvese que los registros utilizados son de 32 bits, y por tanto tienen tamao suficiente como para almacenar una direccin de dicho espacio. Nunca vamos a utilizar directamente la segmentacin en este curso.

=============================================================================

2.5 Resumen de los registros de la CPU en IA-32. =============================================================================

Dentro de los registros de la CPU hay porciones las cuales a su vez pueden ser utilizadas como registros independientes. Como tales, reciben su propio nombre. Numeramos los bits de los registros comenzando por el bit 0, que representa el bit menos significativo del dato almacenado en el registro. En nuestras representaciones, colocaremos el bit ms significativo siempre en la posicin que se encuentre ms hacia la izquierda. Por tanto, el bit cero ser siempre el que se encuentre ms hacia la derecha.

Para explicar cmo partes de un registro a su vez forman otros registros, comentaremos detalladamente el caso del registro EAX. El registro EAX consta de 32 bits (bits 0 a 31). Los bits 0 a 7 de este registro forman el registro AL. Los bits 8 al 15 de EAX forman el registro AH. Por otra parte, los bits 0 al 15 (en conjunto) forman el registro AX. As podemos decir que el registro AX est formado por los 16 bits menos significativos del registro EAX; que el registro AL est formado por los 8 bits menos significativos del registro AX, y que el registro AH est formado por los 8 bits ms significativos del registro AX.

Lo mismo que hemos dicho del registro EAX podemos decirlo de los registros EBX, ECX y EDX. En resumen:

EAX: bits 0 al 31 (todos los bits del registro). AX, bits 0 al 15. AL, bits 0 al 7. AH, bits 8 al 15.

EBX: bits 0 al 31 (todos los bits del registro). BX, bits 0 al 15. BL, bits 0 al 7. BH, bits 8 al 15.

ECX: bits 0 al 31 (todos los bits del registro). CX, bits 0 al 15. CL, bits 0 al 7. CH, bits 8 al 15.

EDX: bits 0 al 31 (todos los bits del registro). DX, bits 0 al 15. DL, bits 0 al 7. DH, bits 8 al 15.

Hay otros registros de 32 bits, que a su vez contienen registros de 16 bits, que son los siguientes:

- 10 -

ESI: bits 0 al 31 (todos los bits del registro). SI, bits 0 al 15. Se denomina registro ndice de fuente.

EDI: bits 0 al 31 (todos los bits del registro). DI, bits 0 al 15. Se denomina registro ndice de destino.

EBP: bits 0 al 31 (todos los bits del registro). BP, bits 0 al 15. Se denomina registro puntero de base.

ESP: bits 0 al 31 (todos los bits del registro). SP, bits 0 al 15. Se denomina registro de puntero de pila.

EFLAGS: bits 0 al 31 (todos los bits del registro). FLAGS, bits 0 al 15. Se denomina registro de banderas o de estado.

Adems hay otros registros de 16 bits, que no vamos a utilizar en este curso, y que se denominan CS, DS, ES, FS, GS y SS. Se les denomina registros de segmento.

Finalmente est el registro de 32 bits EIP, al que se denomina registro de puntero de instruccin. En dicho registro se almacena la direccin de la siguiente instruccin a ejecutar. Va variando (aumentando o disminuyendo) durante la ejecucin del programa, para estar apuntando siempre a la direccin que en cada momento corresponda.

=============================================================================

2.6 El juego de instrucciones en IA-32. =============================================================================

Podemos clasificar las principales instrucciones de IA-32 dentro de los siguientes grupos:

1) De movimiento de datos.

2) De conversin de datos.

3) Aritmticas.

4) Lgicas y de manipulacin de datos a nivel de bit.

5) De control de flujo de los programas (saltos, llamadas a subrutinas e interrupciones).

6) De entrada/salida.

7) De manipulacin de cadenas de caracteres o de bloques de memoria.

8) De aritmtica de punto flotante.

9) MMX (extensiones para gestin de multimedia).

10) SSE (extensiones para computacin tipo SIMD)

En el resto de la asignatura estudiaremos la funcionalidad de la mayor parte de los grupos de instrucciones mencionados.

- 11 -

- 12 -

=============================================================================

TEMA 3. Instrucciones de movimiento de datos.

=============================================================================

=============================================================================

3.1 Introduccin. =============================================================================

Son instrucciones que mueven informacin entre diversos lugares de almacenamiento.

Los lugares de almacenamiento involucrados pueden ser: registros, posiciones de la memoria, la pila (que es una zona de la memoria que soporta un tipo de manipulacin especial).

En general, a lo largo de la asignatura vamos a utilizar la siguiente notacin:

1) Para referirnos a registros:

- Con "reg" nos referiremos a cualquiera de los registros de propsito general, de cualquier tamao.

- Con "reg8", "reg16" o "reg32" nos referiremos respectivamente a registros de 8, 16 o 32 bits.

2) Para referirnos a la memoria:

- Con "mem" hacemos referencia a una direccin de memoria a partir de la cual se ha almacenado 1 byte de informacin (esto es, el byte que se almacena en esa direccin). Recordemos que toda direccin de memoria se compone de 32 bits.

- 13 -

- Con "mem16" hacemos referencia a una direccin a partir de la que se almacena una palabra (2 bytes, 16 bits). Por tanto, hace referencia a dos ubicaciones de memoria consecutivas. Para referirnos a esa zona de memoria, utilizamos la direccin de la ubicacin ms baja. As, si a partir de mem16 tenemos almacenada una palabra, tendremos almacenado: En la direccin mem16: el byte bajo de la palabra En la direccin mem16+1: el byte alto de la palabra

- Con "mem32" hacemos referencia a una direccin a partir de la que se almacena una palabra doble (4 bytes, 32 bits). Por tanto hace referencia a cuatro ubicaciones de memoria consecutivas. Para referirnos a esa zona de memoria, utilizamos la direccin de la ubicacin ms baja. As, si a partir de mem32 hemos depositado los bytes 0, 1, 2 y 3 de una palabra doble (el byte 0 ser el menos significativo), tendremos almacenados esos bytes en la memoria as: En la direccin mem32: byte 0 (menos significativo) En la direccin mem32+1: byte 1 En la direccin mem32+2: byte 2 En la direccin mem32+3: byte 3 (ms significativo)

Para referirnos a las posiciones de la memoria nunca utilizaremos el valor numrico de la direccin directamente. Siempre nos referiremos a ellas por medio de una etiqueta. La etiqueta es un nombre que asignamos a una direccin de memoria. En los programas hay una zona donde se establece: a) qu etiquetas hay, b) el tipo de dato que se va a almacenar a partir de la direccin asignada a cada etiqueta (esto es, bytes, palabras o palabras dobles).

En muchas ocasiones, se utilizar el trmino "mem" no para referirnos a una direccin de memoria a partir de la que almacenamos 1 byte, sino en general para referirnos a una a partir de la que se almacena no importa qu tamao de dato. Es anlogo a la forma en que se puede utilizar "reg".

=============================================================================

3.2 Instrucciones de copia de datos entre lugares de almacenamiento. =============================================================================

Tienen el mnemnico comn MOV.

Funcin: "mov destino, fuente" hace que se copie el contenido de fuente en destino, sin que se modifique el contenido de fuente.

Utilizacin:

1) mov reg, reg 2) mov mem, reg 3) mov reg, mem 4) mov mem, dato inmediato 5) mov reg, dato inmediato

mem y reg pueden ser ambos de 8, 16 y 32 bits. Ambos deben tener el mismo tamao.

mov no permite copiar directamente de una ubicacin de memoria hacia otra. Para llevar algo de una posicin de memoria hacia otra es necesario hacer una copia intermedia de los datos en un registro.

Los "datos inmediatos" son valores que estn incluidos dentro de la propia instruccin. Por ejemplo "mov al,5" indica cargar el valor 5 en al, y ese 5 se expresa dentro de la instruccin. Los datos inmediatos pueden ser nmeros o cadenas de caracteres. El ensamblador que utilizaremos en la asignatura soporta los siguientes formatos para la codificacin de los datos inmediatos:

- 14 -

a) Datos inmediatos numricos:

- Enteros en base 10: ejemplo, mov ax, 13

- Hexadecimales: pueden expresarse con sufijo h (por ejemplo, mov al, a2h) o sin sufijo poniendo delante 0x (por ejemplo, mov al, 0xa2).

- Octales: se expresan con el sufijo q (por ejemplo, mov ax, 7777q).

- Binarios: se expresan con el sufijo b (por ejemplo, mov al, 10010011b).

b) Caracteres y cadenas de caracteres: se escriben entre comillas simples. Por ejemplo, mov eax, 'abcd' da lugar a que en el registro eax se almacene 0x64636261. 0x64, 0x63, 0x62, 0x61 respectivamente son los cdigos ASCII de la d, c, b y a, en hexadecimal. El de la a se ha almacenado en el byte menos significativo de eax, y el de la d en el byte ms significativo.

=============================================================================

3.3 Instrucciones de intercambio de contenido entre lugares de almacenamiento. =============================================================================

Instruccin: XCHG.

Sirve para intercambiar el contenido de dos lugares de almacenamiento. Los lugares especificados deben ser del mismo tamao en bits.

Utilizacin:

1) xchg reg, mem 2) xchg reg, reg

=============================================================================

3.4 Obtencin de direcciones efectivas de la memoria. =============================================================================

Instruccin: LEA

Sirve para cargar un registro de propsito general con la direccin efectiva de una posicin de memoria.

Utilizacin:

1) lea reg16, mem : copia en reg16 los 16 bits ms bajos de la direccin de memoria etiquetada como mem (esto es, no de lo almacenado en la memoria, sino los 16 bits ms bajos de los 32 bits que expresan esa direccin).

2) lea reg32, mem : copia en reg32 los 32 bits que expresan la direccin de memoria mem.

En los dos casos anteriores, mem puede ser, por ejemplo, una etiqueta.

=============================================================================

3.5 Instrucciones de manejo de la pila. =============================================================================

En IA-32 la pila es una zona de la memoria sobre la que se construye una pila LIFO. Cuando se copian datos en la pila, la pila "crece hacia abajo" en la memoria, esto es, el ltimo byte cargado se carga siempre en una direccin de memoria que se obtiene restando 1 a la direccin de memoria en la que se carg

- 15 -

el penltimo byte cargado. As, los datos introducidos ms recientemente se sitan en posiciones de memoria que numricamente son cada vez ms bajas.

La pila se comienza a construir en una posicin de memoria elevada.

En la pila siempre hay una direccin que es la "cabeza de la pila". La cabeza de la pila indica la menor de las direcciones ocupadas por la pila, y por tanto es la direccin del ltimo byte que fue introducido en la pila. La direccin de cabeza de la pila siempre est almacenada en el registro de propsito general ESP (al que por ello se denomina registro de puntero de pila). Cuando se saca un byte de la pila, se saca de la direccin ESP, y ESP aumenta en una unidad, para seguir apuntando a la cabeza de la pila. Cuando se introduce un byte en la pila, se introduce en la direccin (ESP-1) y ESP disminuye en una unidad por la misma razn.

As, en la pila se pueden guardar valores y recuperar los valores guardados. Para ello hay instrucciones especficas de manipulacin de la pila.

La pila se utiliza para almacenar el contenido de registros u otras posiciones de memoria y para otros usos como pasar parmetros a llamadas de procedimientos.

Cuando se introduce en la pila una palabra, es como si se introdujeran en la pila dos bytes consecutivos: primero el byte alto y luego el byte bajo; por ello, el byte bajo quedar almacenado en una posicin de memoria ms baja que el byte alto. Cuando se introduce en la pila una palabra doble, es como si se introdujeran en la pila cuatro bytes consecutivos: primero el byte 3, luego el byte 2, luego el byte 1 y por ltimo el byte 0. Por ello si miramos la zona de la memoria donde se construye la pila, veramos en la direccin a la que apunta ESP el byte 0, en ESP+1 el byte 1, en ESP+2 el byte 2 y finalmente en ESP+3 el byte 3.

Las instrucciones de manipulacin de la pila son:

PUSH para introducir algo en la pila.

POP para sacar algo de la pila.

Utilizacin de estas instrucciones:

1) Para sacar o meter en la pila una palabra de o hacia un registro de 16 bits:

push reg16: mete en la pila 2 bytes (el contenido de reg16), comenzando por la parte alta de reg16.

pop reg16: saca de la pila 2 bytes para cargarlos en el registro reg16. El primer byte sacado de la pila lo almacena en la parte baja de reg16 y el segundo byte lo almacena en la parte alta de reg16.

2) Para sacar de o introducir en la pila una palabra doble desde o hacia un registro de 32 bits:

push reg32: mete en la pila 4 bytes (el contenido de reg32), comenzando por el byte 3 y terminando por el byte 0 de reg 32.

pop reg32: saca de la pila 4 bytes y rellena con ellos el registro reg32, comenzando por el byte 0 y terminando por el byte 3.

- 16 -

3) Para sacar de o meter en la pila un grupo de bytes (palabra o palabra doble) que estn almacenados en la memoria a partir de la posicin mem:

push word mem16

push dword mem32

pop word mem16

pop dword mem32

Como una etiqueta de memoria lo nico que especifica es una direccin de memoria, para indicar cuntos bytes se deben sacar o meter de la pila, se coloca la partcula word (que expresa 2 bytes, esto es, movimiento de una palabra) o bien la partcula dword (que expresa 4 bytes, esto es, movimiento de una palabra doble).

4) Para sacar de o meter en la pila el contenido de todos los registros de propsito general de 16 bits se utilizan pusha y popa. El contenido de esos registros se carga con pusha en el orden siguiente: ax-cx-dx-bx-sp-bp-si-di, y se extraen con popa en el orden inverso.

5) Para hacer algo anlogo con los registros de propsito general de 32 bits se utiliza pushad y popad. El orden seguido es el mismo, colocando "e" delante de los nombres de registro para obtener los nombres de los registros de 32 bits.

6) Para meter en y sacar de la pila los 16 bits del registro FLAGS se utiliza pushf y popf.

7) Para meter en y sacar de la pila los 32 bits del registro EFLAGS se utiliza pushfd y popfd.

=============================================================================

3.6 Otras instrucciones de movimiento de datos. =============================================================================

LAHF copia la parte baja del registro FLAGS (bits 0 a 7) en el registro AH.

SAHF copia el contenido del registro AH sobre los bits 0 al 7 del registro FLAGS.

- 17 -

- 18 -

=============================================================================

TEMA 4. INSTRUCCIONES DE CONVERSIN DE DATOS.

=============================================================================

=============================================================================

4.1 Instrucciones de extensin de la representacin con y sin signo. =============================================================================

En IA-32 se pueden representar nmeros con signo. Para ello se utiliza la representacin en complemento a 2.

Caractersticas de la representacin en complemento a 2:

- Consideremos que los nmeros son codificados utilizando n bits.

- Si el bit ms significativo es 0, se trata de un nmero positivo. Si es 1, se trata de un nmero negativo.

- La representacin de un nmero positivo se obtiene representando ese nmero ocupando (n-1) bits y colocando un cero a la izquierda de ese grupo de n-1 bits.

- Para representar un nmero negativo con n bits en complemento a 2 se hace lo siguiente:

1) Se toma el valor absoluto del nmero. 2) Se obtiene la representacin de ese valor absoluto como un valor positivo en n bits. 3) Se aplica NOT (inversin) a todos los bits de esa representacin. 4) Se suma 1 al resultado binario de esa operacin.

- 19 -

Nota: cuando se expresa un nmero en complemento a 2 hay que tener muy presente el nmero de bits utilizados para su representacin. Por ejemplo, -17 en 8 bits sera (expresado en hexadecimal y complemento a 2) 0xef, mientras que en 16 bits sera 0xffef.

La finalidad de las instrucciones de extensin es convertir representaciones de nmeros de 8 a 16 bits, de 8 a 32 bits o de 16 a 32 bits para nmeros representados con signo o sin signo. En general la extensin de la representacin de un nmero sin signo simplemente se obtiene rellenando con 0 los bits de mayor orden del nuevo formato. Y la extensin de la representacin de un nmero con signo se llevar a cabo de acuerdo con las reglas de la representacin en complemento a 2.

Las instrucciones de extensin sin signo se construyen como MOVZX destino, fuente. Su funcionalidad es copiar en destino el valor almacenado en fuente con la extensin correspondiente al tamao destino.

Anlogamente, las instrucciones de extensin con signo se construyen como MOVSX destino, fuente. Su funcionalidad es anloga.

Las instrucciones MOVSX se utilizan as:

movsx reg16, mem8 movsx reg16, reg8 movsx reg32, mem8 movsx reg32, reg8 movsx reg32, mem16 movsx reg32, reg16

Las instrucciones MOVZX se utilizan anlogamente a las MOVSX.

Hay otras instrucciones de extensin que resultan muy tiles:

- cbw: extiende con signo los 8 bits del registro al sobre los 16 bits del registro ax.

- cwd: extiende con signo los 16 bits del registro ax sobre los 32 bits del par de registros dx:ax.

- cdq: extiende con signo los 32 bits del registro eax sobre los 64 bits del par de registros edx:eax.

=============================================================================

4.2 Conversin "little endian" / "big endian". =============================================================================

Para almacenar el contenido de registros, palabras o palabras dobles en la memoria hay dos posibles convenciones que se denominan "little endian" y "big endian". Unas arquitecturas siguen una convencin, y otras la otra.

- Convencin "little endian": en un conjunto de bytes que representan algo, el byte menos significativo aparece almacenado en la posicin de memoria ms baja. Por ejemplo, al almacenar el contenido del registro eax en la memoria a partir de la direccin X, los bits eax(0-7) se almacenaran en X, los eax(8-15) en X+1, los eax(16-23) en X+2 y los eax(24-31) en X+3.

- Convencin "big endian": en un conjunto de bytes que representan algo, el byte de menor orden aparece en la direccin de memoria ms alta. Por ejemplo, si se desea almacenar la palabra doble 0x11223344 a partir de la direccin de memoria Y, en la memoria encontraramos 0x11 en Y, 0x22 en Y+1, 0x33 en Y+2, y 0x44 en Y+3.

- 20 -

La instruccin BSWAP sirve para realizar los cambios necesarios para pasar de valores almacenados segn la convencin "little endian" a "big endian" y viceversa.

Utilizacin: bswap reg32.

Funcionalidad: intercambia el contenido del byte 0 de reg32 con el del byte 3, y el del byte 1 con el del byte 2.

El inters de este concepto y esta instruccin es que IA-32 (y en general, los procesadores de Intel) utiliza convencin little-endian (lo mismo que otras arquitecturas), pero hay otras que utilizan convencin big-endian (por ejemplo, procesadores de Motorola). Cuando hay que intercambiar datos almacenados en memoria entre computadores con diferente convencin, hay que realizar cuidadosas transformaciones de los datos utilizando bswap.

- 21 -

=============================================================================

TEMA 5. INSTRUCCIONES ARITMTICAS.

=============================================================================

=============================================================================

5.1 Introduccin. =============================================================================

IA-32 suministra instrucciones aritmticas de: suma, resta, cambio de signo, comparacin, multiplicacin y divisin/obtencin de resto.

El registro EFLAGS (registro de estado del procesador, o registro de banderas) se ve afectado por la ejecucin de las instrucciones aritmticas. Sus funciones son: 1) mantiene el actual modo de funcionamiento de la CPU, 2) informa sobre determinados sucesos relacionados con la ejecucin de ciertas instrucciones. Vamos a comentar los principales bits de EFLAGS que cumplen con esta funcin.

- 22 -

Estos bits son:

Bit 0 - C (se le denomina bandera C). Bit 2 - P Bit 4 - A Bit 6 - Z Bit 7 - S Bit 11 - 0

Significado de esas banderas:

1) Bandera O (bit 11): se la denomina bandera de desbordamiento. Despus de ejecutar una operacin aritmtica O se pone a uno si el resultado no cabe en el operando destino, supuesto que estamos considerando nmeros en representacin con signo. Por ejemplo, supongamos que hacemos lo siguiente:

al

- 23 -

=============================================================================

5.2 Suma. =============================================================================

=============================================================================

5.2.1 Instrucciones ADD y ADC. =============================================================================

Formato:

add destino, fuente adc destino, fuente

Ambos operandos (destino y fuente) deben ser del mismo tamao.

Operacin:

add: destino

- 24 -

Formato: xadd destino, fuente.

Ambos operandos pueden ser reg o mem, pero no mem los dos a la vez, y deben ser del mismo tamao.

La operacin de XADD podemos representarla por el siguiente algoritmo:

temp

- 25 -

=============================================================================

5.4 Instruccin de cambio de signo (NEG). =============================================================================

Formato: neg operando

Cambia de signo lo almacenado en el operando, utilizando representacin en complemento a 2.

Utilizacin:

neg reg neg mem

Afecta a las banderas igual que sub (equivale a hacer operando

- 26 -

Utilizacin:

mul reg mul mem

(el operando reg o mem pueden ser de 8, 16 o 32 bits).

Funcin:

1) Operando de 8 bits:

ax

- 27 -

Combinaciones de tamaos de operando soportadas por las posibilidades especficas de imul:

1) imul operando1, operando2, inmediato:

- Los tres de 16 bits o los tres de 32 bits. - operando1 siempre debe ser un registro. - operando2 puede ser un registro o una posicin de memoria.

2) imul operando1, inmediato

- operando1 siempre debe ser un registro. - Los dos operando han de ser de 16 o de 32 bits.

3) imul operando1, operando2

- Los dos operandos deben ser de 16 o de 32 bits. - operando1 siempre debe ser un registro. - operando2 puede ser un registro o una posicin de memoria.

Obsrvese que imul slo puede funcionar con operandos de 8 bits cuando se utiliza en los modos que le son comunes con mul. En sus modos especficos slo utiliza operandos de 16 o 32 bits.

El resultado de imul se recoge en un operando que tiene el mismo tamao que los operandos iniciales. Las banderas de estado se ven afectadas de maneras no conformes con su funcionalidad definida ("estropea" los contenidos de las banderas). Si hay un desbordamiento, se pierden los bits ms significativos del resultado.

=============================================================================

5.7 Instrucciones de divisin entera. =============================================================================

Son las instrucciones:

DIV (divisin sin signo). IDIV (divisin con signo).

Formato:

div operando idiv operando

Utilizacin:

div reg div mem

El operando puede ser de 8, 16 y 32 bits.

idiv se utiliza del mismo modo que div.

Funcionalidad:

Tanto div como idiv ejecutan divisiones entre operandos de los siguientes tamaos:

- Dividendo de 64 bits entre divisor de 32 bits. - Dividendo de 32 bits entre divisor de 16 bits. - Dividendo de 16 bits entre divisor de 8 bits.

Y slo entre esos tamaos de operandos.

- 28 -

Los resultados se recogen de la forma siguiente, en funcin del tamao del operando:

1) Operando de 8 bits:

Divide ax/operando. El cociente se almacena en al y el resto en ah.

2) Operando de 16 bits:

Divide dx:ax / operando. Cociente: ax. Resto: dx.

3) Operando de 32 bits:

Divide edx:eax / operando. Cociente: eax. Resto: edx.

Para dividir un valor cargado en un almacenamiento del mismo tamao que el del divisor, es necesario extender el dividendo a un tamao del doble.

Ambas instrucciones afectan a las banderas de manera no conforme con la definicin del significado de stas. Si se produce una divisin entera por cero, se produce una excepcin cuyo tratamiento suele ser que el procesador detenga la ejecucin del programa.

- 29 -

=============================================================================

TEMA 6. INSTRUCCIONES LGICAS Y DE MANIPULACIN A NIVEL DE BIT.

=============================================================================

=============================================================================

6.1 Instrucciones lgicas. =============================================================================

Son las instrucciones AND, OR, XOR y NOT.

Formato general: instruccin destino, fuente, donde instruccin puede ser and, or, xor y not.

Esas instrucciones realizan una operacin and, or, xor bit a bit entre los operandos destino y fuente. not invierte los bits del operando.

- 30 -

Funcionalidad:

and destino,fuente destino

- 31 -

3) shld: tiene un funcionamiento que podemos modelar como una secuencia de pasos.

a) Coloca el segundo operando (fuente) a la derecha del primer operando (el destino). Con ello es como si se formara una cadena de bits en la que los bits del operando destino ocupan la parte alta o ms significativa.

b) Desplaza esa cadena de bits tantas veces a la izquierda como exprese el contador. El ltimo bit que desaparece por la izquierda es copiado en C.

c) Copia la parte alta de la cadena resultante sobre el primer operando (el operando destino) y deja intacto el segundo operando (el operando fuente).

4) shrd: anlogamente a shld, se modela su funcionamiento como una secuencia de pasos.

a) Coloca el segundo operando (fuente) a la izquierda del primer operando (el destino). Con ello es como si se formara una cadena de bits en la que los bits del operando destino ocupan la parte baja o menos significativa.

b) Desplaza esa cadena de bits tantas veces hacia la derecha como exprese el contador. El ltimo bit que desaparece por la derecha es copiado en C.

c) Copia la parte baja de la cadena resultante sobre el primer operando (el operando destino) y deja intacto el segundo operando (el operando fuente).

Utilizacin:

shl reg,inmediato shl mem,inmediato shl reg,cl shl mem,cl

sal, shr y sar tiene la misma utilizacin que shl.

shld reg,reg,inmediato shld mem,reg,inmediato shld reg,reg,cl shld mem,reg,cl

shrd tiene la misma utilizacin que shld.

En cuanto al tamao de los operandos, stos pueden ser de 8, 16 y 32 bits para shl, sal, shr y sar. Para shld y shrd los operandos slo pueden ser de 16 o 32 bits (no de 8), y el operando fuente y el destino han de tener el mismo tamao.

En todas estas instrucciones, la bandera C contiene el ltimo bit expulsado en el desplazamiento.

=============================================================================

6.3 Instrucciones de rotacin =============================================================================

Son las siguientes:

rcl: rotacin a la izquierda a travs de la bandera C. rcr: rotacin a la derecha a travs de la bandera C. rol: rotacin a la izquierda sin pasar por C. ror: rotacin a la derecha sin pasar por C.

- 32 -

Formato general:

instruccin destino,contador

(donde instruccin puede ser rcl, rcr, rol, ror).

Funcionalidad: todas ellas generan una rotacin de tantos pasos como exprese el contador.

a) rcl: se puede modelar como si la bandera C se hubiera "pegado" a la izquierda del operando destino y se hace rotar esa estructura tantos bits hacia la izquierda como exprese el contador.

b) rcr: se puede modelar como si la bandera C se hubiera "pegado" a la derecha del operando destino y se hace rotar esa estructura tantos bits hacia la derecha como exprese el contador.

c) rol: se hace rotar el operando destino tantas veces hacia la izquierda como exprese el contador. El ltimo bit que sale por la izquierda para volver a entrar por la derecha queda copiado en la bandera C.

d) ror: se hace rotar el operando destino tantas veces hacia la derecha como exprese el contador. El ltimo bit que sale por la derecha para volver a entrar por la izquierda queda copiado en la bandera C.

Por tanto, la bandera C contiene el ltimo bit que "sale" del operando destino debido a la rotacin (sale de ste para ir a C en rcl o rcr, o para volver a entrar en destino por un extremo de ste).

Utilizacin:

rcl reg,inmediato rcl mem,inmediato rcl reg,cl rcl mem,cl

rol, rcr y ror se utilizan lo mismo que rcl.

Soportan operandos destino de 8, 16 o 32 bits.

=============================================================================

6.4 Instrucciones de manipulacin a nivel de bit. =============================================================================

=============================================================================

6.4.1 Instrucciones de comprobacin y modificacin. =============================================================================

a) Instruccin TEST.

Formato: test destino,fuente

Realiza una operacin AND bit a bit entre los operandos destino y fuente, pero sin almacenar el resultado en el operando destino. Su efecto nicamente queda reflejado en las banderas de estado.

Utilizacin:

test reg,reg test reg,mem test mem,reg test reg,inmediato test mem,inmediato

- 33 -

b) Instruccin BT.

Formato: bt fuente,ndice

Copia en C el bit de posicin "ndice" del operando fuente.

Utilizacin:

bt reg,reg bt mem,reg bt reg,inmediato bt mem,inmediato

c) Instruccin BTR.

Es anloga a BT y adems pone a 0 el bit de la posicin "ndice" del operando fuente.

d) Instruccin BTC.

Es anloga a BT y adems invierte el bit de la posicin "ndice" del operando fuente.

e) Instruccin BTS.

Es anloga a BT y adems pone a 1 el bit de la posicin "ndice" del operando fuente.

f) Instruccin BSF.

Formato: bsf destino,fuente

Busca en el operando fuente el primer bit en 1, comenzando por el bit menos significativo (el bit 0) y terminando por el bit ms significativo. Si encuentra un bit en 1, pone la bandera Z en cero y almacena la posicin de ese bit (un nmero entre 0 y 31) en el operando destino. Si no lo encuentra, pone Z en uno.

Utilizacin:

bsf reg,reg bsf reg,mem

g) Instruccin BSR.

Es anloga a la instruccin BSF pero comenzando la bsqueda por el bit ms significativo del operando fuente.

Para todas estas instrucciones el tamao de los operandos es el siguiente: para test 8, 16 y 32 bits; para el resto slo de 16 o 32 bits (no 8). Como siempre, cuando hay dos operandos stos deben ser del mismo tamao.

=============================================================================

6.4.1 Instrucciones de escribr 1 si se cumple una condicin. =============================================================================

Escriben 1 o 0 en un operando de 8 bits segn que se cumpla o no una determinada condicin. Ese operando puede ser un registro o una direccin de memoria. Si la condicin se cumple se escribe un 1. Si no se cumple se escribe un 0.

No modifican el estado de las banderas.

- 34 -

Formato general: instruccin reg instruccin mem

Clasificamos estas instrucciones segn la condicin que codifiquen. En concreto, la condicin se puede apoyar sobre:

a) El contenido de las banderas de estado:

(se indica al lado de cada instruccin la condicin que se debe cumplir) setc - condicin: bandera C en 1. setnc - bandera C en 0. setz - bandera Z en 1 setnz - bandera Z en 0 sets - bandera S en 1 setns - bandera S en 0 seto - bandera O en 1 setno - bandera O en 0 setp - bandera P en 1 setnp - bandera P en 0

b) El resultado de una precedente instruccin de comparacin (cmp) sin signo. La instruccin set debe ejecutarse inmediatamente despus de la instruccin cmp, de manera que ninguna otra operacin haya modificado el contenido de las banderas de estado.

seta - condicin: el resultado de la comparacin es "mayor que". setna - no mayor que. setae - mayor o igual que. setnae - no mayor o igual que. setb - menor que. setnb - no menor que. setbe - menor o igual que. setnbe - no menor o igual que. sete - igual que. setne - no igual que.

c) El resultado de una comparacin (cmp) con signo. Anlogo comentario que en b).

setg - mayor que. setng - no mayor que. setge - mayor o igual que. setnge - no mayor o igual que. setl - menor que. setnl - no menor que. setle - menor o igual que. setnle - no menor o igual que. sete - igual que. setne - no igual que.

Nota: cuando se escribe el par de instrucciones siguiente

cmp destino,fuente seta operando

el significado es "escribir 1 en el operando si el nmero almacenado en destino es mayor que fuente suponiendo que tanto fuente como destino son nmeros almacenados en representacin sin signo". Con las dems instrucciones de comparacin se podran formar anlogas combinaciones.

- 35 -

=============================================================================

TEMA 7. INSTRUCCIONES DE SALTO.

=============================================================================

=============================================================================

7.1 Introduccin. =============================================================================

Las instrucciones de salto sirven para continuar la ejecucin de un programa en otra instruccin que no es la que est almacenada inmediatamente despus dentro de la secuencia almacenada en memoria. Su funcin consiste, por lo tanto, en modificar el registro de puntero hacia instruccin de una forma especial que viene establecida por el destino del salto.

Las instrucciones de salto las clasificamos en tres grupos:

- la instruccin de salto incondicional, - las instrucciones de salto condicional y - las instrucciones de construccin de bucles.

=============================================================================

7.2 Instruccin de salto incondicional. =============================================================================

Su formato es: jmp etiqueta

- 36 -

Hace que la ejecucin del cdigo contine en la posicin de memoria marcada como "etiqueta". Para poder utilizarla, hay que marcar previamente con "etiqueta" la posicin de destino del salto. Por esa razn se colocan etiquetas dentro del cdigo del programa.

=============================================================================

7.3 Instrucciones de salto condicional. =============================================================================

Su formato general es: instruccin etiqueta. La instruccin se escribe como j[condicin], donde [condicin] son unos caracteres que codifican la condicin que se debe cumplir para saltar (por ejemplo, nc para indicar que la condicin es que C est en 0). Por ejemplo, si "sigue" es una etiqueta, una instruccin de salto condicional podra escribirse as: jnz sigue.

Su funcin es que se contine ejecutando el cdigo en la posicin "etiqueta" si se cumple la condicin, y si no se cumple la condicin se debe continuar en la instruccin que sigue a j[condicin].

Se pueden considerar cuatro tipos de condiciones:

- las basadas en banderas de estado, - las basadas en comparaciones sin signo, - las basadas en comparaciones con signo, - la basada en el contenido del registro ecx.

a) Basadas en banderas de estado:

jc - salta si C=1. jnc - salta si C=0. jz - salta si Z=1. jnz - salta si Z=0. js - salta si S=1. jns - salta si S=0. jo - salta si O=1. jno - salta si O=0. jp - salta si P=1. jnp - salta si P=0.

b) Basadas en comparaciones sin signo: estas instrucciones deben ir colocadas detrs de una instruccin cmp en la que se comparen dos nmeros (destino con fuente) ambos en representacin sin signo.

ja - salta si la comparacin da "mayor que". jna - salta si "no mayor que". jae - salta si "mayor o igual que". jnae - salta si "no mayor o igual que". jb - salta si "menor que". jnb - salta si "no menor que". jbe - salta si "menor o igual que". jnbe - salta si "no menor o igual que". je - salta si "igual que". jne - salta si "no igual que".

c) Basadas en comparaciones con signo: estas instrucciones deben ir colocadas detrs de una instruccin cmp en la que se comparen dos nmeros (destino con fuente) ambos en representacin con signo.

jg - salta si "mayor que". jng - salta si "no mayor que". jge - salta si "mayor o igual que". jnge - salta si "no mayor o igual que".

- 37 -

jl - salta si "menor que". jnl - salta si "no menor que". jle - salta si "menor o igual que". jnle - salta si "no menor o igual que". je - salta si "igual que". jne - salta si "no igual que".

d) Basada en el contenido del registro ecx:

jecxz - salta si ecx=0.

=============================================================================

7.4 Instrucciones de construccin de bucles. =============================================================================

Sirven para establecer los saltos que permiten cerrar un bucle o grupo de instrucciones que se ejecuta de manera repetitiva. Estos bucles utilizan el registro ecx como "contador de vueltas".

Estas instrucciones son:

a) LOOP:

Formato: loop etiqueta

Funcin: en primer lugar decrementa ecx en una unidad (ecx

- 38 -

=============================================================================

TEMA 8. INSTRUCCIONES DE LLAMADAS A SUBRUTINAS.

=============================================================================

=============================================================================

8.1 Introduccin. =============================================================================

Una subrutina es una determinada porcin de cdigo. Se entra en ella por medio de un salto que se ejecuta en un punto del programa al que se denomina "llamada de la subrutina". Cuando se termina su ejecucin se debe continuar ejecutando la instruccin que viene inmediatamente despus de la de llamada de la subrutina.

El inicio de una subrutina estar marcado dentro del cdigo por medio de una etiqueta.

Un criterio bsico: habitualmente el estado del procesador al terminar la ejecucin de una subrutina debe ser el mismo que cuando se llam a esa subrutina. Por ello, cuando se entra en una subrutina es preciso almacenar el estado del procesador, con el fin de que al salir o retornar de ella el procesador recupere ese mismo estado.

- 39 -

La instruccin de llamada de subrutina es CALL y la instruccin que se coloca al final de una subrutina para retornar de ella al punto del cdigo que sigue a la llamada es RET.

=============================================================================

8.2 Instruccin CALL. =============================================================================

Sirve para continuar la ejecucin en el comienzo de una subrutina (por tanto, para construir una llamada de subrutina).

Formato: call etiqueta, donde etiqueta es la etiqueta que marca el comienzo de la subrutina.

Funcin:

1) Almacena en la pila la direccin de la instruccin que est en el cdigo inmediatamente despus de esa instruccin call. Esa direccin es el punto de retorno, al que debe irse en cuanto se termine la ejecucin de la subrutina. Por tanto, para hacer eso introduce 4 bytes dentro de la pila. ESP disminuye en cuatro unidades despus de haberse ejecutado call.

2) Salta a la posicin marcada con etiqueta.

=============================================================================

8.3 Instruccin RET. =============================================================================

Es la instruccin que se coloca al final de una subrutina.

Formato: ret

Funcin:

1) Saca de la pila 4 bytes. Interpreta que esos 4 bytes integran la direccin del punto de retorno que una anterior llamada call introdujo en la pila, en concreto la llamada que motiv la entrada en esa subrutina.

2) Salta a la direccin de memoria que se construye con esos 4 bytes.

Observacin: Si la subrutina maneja inadecuadamente la pila (por ejemplo, mete algo en la pila de manera que se termina sin haberlo sacado ni haber restaurado ESP antes de llegar a ret), ret no sacar la direccin de retorno adecuada. El retorno ser hacia una posicin errnea, y ello producir un fallo en la ejecucin del programa.

- 40 -

=============================================================================

TEMA 9. OTRAS INSTRUCCIONES.

=============================================================================

=============================================================================

9.1 Instrucciones de manipulacin directa de las banderas de estado. =============================================================================

Instruccin CLC: pone la bandera C en 0.

Instruccin STC: pone la bandera C en 1.

Instruccin CMC: invierte el contenido de la bandera C.

=============================================================================

9.2 Instruccin NOP. =============================================================================

Su ejecucin no produce ningn efecto. Simplemente se trae 1 byte de la memoria de instrucciones (su cdigo de operacin) y se decodifica. Se contina su procesamiento sin que ste d lugar a ningn cambio ni en el estado del procesador ni en la memoria.

Sirve para dejar "huecos" en el cdigo del programa dirigidos a optimizar la ejecucin del cdigo segn la estructura del procesador (por ejemplo, de acuerdo con la estructura de un procesador segmentado en previsin de posibles dependencias de datos, riesgos de control, etc.).

=============================================================================

9.3 Instruccin RDTSC. =============================================================================

Almacena en el par de registros edx:eax el nmero de ciclos de reloj que han transcurrido desde la ltima reinicializacin realizada en el procesador.

- 41 -

=============================================================================

TEMA 10. ACCESO A LOS RECURSOS DEL SISTEMA OPERATIVO.

=============================================================================

=============================================================================

10.1 Concepto y necesidad de las llamadas a recursos del S.O. =============================================================================

El sistema operativo suministra una serie de funciones que sirven para:

1) Realizacin de diversas tareas relacionadas con la gestin de procesos: lanzamiento de procesos, finalizacin, comprobacin de estado de ejecucin, etc.

2) Acceso al sistema de entrada/salida, en concreto:

- Teclado - Pantalla - Dispositivos de comunicaciones - Discos, y en concreto gestin de archivos, manejo de directorios, etc.

Slo a travs de esas funciones se puede tener acceso a esos recursos en un sistema operativo como UNIX.

Adems hay funciones que ayudan al usuario a realizar ciertas tareas, aunque no sea forzosamente necesario que recurra a ellas para llevarlas a cabo.

- 42 -

=============================================================================

10.2 Funciones de biblioteca del S.O. y su utilizacin. =============================================================================

Puede encontrase un listado de las mismas en los manuales de programacin de los lenguajes de alto nivel para los compiladores de ese sistema operativo. Por ejemplo, en los manuales de C para programacin dentro de un entorno UNIX.

Para hacer uso de esas funciones, dentro del archivo en ensamblador a la funcin se la invoca simplemente con call, anlogamente a las subrutinas. Por ejemplo, para llamar a printf colocaremos "call printf".

Los nombres de las funciones que van a ser utilizadas dentro del cdigo han de ser declarados como "extern" en la cabecera del archivo en ensamblador.

Paso de parmetros a las funciones:

a) Si el parmetro es simplemente un nmero, se carga dicho parmetro en la pila.

b) Si el parmetro es una cadena de caracteres es necesario almacenar esa cadena a partir de una posicin de memoria, colocando un byte 0x00 en la posicin que siga inmediatamente al ltimo de los caracteres (es el indicador de final de cadena). Hecho eso, se introduce en la pila la direccin de comienzo de almacenamiento de la cadena (que ser un grupo de 4 bytes).

c) En el caso de que haya varios parmetros, deben ser introducidos en la pila en orden inverso al de su aparicin en el formato de la funcin.

Devolucin de resultados de las funciones:

a) Si el resultado es un nmero, ste suele ser devuelto en al, ax o eax segn el tamao del resultado.

b) Si el resultado es una cadena de caracteres, lo devuelven escribindola en la memoria a partir de una posicin determinada. La direccin de esa posicin de inicio debe ser pasada inicialmente a la funcin como parmetro.

Despus de invocar "call funcin" hay que eliminar de la pila los parmetros introducidos; para ello puede hacerse dos cosas:

1) Realizar tantos pop de palabras como push de palabras se hayan realizado para introducir esos parmetros.

2) Modificar directamente el registro ESP (de puntero de cabeza de pila). En concreto, se le hace volver al valor que tena antes de introducir los parmetros de la funcin.

- 43 -

Ejemplo de utilizacin de una funcin de la biblioteca del S.O.:

Escribir en pantalla "Resultado = [entero]" donde [entero] es el contenido de eax interpretado como un nmero en representacin con signo.

extern printf

section .text

push eax push dword cadena call printf add esp, 8

section .data cadena db 'Resultado = %d',10,0

Nota: el 10 de la cadena de formato se introduce para que se salte de lnea despus de escribir eso en pantalla.

- 44 -

=============================================================================

TEMA 11. LOS MODOS INDIRECTOS.

=============================================================================

=============================================================================

11.1 Introduccin. =============================================================================

Concepto: una instruccin utiliza un modo indirecto si para referirse a una determinada posicin de memoria, en lugar de expresar directamente el nmero de dicha direccin, se refiere a ella a travs de un lugar de almacenamiento en el que est escrito el nmero que expresa dicha direccin.

Utilizacin:

1) En instrucciones que impliquen acceso a memoria. A ello se denomina direccionamiento indirecto.

2) En instrucciones de salto, para expresar la direccin de destino del salto. A ello se denomina los saltos indirectos.

3) En las llamadas de subrutina (call), para indicar el punto de comienzo de la subrutina. A ello se denomina llamadas indirectas a subrutinas.

- 45 -

=============================================================================

11.2 Direccionamiento indirecto. =============================================================================

Para fijar ideas, en este apartado mencionaremos ejemplos con la instruccin mov, pero anlogamente podra utilizarse todo lo que se comente aqu para cualquier otra instruccin que acceda a alguna posicin de la memoria.

En una instruccin (por ejemplo, mov) se puede hacer referencia a una direccin de memoria que:

1) Est cargada en un registro de 32 bits.

2) Se puede construir en base a operaciones aritmticas sobre nmeros cargados en registros.

Hay cuatro maneras de realizar el direccionamiento indirecto:

a) Direccionamiento indirecto por registro:

Un registro de 32 bits contiene la direccin involucrada. Por ejemplo, si se desea cargar los 32 bits que estn almacenados en la memoria a partir de la posicin de memoria etiquetada como "a" podemos hacer lo siguiente:

lea ebx, [a] mov eax, [ebx]

b) Direccionamiento indirecto indexado:

Se referencia una posicin de la memoria que se obtiene sumando un nmero (al que se denomina desplazamiento) al contenido de un registro. El formato general sera:

mov destino, [reg+desplazamiento]

donde desplazamiento es un nmero. Puede ponerse reg+desplazamiento o reg-desplazamiento.

c) Direccionamiento indirecto con base ms ndice:

Se referencia a una posicin de la memoria que se obtiene en base a alguna de las siguientes expresiones:

registro1+registro2 registro1+a*registro2 donde a puede ser 2, 4 u 8.

(Nota: no se puede poner registro1-registro2 ni registro1-a*registro2).

d) Direccionamiento indirecto con base, ndice y desplazamiento.

Se referencia una posicin por la suma del contenido de dos registros ms un desplazamiento:

registro1+registro2+desplazamiento registro1+a*registro2+desplazamiento (donde a puede ser 2, 4 u 8) registro1+a*registro2-desplazamiento

- 46 -

=============================================================================

11.3 Saltos indirectos. =============================================================================

Se establece la direccin de un salto en base al contenido de:

1) Un registro: por ejemplo, se desea saltar hacia la posicin etiquetada como "destino"; se puede escribir para ello lo siguiente:

lea eax, [destino] ; se carga en eax la direccin de destino del salto

jmp eax ; salta a la direccin expresada en el registro eax.

2) Una direccin que ha sido almacenada en memoria como una palabra doble a partir de una determinada posicin. Por ejemplo, supongamos que el destino del salto es la posicin de memoria etiquetada como "destino"; para saltar all puede hacerse lo siguiente:

lea eax, [destino] ; obtenemos en eax la direccin de la etiqueta destino

mov [a], eax ; almacenamos a partir de la posicin ; a la direccin destino

jmp [a] ; salta a la direccin que construye tomando los ; cuatro bytes almacenados a partir de ; la posicin etiquetada como a

Nota: slo pueden construirse saltos indirectos incondicionales.

=============================================================================

11.4 Llamadas indirectas a subrutinas. =============================================================================

Se construyen anlogamente a los saltos indirectos.

Se establece la direccin de comienzo de la subrutina en base al contenido de:

1) Un registro que contiene una direccin de 32 bits: call reg32. El contenido de ese registro es la direccin de inicio de la subrutina.

2) Una posicin de memoria a partir de la que se han almacenado 4 bytes consecutivos, con los cuales se construye la direccin de inicio de la subrutina: call [mem32].

- 47 -

=============================================================================

TEMA 12. LA UNIDAD ARITMTICA DE PUNTO FLOTANTE.

=============================================================================

=============================================================================

12.1 Introduccin. =============================================================================

IA-32 tiene una serie de instrucciones para utilizar la unidad de punto flotante o FPU. Esa unidad est dentro de la CPU y es una unidad aritmtica especializada en realizar operaciones con nmeros representados en formato de punto flotante.

La FPU posee diversos registros internos, entre los que destacaremos los 8 registros de datos y el registro de estado.

- 48 -

=============================================================================

12.2 Tipos de datos manejados por la FPU. =============================================================================

La FPU de IA-32 soporta tres formatos de representacin de nmeros en punto flotante:

a) Formato de precisin simple:

- Son 32 bits. - Bits 0 al 22: mantisa (23 bits). Es la mantisa del nmero expresado en binario como 1.[mantisa]. - Bits 23 al 30: exponente (8 bits). Es el resultado de representar en binario la suma del exponente ms 127. - Bit 31: bit de signo. 0 si es positivo. 1 si es negativo. - El nmero se obtiene as: nmero=(signo)1.[mantisa]*2^(bits de exponente - 127) - Rango: [ - 2^128 ... -2^(-127)]... 0 ...[2^(-127) ... 2^128]. - En la prctica, una precisin de unos 6 dgitos en base 10.

b) Formato de precisin doble:

- Son 64 bits. - Anlogo a precisin simple, con un mayor nmero de bits. - Bits 0 al 51: mantisa (52 bits). - Bits 52 al 62: exponente (11 bits). Es el resultado de representar en binario la suma del exponente ms 1023. - Bit 63: signo. - Rango: +/- 2^(+/- 1024). - En la prctica, una precisin de unos 14 dgitos en base 10.

c) Formato de precisin extendida:

- Son 80 bits. - Bits 0 al 63: mantisa (64 bits). Es la mantisa real del nmero. - Bits 64 al 78: exponente (15 bits). Es el resultado de representar en binario la suma del exponente ms 16383. - Bit 79: signo. - Rango: +/- 2 ^ (16384). - En la prctica, una precisin de unos 19 dgitos en base 10.

Internamente la FPU siempre utiliza nmeros expresados en precisin extendida.

La IA-32 suministra instrucciones de punto flotante (FP) para manipular nmeros representados en cualquiera de las 3 precisiones. Antes de realizar las operaciones, la FPU convierte internamente los valores suministrados en nmeros representados en precisin extendida.

=============================================================================

12.3 Los registros de la FPU. =============================================================================

a) Los registros de datos.

Son ocho registros.

Cada uno tiene un tamao de 80 bits. Por tanto, cada uno puede almacenar un nmero expresado en formato de precisin extendida.

No funcionan como los registros enteros de propsito general:

- 49 -

- Estn organizados como una pila LIFO (ltimo en entrar, primero en salir) a la que se denomina la pila FPU. - En ensamblador se les denomina como st0, st1, st2, ... st7. - st0 hace referencia al valor que est en la cabeza de la pila. - st7 hace referencia al valor que puede estar ms al fondo de la pila. - Cuando se introduce un dato en la pila-FPU entra en st0, lo que hace que lo que antes estaba almacenado en st0 se cargue en st1, y as sucesivamente. Cuando se saca un dato de st0, lo que estaba en st1 sube a st0, lo de st2 a st1 y as sucesivamente. Por ello se dice que estos registros estn organizados como una pila LIFO.

b) El registro de estado de la FPU.

Es un registro de 16 bits.

Descripcin de algunos de sus bits: los bits 0 al 7 son las banderas de excepcin. Los bits 8, 9, 10 y 14 se denominan bits de cdigo de condicin FPU.

=============================================================================

12.4 Instrucciones de movimiento de datos en la FPU. =============================================================================

a) FLD

Carga en la pila FPU un nmero representado en formato de punto flotante que puede estar almacenado en:

- La memoria, en formato de 32, 64 u 80 bits.

- Otro registro de la pila-FPU. En ese caso, lo que hace es reintroducir ese valor en la pila-FPU.

Formato y utilizacin:

fld mem32 fld mem64 fld mem80 fld sti, donde i puede ser 0, 1, ... 7

b) FSTP

Saca el contenido de st0 y lo lleva hacia:

- La memoria, almacenndolo ocupando 32, 64 u 80 bits (segn el tipo de representacin FP con el que se desee almacenar ese valor dentro de la memoria).

- Un registro de la pila FPU. En ese caso, copia st0 en el registro sti y saca el valor de st0 de la pila, con lo que cada valor sti sube a st(i-1).

Formato y utilizacin:

fstp mem32 fstp mem64 fstp mem80 fstp sti, donde i puede ser 0, 1, ... 7

- 50 -

c) FST

Hace lo mismo que fstp pero sin sacar st0 de la pila.

A diferencia de fstp, slo puede almacenar valores en memoria ocupando 32 o 64 bits, pero no 80.

d) FXCH

Su formato es: fxch sti , donde i puede ser 1, ... 7

Intercambia los contenidos de st0 y sti.

=============================================================================

12.5 Instrucciones de conversin de datos. =============================================================================

Sirven para realizar conversiones de valores almacenados como enteros (en representacin con signo en complemento a 2) a valores almacenados en formato de punto flotante y viceversa.

a) FILD

Formato:

fild mem16 fild mem32 fild mem64

A partir de mem16, mem32 o mem64 se supone que hay un entero almacenado ocupando 16, 32 o 64 bits respectivamente. FILD lee ese nmero, lo convierte a representacin de punto flotante extendida y lo introduce en st0.

b) FISTP

Formato:

fistp mem16 fistp mem32 fistp mem64

Saca el contenido de st0 y lo almacena en formato entero (haciendo redondeo de la parte decimal si procede) de 16, 32 o 64 bits.

c) FIST

Hace lo mismo que fistp sin sacar el valor de st0. A diferencia de fistp slo opera con representaciones en memoria de 16 o 32 bits para almacenar los enteros (no 64 bits).

Nota: para especificar el tamao de la representacin en memoria se utilizan las partculas word (16 bits), dword (32 bits) o qword (64 bits) delante de la etiqueta que especifica el lugar de la memoria.

- 51 -

=============================================================================

12.6 Las instrucciones aritmticas. =============================================================================

Sirven para llevar a cabo operaciones aritmticas entre nmeros almacenados en formato de punto flotante.

=============================================================================

12.6.1 Suma FP. =============================================================================

fadd mem32 fadd mem64

Suman el contenido de mem32 o mem64 a st0 y dejan el resultado en st0. mem no puede ser algo almacenado en memoria en formato de punto flotante de precisin extendida. Simplemente podemos expresarlo as:

fadd mem; st0

- 52 -

=============================================================================

12.6.3 Multiplicacin FP. =============================================================================

fmul mem; st0

- 53 -

Obsrvese que fcomi y fcomip pueden utilizarse anlogamente a la instruccin cmp con el fin de llevar a cabo la comparacin entre valores representados en punto flotante y luego poder tomar decisiones (saltos, etc.) basadas en esa comparacin.

=============================================================================

12.8 Predefinicin de constantes =============================================================================

Colocan en st0 ciertos valores tiles. Obsrvese que no hay ninguna instruccin de FP que permita la introduccin de inmediatos.

fldz; st0

- 54 -

=============================================================================

12.10 Operaciones con operandos enteros. =============================================================================

Realizan las mismas operaciones que sus homnimas cuyos mnemnicos no llevan la "i", pero considerando que el operando est almacenado en memoria como un entero de 16 o de 32 bits. Para ello primero convierten internamente (dentro de la FPU, sin modificar lo almacenado en la memoria) el entero de 16 o 32 bits a representacin de punto flotante de precisin extendida, y despus realizan la operacin.

Estas instrucciones siempre utilizan st0 como operando destino.

Para todas ellas el formato de utilizacin es: instruccin mem, donde mem puede ser mem16 o mem32. mem representa la posicin de la memoria (etiqueta) a partir de la que est almacenado un entero en representacin de 16 o de 32 bits.

Estas instrucciones son:

a) Suma: fiadd b) Sustraccin: fisub,fisubr c) Multiplicacin: fimul d) Divisin: fidiv, fidivr

=============================================================================

12.11 Otras instrucciones FP. =============================================================================

Hay otras muchas instrucciones FP que no hemos comentado. Simplemente comentamos una ms, que es finit y que sirve para devolver la FPU a su estado inicial por defecto. finit reinicializa el registro de estado de la FPU y vaca la pila-PFU.

- 55 -

=============================================================================

TEMA 13. MANIPULACIN DE CADENAS Y CONJUNTOS DE CARACTERES.

=============================================================================

=============================================================================

13.1 Introduccin. =============================================================================

Vamos a denominar cadena a una coleccin de objetos (bytes, palabras, dobles palabras) almacenados en posiciones contiguas de la memoria. A ese conjunto de posiciones contiguas ocupadas por la cadena lo vamos a denominar bloque de memoria, o sencillamente bloque.

Hay instrucciones especficas para manipulacin de cadenas, que son tiles para realizar operaciones sobre arrays de datos y cadenas de caracteres.

=============================================================================

13.2 Caractersticas generales de las instrucciones de manipulacin de cadenas. =============================================================================

Operan sobre bloques.

Operan en memoria. No se les suministra ningn operando explcitamente. Los datos que controlan el funcionamiento de estas instrucciones estn almacenados en registros de propsito general.

- 56 -

Implementan las funciones siguientes:

a) Copiar secuencias de bytes de una ubicacin de memoria hacia otra. b) Comparar secuencias almacenadas en memoria. c) Buscar un valor dentro de una secuencia. d) Inicializar zonas de memoria con un determinado valor.

La operacin que implementan estas instrucciones suele ser la repeticin de una operacin unitaria, repeticin que viene controlada por:

a) Registro ESI: contiene la direccin inicial del bloque de datos "fuente".

b) Registro EDI: contiene la direccin inicial del bloque de datos "destino".

c) Registro ECX: es el contador, y contiene el nmero de veces que se va a repetir la operacin unitaria. Se ir modificando durante la ejecucin, y su valor final ser lo que resulte despus de la ltima modificacin relacionada con una operacin unitaria.

d) Bandera de direccin: es la bandera D, que es el bit 10 del registro EFLAGS.

- Si D=0, ESI y EDI se incrementan despus de cada operacin unitaria.

- Si D=1, ESI y EDI se decrementan despus de cada operacin unitaria.

- Para establecer el estado de la bandera D se utilizan las instrucciones cld (pone D en 0) y std (pone D en 1).

e) Registro EAX: asume diversas funciones que detallaremos en cada caso.

Su formato es: [prefijo] [funcin]:

a) Trmino funcin:

Establece el tipo de operacin a realizar.

Puede ser movs, cmps, scas, lods y stos.

Pueden llevar al final las partculas b, w o d para indicar que las operaciones unitarias se van a realizar respectivamente a nivel de byte, palabra o palabra doble.

b) Trmino prefijo:

Especifica si va a haber repeticin de operacin unitaria y cmo se va a realizar sta.

Pueden ser rep, repe y repne.

Cuando se ejecuta una operacin con prefijo, el registro ECX se va decrementando en una unidad por cada operacin unitaria realizada. Siempre se de