Instrucciones Aritmeticas

El microprocesador Z-80 dispone de una unidad aritmética-lógica que le permite realizar una serie
de operaciones, tanto aritméticas, como lógicas.

Las aritméticas incluyen la suma y resta con o sin acarreo, incremento y decremento de un
registro, comparaciones, ajuste decimal, complemento y negación.

Las lógicas incluyen las operaciones que se realizan con los operadores ͞AND͟, ͞OR͟ y ͞XOR͟.

Las instrucciones del ensamblador

Instrucciones lógicas:

Son utilizadas para realizar operaciones lógicas sobre los operandos:

AND

NEG

NOT

OR

TEST

XOR

Instrucciones aritméticas:

Se usan para realizar operaciones aritméticas sobre los operandos:

ADC

ADD

DIV

IDIV

MUL

IMUL

SBB
SUB

Instrucción AND

Propósito: Realiza la conjunción de los operandos bit por bit.

Sintaxis:

AND destino, fuente

Con esta instrucción se lleva a cabo la operación ͞y͟ lógica de los dos operandos:

Fuente Destino | Destino

--------------------------------------------------------------------------------

11|1

10|0

01|0

00|0

El resultado de la operación se almacena en el operando destino.

Instrucción NEG

Propósito: Genera el complemento a 2

Sintaxis:

NEG destino

Esta instrucción genera el complemento a 2 del operando destino y lo almacena en este mismo
operando. Por ejemplo, si AX guarda el valor de 1234H, entonces:

NEG AX

Nos dejaría almacenado en el registro AX el valor EDCCH.

Instrucción NOT

Propósito: Lleva a cabo la negación bit por bit del operando destino.

Sintaxis:
NOT destino

El resultado se guarda en el mismo operando destino.

Instrucción OR

Propósito: OR inclusivo lógico

Sintaxis:

OR destino, fuente

La instrucción OR lleva a cabo, bit por bit, la disyunción inclusiva lógica de los dos operandos:

Fuente Destino | Destino

--------------------------------------------------------------------------------

11|1

10|1

01|1

00|0

Instrucción TEST

Propósito: Comparar logicamente los operandos

Sintaxis:

TEST destino, fuente

Realiza una conjunción, bit por bit, de los operandos, pero a diferencia de AND esta instrucción no
coloca el resultado en el operando destino, solo tiene efecto sobre el estado de las banderas.

Instrucción XOR

Propósito: OR exclusivo

Sintaxis:

XOR destino, fuente

Su función es efectuar bit por bit la disyunción exclusiva lógica de los dos operandos.
Fuente Destino | Destino

---------

11|0

00|1

01|1

00|0

Instrucción ADC

Propósito: Adición con acarreo.

Sintaxis:

ADC destino, fuente

Lleva a cabo la suma de dos operandos y suma uno al resultado en caso de que la bandera CF esté
activada, esto es, en caso de que exista acarreo.

El resultado se guarda en el operando destino.

Instrucción ADD

Propósito: Adición de los operandos.

Sintaxis:

ADD destino, fuente

Suma los dos operandos y guarda el resultado en el operando destino.

Instrucción DIV

Propósito: División sin signo

Sintaxis:

DIV fuente

El divisor puede ser un byte o palabra y es el operando que se le da a la instrucción.

Si el divisor es de 8 bits se toma como dividendo el registro de 16 bits AX y si el divisor es de 16

bits se tomara como dividendo el registro par DX:AX, tomando como palabra alta DX y como baja
AX.
Si el divisor fué un byte el cociente se almacena en el registro AL y el residuo en AH, si fué una
palabra el cociente se guarda en AX y el residuo en DX.

Instrucción IDIV

Propósito: División con signo

Sintaxis:

IDIV fuente

Consiste basicamente en lo mismo que la instrucción DIV, solo que esta última realiza la operación
con signo. Para sus resultados utiliza los mismos registros que la instrucción DIV.

Instrucción MUL

Propósito: Multiplicación sin signo

Sintaxis:

MUL fuente

El ensamblador asume que el multiplicando sera del mismo tamaño que el del multiplicador, por
lo tanto multiplica el valor almacenado en el registro que se le da como operando por el que se
encuentre contenido en AH si el multiplicador es de 8 bits o por AX si el multiplicador es de 16 bits.

Cuando se realiza una multiplicación con valores de 8 bits el resultado se almacena en el registro
AX y cuando la multiplicación es con valores de 16 bits el resultado se almacena en el registro par
DX:AX.

Instrucción IMUL

Propósito: Multiplicación de dos enteros con signo.

Sintaxis:

IMUL fuente

Este comando hace lo mismo que el anterior, solo que si toma en cuenta los signos de las
cantidades que se multiplican.

Los resultados se guardan en los mismos registros que en la instrucción MUL.

Instrucción SBB

Propósito: Substracción con acarreo

Sintaxis:

SBB destino, fuente

Esta instrucción resta los operandos y resta uno al resultado si CF está activada. El operando
fuente siempre se resta del destino.

Este tipo de substracción se utiliza cuando se trabaja con cantidades de 32 bits.

Instrucción SUB

Propósito: Substracción

Sintaxis:

SUB destino, fuente

Resta el operando fuente del destino.

Instrucciones De Comparacion

Las instrucciones del ensamblador

Instrucciones de salto Son utilizadas para transferir el flujo del proceso al operando indicado.

JMP JA (JNBE) JAE (JNBE) JB (JNAE) JBE (JNA) JE (JZ) JNE (JNZ) JG (JNLE) JGE (JNL) JL (JNGE) JLE (JNG)
JC JNC JNO JNP (JPO) JNS JO JP (JPE) JS

Instrucciones para ciclos: LOOP Transfieren el flujo del proceso, condicional o incondicionalmente,
a un destino repitiendose esta acción hasta que el contador sea cero.

LOOP LOOPE LOOPNE

Instrucciones de conteo Se utilizan para decrementar o incrementar el contenido de los

contadores.

DEC INC

Instrucciones de comparación Son usadas para comparar operandos, afectan al contenido de las
banderas.

CMP CMPS (CMPSB) (CMPSW)

Instrucciones de banderas Afectan directamente al contenido de las banderas.

CLC CLD CLI CMC STC STD STI

Instrucción JMP

Propósito: Salto incondicional

Sintaxis:

JMP destino

Esta instrucción se utiliza para desviar el flujo de un programa sin tomar en cuenta las condiciones
actuales de las banderas ni de los datos.

Instrucción JA (JNBE)

Propósito: Brinco condicional

Sintaxis:

JA Etiqueta

Después de una comparación este comando salta si está arriba o salta si no está abajo o si no es
igual.

Esto significa que el salto se realiza solo si la bandera CF esta desactivada o si la bandera ZF esta
desactivada (que alguna de las dos sea igual a cero).

Instrucción JAE (JNB)

Propósito: salto condicional

Sintaxis:

JAE etiqueta

Salta si está arriba o si es igual o salta si no está abajo.

El salto se efectua si CF esta desactivada.

Instrucción JB (JNAE)

Propósito: salto condicional

Sintaxis:

JB etiqueta
Salta si está abajo o salta si no está arriba o si no es igual.

Se efectúa el salto si CF esta activada.

Instrucción JBE (JNA)

Propósito: salto condicional

Sintaxis:

JBE etiqueta

Salta si está abajo o si es igual o salta si no está arriba.

El salto se efectúa si CF está activado o si ZF está activado (que cualquiera sea igual a 1).

Instrucción JE (JZ)

Propósito: salto condicional

Sintaxis:

JE etiqueta

Salta si es igual o salta si es cero.

El salto se realiza si ZF está activada.

Instrucción JNE (JNZ)

Propósito: salto condicional

Sintaxis:

JNE etiqueta

Salta si no es igual o salta si no es cero.

El salto se efectua si ZF está desactivada.

Instrucción JG (JNLE)

Propósito: salto condicional, se toma en cuenta el signo.

Sintaxis:

JG etiqueta
Salta si es más grande o salta si no es menor o igual.

El salto ocurre si ZF = 0 u OF = SF.

Instrucción JGE (JNL)

Propósito: salto condicional, se toma en cuenta el signo.

Sintaxis:

JGE etiqueta

Salta si es más grande o igual o salta si no es menor que.

El salto se realiza si SF = OF

Instrucción JL (JNGE)

Propósito: salto condicional, se toma en cuenta el signo.

Sintaxis:

JL etiqueta

Salta si es menor que o salta si no es mayor o igual.

