El lenguaje ensamblador que se describe a continuación sigue la sintaxis comúnmente conocida con el nombre de “AT&T” y sus principales características son que los operandos destino se escriben en último lugar en las instrucciones, los registros se escriben con el prefijo % y las constantes con el prefijo $.

Una sintaxis alternativa utilizada por otros compiladores es la conocida con el nombre de “Intel”. En ella, los operandos destino se escriben los primeros en una instrucción, y los registros y constantes no se escriben con prefijo alguno.

En principio es el programa ensamblador quien estipula la forma en la que se deben escribir las instrucciones. Por tal motivo, es posible que existan diferentes ensambladores con diferentes definiciones de su lenguaje, pero que produzcan el mismo lenguaje máquina. Existen también ensambladores capaces de procesar programas escritos en más de un formato, el programa gcc, incluido con el sistema operativo Linux es uno de ellos. En adelante se utilizará únicamente la sintaxis “AT&T”.

Las instrucciones del lenguaje máquina de la arquitectura IA-32 pueden tener uno de los tres siguientes formatos:

Algunas de las instrucciones del procesador tienen un formato diferente a estos tres, pero serán tratadas como casos excepcionales. El ejemplo 5.2 muestra instrucciones de los tres tipos descritos anteriormente escritas en lenguaje ensamblador.

        push (%ecx)
        push 4(%ecx)
        push $msg
        call printf
        add $12, %esp

        pop %edx
        pop %ecx
        pop %eax
        ret

Para escribir programas en lenguaje ensamblador se necesita una descripción detallada de todas y cada una de sus instrucciones. Dicha descripción debe incluir todos los formatos de operandos que admite, así como el efecto que tiene su ejecución en el procesador y los datos. Esta información se incluye en los denominados manuales de programación y acompañan a cualquier procesador.

En el caso de la arquitectura IA-32, su descripción detallada, el lenguaje máquina y funcionamiento se incluye en el documento de poco más de 2000 páginas que lleva por título IA-32 Intel architecture Software Developer's Manual y cuyo contenido está dividido en los siguientes tres volúmenes:

El ejemplo 5.3 muestra la definición de la instrucción de suma de enteros que forma parte del lenguaje máquina de la arquitectura IA-32 tal y como consta en su manual.

La parte superior incluye las diferentes versiones de suma de enteros que soporta el procesador dependiendo de los tipos de operandos. La primera columna muestra los códigos de operación para cada una de las versiones y la segunda columna muestra la estructura en lenguaje ensamblador de cada una de ellas. La sintaxis utilizada en este documento es de tipo Intel (ver la sección 5.3.1), por tanto, el operando destino es el primero que se escribe.

La codificación de la instrucción ADD $4, 14(%eax, %ebx, 8) utilizada en el figura 5.4 coincide con la mostrada por esta tabla en la octava fila ADD r/m32, imm8, o en otras palabras, la suma de una constante de ocho bits (imm8) a un registro o un dato en memoria (en el ejemplo, un dato en memoria).

En el código de operación, los símbolos “ib”, “iw” e “id” significan respectivamente una constante de 8, 16 o 32 bits. El símbolo “\r” representa cualquiera de los registros de propósito general del procesador. En la segunda y tercera columna el prefijo “imm” seguido de un número representa una constante del tamaño en bits indicado por el número. El prefijo “r/m” seguido de un número significa que el operando es o un registro o un dato en memoria del tamaño del número indicado.

El documento continua con una descripción de palabra de la operación que realiza la instrucción. Se aclara que uno de los operandos es fuente y destino a la vez, y que no es posible sumar dos operandos que estén ambos en memoria.

La siguiente sección es una descripción funcional de la operación y se utiliza como resumen formal de la descripción textual que le precede. Algunas instrucciones, debido a su complejidad, son más fácilmente descritas mediante esta notación que mediante texto. Finalmente se mencionan aquellos bits de la palabra de estado del procesador que se modifican al ejecutar una de estas instrucciones.

Los operandos que utilizan las instrucciones de la arquitectura IA-32 se dividen en las siguientes categorías:

En la arquitectura IA-32 no todas las combinaciones posibles de tipos de operandos se pueden dar en todas las instrucciones. La arquitectura impone la restricción de que no se permite la ejecución de una instrucción con dos operandos explícitos que estén almacenados ambos en memoria. Además, no todas las combinaciones de instrucciones con tipos de operandos tienen sentido. La tabla 5.1 muestra ejemplos de instrucciones en lenguaje ensamblador correctas e incorrectas.

