Unidad III procedimientos

Lenguajes de Interfaz
Unidad III: Modularización

Si ya ha estudiado un lenguaje de programación de alto nivel,
entonces sabe lo útil que puede ser dividir los programas en
subrutinas.
Por lo general, un problema complicado se divide en tareas
separadas para poder comprenderlo, implementarlo y
probarlo con efectividad.
En el lenguaje ensamblador, por lo regular, usamos el término
procedimiento para indicar una subrutina.
En otros lenguajes, a las subrutinas se les llama métodos o
funciones.

En términos de la programación orientada a objetos, las
funciones o métodos de una clase individual son apenas
equivalentes a la colección de procedimientos y datos
encapsulados en un módulo en lenguaje ensamblador.
Este lenguaje se creó mucho antes de la programación
orientada a objetos, por lo que no tiene la estructura formal
que se encuentra en los lenguajes orientados a objetos.
Los programadores de ensamblador deben imponer su propia
estructura formal en los programas.

 De manera informal, podemos definir a un procedimiento
como un bloque de instrucciones con nombre, que
termina en una instrucción de retorno.
 Para declarar un procedimiento se utilizan las directivas
PROC y ENDP. Se le debe asignar un nombre (un
identificador válido).
 Cada uno de los programas que hemos escrito hasta ahora
contiene un procedimiento llamado MAIN, por ejemplo,
MAIN PROC
.
.
MAIN ENDP

 Al crear un procedimiento distinto al procedimiento
de inicio de un programa, se debe terminar con una
instrucción RET, la cual obliga a la CPU a regresar a la
ubicación desde la que se llamó al procedimiento:
ejemplo PROC
.
.
RET
ejemplo ENDP
 El procedimiento de inicio (MAIN) es un caso especial,
ya que termina con la instrucción INVOKE
ExitProcess,0

 La instrucción CALL llama a un procedimiento, para lo cual dirige al
procesador para que empiece la ejecución en una nueva ubicación de
memoria.
 El procedimiento utiliza una instrucción RET (retorno del procedimiento)
para regresar al procesador al punto en el programa en el que se llamó
al procedimiento.
 Hablando en sentido mecánico, la instrucción CALL mete su dirección de
retorno en la pila y copia la dirección del procedimiento al que se llamó
en el apuntador de instrucciones.
 Cuando el procedimiento está listo para regresar, su instrucción RET
saca la dirección de retorno de la pila y la coloca en el apuntador de
instrucciones.
 En modo de 32 bits, la CPU ejecuta la instrucción en la memoria a la que
apunta EIP (registro apuntador de instrucciones). En modo de 16 bits, IP
apunta a la instrucción.

 Suponga que en MAIN, una instrucción CALL se encuentra en el
desplazamiento 00000020. Por lo general, esta instrucción requiere
cinco bytes de código máquina, por lo que la siguiente instrucción (MOV
en este caso) se encuentra en el desplazamiento 00000025:
MAIN PROC
00000020 CALL MiSub
00000025 MOV EAX, EBX
 Ahora, suponga que la primera instrucción ejecutable en MiSub se
encuentra en el desplazamiento 00000040:
MiSub PROC
00000040 MOV EAX, EDX
.
.
RET
MiSub ENDP

 Cuando se ejecuta la instrucción CALL
(siguiente figura), la dirección que sigue
después de la llamada (00000025) se mete
en la pila, y la dirección de MiSub se carga en
EIP.

 Todas las instrucciones en MiSub se ejecutan
hasta su instrucción RET.
 Cuando se ejecuta la instrucción RET, el valor
en la pila al que apunta ESP se saca y se
coloca en EIP (paso 1 en la siguiente figura).
En el paso 2, ESP se decrementa, de manera
que apunta al valor anterior en la pila (paso
2).

 Una llamada a procedimiento anidada ocurre
cuando un procedimiento al cual se llamó hace
una llamada a otro procedimiento, antes de que
el primer procedimiento regrese.
 Suponga que MAIN llama a un procedimiento
