Tarea 4 Desarrollar códigos en lenguaje ensamblador

Presentado por
Jose Salvador Cruz

Dirigido a
Jonathan Sánchez Giraldo

Universidad Nacional Abierta y a Distancia - UNAD

Escuela de Ciencias Básicas, Tecnología e Ingeniería (ECBTI)
Ingeniería de Sistemas
Arquitectura de computadores
Noviembre 2021
 Tabla de Contenidos

Actividad Individual........................................................................................................................1
Ejercicio 2........................................................................................................................................1
El estudiante crea una tabla explicativa de las instrucciones en lenguaje ensamblador
referentes a: saltos incondicionales, saltos condicionales, comparaciones, decisiones y bucles.1
Ejercicio 3........................................................................................................................................5
El estudiante desarrolla uno de los siguientes programas en lenguaje ensamblador...................5
Conclusiones....................................................................................................................................9
Lista de referencias........................................................................................................................10
 Actividad Individual

Ejercicio 2

El estudiante crea una tabla explicativa de las instrucciones en lenguaje ensamblador

referentes a: saltos incondicionales, saltos condicionales, comparaciones, decisiones y

bucles.

Instrucció Descripción Sintaxis Ejemplo

n
MOV Transfiere un byte o una palabra MOV destino, fuente MOV AX,[DI]
desde el operando fuente el
operando destino.
LEA Transfiere el desplazamiento del LEA destino, fuente LEA DI,MENSAJE
operando fuente al operando
destino. El operando destino
debe ser un registro de 16 bits,
pero no un registro de
segmento.
PUSH Decrementa el puntero de la pila PUSH fuente PUSH DX
en 2 y luego transfiere la
palabra especificada en el
operando fuente a lo alto de la
pila. El registro CS no se puede
especificar como operando
fuente.
POP Transfiere el elemento que está POP destino POP DX
en lo alto de la pila al operando
destino (palabra) y luego
incrementa en dos el puntero de
pila. El registro CS no se puede
especificar como destino.
AND Realiza un AND lógico bit a bit AND destino, fuente AND R9,RAX
entre los operandos.

OR Realiza un OR lógico bit a bit OR destino, fuente OR R9, RAX

entre los operandos.
NOT Realiza un complemento bit a NOT destino NOT RAX
bit del operando destino.
SHL Desplaza a izquierda la cantidad SHL destino, temp=contador
de bits de destino especificada contador Mientras temp<>0
en el segundo operando. CF=bit superior de
destino
destino=destino*2
temp=temp-1
SHR Desplaza a derecha la cantidad SHR destino, SHR RAX,CL
de bits de destino especificada contador
en el segundo operando.
ROR Rota a derecha la cantidad de ROR destino, ROR RAX,1
bits especificada en el contador contador
ROL Rota a derecha la cantidad de ROL destino, ROL DWORD
bits especificada en el contador. contador [RBX],CL
ADD Suma los dos operandos y ADD destino, fuente ADD R9,RAX
almacena el resultado en
destino. Realiza una suma bit a
bit.
AAA Corrige el resultado en AL de AAA MOV AX, 15 ; AH
una suma de dos números = 00, AL = 0Fh
decimales desempaquetados, AAA ; AH =
convirtiéndolo en un valor 01, AL = 05
decimal desempaquetado RET
JMP Transfiere el control a la JMP dirección JMP bucle
dirección especificada por el
operando, La bifurcación puede
ser directa (si operando es una
etiqueta) o indirecta (si
operando es una dirección)
CALL Salta un procedimiento fuera de CALL destino CALL subrutina1
línea, salvando previamente en
la pila la dirección de la
instrucción siguiente, para
poder volver a esta instrucción
una vez ejecutado el
procedimiento. El
procedimiento llamado puede
estar en el mismo segmento
(NEAR) o en otro segmento
(FAR)
RET Retorna un procedimiento RET RET
previamente invocado por
CALL utilizando como retorno
la dirección salvada en la pila
 por CALL, que corresponde a la