POP $0b11011101

MOV $-4, %eax

MOV %eax, $0x11011110

MOV %eax, contador

MOV $'A, %eax

MOV $65, %eax

MOV contador, resultado

MOV $-4, contador

De los tipos de operandos presentados en la sección anterior, no todos tienen definido el tamaño de todos sus componentes. Tal y como se ha visto en el capítulo 2, cuando se procesan datos es preciso saber el tamaño utilizado para su codificación.

Considérese la instrucción utilizada como último ejemplo en la tabla 5.1, MOV $-4, contador. A primera vista, la instrucción puede parecer correcta, pues se mueve una constante a una dirección de memoria representada, en este caso, por el símbolo contador. El primer operando, sin embargo, puede ser representado por un número arbitrario de bits. Lo mismo sucede con el segundo operando, pues al ser una dirección de memoria, lo único que se puede asegurar es que se utilizarán tantos bytes de memoria como sea preciso.

Como conclusión, la instrucción MOV $-4, contador a pesar de tener un formato correcto, es ambigua. El mismo formato puede representar las instrucciones que almacena la constante -4 representada por un número variable de bytes en la dirección indicada por contador. La arquitectura IA-32 sólo permite 3 tamaños para sus operandos: 1 byte, 2 bytes (un word), o 4 bytes (un doubleword, ver la tabla 4.1). Por tanto, la instrucción MOV $-4, contador, puede ser interpretada de tres formas diferentes dependiendo del tamaño con el que se representa la constante y el número de bytes utilizados para almacenar su valor en memoria (ambos deben ser el mismo número, 1, 2 o 4).

Para solventar este problema, el lenguaje ensamblador permite la utilización de un sufijo en el código de instrucción que indica el tamaño de los operandos utilizados. Este sufijo es la letra “B” para operandos de 1 byte, “W” para operandos de 2 bytes (un word), y “L” para operandos de 4 bytes (un doubleword).

Por tanto, si se quiere codificar la instrucción que almacena la constante -4 representada por 32 bits en la dirección indicada por contador se debe escribir MOVL $-4, contador.

De todas las instrucciones posibles sólo algunas de ellas son ambiguas. Si alguno de los operandos es un registro, el tamaño del operando queda fijado por el tamaño del registro. La ambigüedad aparece cuando ninguno de los operandos es un registro, y por tanto no es posible deducir el tamaño. Se permite el uso del sufijo de tamaño en una instrucción que no lo requiera, siempre y cuando esté en consonancia con el tamaño de los operandos. La tabla 5.2 muestra ejemplos de utilización del sufijo de tamaño.

PUSHL $0b11011101

MOVB $-4, contador

MOV $-4, %ax

MOVL %eax, contador

MOVB $'A, %eax

INCL contador

En esta categoría se incluyen las instrucciones que permiten la transferencia de datos entre registros y memoria tales como MOV, PUSH, POP y XCHG.

La instrucción MOV recibe dos operandos y transfiere el dato indicado por el primer operando al lugar indicado por el segundo. Dada la restricción que impone el procesador de que en una instrucción con dos operandos no pueden estar ambos en memoria, si se quiere transferir datos de un lugar de memoria a otro, se deben utilizar dos instrucciones y utilizar un registro de propósito general.

Las instrucciones PUSH y POP también transfieren datos, aunque en este caso, uno de los operandos es implícito y se refiere a la cima de la pila. La instrucción PUSH necesita como operando el dato a colocar en la cima de la pila mientras que la instrucción POP requiere un único operando para indicar el lugar en el que depositar el dato contenido en la cima de la pila. Ambas instrucciones modifican el registro %esp que contiene la dirección de la cima de la pila (tal y como se ha descrito en la sección 4.3).

Estas dos instrucciones aceptan como operando una posición de memoria, por ejemplo PUSH contador. El procesador carga en la pila el dato en memoria en la posición con nombre contador. En este caso, a pesar de que la transferencia se está realizando de memoria a memoria, la arquitectura sí permite la operación. La restricción de dos operandos en memoria aplica únicamente a aquellas instrucción con dos operandos explícitos.

