Aquí tenemos una instrucción de 11 bits que tiene los primeros 2 bits para representar el modo de direccionamiento, los siguientes 3 bits para el código de operación y los últimos 6 bits son para los dos operandos, 3 bits cada uno.
Ejecutaremos esta instrucción de 11 bits utilizando cuatro modos de direccionamiento diferentes:
- Modo directo: en este modo, las direcciones de dos operandos se especifican en la instrucción. Podemos recibir los datos reales directamente de las direcciones de memoria.
- Modo indirecto: En este modo, las direcciones mencionadas en la instrucción apuntan a las direcciones efectivas de los operandos.
- Modo inmediato: en este modo, los datos reales se mencionan en la instrucción misma.
- Modo de registro: en este modo, la instrucción contiene las direcciones de los registros que contienen los datos reales.
Usaremos los primeros 2 bits para representar los cuatro modos de direccionamiento diferentes de esta manera:
For direct mode- 00 For indirect mode- 01 For immediate mode- 10 For register mode- 11
Los siguientes 3 bits son para representar el código de operación, por lo que podemos usar 8 operaciones diferentes como máximo. Definiremos 6 operaciones y las otras dos quedarán reservadas para futuro de esta forma:
000- Do nothing 001- Addition 010- Subtraction 011- Multiplication 100-Division 101-Transfer operand2 to operand1 110-Reserve for future 111-Reserve for future
Los siguientes 3 bits son para el operando1 y los últimos 3 bits son para el operando2, por lo que los valores de los operandos oscilarán entre 0 y 7 en modo inmediato.
Para el modo directo, indirecto y de registro, necesitamos definir una array de memoria y una array de registro. Como solo tenemos 3 bits para representar las direcciones, el número máximo de elementos en estas arrays será 8.
memory=[2,15,40,25,7,36,64,19] register=[17,20,43,52,None,None,None,None]
Aquí, la memoria contiene 8 datos y el registro contiene 4 datos. El concepto discutido anteriormente funcionará de la siguiente manera:
Entrada: 01001000100
Aquí, de izquierda a derecha
Modo-01- Modo indirecto
Opcode-001- Suma
Operando1-000- 0
Operando2 – 100- 4
Como es el modo indirecto, estos operandos dan las direcciones de la dirección efectiva de los datos.
Significa que las direcciones efectivas están presentes en las ubicaciones de memoria 0 y 4, que son 2 y 7.
Y los datos reales están presentes en las ubicaciones de memoria 2 y 7, que son 40 y 19.
Entonces, el resultado será la suma de 40 y 19Salida: 59
Ejemplo:
Python
memory=[2,15,40,25,7,36,64,19]
register=[17,20,43,52,None,None,None,None]
#This function execute the instruction and print the result.
def execute(st):
mode=st[:2]
opcode=st[2:5]
operand1=st[5:8]
operand2=st[8:]
print()
print("Instruction mode:",mode)
print("Opcode:",opcode)
print("operand1:",operand1)
print("operand2:",operand2)
#For direct mode
if mode=='00':
idx1=int(operand1,2)
idx2=int(operand2,2)
if opcode=='000':
print("Do nothing")
elif opcode=='001':
print("RESULT")
print(memory[idx1]+memory[idx2])
elif opcode=='010':
print("RESULT")
print(memory[idx1]-memory[idx2])
elif opcode=='011':
print("RESULT")
print(memory[idx1]*memory[idx2])
elif opcode=='100':
print("RESULT")
print(memory[idx1]/memory[idx2])
elif opcode=='101':
print("RESULT")
print("operand1=:")
print(int(operand2,2))
else:
print("Reserve For Future")
#For indirect mode
elif mode=='01':
idx1=int(operand1,2)
idx2=int(operand2,2)
idx1=memory[idx1]
idx2=memory[idx2]
if opcode=='000':
print("Do nothing")
elif opcode=='001':
print("RESULT")
print(memory[idx1]+memory[idx2])
elif opcode=='010':
print("RESULT")
print(memory[idx1]-memory[idx2])
elif opcode=='011':
print("RESULT")
print(memory[idx1]*memory[idx2])
elif opcode=='100':
print("RESULT")
print(memory[idx1]/memory[idx2])
elif opcode=='101':
print("RESULT")
print("operand1=:")
print(int(operand2,2))
else:
print("Reserve For Future")
#For immediate mode
elif mode=='10':
idx1=int(operand1,2)
idx2=int(operand2,2)
if opcode=='000':
print("Do nothing")
elif opcode=='001':
print("RESULT")
print(idx1+idx2)
elif opcode=='010':
print("RESULT")
print(idx1-idx2)
elif opcode=='011':
print("RESULT")
print(idx1*idx2)
elif opcode=='100':
print("RESULT")
print(idx1/idx2)
elif opcode=='101':
print("RESULT")
print("operand1=:")
print(int(operand2,2))
else:
print("Reserve For Future")
#For register mode
else:
idx1=int(operand1,2)
idx2=int(operand2,2)
if idx1>3 or idx2>3:
print("Invalid")
exit()
if opcode=='000':
print("Do nothing")
elif opcode=='001':
print("RESULT")
print(register[idx1]+register[idx2])
elif opcode=='010':
print("RESULT")
print(register[idx1]-register[idx2])
elif opcode=='011':
print("RESULT")
print(register[idx1]*register[idx2])
elif opcode=='100':
print("RESULT")
print(register[idx1]/register[idx2])
elif opcode=='101':
print("RESULT")
print("operand1=:")
print(int(operand2,2))
else:
print("Reserve For Future")
#driver code
st="00001000001"
execute(st);
st="01001000100"
execute(st);
st="10001000001"
execute(st);
st="11001000001"
execute(st);
Producción:
Instruction mode: 00 Opcode: 001 operand1: 000 operand2: 001 RESULT 17 Instruction mode: 01 Opcode: 001 operand1: 000 operand2: 100 RESULT 59 Instruction mode: 10 Opcode: 001 operand1: 000 operand2: 001 RESULT 1 Instruction mode: 11 Opcode: 001 operand1: 000 operand2: 001 RESULT 37
Publicación traducida automáticamente
Artículo escrito por SUDIPTADANDAPAT y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA