GeeksforGeeks App
Open App
Browser
Continue

# How to execute a 11-digit instruction using different addressing modes in Python?

Here, we have an 11 bit instruction which has first 2 bits for representing addressing mode, next 3 bits for the opcode and the last 6 bits are for the two operands, 3 bits each.

We will execute this 11 bit Instruction using four different addressing modes:-

1. Direct mode: In this mode, the addresses of two operands are specified in the instruction. We can receive the actual data directly from the memory addresses.
2. Indirect mode: In this mode, the addresses mentioned in the instruction are point to the effective addresses of the operands.
3. Immediate mode: In this mode, the actual data is mentioned in the instruction itself.
4. Register mode: In this mode, the instruction contains the addresses of the registers which contain the actual data.

We will use the first 2 bits for representing the four different addressing modes in this way:

```For direct mode- 00
For indirect mode- 01
For immediate mode- 10
For register mode- 11
```

Next 3 bits are for representing opcode, so we can use 8 different operations maximum. We will define 6 operations and the other two will be reserve for future in this way:

```000- Do nothing
010- Subtraction
011- Multiplication
100-Division
101-Transfer operand2 to operand1
110-Reserve for future
111-Reserve for future
```

The next 3 bits are for operand1 and the last 3 bits are for operand2, so the values of operands will be ranging from 0 to 7 in immediate mode.
For the direct, indirect and register mode we need to define a memory array and a register array. As we have only 3 bits for representing the addresses so the maximum number of elements in these arrays will be 8.

```memory=[2,15,40,25,7,36,64,19]
register=[17,20,43,52,None,None,None,None]
```

Here, the memory contains 8 data and the register contain 4 data. The concept discussed above will work in the following way:

Input: 01001000100

Here, from left to right
Mode-01- Indirect mode
Operand1-000- 0
Operand2 – 100- 4
As it is the indirect mode, so these operands gives the addresses of the effective address of the data.
Means, the effective addresses are present in the memory location 0 and 4 , which are 2 and 7.
And the actual data is present in the memory location 2 and 7 which are 40 and 19.
So, the result will be the addition of 40 and 19.

Output: 59

Example:

## 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);`

Output:

```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
```

My Personal Notes arrow_drop_up