llamado Sub1. Mientras Sub1 se ejecuta, hace
una llamada al procedimiento Sub2. Mientras
Sub2 se ejecuta, hace una llamada al
procedimiento Sub3.
 El proceso se muestra en la siguiente figura.

 Cuando se ejecuta la instrucción RET al final
de Sub3, saca el valor que hay en pila[ESP] y
lo coloca en el apuntador de instrucciones.
 Esto hace que la ejecución continúe en la
instrucción que va después de la instrucción
que llama a Sub3.
 El siguiente diagrama muestra la pila, justo
antes de que se ejecute el retorno de Sub3:

 Después del retorno, ESP apunta a la
siguiente entrada más alta en la pila.
 Cuando la instrucción RET al final de Sub2
está a punto de ejecutarse, la pila aparece
como se muestra a continuación:

 Por último, cuando Sub1 regresa, se saca
pila[ESP] y se coloca en el apuntador de
instrucciones, y la ejecución se reanuda en
MAIN:

 Si usted escribe un procedimiento que realice alguna
operación estándar, como calcular la suma de un
arreglo de enteros, no es conveniente incluir
referencias a nombres de variables específicos dentro
del procedimiento.
 Si lo hace, el procedimiento sólo podrá usarse con un
arreglo. Un mejor método es pasar el desplazamiento
de un arreglo al procedimiento, y pasarle un entero
que especifique el número de elementos del arreglo.
 A estos valores les llamamos argumentos (o
parámetros de entrada). En lenguaje ensamblador, es
común pasar argumentos dentro de los registros de
propósito general.

 Un tipo bastante común de ciclo, es el que
calcula la suma de un arreglo de enteros. Esto
es muy fácil de llevarse a cabo en el lenguaje
ensamblador, y puede codificarse de tal
forma que se ejecute lo más rápido posible.
 Vamos a crear un procedimiento llamado
SumaArreglo, el cual recibe dos parámetros
de un programa que lo llama: un apuntador a
un arreglo de enteros de 32 bits, y una
cuenta del número de valores del arreglo.

 Este procedimiento calcula y devuelve la suma del arreglo en EAX:
;-----------------------------------------------------
SumaArreglo PROC
;
; Calcula la suma de un arreglo de enteros de 32 bits.
; Recibe: ESI = el desplazamiento del arreglo
; ECX = número de elementos en el arreglo
; Devuelve: EAX = suma de los elementos del arreglo
;-----------------------------------------------------
PUSH ESI ; guarda ESI, ECX
PUSH ECX
MOV EAX, 0 ; establece la suma en cero
L1: ADD EAX, [ESI] ; agrega cada entero a la suma
ADD ESI,TYPE DWORD ; apunta al siguiente entero
LOOP L1 ; repite para el tamaño del arreglo
POP ECX ; restaura a ECX, ESI
POP ESI
RET ; la suma está en EAX
SumaArreglo ENDP

 Nada en este procedimiento es específico
para el nombre o el tamaño de un cierto
arreglo.
 Podría utilizarse en cualquier programa que
necesite sumar un arreglo de enteros de 32
bits.
 Siempre que sea posible, debemos crear
procedimientos que sean flexibles y
adaptables.

 A continuación se muestra un ejemplo de una llamada a SumaArreglo, en
donde se le pasa la dirección de arreglo en ESI y la cuenta del arreglo en ECX.
Después de la llamada, copiamos la suma en EAX a una variable:
.DATA
Arreglo DWORD 1, 2, 3, 4,5
laSuma DWORD ?
.CODE
MAIN PROC
LEA ESI, Arreglo ; ESI apunta al arreglo
MOV ECX, LENGTHOF Arreglo; ECX = cuenta del arreglo
CALL SumaArreglo ; calcula la suma
MOV laSuma, EAX ; se devuelve en EAX

 En el ejemplo SumaArreglo, ECX y ESI se metieron en
la pila al principio del procedimiento y se sacaron al
final.
 Esta acción es común en la mayoría de los
procedimientos que modifican registros. Siempre hay
que guardar y restaurar los registros que modifican
un procedimiento, para que el programa que hace la
llamada pueda estar seguro de que no se
sobrescribirá ninguno de sus propios valores de los
registros.
 La excepción a esta regla pertenece a los registros
