5.6 Repertorio de instrucciones

El simulador VonSim8 implementa un repertorio reducido de instrucciones, diseñado para facilitar la comprensión de los conceptos fundamentales de la arquitectura de computadoras. Este repertorio incluye instrucciones aritméticas, lógicas, de transferencia de datos y control de flujo, lo que facilita que los estudiantes se familiaricen con las operaciones básicas, evitando la complejidad del repertorio completo de instrucciones x86.

El repertorio de instrucciones del simulador fue concebido como una abstracción pedagógica basada en la arquitectura x86, orientada a optimizar los procesos de enseñanza y aprendizaje en el ámbito educativo. En las primeras etapas del curso, se seleccionan únicamente las instrucciones esenciales, lo que permite introducir de forma gradual y accesible los contenidos fundamentales de la asignatura Arquitectura de Computadoras. Este enfoque progresivo facilita la comprensión de los conceptos clave, evitando la complejidad innecesaria que podría dificultar el aprendizaje inicial (John L. Hennessy and Patterson 2017a; Tanenbaum 2016). La Tabla 5.7 expone un repertorio acotado de instrucciones, seleccionado para abordar las operaciones fundamentales en una etapa inicial de aprendizaje. Este conjunto, enfocado en la transferencia y el procesamiento de datos, así como en el control de flujo, constituye una estrategia pedagógica que facilita la comprensión de los principios básicos de la arquitectura x86 y responde a los objetivos formativos del curso.

Las instrucciones del simulador VonSim8 se dividen en dos categorías principales: las instrucciones de transferencia y procesamiento de datos, y las instrucciones de control de flujo. Las primeras permiten mover datos entre registros y memoria, realizar operaciones aritméticas y lógicas, y manipular el contenido de los registros. Las segundas permiten alterar el flujo de ejecución del programa mediante saltos condicionales e incondicionales, así como la detención del procesador.

Con el objetivo de favorecer el aprendizaje de la programación en ensamblador y la comprensión del ciclo de instrucción, se presenta a continuación un repertorio de instrucciones alineado con el programa de estudio de la asignatura Arquitectura de Computadoras (Facultad de Ciencias de la Administración, UNER 2025).

Tabla 5.7: Tabla de instrucciones de VonSim8
Instrucciones	nemónico	Acción
Transferencia de datos	MOV	Copiar
Procesamiento de datos	ADD	Sumar
	SUB	Restar
	CMP	Comparar
Control de flujo	JMP	Salto incondicional
	Jxx	Salto condicional si xx=1
	HLT	Detiene CPU

En el simulador VonSim8, el parámetro xx de las instrucciones Jxx permite realizar saltos condicionales en función de distintas combinaciones de banderas de estado, como cero (Z), acarreo (C), signo (S) y desbordamiento (O). La negación de una bandera se indica mediante la letra N, lo que otorga mayor flexibilidad para controlar el flujo de ejecución en programas ensamblador. La Tabla 5.8 sintetiza las instrucciones de salto condicional implementadas, detallando la condición asociada a cada bandera y su efecto sobre el flujo del programa.

Tabla 5.8: Saltos condicionales: instrucciones y condiciones
Instrucción	Acción
JZ Dirección	Salta a Dirección si Z = 1
JNZ Dirección	Salta a Dirección si Z = 0
JC Dirección	Salta a Dirección si C = 1
JNC Dirección	Salta a Dirección si C = 0
JS Dirección	Salta a Dirección si S = 1
JNS Dirección	Salta a Dirección si S = 0
JO Dirección	Salta a Dirección si O = 1
JNO Dirección	Salta a Dirección si O = 0

Con base en las entrevistas realizadas a los docentes y el análisis de los contenidos del curso, a continuación se presenta el uso pedagógico esperado para cada categoría de instrucciones.

Transferencia y procesamiento de datos: este grupo de instrucciones permite mover datos entre registros y memoria, así como realizar operaciones aritméticas. Resultan fundamentales para comprender el flujo de información en una arquitectura computacional. Por ejemplo, la siguiente operación aritmética en Python:

x=2
y=3
z=0
z = x + y

Puede expresarse de forma equivalente en lenguaje ensamblador, tal como se muestra a continuación:

