Está en la página 1de 11

Nombre de la materia

Lenguaje Ensamblador
Nombre de la Licenciatura
Ingeniera en Sistemas Computacionales

Nombre del alumno


Pamela Gil
Matrcula
26292

Nombre de la Tarea
Macros y Procedimientos
Unidad #
Unidad 6. Macros y Procedimientos

Nombre del Tutor


No Amir Rodrguez Olivares
Fecha
29.11.2016
Unidad #: 6. Macros y Procedimientos
Lenguaje Ensamblador

INTRODUCCION

En lenguaje ensamblador se denomina macro al conjunto de instrucciones que se agrupan bajo un nombre
descriptivo, despus de que la macro ha sido declarada, slo es necesario indicar su nombre en el cuerpo del
programa y el ensamblador se encargara de reemplazarla por las instrucciones de dicha. Las instrucciones de
macros se pueden guardar en el mismo programa o en un archivo separado que el programa pueda identificar
y se ejecutan pulsando una combinacin especial de teclas o un botn creado para esa accin.
Una de las ventajas que brinda el uso de las macros es la creacin de bibliotecas, las cuales son grupos de
macros que pueden ser incluidas en un programa desde un archivo diferente. Para la creacin de estas
bibliotecas, solo tenemos que escribir un archivo con todas las macros que se necesitarn y guardarlo como
archivo de texto y posteriormente se pueden integrar para su ejecucin.
Un procedimiento es un conjunto de instrucciones en el cual podemos dirigir el flujo de nuestro programa, al
finalizar la ejecucin de dichas instrucciones se restablece el control a la siguiente linea a procesar del cdigo
que mando llamar al procedimiento. Los procedimientos nos ayudan a crear programas legibles y fciles de
modificar. Al momento de invocar a un procedimiento se guarda en la pila la direccin de la siguiente
instruccin del programa para que, una vez transferido el flujo del programa y terminado el procedimiento, se
pueda regresar a la linea siguiente del programa original.

2
Unidad #: 6. Macros y Procedimientos
Lenguaje Ensamblador

Ejercicios de programacin:
Escriba los siguientes programas en ensamblador de 16 bits con comentarios y estructura estndar. Para ello
puede utilizar todos los programas que se han realizado con anterioridad. Puede reutilizar cdigo de las clases
y libros, pero no copiarlos en su totalidad. Todos los procedimientos y macros deben localizarse en una
librera aparte con extensin *.lib
1) Escriba SOLO UNA de las siguientes macros (El resultado se deja en DX):
Macro para elevar a la potencia n-sima un nmero entero.

Macro para calcular el factorial del valor n.


TITLE Clculo de un factorial (Fact.asm)
INCLUDE Irvine32.inc
.code
main PROC
push 12 ; calcula el factorial de 12
call Factorial ; calcula factorial (EAX)
RetornoMain:
call WriteDec ; lo muestra
call Crlf
exit
main ENDP
;--------------------------------------------------------
Factorial PROC
; Calcula un factorial.
; Recibe: [ebp+8] = n, el nmero a calcular
; Devuelve: eax = el factorial de n
;---------------------------------------------------------
push ebp
mov ebp,esp
mov eax,[ebp+8] ; obtiene n
cmp eax,0 ; n > 0?
ja L1 ; s: contina

3
Unidad #: 6. Macros y Procedimientos
Lenguaje Ensamblador

mov eax,1 ; no: regresa a 1


jmp L2
L1: dec eax
push eax ; Factorial(n-1)
call Factorial
; Las instrucciones de aqu en adelante se ejecutan cuando
; regresa cada una de las llamadas recursivas.
RetornoFact:
mov ebx,[ebp+8] ; obtiene n
mul ebx ; EDX: EAX = EAX * EBX
L2: pop ebp ; devuelve EAX
ret 4 ; limpia la pila
Factorial ENDP
END main

Macro para calcular la suma de los enteros que hay entre n1 y n2 (incluyndolos).

2) Escriba una macro que reciba los coeficientes (enteros) de una ecuacin cuadrtica y determine el
valor de las races, si stas son enteras.
a*x^2 + b*x + c = 0
Prototipo de C:
int quadratic( double a, double b, double c,
double * root1, double *root2 )
Parametros:
a, b, c - Coeficientes de la ecuacion cuadratica (ver arriba)
root1 - Apuntador al double que almacena la primera raz
root2 - Apuntador al double que almacena la segunda raz
Valor de retorno:
devuelve 1 si las races son reales si no 0
%define a qword [ebp+8]
%define b qword [ebp+16]
%define c qword [ebp+24]
%define root1 dword [ebp+32]

4
Unidad #: 6. Macros y Procedimientos
Lenguaje Ensamblador

%define root2 dword [ebp+36]


%define disc qword [ebp-8]
%define one_over_2a qword [ebp-16]

segment .data
MinusFour dw -4

segment .text
global _quadratic
_quadratic:
push ebp
mov ebp, esp
sub esp, 16 ; asigna 2 doubles (disc & one_over_2a)
push ebx ; debe guardar el valor original de ebx

fild word [MinusFour]; pila -4


fld a ; pila: a, -4
fld c ; pila: c, a, -4
fmulp st1 ; pila: a*c, -4
fmulp st1 ; pila: -4*a*c
fld b
fld b ; pila: b, b, -4*a*c
fmulp st1 ; pila: b*b, -4*a*c
faddp st1 ; pila: b*b - 4*a*c
ftst ; prueba con 0
fstsw ax
sahf
jb no_real_solutions ; if disc < 0, no hay soluciones reales
fsqrt ; pila: sqrt(b*b - 4*a*c)
fstp disc ; almacena y saca de la pila
fld1 ; pila: 1.0
fld a ; pila: a, 1.0
fscale ; pila: a * 2^(1.0) = 2*a, 1