El salto se efectúa si SF es diferente a OF.

Instrucción JLE (JNG)

Propósito: salto condicional, se toma en cuenta el signo.

Sintaxis:

JLE etiqueta

Salta si es menor o igual o salta si no es más grande.

El salto se realiza si ZF = 1 o si SF es diferente a OF

Instrucción JC

Propósito: salto condicional, se toman en cuenta las banderas.

Sintaxis:

JC etiqueta
Salta si hay acarreo.

El salto se realiza si CF = 1

Instrucción JNC

Propósito: salto condicional, se toma en cuenta el estado de las banderas.

Sintaxis:

JNC etiqueta

Salta si no hay acarreo.

El salto se efectúa si CF = 0.

Instrucción JNO

Propósito: salto condicional, se toma en cuenta el estado de las banderas.

Sintaxis:

JNO etiqueta

Salta si no hay desbordamiento.

El salto se efectua si OF = 0.

Instrucción JNP (JPO)

Propósito: salto condicional, toma en cuenta el estado de las banderas.

Sintaxis:

JNP etiqueta

Salta si no hay paridad o salta si la paridad es non.

El salto ocurre si PF = 0.

Instrucción JNS

Propósito: salto condicional, toma en cuenta el estado de las banderas.

Sintaxis:

JNP etiqueta
Salta si el signo esta desactivado.

El salto se efectúa si SF = 0.

Instrucción JO

Propósito: salto condicional, toma en cuenta el estado de las banderas.

Sintaxis:

JO etiqueta

Salta si hay desbordamiento (overflow).

El salto se realiza si OF = 1.

Instrucción JP (JPE)

Propósito: salto condicional, toma en cuenta el estado de las banderas.

Sintaxis:

JP etiqueta

Salta si hay paridad o salta si la paridad es par.

El salto se efectúa si PF = 1.

Instrucción JS

Propósito: salto condicional, toma en cuenta el estado de las banderas.

Sintaxis:

JS etiqueta

Salta si el signo está prendido.

El salto se efectúa si SF = 1.

Instrucción LOOP

Propósito: Generar un ciclo en el programa.

Sintaxis:

LOOP etiqueta
La instrucción loopdecrementa CX en 1, y transfiere el flujo del programa a la etiqueta dada como
operando si CX es diferente a 1.

Instrucción LOOPE

Propósito: Generar un ciclo en el programa considerando el estado de ZF

Sintaxis:

LOOPE etiqueta

Esta instrucción decrementa CX en 1. Si CX es diferente a cero y ZF es igual a 1, entonces el flujo

del programa se transfiere a la etiqueta indicada como operando.

Instrucción LOOPNE

Propósito: Generar un ciclo en el programa, considerando el estado de ZF

Sintaxis:

LOOPNE etiqueta

Esta instrucción decrementa en uno a CX y transfiere el flujo del programa solo si ZF es diferente a
0.

Instrucción DEC

Propósito: Decrementar el operando

Sintaxis:

DEC destino

Esta operación resta 1 al operando destino y almacena el nuevo valor en el mismo oeprando.

Instrucción INC

Propósito: Incrementar el operando.

Sintaxis:

INC destino

La instrucción suma 1 al operando destino y guarda el resultado en el mismo operando destino.

Instrucción CMP

Propósito: Comparar los operandos.

Sintaxis:

CMP destino, fuente

Esta instrucción resta el operando fuente al operando destino pero sin que éste almacene el
resultado de la operación, solo se afecta el estado de las banderas.

Instrucción CMPS (CMPSB) (CMPSW)

Propósito: Comparar cadenas de un byte o palabra.

Sintaxis:

CMP destino, fuente

Con esta instrucción la cadena de caracteres fuente se resta de la cadena destino.

Se utilizan DI como indice para el segmento extra de la cadena fuente y SI como indice de la
cadena destino.

Solo se afecta el contenido de las banderas y tanto DI como SI se incrementan.

Instrucción CLC

Propósito: Limpiar bandera de acarreo.

Sintaxis:

CLC

Esta instrucción apaga el bit correspondiente a la bandera de acarreo, o sea, lo pone en cero.

Instrucción CLD

Propósito: Limpiar bandera de dirección

Sintaxis:

CLD

La instrucción CLD pone en cero el bit correspondiente a la bandera de dirección.

Instrucción CLI

Propósito: Limpiar bandera de interrupción

Sintaxis:
CLI

CLI pone en cero la bandera de interrupciones, desabilitando así aquellas interrupciones

enmascarables.

Una interrupción enmascarable es aquella cuyas funciones son desactivadas cuando IF = 0.

Instrucción CMC

Propósito: Complementar la bandera de acarreo.

Sintaxis:

CMC

Esta instrucción complementa el estado de la bandera CF, si CF = 0 la instrucción la iguala a 1, y si

es 1 la instrucción la iguala a 0.

Podemos decir que unicamente ͞invierte͟ el valor de la bandera.

Instrucción STC

Propósito: Activar la bandera de acarreo.

Sintaxis:

STC

Esta instrucción pone la bandera CF en 1.

Instrucción STD

Propósito: Activar la bandera de dirección.

Sintaxis:

STD

La instrucción STD pone la bandera DF en 1.

Instrucción STI Propósito: Acticar la bandera de interrupción.

Sintaxis:

STI
La instrucción activa la bandera IF, esto habilita las interrupciones externas enmascarables (las que
funcionan unicamente cuando IF = 1 ).

Instrucciones De Saltos

Empecemos por el salto sin condiciones, con el que podremos cambiar el control a cualquier punto
del programa.
Sería como el ͞Goto͟ del Basic, símplemente transferir el control a otro punto del programa. La
orden es

JMP ( deJump, salto )

Si record is a estas alturas los registros CS:IP, se podra ver que͢ es lo que hace realmente la
instrucción, y no es mas que incrementar o decrementar IP para llegar a la zona del programa a la
que queremos transferir el control ( IP es el Offset que indica la zona de memoria que contiene la
siguiente instrucción a ejecutar, y CS el segmento )

El formato mas sencillo para el salto sería JMP 03424h, lo que saltaría a esa zona.

Pero es digamos que ͞algo pesado͟ calcular en que͢ dirección va a estar esa instrucción, con lo que
utilizaremos etiquetas. Aquí hay un ejemplo, en el que de paso se repasa un poco:

MOV AX,0CC34h

MOV CL,22h

JMP PALANTE

VUELVE: CMP BX,AX

JMP FIN

PALANTE: MOV BX,AX

JMP VUELVE

FIN: XOR CX,CX

Ahora voy a comentar un poco el programa. Tras la primera instrucción, AX vale 0CC34h, y tras la
segunda, CL vale 22h. Despues se realiza un salto a la instrucción etiquetada con ͞PALANTE͟.

La etiqueta ha de estar continuada por dos puntos ͚:͛, y puede ser llamada desde cualquier lugar
del programa. Tambi͢n podremos hacer un MOV AX,[PALANTE], como hacíamos antes con un MOV
AX,[BX], pero asignando a AX el valor que haya en la dirección en la que esta ͞PALANTE͟.

El caso, que tras el salto a ͞PALANTE͟, se copia el valor del registro BX en AX, y se vuelve a
͞VUELVE͟. Se realiza una comparación entre AX y BX, que pondr el flag de cero a 1 ( recordemos la
anterior lección ), se saltar a ͞FIN͟, donde tan sólo se realizar la orden Xor CX,CX cuyo resultado,
por cierto, es poner CX a cero tenga el valor que tenga ( y esto se utilizar bastante programando,
por eso me ha dado por incluir la orden )

Volvamos con la sintaxis del JMP con algunos ejemplos de como utilizarlo:

JMP 100h

Salta a la dirección 100h. Un archivo .COM comienza normalmente en esa dirección, así que quiz lo
ve is en algunos virus.

JMP 542Ah:100h

Salta a la dirección 100h pero del segmento 542Ah. ¨ Os acordais aún de los Segments y Offsets?.
Se trata de un salto lejano.

JMP SHORT 223Ah

Salto corto a la dirección 223Ah. Tranquilidad, ahora explico lo de salto corto, lejano,͙

JMP NEAR 55AAh

Salto cercano, es diferente al corto

JMP [100h]

Salta a la dirección contenida en 100h. Sin embargo es un error, ya que

no se especifíca si es cercano, lejano, si se lee un sólo byte,͙ o sea,

que͢esta instrucción no vale.

 JMP WORD PTR [BX]