```assembly
x db 2
y db 3
z db 0
mov AL, x   ;Se carga el valor de x (2) en AL
add AL, y   ;Se suma el valor de y (3) a AL (2) = 5
mov z, AL   ;Se guarda el valor del registro AL (5) en z 
hlt
```

Control de flujo: este tipo de instrucciones permite modificar el orden de ejecución del programa mediante saltos condicionales e incondicionales, así como detener la ejecución del procesador. Son fundamentales para comprender cómo se toman decisiones y se gestiona el flujo de ejecución en un programa. Por ejemplo, la siguiente estructura condicional igual en lenguaje Python:

x=2
y=3
z=0
if x == y:
  z = y  + x

Puede representarse de manera equivalente en lenguaje ensamblador, como se muestra a continuación:

```assembly

x db 2 y db 3 z db 0 mov AL, x cmp AL, y jz EsIgual jmp Fin EsIgual: add AL, y mov z, AL Fin: hlt ```

Otro ejemplo de estructura condicional en Python, utilizando la comparación de menor que:

x=2
y=3
z=0
if x < y:
  z = y  + x

Puede representarse de manera equivalente en lenguaje ensamblador, como se muestra a continuación:

```assembly

x db 2 y db 3 z db 0 mov AL, x cmp AL, y jc EsMenor jmp Fin EsMenor: add AL, y mov z, AL Fin: hlt ```

Por ejemplo, la estructura iterativa while en Python:

x = 0
suma = 0

while x < 10:
    suma = suma + x
    x = x + 1

Puede representarse de manera equivalente en lenguaje ensamblador, como se muestra a continuación:

```assembly

x db 1
suma db 0
Condicion: cmp x, 10 jc Bucle ; si x < 10 salta a etiqueta Bucle: jmp FinBucle ; si no salta a la etiqueta FinBucle: Bucle: mov BL, x add suma, BL add x, 1 jmp Condicion ; salta a Condicion: FinBucle: hlt ```

Tratamiento de vectores: el simulador permite operar con vectores y matrices, lo que resulta fundamental para comprender el manejo de estructuras de datos complejas en una arquitectura computacional. Por ejemplo, el siguiente fragmento en Python ilustra cómo encontrar el valor máximo en un vector:

# Búsqueda del máximo en un vector
vector = [5, 2, 10, 4, 5, 0, 4, 8, 1, 9]
maximo = 0

for i in range(len(vector)):
    if vector[i] > maximo:
        maximo = vector[i]

Esta lógica puede implementarse de manera equivalente en lenguaje ensamblador, como se muestra a continuación:

```assembly

max db 0 vector db 5, 2, 10, 4, 5, 0, 4, 8, 1, 9 mov CL, 0 ; contador mov BL, offset vector ; obtiene la dirección del primer elemento del vector Condicion: cmp CL, 10 jc Bucle ; si x < 10 salta a etiqueta Bucle jmp FinBucle ; si no salta a la etiqueta FinBucle Bucle: mov AL, [BL] ; AL = vector[indice] cmp AL, max jc Proximo ; si AL < max, salta a Proximo mov max, AL ; si no, actualiza max Proximo: add BL, 1 ; BL = BL + 1 add CL, 1 ; CL = CL + 1
jmp Condicion FinBucle: hlt```

La selección de instrucciones está diseñada para facilitar la comprensión de los procesos esenciales de la arquitectura de computadoras, como la ejecución de operaciones aritméticas, la transferencia de datos entre registros y memoria, y el control del flujo de ejecución. Al emplear un repertorio reducido e inspirado en la arquitectura x86, se logra un equilibrio entre el rigor conceptual y la simplicidad pedagógica.

La implementación de estas instrucciones en el simulador VonSim8 tiene como objetivo ofrecer una experiencia de aprendizaje que favorezca la asimilación de los principios fundamentales de la arquitectura de computadoras, disminuyendo la carga cognitiva en las etapas iniciales y fortaleciendo la transición hacia repertorios más avanzados. Esta selección de instrucciones y modos de direccionamiento, inspirada en x86 pero pedagógicamente acotada, proporciona al estudiante un modelo mental preciso sobre la ejecución de operaciones aritméticas, la transferencia de datos entre registros y memoria, y la gestión del flujo de ejecución.

