|
|
Ejemplo 1
Este primer programa nos permite hacer una introducción a la programación en ensamblador. El objetivo
es que mediante un sencillo programa dados dados dos vectores de mismo tamaño y tipo,que residen en
memoria, sean intercambiados valor a valor.
Probablemente uno de los aspectos mas relevantes a señalar es la llamada a funciones pasando una serie de parámetros,
hemos de recordar que trabajamos con un lenguaje a nivel de máquina, el paso de parámetros se hace almacenando
en la pila del programa estos, que más tarde en la función seran desapilados.
La forma que lo vamos a abordar es como una serie de
llamadas a una función que dadas dos posiciones en memoria pasadas como parámetros, el inicio de un
vector origen y del vector destino, va recorriendo todas las posiciones moviendo
los elementos del origen al destino.
No creo que quepa hacer alguna explicación más, aunque probablemente puedan surgir dudas dobre la utilización de la pila,
aquí es donde os recomendaria hacer un dibujo en un papel y hacer un seguimiento de su estado en todo momento.
Recordad también que cuando se llama a una función far se almacenan automáticamente en la pila los valores de regreso, es
decir el segmento y el desplazamiento de la siguiente instrucción que se iba a ejecutar antes de que se produjerá la llamada.
Estos se desapilan cuando se produce el Ret al final del programa. Si ademas aparece un número después de Ret significa que antes
de esta acción se desapilaran esos n bytes anteriores.
;****** Segmento de datos **********************
;* Definimos los dos vectores a intercambiar *
;* y uno auxiliar para almacenar temporalmente *
;* el origen. *
;***********************************************
datos segment
vect_a db 1,2,3,4,5,6,7,8,9
vect_b db 9,8,7,6,5,4,3,2,1
vect_tmp db 10 dup(0)
longitud dw 9
cadena db 'ya he terminado...'
db '$'
datos ends
;****** Segmento de pila ****************
pila segment stack
db 100 dup (0)
pila ends
;**Segmento de código*
codigo segment
assume cs:codigo,ds:datos,ss:pila
;****************************************
;* Nombre: ppal *
;* Descripción: función principal que *
;* hace 3 llamadas a copiavec para *
;* intercambiar los 2 vectores con los *
;* parámetros: *
;* -dirección del vect. origen *
;* -dirección del vect. destino *
;* -tamaño de las cadenas *
;* estos se pasan por la pila. *
;****************************************
ppal proc far
;* si quieres que termine bien no te olvides de esto *
push ds
xor ax,ax
push ax
mov ax,datos
mov ds,ax
;****** Primera llamada ******************
;** Parametros: **
;** Origen: direcc vector_a, **
;** destino:direcc vector_temp **
;** tamaño: direcc longitud **
;*****************************************
push ds
mov ax,offset vect_a
push ax
push ds
mov ax, offset vect_tmp
push ax
mov ax, longitud
push ax
call copiavec
;****** Segunda llamada ******************
;** Parametros: **
;** Origen: direcc vector_b **
;** destino:direcc vector_a **
;** tamaño: direcc longitud **
;*****************************************
push ds
mov ax,offset vect_b
push ax
push ds
mov ax, offset vect_a
push ax
mov ax, longitud
push ax
call copiavec
;********* Tercera llamada ***************
;** Parametros: **
;** Origen: direcc vector_temp **
;** destino:direcc b **
;** tamaño: direcc longitud **
;*****************************************
push ds
mov ax,offset vect_tmp
push ax
push ds
mov ax, offset vect_b
push ax
mov ax, longitud
push ax
call copiavec
;** Mostrar cadena (int 21h) **
push ax dx
mov ah,9
mov dx, offset cadena
int 21h
pop dx ax
ret
ppal endp
;****************************************
;* Nombre: copiavec *
;* Descripción: mueve los elementos *
;* de un vector origen a un vector *
;* destino. *
;* Para ello se le pasan las direcciones*
;* de estos mediante la pila. *
;****************************************
copiavec proc far
push bp
mov bp,sp
push cx ds di es si ax bx
;** Guardar valores de los parámetros **
;** de la pila en registros. **
mov cx, [bp]+6
mov ds, [bp]+14
mov di, [bp]+12
mov es, [bp]+10
mov si, [bp]+8
;** Mover valores de origen a destino **
xor bx,bx
;** Puesto que los vectores se han **
;** definido como arrays de bytes **
;** las operaciones se harán con **
;** registros y posiciones en memoria **
;** de 8 bits **
bucle:mov al, byte ptr ds:[di][bx]
mov byte ptr es:[si][bx], al
inc bx
loop bucle
pop bx ax si es di ds bx bp
ret 10
copiavec endp
codigo ends
end ppal
codigo ends
|
|