La instrucción XCHG (del inglés exchange) consta de dos operandos e intercambia sus valores por lo que modifica los operandos (a no ser que tengan idéntico valor). No se permite que los operandos estén ambos en memoria.

La tabla 5.3 muestra ejemplos correctos e incorrectos de la utilización de este tipo de instrucciones. Se asume que los símbolos contador1 y contador2 se refieren a operandos en memoria.

MOV $4, %al

MOV contador1, %esi

MOV $4, contador1

MOVL contador, $4

MOV %al, %ecx

PUSH $4

POP $4

XCHG %eax, %ebx

XCHG %eax, contador1

XCHG $4, %eax

XCHG contador1, contador2

En este grupo se incluyen aquellas instrucciones que realizan operaciones aritméticas sencillas con números enteros y naturales tales como la suma, resta, incremento, decremento, multiplicación y división.

ADDL $3, contador

SUB %eax, contador

NEGL contador

MULB $3

IMUL %eax

MUL contador, %edi

IMUL $123, contador, %ecx

IDIVB $-53

IDIV %eax

DIVW contador

En este grupo se incluyen las instrucciones de conjunción, disyunción, disyunción exclusiva y negación. La aplicación práctica de estas instrucciones no es a primera vista del todo aparente, sin embargo, suelen estar presentes en la mayoría de programas.

Las cuatro instrucciones lógicas consideradas son AND, OR, NOT y XOR para la conjunción, disyunción, negación y disyunción exclusiva, respectivamente.

Estas instrucciones tienen en común que realizan sus operaciones “bit a bit”. Es decir, el procesador realiza tantas operaciones lógicas como bits tienen los operandos tomando los bits que ocupan la misma posición y, por tanto, produciendo otros tantos resultados.

Considérese el caso de la instrucción de conjunción AND con sus dos operandos. Al igual que en el caso de instrucciones como la de suma o resta, el segundo operando es a la vez fuente y destino. El procesador obtiene un resultado de igual tamaño que sus operandos y en el que cada bit es el resultado de la conjunción de los bits de idéntica posición de los operandos. Las instrucciones de disyunción (OR) y disyunción exclusiva (XOR) se comportan de forma análoga.

La instrucción NOT tiene un único operando que es fuente y destino y cambia el valor de cada uno de sus bits.

La tabla 5.7 muestra ejemplos de utilización de este tipo de instrucciones. Se asume que el símbolo contador se refiere a un operando almacenado en memoria.

AND $-1, %eax

ORL $1, contador

NOTL contador

En este grupo se incluyen instrucciones que mediante desplazamientos efectúan operaciones aritméticas de multiplicación y división por potencias de dos. Además, se incluyen también instrucciones que manipulan sus operandos como si los bits estuviesen dispuestos de forma circular y permite rotaciones en ambos sentidos.

5.4.4.1. Instrucciones de desplazamiento

Las instrucciones de desplazamiento se subdividen a su vez en dos categorías: desplazamiento aritmético y desplazamiento lógico.

Las instrucciones de desplazamiento aritmético son aquellas que equivalen a multiplicar y dividir un número por potencias de 2. Un desplazamiento de un bit quiere decir que cada uno de ellos pasa a ocupar la siguiente posición (a derecha o izquierda) y por tanto, dependiendo de cómo se introduzcan nuevos valores y cómo se descarte el bit sobrante, dicha operación es idéntica a multiplicar por 2.

En adelante se asume que el bit más significativo de un número es el de más a su izquierda. La figura 5.5 muestra un desplazamiento aritmético a izquierda y derecha de un número de 8 bits.

Figura 5.5. Desplazamiento aritmético de 1 bit en un número de 8 bits

Para que la equivalencia entre los desplazamientos de bits y la operación aritmética de multiplicación y división por 2 sean realmente equivalentes hay que tener en cuenta una serie de factores.

• Si se desplaza un número a la izquierda, el nuevo bit menos significativo debe tener el valor cero.

• Si se desplaza a la izquierda un número natural con su bit más significativo a uno se produce desbordamiento.

• Si se desplaza un número a la derecha, el nuevo bit más significativo debe tener valor idéntico al antiguo.