5.6.1 Modos de direccionamiento

Los modos de direccionamiento especifican cómo el procesador determina la ubicación de los operandos de una instrucción. Estos mecanismos permiten identificar de dónde se obtienen los datos necesarios para ejecutar una operación y dónde se almacena el resultado. En VonSim8 se implementan los siguientes modos de direccionamiento:

Registro a registro (Rx, Ry): ambos operandos corresponden a registros del procesador; Rx es el registro destino y Ry el registro fuente.
Directo ([M]): uno de los operandos es el contenido de una dirección de memoria [M].
Indirecto ([BL]): la dirección del operando se encuentra almacenada en el registro [BL].
Inmediato (d): uno de los operandos es un valor inmediato incluido en la propia instrucción.

La Tabla 5.9 sintetiza los modos de direccionamiento implementados en el simulador para instrucciones que requieren dos operandos, acompañando cada modalidad con ejemplos representativos. Esta presentación facilita la comprensión de las distintas formas de acceso a datos y su aplicación práctica en el contexto de la arquitectura simulada.

Tabla 5.9: Tabla de modos de direccionamiento
Destino	Fuente	Ejemplo
Registro Rx	Puede ser: registro `Ry` dirección `[M]` (1) dirección registro `[BL]` (2) valor inmediato `d` (3)	Entre registro: MOV `Rx`,`Ry` Directo: MOV `Rx`,`[M]` Indirecto: MOV `Rx`,`[BL]` Inmediato: MOV `Rx`,`d`
Memoria puede ser: dirección `[M]` dirección registro `[BL]`	Puede ser: Registro: `Ry` valor en la instrucción `d`	Directo: MOV `[M]`,`Ry` Indirecto: MOV `[BL]`,`Ry` Directo-Inmediato: MOV `[M]`,`d` Indirecto-Inmediato: MOV `[BL]`,`d`
Nota:
Las instrucciones de dos operando, tanto de transferencia y procesamiento tienen los mismos modos de direccionamiento.

La incorporación de estos modos de direccionamiento en el simulador posibilita la ejecución de una amplia variedad de operaciones, desde la manipulación directa de registros hasta el acceso flexible a la memoria. Su implementación constituye un pilar fundamental para el análisis y la comprensión del flujo de datos en una arquitectura computacional.

A continuación se muestra un ejemplo representativo de cómo se implementan los modos de direccionamiento en el simulador, evidenciando la gestión de operaciones sobre registros y memoria:

x db 2 
y db 3

; Ejemplo modos direccionamiento
;----------------------
; carga en registro
;----------------------
; Directo
mov al, x

; Por registro
mov dl, al

; Inmediato
mov bl, 16

; Indirecto
mov cl, [bl] ; celda 16 = BL

;----------------------
; Almacenar en memoria
;----------------------
; Directo
mov x, cl

; Indirecto
mov [bl], al

; Directo-Inmediato
mov x, 5

; Indirecto-Inmediato
mov [bl], 4

hlt

5.6.2 Formato de instrucciones

El formato de las instrucciones en VonSim8 se basa en una codificación binaria de longitud variable (1, 2 o 3 bytes). Los 4 bits de mayor peso del primer byte corresponden al código de operación (opcode), mientras que los 4 bits restantes pueden contener información adicional sobre los operandos, según el modo de direccionamiento empleado. El opcode determina la operación a ejecutar, y los operandos especifican los datos o registros implicados en la instrucción.

El repertorio de instrucciones implementado en el simulador VonSim8 se organiza en dos grandes categorías: instrucciones de transferencia y procesamiento de datos, e instrucciones de control de flujo. Cada categoría agrupa operaciones fundamentales para la manipulación de datos y la gestión del flujo de ejecución en programas ensamblador.

La Tabla 5.10 sintetiza las principales instrucciones disponibles en VonSim8, detallando su categoría, código de operación, cantidad de operandos y acción asociada. Esta presentación estructurada facilita la comprensión de la lógica interna del simulador y constituye una referencia esencial para el análisis y la programación en el entorno educativo.