Ahora si vale ;). Salta a la dirección contenida en la palabra ( dos

bytes ) a la que apunta BX. O sea, si BX valiese 300h y en 300h los dos

bytes fuesen 0CC33h, el JMP saltaría a ͢sta dirección.

JMP DWORD PTR [BX+SI+5]

Dword son 32 bits, o sea, un salto lejano. Y saltaría al contenido en

la dirección de memoria a la que apuntan la suma de BX,SI y 5.

Ahora voy a contar algo sobre los saltos lejanos, cercanos y cortos. El

salto corto se realiza entre el punto en el que se est y +127 o о128, o

sea, que la cantidad que se puede contener en un byte con signo. A veces

es necesario indicar que se trata de salto corto, cercano o lejano.

El salto cercano se realiza contando como distancia el contenido de dos

bytes, o sea, que el rango sería desde 32767 a о32768 bytes de distancia.

Y el lejano se realiza contando como distancia el contenido de cuatro

bytes, y,͙ paso de calcular la distancia, pero es mucha X-)

Por ejemplo, es incorrecto que haya en la dirección 100h una instrucción

que diga JMP SHORT 500h, ya que la distancia no corresponde a un salto

corto. Además, el salto dependiendo de que sea cercano, corto o largo se

codifica de manera diferente en modo hexadecimal.

SALTOS CONDICIONALES

¨ Record es aquel IF-THEN-ELSE, o el FOR, o el WHILE-DO ?

Bien, pues aquí esto que suple a estas instrucciones en lenguaje

ensamblador. Se basan completamente en los flags, por ello el rollo de la

anterior lección, pero est n simplificados de tal manera que no os hará

falta saberlos de memoria para poder hacerlos.

Los saltos podrían resumirse en un modo ͞Basic͟ de la manera IF-THEN-GOTO

de tal manera que cuando se cumple una condición se salta a un sitio

determinado.

He aquí los tipos de saltos condicionales ( las letras en mayúsculas son

las instrucciones ):

JO: Jumpifoverflow. Salta si el flag de desbordamiento este a uno

JNO: Jump if not overflow. Salta si el flag de desbordamiento est a

cero.

JC, JNAE, JB: Los tres sirven para lo mismo. Significan: Jump if Carry,

Jump if Not Above or Equal y Jump if Below. Saltan por lo tanto si al

haber una comparación el flag de acarreo se pone a 1, es entonces

equivalente a < en una operación sin signo. Vamos, que si se compara así:

CMP 13h,18h, saltar , ya que 13h es menor que 18h. Tambi͢n se suelen usar

para detectar si hubo fallo en la operación, ya que muchas interrupciones

al acabar en fallo encienden el carryflag.

JNC, JAE, JNB: Otros tres que valen ex ctamente para lo mismo. Jump if

not Carry, Jump if Above or Equal y Jump if Not Below. Saltan por tanto si

al haber una comparación el flag de acarreo vale 0, o sea, es equivelente

al operador >=. En la comparación CMP 0,0 o CMP 13h,12h saltar , ya que el

segundo operando es MAYOR O IGUAL que el primero.

JZ o JE: Jump if Zero o Jump if Equal. Salta si el flag de cero est a

1, o sea, si las dos instrucciones comparadas son iguales. Saltaría en el

caso CMP 0,0

JNZ o JNE: Jump if Not Zero o Jump if Not Equal. Salta si el flag de cero

est a 0, o sea, si las dos instrucciones comparadas no son iguales.

JBE o JNA: Jump if Below or Equal o Jump if Not Above. Saltaría si en

resultado de la comparación el primer miembro es menor o igual que el

segundo ( <= )

JA o JNBE: Jump if Above o Jump if Not Below of Equal. Justo lo contrario

que la anterior, salta si en el resultado de la comparación el primer

miembro es mayor al segundo.

JS: JumpifSign. Salta si el flag de signo est a uno.

JNS: Jump if Not Sign. Salta si el flag de signo est a cero.

JP, JPE: Jump if Parity o Jump if Parity Even. Salta si el flag de

paridadest a uno.

JNP, JPO: Jump if Not Parity, Jump if Parity Odd. Salta si el flag de

paridadest a cero.

JL, JNGE: Jump if Less, Jump if Not Greater of Equal. Salta si en el