5
Unidad #: 6. Macros y Procedimientos
Lenguaje Ensamblador

fdivp st1 ; pila: 1/(2*a)


fst one_over_2a ; pila: 1/(2*a)
fld b ; pila: b, 1/(2*a)
fld disc ; pila: disc, b, 1/(2*a)
fsubrp st1 ; pila: disc - b, 1/(2*a)
fmulp st1 ; pila: (-b + disc)/(2*a)
mov ebx, root1
fstp qword [ebx] ; almacena en *root1
fld b ; pila: b
fld disc ; pila: disc, b
fchs ; pila: -disc, b
fsubrp st1 ; pila: -disc - b
fmul one_over_2a ; pila: (-b - disc)/(2*a)
mov ebx, root2
fstp qword [ebx] ; almacena en *root2
mov eax, 1 ; valor de retorno es 1
jmp short quit

no_real_solutions:
mov eax, 0 ; valor de retorno es 0
quit:
pop ebx
mov esp, ebp
pop ebp
ret quad.asm

Assembler;
Asm
Mov AX,0600h
Mov BH,18h
Mov CX,0000h

Mov DX,184Fh

6
Unidad #: 6. Macros y Procedimientos
Lenguaje Ensamblador

Int 10h
End

3) Escriba los siguientes procedimientos:

I) clear: procedimiento que borra la pantalla

.model tiny
.data
.code
clear macro
mov ah,00h ;limpia la pantalla
mov al,03h
int 10h
endm
.startup
clear ;macro clear

mov ah,01h ;pedimos un caracter


int 21h ;para esperar el resultado
.exit
end

II) blue: procedimiento que deja en azul la pantalla

mov dx,3c8h ; Empezamos a modificar la paleta de colores


mov al,0 ; desde la entrada 0
out dx,al
inc dx ; DX = 3C9h.
mov cx,10

ciclo_2: ; Modificar 10 entradas de la paleta


mov al,0 ; Rojo.
out dx,al
mov al,0 ; Verde

7
Unidad #: 6. Macros y Procedimientos
Lenguaje Ensamblador

out dx,al
mov al,6 ; Azul
mul cl
out dx,al
loop ciclo_2

; esperar por tecla


mov ah,10h
int 16h

III) recibe: procedimiento que recibe un entero de varias cifras por teclado y lo coloca en la pila

4) Escriba UNO SOLO de los siguientes procedimientos (el resultado se deja en DX):
Determine el mayor, menor de n valores enteros guardados en la pila.
Calcule el promedio con dos decimales de n valores enteros en la pila.:

.Model Small
.Stack 64
.Data
msj Db 0ah,0dh, ' Digita las 3 calificaciones: ','$'
msj2 Db ' Aprobado','$'
msj3 Db ' Reprobado','$'
msj4 Db 0ah,0dh, ' Desea capturar otro alumno? 1.-Si, 2.-No','$'
num db 0
sum db 0
prom db 0
.Code
inicio:
mov cx,03h ;numero de calificaciones a pedir
mov bl,0000h
mov al,0000h
mov ax,@data
mov ds,ax
mov ah,09

8
Unidad #: 6. Macros y Procedimientos
Lenguaje Ensamblador

mov dx,offset msj


int 21h

Pedir: ;Pide 3 calificaciones, contador asignado en CX


mov ah,01h
int 21h
sub al,30h
add bl,al ;Hacemos la suma de las calificaciones y las asignamos en bl
aaa
loop pedir ;repite ciclo
jmp promedio

promedio: ;siemplemente divide el resultado de la suma entre 3


mov ax,bx ;pasamos el total de la suma a AX
mov bl,03h
div bl ;dividimos AX entre bl
aad ;ajuste
mov bl,al ;movemos el resultado a bl para imprimirlo
mov ah,02h
mov dl,bh
add dl,30h
int 21h
mov dl,bl
add dl,30h
int 21h
cmp bl,07h ;comparamos si el resultado (bl) es 7
ja apro ;si es mayo salta a la etiqueta apro
je apro ;si es igual salta a la etiqueta apro
jb repro ; si es menor salta a la etiqueta repro

apro: ;Solo imprime el mensaje de aprobado


mov ax,@data
mov ds,ax

9
Unidad #: 6. Macros y Procedimientos
Lenguaje Ensamblador

mov ah,09
mov dx,offset msj2
int 21h
jmp otro
repro: ;Solo imprime el mensaje de reprobado
mov ax,@data
mov ds,ax
mov ah,09
mov dx,offset msj3
int 21h
jmp otro

otro: ;Imprime el mensaje si quiere otro promedio y compara con 1 para repetir todo el programa
mov ax,@data
mov ds,ax
mov ah,09
mov dx,offset msj4
int 21h
mov ah,01h
int 21h
cmp al,31h
je inicio
ja salir
jb salir
salir:
mov ah,04ch
int 21h

end inicio

Cuente las veces que un nmero x aparece dentro de los primeros n valores de la pila.

10
Unidad #: 6. Macros y Procedimientos
Lenguaje Ensamblador

CONCLUSION

Los macros son una herramienta muy importante, ya que nos facilitan la manera de simplificar el cdigo de los
programas, al llamar la macro en determinada seccin del cdigo para realizar una tarea especfica, de igual
manera los procedimientos nos ayudan a crear programas legibles, precisos y fciles de modificar.

11