que se utilizan como valores de retorno, por lo
general, EAX. No se deben meter y sacar.

 El operador USES, junto con la directiva PROC, nos permite
presentar los nombres de todos los registros que se
modifican dentro de un procedimiento.
 USES indica al ensamblador que debe hacer dos cosas:
primero, debe generar instrucciones PUSH que guarden los
registros en la pila, al principio del procedimiento.
 Después, debe generar instrucciones POP para restaurar
los valores de los registros al final del procedimiento.
 El operador USES va inmediatamente después de PROC, y
va seguido de una lista de registros en la misma línea,
separados por espacios o tabuladores (no por comas).

 El procedimiento SumaArreglo anterior utiliza instrucciones
PUSH y POP para almacenar y restaurar los registros ESI y ECX.
El operador USES puede hacer lo mismo, con más facilidad:
SumaArreglo PROC USES ESI ECX
MOV EAX, 0 ; establece la suma a cero
L1:
ADD EAX, [ESI] ; agrega cada entero a suma
ADD ESI, 4 ; apunta al siguiente entero
RET ; la suma está en EAX
SumaArreglo ENDP

 El código correspondiente que genera el ensamblador nos
muestra el efecto de USES:
SumaArreglo PROC
PUSH ESI
PUSH ECX
MOV EAX, 0 ; establece la suma a cero
L1:
ADD EAX, [ESI] ; agrega cada entero a la suma
ADD ESI, 4 ; apunta al siguiente entero
POP ECX
POP ESI
RET
SumaArreglo ENDP

 Un marco de pila (o registro de activación) es el área de la pila que se
aparta para los argumentos que se pasan, la dirección de retorno de las
subrutinas, las variables locales y los registros almacenados. El marco de
pila se crea mediante los siguientes pasos secuenciales:
• Los argumentos que se pasan, en caso de haber, se meten en la pila.
• Se hace la llamada a la subrutina, lo cual provoca que la dirección de retorno de la
misma se meta en la pila.
• En cuanto la subrutina se empieza a ejecutar, EBP se coloca en la pila.
• EBP se hace igual a ESP. De este punto en adelante, EBP actúa como una referencia
base para todos los parámetros de la subrutina.
• Si hay variables locales, ESP se decrementa para reservar espacio para las variables en
la pila.
• Si hay que guardar algún registro, se mete en la pila.

 La estructura de un marco de pila se ve afectada
directamente por el modelo de memoria de un
programa y su elección de la convención de paso
de argumentos.
 Existe un buen motivo para aprender acerca del
paso de argumentos a la pila: casi todos los
lenguajes de alto nivel los utilizan. Por ejemplo,
si desea llamar a las funciones en la Interfaz de
programación de aplicaciones (API) de MS
Windows, debe pasar argumentos a la pila.

 Existen dos tipos básicos de parámetros de subrutinas: los parámetros
de registro y los parámetros de pila.
 La subrutina que se llamó accede a los argumentos que se meten en la
pila al momento de su llamada. Los parámetros de registro están
optimizados para la velocidad de ejecución del programa. Por desgracia,
tienden a crear amontonamiento de código en los programas que hacen
llamadas. A menudo hay que guardar el contenido existente de los
registros antes de que se puedan cargar con los valores de los
argumentos. Tal es el caso de cuando se hace una llamada a un
procedimiento (DumpMem en este ejemplo) que usa parámetros de
registro:
PUSHAD
LEA ESI, Arreglo ; desplazamiento inicial
MOV ECX,LENGTHOF Arreglo ; tamaño, en unidades
MOV EBX,TYPE Arreglo ; formato de doble palabra
CALL DumpMem ; muestra la memoria
POPAD

 Los parámetros de pila ofrecen un método más
flexible. Justo antes de la llamada a la subrutina,
los argumentos se meten en la pila.
 Por ejemplo, si DumpMem utilizara parámetros