resultado de la comparación, el primer número es inferior al segundo, pero

connúmeros con signo.

JGE, JNL: Jump if Greater or Equal, Jump if Not Less. Salta si en el

resultado de la comparación, el primer número es mayor o igual que el

segundo, pero con números con signo.

JLE, JNG: Jump if Lower or Equal, Jump if Not Greater. Salta si en el

resultado de la comparación, el primer número es menor o igual que el

segundo, pero con números con signo.

JG, JNLE: Jump if Greater, Jump if Not Lower or Equal. Salta si en el

resultado de la comparación, el primer número es mayor que el segundo, para

números con signo.

Fiuuuuu !!! Menuda lista. Bueno, aconsejo que os quedais de cada

parrafito con uno, aunque algunos se usen poco, pero como veis para una

misma instrucción hay varios,͙ y para gustos no hay nada escrito, lo mismo

os da usar JG que JNLE por ejemplo.

Vamos, que despu͢s de toda ͢sta aridez me temo que voy a tener que poner

algunos ejemplos de los más utilizados:

MOV AX,1111h

MOV BX,1112h

CMP AX,BX ; AX es menor que BX ( toma pero grullada )

JB tirapalante ; Saltar a tirapalante

HLT ; Esta orden bloquea el ordenador, halt

tirapalante: DEC BX ; Ahora BX valdr 1111h

CMP AX,BX ; Ahora valen igual

 JNE Acaba ; No saltar , ya que son iguales

JE Continua ; Esta vez si

Continua: DEC BX ; Ahora BX vale 1110h

CMP AX,BX

JE Acaba ; No son iguales, por tanto no saltar

JB Acaba ; No es menor, tampoco salta

JG Acaba ; Es mayor, ahora SI saltar

Acaba: XOR AX,AX

XOR BX,BX ; AX y BX valen ahora cero.

Espero que con ͢esto haya aclarado un poco la utilidad de los saltos.

Evidentemente, ahora al escribir sabemos cuando uno es menor o mayor, pero

a veces mediante interrupciones sacaremos valores que no conoceremos al ir

a programar, o quiz lo hagamos de la memoria, y queremos comprobar si

son iguales, etc.

Por cierto, que en los saltos condicionales se puede hacer como en los

incondicionales, o sea, formatos como:

JE 0022h

JNE 0030h

JNO AL

Sin embargo, estamos limitados a saltos cortos, o sea, de rango a 127

bytes hacia adelante o 128 hacia atrás, no pudiendo superar ͢esta distancia.

BUCLES

He aquí el equivalente al FOR-TO-NEXT en ensamblador, se trata de la

orden LOOP. Lo que hace ͢esta orden es comparar CX con cero; si es igual,

sigue adelante, si no lo es, vuelve al lugar que se indica en su operando

decrementando CX en uno. Por lo tanto, CX ser un contador de las veces

que ha de repetirse el bucle. Vamos con un ejemplo:

MOV CX,0005h

bucle: INC DX

CMP DX,0000h

JE Acaba

LOOP bucle

Acaba: ͙

Veamos como funciona ͢este programa. Se mueve a CX el valor 5h, que van

a ser las veces que se repita el bucle. Ahora, llegamos al cuerpo del bucle.

Se incrementa DX y se compara con 0, cuando es igual salta a ͞Acaba͟. Si

llega a la orden LOOP, CX se decrementar y saltar a bucle. Esto se

repetir cinco veces. En fin, que el programa acabar en el grupo de

instrucciones de ͞Acaba͟ cuando la comparación de un resultado positivo o

cuando el bucle se haya repetido cinco veces.

Tambi͢n tiene la limitación de que sólo realiza saltos cortos, y también

puede usarse como el JMP, de la forma:

LOOP 0003h

LOOP [AL]

En resumen, la orden LOOP es la equivalente a CMP CX,0/JNZ par metro,

donde par metro es el operando de LOOP.

Y en fin, hemos terminado con los condicionales. Parece muy rido, pero

luego seguramente usaras poco más que un JZ o JNZ al principio,͙ y el

LOOP, claro. Ya no nos queda mucho. La explicación de la pila y las

interrupciones, y ya podrás empezar a programar.͛

Instrucciones Para Stack

͟Stack͟ significa pila en inglés, pila en el sentido de ͞apilar cosas͟, no de batería eléctrica. Es una
zona de la memoria en donde se guardan cosas. Por ejemplo las variables locales de las subrutinas
y funciones, los parámetros, algunos resultados intermedios de cálculos complejos, etc. Todo el
manejo del stack lo realiza el compilador de forma automática, así que no hace falta preocuparse
salvo cuando se acaba el lugar y el programa genera un error (͞stackoverflow͟). Lo más
importante de esta estructura es que en cada momento sólo se tiene acceso a la parte superior del
stack (no a las cosas que están apiladas debajo). Entonces cada subrutina puede guardar sus datos
en el stack, y las subrutinas a las que llame no los afectarán.La pila es una zona de la memoria
sobre la que se pueden escribir y leer datos de forma convencional. Esta zona tiene una posición
especial que se denomina ͞la cima de la pila͟. El procesador contiene dos instrucciones de su
lenguaje máquina para realizar las operaciones de ͞apilar͟ y ͞des apilar͟ datos de la pila. Los datos
que se pueden apilar y des apilar, en el caso del Intel Pentium son siempre de tamaño 4 bytes.
Kacros Ensamblador
Un macro ensamblador es un ensamblador modular, descendiente de los ensambladores básicos.
Fueron muy populares en los años 1950 y años 1960, antes de la generalización de los lenguajes
de alto nivel. Hacen todo lo que puede hacer un ensamblador, y además proporcionan una serie
de Directivas para definir y ejecutar macro instrucciones (o simplemente, Macros). Cuando
ejecutamos a una ͞macro͟, ésta se expande al cuerpo que hayamos definido.
MACRO

Macro, del griego ʅɲʃʌʉ significa ͞grande͟. En el ámbito informático es la abreviatura del término
͞macroinstrucción͟.

Una macro o macroinstrucción es una serie de instrucciones que se almacenan para que se
puedan ejecutar de forma secuencial mediante una sola llamada u orden de ejecución.

CARACTERISTICAS

Una macroinstrucción es por tanto una instrucción compleja, formada por otras instrucciones más
sencillas.

Además tiene que estar almacenada, el término no se aplica a una serie de instrucciones escritas
en la linea de comandos enlazadas unas con otras por redirección de sus resultados (piping) o para
su ejecución consecutiva.

Las macros suelen almacenarse en el ámbito del propio programa que las utiliza y se ejecutan
pulsando una combinación especial de teclas.

La diferencia entre una macroinstrucción y un programa es que en las macroinstrucciones la

ejecución es secuencial y no existe otro concepto del flujo de programa que por tanto, no puede
bifurcarse.

MACROS DE APLICACIONES

Las macros son grupos de instrucciones que tienen un seguimiento cronológico usadas para
economizar tareas; una macro no es más que un conjunto de instrucciones tales como ͞borrar
archivo͟, ͞añadir registro͟, etc., y que se almacenan en una ubicación especial (por ejemplo en
Microsoft Access observamos que hay una zona para crear macros, una macro en Access
trabajando para una base de datos podría ser un archivo que al llamarse desde otra instrucción:
borrara los registros de un cliente o accionista, luego borrara ciertos registros en otras tablas,
extraerá su información de un log, entre otras cosas.

MACROZ EN PROGRAMACION

Con el fin de evitar al programador la tediosa repetición de partes idénticas de un programa, los
ensambladores y compiladores cuentan con macroprocesadores que permiten definir una
abreviatura para representar una parte de un programa y utilizar esa abreviatura cuantas veces
sea necesario. Para utilizar una macro, primero hay que declararla. En la declaración se establece
el nombre que se le dará a la macro y el conjunto de instrucciones que representará.

El programador escribirá el nombre de la macro en cada uno de los lugares donde se requiera la
aplicación de las instrucciones por ella representadas. La declaración se realiza una sola vez, pero
la utilización o invocación a la macro (macrollamada) puede hacerse cuantas veces sea necesario.
La utilización de macros posibilita la reducción del tamaño del código fuente, aunque el código
objeto tiende a ser mayor que cuando se utilizan funciones.

Es tan común el empleo de macroinstrucciones que se les considera como una extensión de los
lenguajes. De manera similar se considera al procesador de macroinstrucciones o
macroprocesador como una extensión del ensamblador o compilador utilizado. El
macroprocesador se encarga, en una primera pasada, de registrar todas las declaraciones de
macros y de rastrear el programa fuente para detectar todas las macrollamadas. En cada lugar
donde encuentre una macro llamada, el macroprocesador hará la sustitución por las instrucciones
correspondientes. A este proceso de sustitución se le denomina expansión de la macro. El
macroprocesador elabora dos tablas para el manejo de las macros.

Interrupciones Ensamblador
Definición y Tipos de Interrupciones.

La primera cosa de todas, ¿qué son las interrupciones?, bien, las interrupciones son un
͞mecanísmo͟ por medio del cual hacemos que la CPU deje la tarea en la que estaba para que se
vaya a ocupar de otra cosa distinta, es decir, es una forma de llamar la atención de la CPU de tal
forma que cada dispositivo cuando necesita ser atendido por la CPU, emite una interrupción o
señal haciendo que la CPU vaya a atenderla de inmediato. Esto es importantísimo ya que de no
existir interrupciones, la CPU debería de ir preguntando, cada cierto tiempo, a los dispositivos para
ver si necesitan de su intervención y como podeis suponer, eso significaría lentitud, mucha
lentitud. Por tanto, quedaros con que las interrupciones sirven para controlar el hardware, ya que
son las que llaman a la CPU cuando este, el hardware, necesita la intervención de la misma.

Las interrupciones se pueden dividir en 2 grupos:

1. Interrupciones de Software. También son conocidas como ͞falsas interrupciones͟ ya que se

producen como consecuencia de la ejecución de otra instrucción al no ser el hardware las que las
produce. Otra forma de entender estas interrupciones, es verlas desde el punto de vista de
llamadas a subrutinas, lógicamente, la gracia está en que esas subrutinas no son nuestras, sino
que son las propias de cada sistema operativo, driver o similar tiene. Quedaros pues, con que
somos nostros los que hacemos invocamos a la interrupción. Este tipo de interrupción es el más
habitual en la programación.

2. Interrupciones de Hardware. Este tipo de interrupción es invocado directamente por los

dispositivos hardware de nuestro ordenador, por lo que ͞son bastante más auténticas͟ que las
anteriores. Al producir algún dispositivo hardware la interrupción el controlador de interrupciones
o PIC se encarga de gestionarla determinando, en el caso de producirse más de una interrupción a
la vez, cual de ellas tiene más prioridad y debe de ser gestionada por la CPU. El funcionamiento de
este tipo de interrupciones es bastante similar y se suele utilizar mucho para la programación de
sistemas de comunicaciones.

La Tabla de Vectores de Interrupciones. Seguro que alguno se ha preguntado, ͞si cuando llamamos
a una interrupción se ejecuta una determinada rutina͙¿dónde narices se encuentra esta rutina?,
es más, ¿cómo sabe nuestra CPU dónde encontrarla?.͟ Bien, la respuesta a estas dos preguntas (y
muchas más) se encuentra en la tabla de vectores de interrupción. Dicha tabla es una estructura
que se crea durante la inicialización del ordenador y se coloca, en el principio de nuestra memoria
(segmento 0 y desplazamiento 0). Dicha estrucutura ocupa y de forma justa 1Kb, ya que dispone
de 256 entradas de 4 bytes cada una. Lo importante de todo esto es que, dicha estructura,
almacena la dirección, en memoria, de las distintas rutinas que van ligadas a las distintas
interrupciones, de tal modo que cuando invocamos, mediante interrupción software, o se invoca,
mediante hardware, una interrupción, lo que se hace es utilizar un índice que va ligado a la
interrupción, de tal manera que, con dicho índice, se acude a la tabla de vectores de interrupción
para que el sistema encuentre la dirección de la rutina en dónde se encuentra el verdadero
tratamiento a la interrupción, es decir, si se produce la interrupción x, lo que se hace es acudir a la
tabla con el índice x para encontrar la entrada (recordar que eran 256 entradas con 4 bytes cada
una) que contiene la dirección en memoria de la rutina que sirve para tratar a la interrupción de
índice x. Como cada entrada es de 4 bytes, es fácil adivinar que dichos 4 bytes forman la dirección,
ya que 2 de esos bytes se utilizan como segmento y los otros 2 como desplazamiento, total, que ya
tenemos la dirección de memoria con la rutina que hay que utilizar.