ESCUELA DE INGENIERÍAS Y ARQUITECTURA

INGENIERÍA EN SOFTWARE Y SISTEMAS COMPUTACIONALES

TERCER SEMESTRE GRUPO: “301”

EJERCICIOS ENSAMBLADOR #1

ELABORADO POR:

GARCÉS DÍAZ RAFAEL ORLANDO

LÓPEZ GARCÍA RAFAEL ANTONIO

LÓPEZ RUIZ UZIEL ESAÚ

MARTÍNEZ PORTILLO JAIRO ESTEBAN

DOCENTE: BOLAÑOS RODRÍGUEZ VÍCTOR ARMANDO

SANTA CRUZ XOXOCOTLÁN, OAX., 27 DE AGOSTO DE 2020

Índice
Introducción 3
Planteamiento del problema 3
Marco Teórico 4
Desarrollo de la solución 6
Resultados 9
Conclusión 10
Bibliografía 10
Anexos 10

2
Introducción
Desde la creación de la primera computadora, la tecnología de estas ha avanzado de
forma exponencial esta última década, logrando aumentar su rendimiento y velocidad
mientras reducen el tamaño de los componentes; dentro de los avances más
importantes y significativos de la historia tecnológica está la simplificación de la
interacción entre el usuario y el dispositivo, creando interfaces gráficas que redujeron la
complejidad del manejo de la computadora; sin embargo, esta interacción no ha
cambiado su estructura desde el inicio, ya que la plática entre programador y
computadora sigue siendo en código binario, solo que usamos como traductor algún
lenguaje de alto nivel, ya que estos se caracterizan por expresar los algoritmos de una
manera adecuada a la capacidad cognitiva humana, en lugar de a la capacidad
ejecutora de las máquinas.
A pesar de esto, existe un lenguaje de bajo nivel que permite interactuar de forma casi
directa con la máquina, el lenguaje llamado “Ensamblador” ayudó en este proceso de
simplificación, haciendo que las instrucciones fueran más fáciles de leer por el humano
y desarrollando una relación casi simbiótica entre programador y dispositivo.
En el siguiente documento, se plantearán problemas que deberán ser resueltos
utilizando este lenguaje de bajo nivel.

Planteamiento del problema

1. Obtener el código MIPS de la asignación: x[10] = x[11] + c; Suponer que c
corresponde al registro $t1 y el arreglo x tiene una dirección base de 4000. 
2. Escriba el código máquina generado para el ejercicio anterior. 
3. Con el ensamblador MIPS, indique la secuencia de instrucciones que evalúe a los
registros $s0, $s1 y $s2 y deje el valor del menor en $s3. 
4. Escriba el código máquina generado para el ejercicio 3. 
5. El siguiente código acumula los valores del arreglo A en la variable x: for ( x = 0, i =
0; i < 10; i++ ) x = x + A[i]; ¿Cuál será el código MIPS para este código? Suponga
que el comienzo del arreglo A esta en el registro $s3, que el registro $t1 contiene
10, que la variable x se asocia con $s1 y la variable i con $s2. 

3
6. Transforme la siguiente asignación: c = ( a > b ) ? a : b; a código MIPS. Asocie a, b
y c con $s0, $s1 y $s2, respectivamente.

Marco Teórico
Lenguaje ensamblador
El lenguaje Ensamblador es un lenguaje traductor que permite tener un control total
sobre cada instrucción generada por una máquina en particular mediante el programa
traductor, tal programa traductor es llamado Ensamblador.
Expresa las instrucciones de una forma más natural al hombre y a la vez que muy
cercana al microcontrolador, ya que cada una de esas instrucciones se corresponde
con otra en código máquina. Trabaja con nemónicos, que son grupos de caracteres
alfanuméricos que simbolizan las órdenes o tareas a realizar.
La traducción de los nemónicos a código máquina entendible por el microcontrolador la
lleva a cabo el traductor; el programa escrito en lenguaje ensamblador se denomina
código fuente (*.asm). El programa ensamblador proporciona a partir de este fichero el
correspondiente código máquina, que suele tener la extensión *.hex.

[Figura 1. Ejemplo de un archivo en código fuente]

Código fuente
Está compuesto por una sucesión de líneas de texto, cada línea puede estructurarse en
hasta cuatro campos o columnas separados por uno o más espacios o tabulaciones
entre sí:
i. Declaraciones y definiciones: definición de constantes, importación de código o
información al compilador.
ii. Segmento de datos: Reserva de espacio para las variables que usa el programa,
define un bloque de sentencias fuente, ya sean directivas o instrucciones.
iii. Segmento de pila: depositar la información necesaria para las llamadas a
funciones, o bien almacenar datos temporalmente. En este bloque se define un
tamaño para la pila.

4
 iv. Segmento de código: Definición de todos los procedimientos e instrucciones del
programa.

[Figura 2. Ejemplificación de la estructura del código fuente]