instrucción siguiente a dicha
sentencia CALL
INT Activa el procedimiento de INT Nro INT 80h
interrupción correspondiente a
Nro. La dirección del
procedimiento se consigue en la
tabla de vectores de
interrupción. En el área de
memoria [0 – 400h]
CMP Compara los dos operandos de CMP destino, fuente CMP R9,RAX
la instrucción sin afectar al
valor de ninguno de los
operandos, actualiza los bits de
resultado según el resultado de
la comparación.
DEC Resta 1 al operando de la DEC destino DEC EAX
instrucción y almacena el
resultado en el mismo operando.
DIV Divide el dividendo implícito DIV reg DIV R8B ; AX /
entre el divisor explícito sin R8B => Cociente en
considerar los signos de los AL; resto en AH
operandos. Si el divisor es de 8
bits, se considera como
dividendo implícito AX. El
cociente de la división queda en
AL y el resto, en AH.
IDIV Divide el dividendo implícito IDIV fuente IDIV CH ; AX / CH
entre el divisor explícito => Cociente en AL;
(fuente) considerando el signo resto en AH
de los operandos. El
funcionamiento es idéntico al de
la división sin signo. Si el
divisor es de 8 bits, se considera
como dividendo implícito AX.
El cociente de la división queda
en AL y el resto, en AH.
JXX Realiza un salto según una Jxx etiqueta JE etiqueta1 ;salta
condición determinada; la si Z=1
condición se comprueba
consultando el valor de los bits
de resultado. La etiqueta
codifica un desplazamiento de
32 bits con signo y permite dar
un salto de –231 bytes a +231 –
 1 bytes. Si la condición se
cumple, se salta a la posición
del código indicada por la
etiqueta; se carga en el registro
RIP el valor RIP +
desplazamiento
TEST Realiza una operación lógica 'y' TEST destino, fuente TEST R9,RAX
bit a bit entre los dos operandos
sin modificar el valor de
ninguno de los operandos;
actualiza los bits de resultado
según el resultado de la 'y'
lógica.
LOOP La instrucción utiliza el registro LOOP etiqueta MOV RCX, 10
RCX. Decrementa el valor de bucle:
RCX, comprueba si el valor es ;
diferente de cero y en este caso ; Las instrucciones se
realiza un salto a la etiqueta repetirán 10 veces
indicada. La etiqueta codifica ; LOOP bucle
un desplazamiento de 32 bits
con signo y permite efectuar un
salto de –231 bytes a +231 – 1
bytes.
IMUL La operación de multiplicación IMUL fuente IMUL EAX, 4
con signo puede utilizar
diferente número de operandos;
se describirá el formato de la
instrucción con un operando y
con dos operandos.
SUB Lleva a cabo una resta sin SUB destino, fuente SUB R9,RAX
considerar el valor del bit de
transporte (CF). Se resta el
valor del operando fuente del
operando destino, el resultado
de la operación se guarda sobre
el operando destino
sobrescribiendo el valor inicial.
El valor del operando fuente no
se modifica.
 Ejercicio 3

El estudiante desarrolla uno de los siguientes programas en lenguaje ensamblador.

 Un programa que permita leer un número de un digito por teclado y determinar si el número es

par.

Código del programa

Nota: Para abrir el archivo en formato texto dar doble clic en el siguiente enlace:

Codigo programa
numero PAR.txt
A continuación, se muestran algunas imágenes de la ejecución del programa

Figura 1

Inicio ejecución del programa

Figura 2

Respuesta del programa al ingresar el numero 3

Figura 3

Respuesta del programa al ingresar el numero 8

Figura 4

Respuesta del programa al presionar 1 para salir

 Conclusiones

El lenguaje ensamblador nos permite conocer como fueron los primeros lenguajes que se

crearon para computadores, este lenguaje nos permite ver la lógica y estructura que se tenía en

ese entonces por parte de los ingenieros que lo crearon, al mismo tiempo podemos compararlo

con los nuevos lenguajes de programación y ver la evolución que han tenido hasta el día de hoy

los lenguajes de programación.

Lenguaje ensamblador es un lenguaje de bajo nivel que a través de mnemónicos representan

instrucciones básicas que se ejecutan en el computador y específicamente el algunos de sus

componentes como lo son el microprocesador, microcontroladores y otros circuitos donde se

envían instrucciones directamente sobre hardware lo cual lo hacía más rápido en su ejecución a

pesar de ser un leguaje de bajo nivel.

 Lista de referencias

Orenga Miguel (2016) Programación en ensamblador (x86-64) Universidad oberta de Catalunya

https://www.exabyteinformatica.com/uoc/Informatica/Estructura_de_computadores/Estru
ctura_de_computadores_(Modulo_6).pdf

Recabado Moreno, S. H. y Arias Figueroa, D. A. (2016). Arquitectura y organización de la

computadora: microprocesadores y programación assembler. Argentina: D - Editorial de
la Universidad Nacional de La Plata. (P. 24-52). Recuperado de https://elibro-
net.bibliotecavirtual.unad.edu.co/es/ereader/unad/77190?page=25

Soriano Payá, A. (2002). Estructuras de computadores: problemas resueltos. Digitalia (P. 13-50).
Recuperado de https://bibliotecavirtual.unad.edu.co/login?
url=http://search.ebscohost.com/login.aspx?
direct=true&db=nlebk&AN=318079&lang=es&site=eds-
live&scope=site&ebv=EB&ppid=pp_13

The Starman's Realm (2017) documentation for emu8086 - assembler and microprocessor
emulator https://thestarman.pcministry.com/