Tabla 5.10: Categoría de instrucciones y códigos de operación en VonSim8
Categoría	Instrucción	Código operación	Operandos	Acción
Transferencia de datos	MOV	{0, 1, 2}	2	Copiar entre registros, cargar de memoria a registro, almacenar en memoria
Procesamiento de datos	ADD	{3, 4, 5}	2	Operación aritmética: operando1 ← operando1 + operando2
	SUB	{6, 7, 8}	2	Operación aritmética: operando1 ← operando1 - operando2
	CMP	{9, 10, 11}	2	Comparación: operando1 - operando2 (no actualiza el destino)
Control de flujo	JMP / Jxx	{12}	1	Salto incondicional JMP, condicionales Jxx
	HLT	{13}	0	HLT: detiene el CPU

Cada instrucción se codifica en un formato binario específico, que incluye un código de operación (opcode) y, en algunos casos, operandos adicionales. La Tabla 5.11 ofrece una relación detallada de las instrucciones implementadas en el simulador, acompañadas de su correspondiente codificación binaria. Esta información resulta esencial para comprender el proceso de traducción entre el lenguaje ensamblador y la representación interna utilizada por el sistema.

Tabla 5.11: Tabla de codificación de instrucciones
CodOp	Instrucción	Byte	Codificación
0	`MOV Rx, Ry`	1	`0000 RxRy`
1	`MOV Rx, [M]`	2	`0001 Rx00 MMMMMMMM`
1	`MOV Rx, [BL]`	1	`0001 Rx01`
1	`MOV Rx, D`	2	`0001 Rx10 DDDDDDDD`
2	`MOV [M], Ry`	2	`0010 00Ry MMMMMMMM`
2	`MOV [BL], Ry`	2	`0010 01Ry`
2	`MOV [M], D`	3	`0010 1100 MMMMMMMM DDDDDDDD`
2	`MOV [BL], D`	2	`0010 1101 DDDDDDDD`
3	`ADD Rx, Ry`	1	`0011 RxRy`
4	`ADD Rx, --`	Idem	`0100 ---- --------`
5	`ADD [M], --`	Idem	`0101 ---- -------- --------`
6	`SUB Rx, Ry`	1	`0110 RxRy`
7	`SUB Rx, --`	Idem	`0111 ---- --------`
8	`SUB [M], --`	Idem	`1000 ---- -------- --------`
9	`CMP Rx, Ry`	1	`1001 RxRy`
A	`CMP Rx, --`	Idem	`1010 ---- --------`
B	`CMP [M], --`	Idem	`1011 ---- -------- --------`
C	`JMP M`	1	`1100 0000 MMMMMMMM`
C	`Jxx M`	1	`1100 ffff MMMMMMMM`
D	`HLT`	1	`1101 0000`
Nota:
Las instrucciones de dos operandos, tanto de transferencia y procesamiento tienen los mismos modos de direccionamiento.<br>Considerando:<br>____: Código de operación de la instrucción, 4 bits.<br>Rx o Ry: Índices de registros de propósito general, 0 a 3, 2 bits cada uno.<br>M: Dirección de memoria 8 bits.<br>ffff: representa el comportamiento de la instrucción 4 bits.<br>d: Dato inmediato 8 bits.<br>MMMMMMMM: Dirección de memoria 8 bits.<br>dddddddd: Dato inmediato 8 bits.

La Tabla 5.12 muestra los códigos binarios y decimales asignados a los registros de propósito general AL, BL, CL y DL, habilitados para su uso como Rx y Ry en las instrucciones del simulador.

Tabla 5.12: Tabla de registros de propósito general
Registros R	Binario	Decimal
AL	00	0
BL	01	1
CL	10	2
DL	11	3
Nota:
Los registros AL, BL, CL y DL corresponden a registros de propósito general de 8 bits.

Bibliografía

Facultad de Ciencias de la Administración, UNER. 2025. “Programa de la asignatura Arquitectura de Computadoras.” Consejo Directivo, Facultad de Ciencias de la Administración, UNER; https://digesto.uner.edu.ar/documento.frame.php?cod=170316.

Hennessy, John L., and David A. Patterson. 2017a. Computer Architecture: A Quantitative Approach. 6th ed. Boston: Morgan Kaufmann.

Tanenbaum, Andrew S. 2016. Structured Computer Organization. Pearson Education India.