Las instrucciones SAL (Shift Arithmetic Left) y SAR (Shift Arithmetic Right) desplazan su segundo operando a izquierda y derecha respectivamente tantas veces como indica el primer operando. En ambas instrucciones, el último bit que se ha descartado se almacena en el bit de acarreo CF. Estas instrucciones tienen la limitación adicional de que el primer operando sólo puede ser una constante o el registro %cl.

La tabla 5.8 muestra ejemplos de utilización de este tipo de instrucciones. Se asume que el símbolo contador se refiere a un operando almacenado en memoria.

Tabla 5.8. Instrucciones de desplazamiento aritmético

Instrucción	Comentario
SAR $4, %eax	Desplaza 4 bits a la derecha el contenido del registro %eax. Esta operación es equivalente a multiplicar por 16 el registro %eax.
SALB %cl, contador	Desplaza el byte almacenado en la posición de memoria denotada por contador tantas posiciones a la izquierda como indica el registro %cl. El sufijo de tamaño es necesario porque a pesar de que el primer operando es un registro, éste contiene sólo el número de posiciones desplazar. El tamaño de los datos se deduce, por tanto del segundo operando.

Las instrucciones de desplazamiento no aritmético son SHR y SHL para desplazar a derecha e izquierda respectivamente. El comportamiento y restricciones son idénticas a las instrucciones anteriores con una única diferencia. Los nuevos bits que se insertan en los operandos tienen siempre el valor cero. Por tanto, dependiendo de los valores de los operandos, las instrucciones SAR y SAL se pueden comportar de forma idéntica.

5.4.4.2. Instrucciones de rotación

Las instrucciones de rotación permiten manipular un operando como si sus bits formasen un círculo y se rotan en ambos sentidos un número determinado de posiciones.

Las instrucciones ROL y ROR rotan a izquierda y derecha respectivamente el contenido de su segundo operando tantas posiciones como indica el primer operando. El último bit que ha traspasado los límites del operando se almacena en el bit de acarreo CF.

Las instrucciones RCL y RCR son similares a las anteriores con la excepción que el bit de acarreo CF se considera como parte del operando. El bit que sale del límite del operando se carga en CF y éste a su vez pasa a formar parte del operando.

La figura 5.6 ilustra el funcionamiento de estas instrucciones.

Figura 5.6. Rotación de un operando de 8 bits

Al igual que las instrucciones de desplazamiento aritmético, el primer operando puede ser o una constante o el registro %cl. El tamaño del dato a manipular se deduce del segundo operando, y si este está en memoria, a través del sufijo de tamaño de la instrucción.

La tabla 5.9 muestra ejemplos de utilización de este tipo de instrucciones. Se asume que el símbolo contador se refiere a un operando almacenado en memoria.

Tabla 5.9. Instrucciones de rotación

Instrucción	Comentario
RCR $4, %ebx	Rota el registro %ebx cuatro posiciones a su derecha utilizando el bit de acarreo CF.
RCLL %cl, contador	Rota a la izquierda tantas posiciones como indica el registro %cl el operando de 32 bits almacenado en memoria a partir de la posición denotada por contador. A pesar de que el primer operando es un registro, la instrucción necesita sufijo de tamaño, pues éste se deduce únicamente del segundo operando que está en memoria.
ROR %cl, %eax	Rota a la derecha el registro %eax tantas posiciones como indica el registro %cl. El bit CF almacena el bit más significativo del resultado.
ROLL %cl, contador	Rota a la izquierda tantas posiciones como indica el registro %cl el número de 32 bits almacenado en memoria a partir de la posición contador. De nuevo se precisa el sufijo de tamaño porque éste se deduce únicamente a la vista del segundo operando.

El procesador ejecuta una instrucción tras otra de forma secuencial a no ser que dicho flujo de ejecución se modifique. Las instrucciones de salto sirven para que el procesador, en lugar de ejecutar la siguiente instrucción, pase a ejecutar otra en un lugar que se denomina “destino del salto”.

La instrucción de salto JMP (del inglés jump) tiene un único operando que representa el lugar en el que el procesador debe continuar ejecutando. Al llegar a esta instrucción, el procesador no realiza operación alguna y simplemente pasa a ejecutar la instrucción en el lugar especificado como destino del salto. El único registro, por tanto, que se modifica es el contador de programa.

A la instrucción JMP se le denomina también de salto incondicional por contraposición a las instrucciones de salto en las que el procesador puede saltar o no al destino dependiendo de una condición.