Código máquina
Es el único que entiende directamente la computadora, utiliza el alfabeto binario que
consta de los dos únicos símbolos 0 y 1, denominados bits (abreviatura inglesa de
dígitos binarios).
Fue el primer lenguaje utilizado en la programación de computadoras, pero dejó de
utilizarse por su dificultad y complicación, siendo sustituido por otros lenguajes más
fáciles de aprender y utilizar, que además reducen la posibilidad de cometer errores

[Figura 3. Ejemplo de un programa en código máquina]

SPIM MIPS Simulator (QtSpim)

5
SPIM es un simulador autónomo para programas en lenguaje ensamblador escritos
para los procesadores R2000/R3000, los cuales son procesadores de 32 bits de la
corporación MIPS. SPIM lee y ejecuta el código en lenguaje ensamblador, proporciona
un depurador simple y un juego simple de servicios del sistema operativo.

Desarrollo de la solución
Para la solución de los problemas, se utilizó el editor Atom para escribir el código; a
continuación, se presenta el código fuente y el resultado que arrojó QtSpim.
Problema 1
Código MIPS
main:

li $t1, 40 #Establece al registro t1 con valor de 40

li $t0, 0 #Establece el registro t0 con valor de 0

lw $t2, 4000($zero) #Carga la dirección 4000 + 0 en el registro

t2
lw $s2, 44($t2) #Carga lo que hay en t2 + 40 al registro s2

add $t0, $s2, $t1 #Suma s2 + t1 y lo almacena en t0

sw $t0, 40($t2) #Guarda lo que tenga t0 en la dirección t2 + 40

[Tabla 1. Código fuente del problema 1]

Problema 2
Campos MIPS
08 9 0 40
08 8 0 0
35 0 10 4000
35 10 18 44
0 18 9 8 0 32
43 10 8 40
[Tabla 2. Campos MIPS problema 1]

Código Máquina
001000 01001 00000 0000000000101000
001000 01000 00000 0000000000000000

6
 100011 00000 01010 0000111110100000
100011 01010 10010 0000000000101100
000000 10010 01001 01000 00000 100000
101011 01010 01000 0000000000101000
[Tabla 3. Código máquina del problema 1]

Problema 3
Código MIPS
ble $s0, $s1, l1 # Si s0 < s1 se va a l1
ble $s1, $s2, l2 # Si s0 < s1 se va a l1
b l3 # Como s1 < s0 y s2 < s1, s2 es menor

l1:
ble $s0, $s2, l0 # Si s0 < s2 eso significa que s0 es el
menor
b l3 # Si no entró la condición, s2 es el menor
j END # Se va a la secuencia para terminar

l0:
addi $s3, $s0, 0 #s0 es el menor
j END # Se va a la secuencia para terminar

l2:
addi $s3, $s1, 0 #s1 es el menor
j END # Se va a la secuencia para terminar

l3:
addi $s3, $s2, 0 #s2 es el menor
j END # Se va a la secuencia para terminar

[Tabla 4. Código fuente del problema 2]

Problema 4
Campos MIPS
08 16 0 15
08 17 0 3
08 18 0 5
08 19 0 0
06 16 17 l1
06 17 18 l2
02 l3
06 16 18 l0
02 l3
02 END
08 19 16 0
02 END

7
 08 19 17 0
02 END
08 19 18 0
02 END
[Tabla 5. Campos MIPS problema 2]

Código Máquina
001000 10000 00000 0000000000001111
001000 10001 00000 0000000000000011
001000 10010 00000 0000000000000101
001000 10011 00000 0000000000000000
000110 10000 10001 0110110000110001
000110 10001 10010 0110110000110010
000010 0110110000110011
000110 10000 10010 0110110000110000
000010 0110110000110011
000010 011001010110111001100100
001000 10011 10000 0000000000000000
000010 011001010110111001100100
001000 10011 10001 0000000000000000
000010 011001010110111001100100
001000 10011 10010 0000000000000000
000010 011001010110111001100100
[Tabla 6. Código máquina del problema 2]

Problema 5
Código MIPS
for_loop:
beq $s2, $t1, exit # Si i == 10, se va a exit
lw $t0, 0($s3) # Cargamos el elemento de A[i]
add $s1, $s1, $t0 # x = x + A[i]
addi $s3, $s3, 4 # Se pasa al siguiente elemento del array
addi $s2, $s2, 1 # Se incrementa i + 1
b for_loop # regresa al for_loop

exit:
[Tabla 7. Código fuente del problema 5]

Problema 6
Código MIPS
bgt $s0, $s1, a_menor # Si s0 > s1 se va a_mayor
addi $s2, $s1, 0 # Si no se cumplió lo anterior, entonces c =
b
j Exit # Salta a Exit

8
 a_menor:
