Nombre de la materia

Lenguaje ensamblador

Nombre de la Licenciatura
Ingeniería en Sistemas
c Computacionales

Nombre del alumno

María Fernanda Bárcenas Enciso

Matrícula
000015772

Nombre de la Tarea
Tarea 6

Unidad #
Macros y procedimientos

Nombre del Tutor

Miriam Armenta González

Fecha
21/10/15
 Unidad 6. Macros y procedimientos
Lenguaje Ensamblador, Tarea 6

MACROS Y PROCEDIMIENTOS
Introducción:

En lenguaje ensamblador se denomina macro al conjunto de instrucciones que se agrupan bajo

un nombre descriptivo, después de que la macro ha sido declarada, sólo 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
combinación especial de teclas o un botón creado para esa acción.
Una de las ventajas que brinda el uso de las macros es la creación de bibliotecas, las cuales
son grupos de macros que pueden ser incluidas en un programa desde un archivo diferente.
Para la creación de estas bibliotecas, solo tenemos que escribir un archivo con todas las
macros que se necesitarán y guardarlo como archivo de texto y posteriormente se pueden
integrar para su ejecución.
Un procedimiento es un conjunto de instrucciones en el cual podemos dirigir el flujo de nuestro
programa, al finalizar la ejecución de dichas instrucciones se restablece el control a la siguiente
linea a procesar del código que mando llamar al procedimiento. Los procedimientos nos ayudan
a crear programas legibles y fáciles de modificar. Al momento de invocar a un procedimiento se
guarda en la pila la dirección de la siguiente instrucción 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.
 Unidad 6. Macros y procedimientos
Lenguaje Ensamblador, Tarea 6

Desarrollo:

Ejercicios de programación:

Escriba los siguientes programas en ensamblador de 16 bits con comentarios y estructura

estándar. Para ello puede utilizar todos los programas que se han realizado con anterioridad.
Puede reutilizar código de las clases y libros, pero no copiarlos en su totalidad. Todos los
procedimientos y macros deben localizarse en una librería aparte con extensión *.lib

1) Escriba SOLO UNA de las siguientes macros (El resultado se deja en DX):

• Macro para elevar a la potencia n-ésima un número entero.

• Macro para calcular el factorial del valor n.

TITLE Cálculo 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 número a calcular
; Devuelve: eax = el factorial de n
;---------------------------------------------------------
push ebp
mov ebp,esp
mov eax,[ebp+8] ; obtiene n
 Unidad 6. Macros y procedimientos
Lenguaje Ensamblador, Tarea 6

cmp eax,0 ; n > 0?

ja L1 ; sí: continúa
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 (incluyéndolos).

2) Escriba una macro que reciba los coeficientes (enteros) de una ecuación cuadrática y
determine el valor de las raíces, si éstas son enteras.

3 ; a*x^2 + b*x + c = 0
4 ; Prototipo de C:
5 ; int quadratic( double a, double b, double c,
6 ; double * root1, double *root2 )
7 ; Par´ametros:
8 ; a, b, c - Coeficientes de la ecuaci´on cuadr´atica (ver arriba)
9 ; root1 - Apuntador al double que almacena la primera ra´ız
10 ; root2 - Apuntador al double que almacena la segunda ra´ız
11 ; Valor de retorno:
12 ; devuelve 1 si las ra´ıces son reales si no 0
13
14 %define a qword [ebp+8]
 Unidad 6. Macros y procedimientos
Lenguaje Ensamblador, Tarea 6

15 %define b qword [ebp+16]

16 %define c qword [ebp+24]
17 %define root1 dword [ebp+32]
18 %define root2 dword [ebp+36]
19 %define disc qword [ebp-8]
20 %define one_over_2a qword [ebp-16]
21
22 segment .data
23 MinusFour dw -4
24
25 segment .text
26 global _quadratic
27 _quadratic:
28 push ebp
29 mov ebp, esp
30 sub esp, 16 ; asigna 2 doubles (disc & one_over_2a)
31 push ebx ; debe guardar el valor original de ebx
32
33 fild word [MinusFour]; pila -4
34 fld a ; pila: a, -4
35 fld c ; pila: c, a, -4
36 fmulp st1 ; pila: a*c, -4
37 fmulp st1 ; pila: -4*a*c
38 fld b
39 fld b ; pila: b, b, -4*a*c
40 fmulp st1 ; pila: b*b, -4*a*c
41 faddp st1 ; pila: b*b - 4*a*c
42 ftst ; prueba con 0
43 fstsw ax
44 sahf
45 jb no_real_solutions ; if disc < 0, no hay soluciones reales
46 fsqrt ; pila: sqrt(b*b - 4*a*c)
47 fstp disc ; almacena y saca de la pila
48 fld1 ; pila: 1.0
 Unidad 6. Macros y procedimientos
Lenguaje Ensamblador, Tarea 6

49 fld a ; pila: a, 1.0

50 fscale ; pila: a * 2^(1.0) = 2*a, 1
51 fdivp st1 ; pila: 1/(2*a)
52 fst one_over_2a ; pila: 1/(2*a)
53 fld b ; pila: b, 1/(2*a)
54 fld disc ; pila: disc, b, 1/(2*a)
55 fsubrp st1 ; pila: disc - b, 1/(2*a)
56 fmulp st1 ; pila: (-b + disc)/(2*a)
57 mov ebx, root1
58 fstp qword [ebx] ; almacena en *root1
59 fld b ; pila: b
60 fld disc ; pila: disc, b
61 fchs ; pila: -disc, b
62 fsubrp st1 ; pila: -disc - b
63 fmul one_over_2a ; pila: (-b - disc)/(2*a)
64 mov ebx, root2
65 fstp qword [ebx] ; almacena en *root2
66 mov eax, 1 ; valor de retorno es 1
67 jmp short quit
68
69 no_real_solutions:
70 mov eax, 0 ; valor de retorno es 0
71
72 quit:
73 pop ebx
74 mov esp, ebp
75 pop ebp
76 ret quad.asm

Assembler;
Asm
Mov AX,0600h
Mov BH,18h
Mov CX,0000h
 Unidad 6. Macros y procedimientos
Lenguaje Ensamblador, Tarea 6

Mov DX,184Fh
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

http://tipsparaisc.blogspot.mx/2012/04/ensamblador-8086-modo-13h-paleta-de.html
copiar el ejemplo de esa pág, posteriormente eliminar estas lineas

III) recibe: procedimiento que recibe un entero de varias cifras por teclado y lo coloca en
la pila
 Unidad 6. Macros y procedimientos
Lenguaje Ensamblador, Tarea 6

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
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
 Unidad 6. Macros y procedimientos
Lenguaje Ensamblador, Tarea 6

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
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
 Unidad 6. Macros y procedimientos
Lenguaje Ensamblador, Tarea 6

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 número x aparece dentro de los primeros n valores de la pila.

Entregue sólo los archivos *.asm y una librería *.lib una vez que haya probado el
correcto funcionamiento de cada programa, procedimiento o macro.
 Unidad 6. Macros y procedimientos
Lenguaje Ensamblador, Tarea 6

Conclusión:

Los macros son una herramienta muy importante, ya que nos facilitan la manera de simplificar
el código de los programas, al llamar la macro en determinada sección del código para realizar
una tarea específica, de igual manera los procedimientos nos ayudan a crear programas
legibles, precisos y fáciles de modificar.

Bibliografía:

Scribd (2010) Ensamblador. En Scribd. Consultado el 20 de octubre del 2015. Disponible en:
https://es.scribd.com/doc/23105148/Unidad-III-Ensamblador

Monografías (2013) Programación en ensamblador. En monografías. Consultado el 21 de

octubre del 2015. Disponible en: http://www.monografias.com/trabajos-pdf/programacion-
ensamblador-procesadores/programacion-ensamblador-procesadores.pdf

Lenguaje ensamblador (2012) Lenguaje ensamblador. En Wikipedia. Consultado el 21 de

octubre del 2015. Disponible en: https://es.wikipedia.org/wiki/Lenguaje_ensamblador