La arquitectura IA-32 dispone de 32 instrucciones de salto condicional. Todas ellas comienzan por la letra J seguida de una abreviatura de la condición que determina si el salto se lleva a cabo o no. Al ejecutar esta instrucción el procesador consulta esta condición, si es cierta continua ejecutando la instrucción en la dirección destino del salto. Si la condición es falsa, la instrucción no tienen efecto alguno sobre el procesador y se ejecuta la siguiente instrucción.

Las condiciones en las que se basa la decisión de saltar dependen de los valores de los bits de estado CF, ZF, OF, SF y PF. La tabla 5.10 muestra para cada instrucción los valores de estos bits para los que se salta a la instrucción destino.

JA mem

JNBE mem

JBE mem

JNA mem

JAE mem

JNB mem

JB mem

JNAE mem

JE mem

JZ mem

JNE mem

JNZ mem

JG mem

JNLE mem

JLE mem

JNG mem

JGE mem

JNL mem

JL mem

JNGE mem

JC mem

JNC mem

JCXZ mem

JECXZ mem

JO mem

JNO mem

JPO mem

JNP mem

JPE mem

JP mem

JS mem

JNS mem

En la tabla se incluyen instrucciones con diferente nombre e idéntica condición. Estos sinónimos son a nivel de lenguaje ensamblador, es decir, las diferentes instrucciones tienen una codificación idéntica y por tanto corresponden con la misma instrucción máquina del procesador.

La utilidad de estas instrucciones se debe entender en el contexto del flujo normal de ejecución de un programa. El resto de instrucciones realizan diferentes operaciones sobre los datos, y a la vez modifican los bits de la palabra de estado. Las instrucciones de salto se utilizan después de haber modificado estos bits y para poder tener dos posibles caminos de ejecución.

El ejemplo 5.4 muestra una porción de código ensamblador muestra un posible uso de las instrucciones de salto.

        MOV $100, %ecx
dest2:  DEC %ecx
        JZ dest1
        ADD %ecx, %eax
        JMP dest2

La instrucción DEC %ecx decrementa el valor del registro %ecx y modifica los bits de la palabra de estado. La instrucción JZ provoca un salto si ZF = 1. Como consecuencia, la instrucción ADD %ecx, %eax se ejecuta un total de 100 veces.

Las instrucciones de salto condicional son útiles siempre y cuando los valores de los bits de estado hayan sido previamente producidos por instrucciones anteriores, como por ejemplo, operaciones aritméticas. Pero en algunos casos, la ejecución de un salto condicional requiere que se realice una operación aritmética y no se almacene su resultado, sino simplemente que se realice una comparación. Por ejemplo, si se necesita saltar sólo si un número es igual a cero, en lugar de ejecutar una instrucción ADD, SUB, INC o DEC para que se modifique el bit ZF sólo se necesita comprobar si tal número es cero y modificar los bits de estado. Para este cometido el procesador dispone de las instrucciones de comparación y comprobación.

Las instrucciones CMP (comparación) y TEST (comprobación) realizan sendas operaciones aritméticas de las que no se guarda el resultado obtenido sino que únicamente se modifican los bits de estado.

La instrucción CMP recibe dos operandos. El primero de ellos puede ser de tipo constante, registro u operando en memoria. El segundo puede ser únicamente de tipo registro u operando en memoria. La instrucción no permite que ambos operandos estén en memoria. Al ejecutar esta instrucción se resta el primer operando del segundo. El valor resultante no se almacena en lugar alguno, pero sí se modifican los bits de estado del procesador.

Considérese el código mostrado en el ejemplo 5.5. La instrucción de comparación modifica los bits de estado para que la instrucción de salto los interprete y decida si debe saltar o continuar ejecutando la instrucción ADD.

        CMP $0, %eax     # Se calcula %eax - 0
        JE destino
        ADD %eax, %ebx

La instrucción JE produce un salto cuando el bit de estado ZF tiene el valor 1. Este bit, a su vez se pone a uno si los operandos de la instrucción CMP son iguales. Por tanto, la instrucción JE, cuando va a continuación de una instrucción de comparación, se puede interpretar como “salto si los operandos (de la instrucción anterior) son iguales”.