addi $s2, $s0, 0 # Si entró, entonces c = a
j Exit # Salta a Exit
Exit:
[Tabla 8. Código fuente del problema 6]
Resultados
A continuación, se presentan los resultados mostrados por el programa QtSpim en la
parte de registros, ya que no se mostró nada en consola.

Problema 1

[Figura 4. Registros del programa 1]

Problema 3

[Figura 5. Registros del programa 3]

Problema 5

[Figura 6. Registros del programa 5]

Problema 6

9
 [Figura 7. Registros del programa 6]
Conclusión
Hubo retos al momento de entender este lenguaje viejo debido al nivel de abstracción
que tiene, ya que nos metemos con asuntos como manejo de memoria, registros,
llamadas, entre otras cosas; para nosotros los programadores novatos nos cuesta
entender la lógica que hay detrás de algunos algoritmos, y es aún más complicado al
tratar de convertirlo todo a 0’s y 1’s, en efecto, un buen reto que nos obligó a buscar
nuevas de pensar, formular ideas y encontrar soluciones más allá de lo superficial.
La importancia de entender el lenguaje ensamblador es que nos permitirá comprender
de forma completa los algoritmos y los lenguajes de alto nivel, ya que una buena lógica
y saber cómo darle órdenes a la computadora será una combinación letal al momento
de programar y codificar nuestros programas.

Bibliografía
Recuperado de: http://profesores.elo.utfsm.cl/~tarredondo/info/comp-
architecture/paralelo2/C03_MIPS.pdf el día 26 de agosto de 2020.
Recuperado de: https://opencores.org/projects/plasma/opcodes el día 26 de agosto de
2020.
Recuperado de: http://www.mscs.mu.edu/~rge/cosc2200/lectures/MIPS-jumps.pdf el
día 26 de agosto de 2020.
Recuperado de: http://profesores.elo.utfsm.cl/~tarredondo/info/comp-
architecture/elo311-3-Ensamblador.pdf el día 26 de agosto de 2020.
Recuperado de: https://courses.cs.washington.edu/courses/cse378/04au/lec378au04-
04.pdf el día 26 de agosto de 2020.
Recuperado de: http://www.utm.mx/~jjf/le/TEMA1.pdf el día 26 de agosto de 2020.
Recuperado de: https://www.ecured.cu/Código_máquina el día 26 de agosto de 2020.

Anexos
ensamblador_1
main:

li $t1, 40 #Establece al registro t1 con valor de 40

li $t0, 0 #Establece el registro t0 con valor de 0

lw $t2, 4000($zero) #Carga la direccion 4000 + 0 en el registro

10
t2
lw $s2, 44($t2) #Carga lo que hay en t2 + 40 al registro s2

add $t0, $s2, $t1 #Suma s2 + t1 y lo almacena en t0

sw $t0, 40($t2) #Guarda lo que tenga t0 en la dirección t2 + 40
ensamblador_3
main:
# Aqui va el código
addi $s0, $zero, 15 # 0= +
addi $s1, $zero, 3 # =1 +
addi $s2, $zero, 5
addi $s3, $zero, 0

ble $s0, $s1, l1 # Si s0 < s1 se va a l1

ble $s1, $s2, l2 # Si s0 < s1 se va a l1
b l3 # Como s1 < s0 y s2 < s1, s2 es menor

l1:
ble $s0, $s2, l0 # Si s0 < s2 eso significa que s0 es el
menor
b l3 # Si no entró la condición, s2 es el menor
j END # Se va a la secuencia para terminar

l0:
addi $s3, $s0, 0 #s0 es el menor
j END # Se va a la secuencia para terminar

l2:
addi $s3, $s1, 0 #s1 es el menor
j END # Se va a la secuencia para terminar

l3:
addi $s3, $s2, 0 #s2 es el menor
j END # Se va a la secuencia para terminar

END: # Ya no ejecuta nada

ensamblador_5
array: .word 2, 3, 5, 7, 11, 13, 17, 19, 23, 29

main:
# Aqui va el código
li $t1, 10 #t1 = 10
li $s1, 0 # s= 0
li $s2, 0 # s2 0
la $s3, array #

for_loop:
beq $s2, $t1, exit # Si i == 10, se va a exit
lw $t0, 0($s3) # Cargamos el elemento de A[i]
add $s1, $s1, $t0 # x = x + A[i]

11
 addi $s3, $s3, 4 # Se pasa al siguiente elemento del array
addi $s2, $s2, 1 # Se incrementa i + 1
b for_loop # regresa al for_loop

exit:
ensamblador_6
main:
# Aqui va el código

addi $s0, $zero, 15 # 0= +

addi $s1, $zero, 28 # =1 +
addi $s2, $zero, 0

bgt $s0, $s1, a_menor # Si s0 > s1 se va a_mayor

addi $s2, $s1, 0 # Si no se cumplió lo anterior, entonces c =
b
j Exit # Salta a Exit

a_menor:
addi $s2, $s0, 0 # Si entró, entonces c = a
j Exit # Salta a Exit

Exit:

12