de pila, lo llamaríamos usando el siguiente
código:
PUSH TYPE Arreglo
PUSH LENGTHOF Arreglo
PUSH OFFSET Arreglo
CALL DumpMem

 Durante las llamadas a subrutinas, se meten
en la pila dos tipos generales de argumentos:
• Argumentos de valor (los valores de las variables y
constantes).
• Argumentos de referencia (las direcciones de las
variables).

 Cuando un argumento se pasa por valor, se mete
una copia del valor en la pila. Suponga que
llamamos a una subrutina de nombre SumarDos
y le pasamos dos enteros de 32 bits:
.DATA
val1 DWORD 5
val2 DWORD 6
.CODE
PUSH val2
PUSH val1
CALL SumarDos

 A continuación se muestra una imagen de la pila, justo antes de la
instrucción CALL:
 Una llamada a una función equivalente en C++ sería
int suma = SumarDos( val1, val2 );
 Observe que los argumentos se meten en la pila en orden inverso, lo
cual es la norma para los lenguajes C y C++.

 Un argumento que se pasa por referencia
consiste en la dirección (desplazamiento) de
un objeto. Las siguientes instrucciones
llaman a Intercambiar y le pasan los dos
argumentos por referencia:
PUSHOFFSET val2
PUSHOFFSET val1
CALL Intercambiar

 A continuación se muestra una imagen de la
pila, justo antes de la llamada a Intercambiar:

 Hay una importante excepción a la regla que acabamos de
presentar, relacionada con el paso por valor. Al pasar un arreglo,
los programas de lenguajes de alto nivel siempre lo pasan por
referencia.
 No es práctico pasar una extensa cantidad de datos por valor, ya
que habría que meter los datos directamente en la pila. Hacer
esto reduciría la velocidad de ejecución del programa y ocuparía
el valioso espacio de la pila. Por ejemplo, las siguientes
instrucciones pasan el desplazamiento de arreglo a una
subrutina llamada LlenarArreglo:
.DATA
Arreglo DWORD50 DUP(?)
.CODE
PUSH OFFSET arreglo
CALL LlenarArreglo

 Los programas de C y C++ tienen formas estándar de inicializar y acceder a los
parámetros durante las llamadas a funciones.
 Empiezan con un prólogo que consiste en instrucciones que guardan el registro
EBP, y lo establecen en la parte superior de la pila.
 De manera opcional, pueden meter ciertos registros en la pila, cuyos valores se
restauren cuando la función regrese.
 El final de la función consiste en un epílogo, en el cual se restaura el registro EBP y
la instrucción RET regresa de la función, y borra los parámetros de la pila.
 Ejemplo. La siguiente función SumarDos, escrita en C, recibe dos enteros que se
pasan por valor y devuelve su suma:
int SumarDos( int x, int y )
{
return x + y;
}

 Vamos a crear una implementación equivalente en
lenguaje ensamblador. En su prólogo, SumarDos mete a
EBP en la pila para preservar su valor existente:
SumarDos PROC
PUSH EBP
 A continuación, EBP se establece con el mismo valor que
ESP, de manera que EBP pueda ser el apuntador base para
el marco de pila de SumarDos:
SumarDos PROC
PUSH EBP
MOV EBP, ESP

 La siguiente figura muestra el contenido del
marco de pila después de ejecutar las dos
instrucciones anteriores. Cada entrada en la
pila es una doble palabra:

 Las funciones en C y C++ utilizan el direccionamiento base-
desplazamiento para acceder a los parámetros de pila. EBP es el
registro base y el desplazamiento es una constante.
 Por lo general, los valores de 32 bits se devuelven en EAX. La
siguiente implementación de SumarDos suma los parámetros y
devuelve su suma en EAX:
SumarDos PROC
PUSH EBP
MOV EBP, ESP ; base del marco de pila
MOV EAX, [EBP + 12]; segundo parámetro
ADD EAX, [ebp + 8] ; primer parámetro
POP EBP
RET
SumarDos ENDP

 Debe haber una manera para que los parámetros
se eliminen de la pila, al momento en que
regrese una subrutina.
 De no ser así se produce una fuga de memoria, y