En la mayoría de las instrucciones de salto condicional detalladas en la sección 5.4.5, las últimas letras del nombre hacen referencia a la condición que se comprueba cuando se ejecutan a continuación de una instrucción de comparación. Por ejemplo, la instrucción JLE produce un salto cuando los bits de condición cumplen ZF = 1 o SF != OF. Si esta instrucción va precedida de una instrucción de comparación, ZF es igual a 1 si los dos operandos son iguales. Si SF es diferente a OF la resta ha producido un bit de signo, y el bit de desbordamiento con valores diferentes. Esta situación se produce si el segundo operando es menor que el primero, de ahí el sufijo LE (del inglés less or equal) en la instrucción de salto. La tabla 5.11 muestra las combinaciones obtenidas del bit de desbordamiento y la resta para el caso de enteros representados con 2 bits.

El bit de signo y el de desbordamiento tienen valores diferentes únicamente en el caso en que el primer operando de la resta es menor que el segundo. Por tanto, la instrucción JLE si se ejecuta a continuación de una instrucción CMP se garantiza que el salto se lleva a cabo si el segundo operando es menor que el primero.

Las instrucciones de salto cuya condición puede interpretarse con respecto a la instrucción de comparación que le precede son las que en la descripción mostrada en la tabla tabla 5.10 incluyen una comparación. Aunque estas instrucciones no debe ir necesariamente precedidas por una instrucción de comparación porque la condición se evalúa con respecto a los bits de estado, generalmente se utilizan acompañadas de éstas.

Para interpretar el comportamiento de una instrucción de comparación seguida de una de salto condicional se puede utilizar la siguiente regla mnemotécnica:

	Salto condicional precedido de comparación
	Dada la siguiente secuencia de dos instrucciones en ensamblador: CMP B, A Jcond donde A y B son cualquier operando y cond es cualquiera de las condiciones posibles, el salto se lleva a cabo si se cumple A cond B.

Por ejemplo, si la instrucción CMP $4, %eax va seguida del salto condicional JL destino, el procesador saltará a destino si %eax < 4.

La tabla 5.12 muestra posibles secuencias de instrucciones de comparación y salto condicional.

inicio: inc %eax
        cmp $128, %eax
        jae final
        ...
        jmp inicio
final:  mov $'A, %cl
        ...

        cmp $12, %eax
        jle menor
        mov $10, %eax
        ....
        jmp final
menor:  mov $100, %eax
        ...
final:  inc %ebx

La posibilidad de saltar a una posición de código dependiendo de una condición está presente en la mayoría de lenguajes de programación de alto nivel. Por ejemplo, en el lenguaje Java, la construcción if () {} else {} se implementa a nivel de ensamblador basado en instrucción de salto condicional.

La instrucción de comprobación TEST es similar a la de comparación, también consta de dos operandos, el segundo de ellos puede ser únicamente de tipo registro o memoria y no se permite que ambos sean de tipo memoria. La diferencia con CMP es que se realiza una conjunción bit a bit de ambos operandos. El resultado de esta conjunción tampoco se almacena, pero sí modifica los bits de estado OF, CF (ambos se ponen a cero), SF, ZF y PF.

La tabla 5.13 muestra posibles secuencias de instrucciones de comprobación y salto condicional.

        testl $0x0080, contador
        jz ignora
        ....
ignora: incl %ebx

        test 0xFF00FF00, %eax
        jnz pl
        ....
        jmp final
pl:     mov %eax
        ...

Una de las construcciones más comunes en la ejecución de programas es la invocación de porciones de código denominadas subrutinas con un conjunto de parámetros. Este mecanismo es en el que está basada la invocación de procedimientos, métodos o funciones en los lenguajes de programación de alto nivel.

Para implementar este mecanismo, el procesador dispone de dos instrucciones. La instrucción CALL tiene un único parámetro que es la posición de memoria de la primera instrucción de una subrutina. El efecto de esta instrucción es similar a la de salto incondicional con la diferencia de que el procesador guarda ciertos datos en lugares para facilitar el retorno una vez terminada la la ejecución de la subrutina.

La instrucción RET es la que se utiliza al final de una subrutina para retomar la ejecución en el punto anterior a la invocación mediante la instrucción CALL. No recibe ningún parámetro y el procesador gestiona internamente el lugar en el que debe continuar la ejecución.

En el capítulo 8 se estudia con todo detalle la utilización de estas instrucciones para implementar construcciones presentes en lenguajes de programación de alto nivel.