la pila se vuelve corrupta.
 Por ejemplo, suponga que las siguientes
instrucciones en MAIN llaman a SumarDos:
PUSH 5
PUSH 6
CALL SumarDos

 He aquí una imagen de la pila, después de
regresar de la llamada:

 Dentro de MAIN, podemos ignorar el problema y esperar a que el
programa termine en forma normal. Si llamamos a SumarDos dentro de
un ciclo, la pila podría desbordarse debido a que cada llamada consume
8 bytes de memoria. Se produce un problema más serio si llamamos a
Ejemplo1 desde MAIN, que a su vez llama a SumarDos:
MAIN PROC
CALL Ejemplo1
INVOKE ExitProcess, 0
MAIN ENDP
Ejemplo1 PROC
PUSH 5
PUSH 6
CALL SumarDos
RET ; ¡la pila está corrupta!
Ejemplo1 ENDP

 Cuando la instrucción RET en Ejemplo1 está a
punto de ejecutarse, ESP apunta al entero 5,
en vez de apuntar a la dirección de retorno
que nos regresa a MAIN.
 Evidentemente el programa se bifurca a la
ubicación 5 y falla:

 Una solución simple para este problema es sumar un valor a ESP
que haga que apunte a la dirección de retorno.
 En el ejemplo actual, podemos colocar una instrucción ADD
después de CALL:
Ejemplo1 PROC
PUSH 5
PUSH 6
CALL SumarDos
ADD ESP,8 ; elimina argumentos de la pila
RET ; la pila está bien
Ejemplo1 ENDP
 Ésta es la acción que toman los programas en C y C++.

 Otra forma común de manejar el problema de la limpieza de la
pila es utilizar una convención llamada STDCALL.
 Podemos suministrar un parámetro entero a la instrucción RET
dentro de SumarDos para corregir a ESP. El entero debe ser igual
al número de bytes del espacio que consumen en la pila los
parámetros de la subrutina:
SumarDos PROC
PUSH EBP
MOV EBP, ESP ; base del marco de pila
MOV EAX, [EBP+12] ; segundo parámetro
ADD EAX, [EBP + 8] ; primer parámetro
POP EBP
RET 8 ;limpia la pila
SumarDos ENDP

 Las macros son secuencias de instrucciones y
directivas del lenguaje ensamblador que pueden
definirse una sola vez y pueden ser utilizadas
tantas veces como sean requeridas en un
programa.
 Las macros se ejecutan (expanden) en tiempo de
ensamble, esto significa que cuando se está
ensamblando el programa, el código que
contiene la macro se copia en el lugar donde esta
la llamada y ésta desaparece del código, los
parámetros formales en la expansión son
cambiados por los parámetros actuales (los que
aparecen en la llamada).

 Una macro es un bloque con nombre de
instrucciones en lenguaje ensamblador.
 Una vez definido, puede invocarse (llamarse)
todas las veces que se desee en un programa.
 Al invocar a una macro, se inserta una copia de
su código directamente en el programa, en la
ubicación en la que se invocó.
 Se acostumbra utilizar el término llamar a una
macro, aunque técnicamente no hay una
instrucción CALL implicada.

 Las macros se definen de manera directa al
principio de un programa de código fuente, o se
colocan en un archivo separado y se copian en un
programa mediante una directiva INCLUDE.
 Los macros se expanden durante el paso de
preprocesamiento del ensamblador.
 En este paso, el preprocesador lee la definición
de un macro y explora el resto del código fuente
en el programa.

 En cada punto en el que se hace una llamada
al macro, el ensamblador inserta una copia de
su código fuente en el programa.
 El ensamblador debe encontrar la definición
de un macro antes de tratar de ensamblar
cualquier llamada del macro.
 Si un programa define a un macro pero nunca
lo llama, el código de ese macro no aparece
en el programa compilado.

 Un macro se defi ne usando las directivas
MACRO y ENDM. La sintaxis es
nombremacroMACRO parámetro-1, parámetro-2...
lista-instrucciones
ENDM

 No hay una regla fija en relación con la
sangría, pero le recomendamos aplicar
sangría a las instrucciones entre
nombremacro y ENDM.
 También podría ser conveniente colocar
prefijos en los nombres de los macros con la
letra m, para crear nombres reconocibles
como mColocarCar, mEscribirCadena y
mGotoxy.

 Las instrucciones entre las directivas MACRO
y ENDM no se ensamblan sino hasta que se
llama al macro.
 Puede haber cualquier número de parámetros
en la definición del macro, separados por
comas.

 Los parámetros de las macros son
receptáculos para los argumentos de texto
que se pasan al procedimiento que hace la
llamada.
 De hecho, los argumentos pueden ser
enteros, nombres de variables u otros
valores, pero el preprocesador los trata como
texto.

 Los parámetros no tienen tipo, por lo que el
preprocesador no comprueba los tipos de los
argumentos para ver si son correctos.
 Si ocurre un conflicto de tipos, el
ensamblador lo atrapa después de que se
expande el macro.

 Esta macro lleva por nombre la palabra SUMA
y tiene tres parámetros de entrada y su
cuerpo está compuesto por tres
instrucciones:
SUMA MACRO op1, op2, Resultado
MOV EAX, op1
ADD EAX, op2
MOV Resultado, EAX
ENDM

 Para llamar (invocar) a una macro, se inserta
su nombre en el programa, posiblemente
seguido de los argumentos de la macro.
 La sintaxis para llamar a una macro es
nombremacro argumento-1, argumento-2, ...

 nombremacro debe ser el nombre de un macro definido
antes de este punto en el código fuente.
 Cada argumento es un valor de texto que sustituye a un
parámetro en el macro.
 El orden de los argumentos debe corresponder al orden de
los parámetros, pero el número de argumentos no tiene
que coincidir con el número de parámetros.
 Si se pasan demasiados argumentos, el ensamblador
genera una advertencia.
 Si se pasan muy pocos argumentos a un macro, los
parámetros faltantes se dejan en blanco.

 Cuando se usan etiquetas en una macro, deben
ser declaradas con la directiva LOCAL para que se
vayan generando etiquetas diferentes en cada
expansión que se realice dentro del programa.
 Esto es debido a que no pueden existir en el
código etiquetas con el mismo nombre.
 Cuando se usa la directiva LOCAL esta debe estar
inmediatamente después del encabezado.

Ej.-
ESPERA MACRO Cuanto
LOCAL Siguiente
PUSH ECX
MOV ECX, Cuanto
Siguiente: LOOP Siguiente
POP ECX
ENDM

 Las macros, como módulos del programa pueden ser
comparadas con los procedimientos. A continuación
se mencionan sus ventajas y desventajas.
Ventajas de las macros.-
 Las macros son dinámicas.- Esto significa que el
código de la macro puede variar cambiando los
parámetros actuales con los que efectúa la llamada.
 El código de una macro se ejecuta más rápido en
tiempo de ejecución.- Esto es posible debido a que el
procesador no pierde tiempo en guardar y recuperar
de la pila las direcciones de retorno.

Desventajas de las macros.-
 Los programas que usan macros generan más
código ejecutable.- Esto se debe a que cuando se
expande una macro se elimina la instrucción de
la llamada, pero en su lugar se inserta el código
que contiene la definición de la macro.
 Los programas con macros tardan más tiempo en
ensamblarse.- Porque el código de la macro debe
ser traducido tantas veces como la macro sea
llamada.

INCLUDE nombre_de_archivo
Ó
INCLUDE <nombre_de_archivo>
 La directiva INCLUDE inserta código fuente desde el
archivo especificado dentro del archivo fuente actual
durante el ensamblado.
 No se asume ninguna extensión por omisión para el
nombre de archivo. Los símbolos mayor que y menor que
(< y >) se requieren sólo si el nombre del archivo contiene
una diagonal invertida, un punto y coma, un apóstrofe,
una comilla o los símbolos de mayor que o menor que.

Unidad III procedimientos

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Unidad III procedimientos

Similar a Unidad III procedimientos (20)

Último

Último (20)

Unidad III procedimientos