Data processing vs instruction processing in processor [closed]

Quick note before I start answering this question, I'm going to be using a mips-like assembly language. In this language, R0 (or register 0) always has the value 0 in it, even if you try and store a different value in R0. For the sake of simplicity, all the other registers behave as you would expect them.

So essentially the idea is that you have an instruction which does something. Let's say, for example, you have ADD R1, R2, R3 What does this mean? Add the contents of register R2 to the contents of register R3 and store the resulting number in R1.

So in a slightly easier to read format:

ADD R1, R2, R3 is the same as R1 = R2 + R3

Makes sense? Good!

So what is in R1? Most of the time, you will do something to put a value or "data" into that register. For example:

ADDI R1, R0, 10 which is just R1 = R0 + 10 Since R0 is always 0, this will put the number "10" into the register R1.

Still following? So the number 10 in this case is called "immediate data". To see why requires a bit more explanation about how the instruction looks to the CPU.

So ADDI R1, R0, 10 when assembled will become 0x2001000A which is binary: 001000 00000 00001 0000000000001010

To make that a bit more sensible, the first 6 bits are the opcode: so 001000 == 0x08 == ADDI

The next 5 bits are where we store the what register we're reading from: so 00000 == 0x00 == R0

The next 5 bits are where we'll store the answer: so 00001 == 0x01 == R1

And the last 16 bits are the "immediate data": 0000000000001010 == 0x0A == 10

Let's compare this with the other instruction we were looking at: ADD R1, R2, R3

When assembled, it will look like this: 0x00430820 which is binary 000000 00010 00011 00001 00000 100000

Just like before, the first 6 bits are the opcode: 000000 == 0x00 == ADD

And just like before, we will red from the register defined by the next 5 bits: 00010 == 0x02 == R2

And we will read the second chunk of information from the register defined by the next 5 bits: 00011 == 0x03 == R3

And we will store it in the register defined by the next 5 bits: 00001 == 0x01 == R1

The remaining bits contain information which doesn't matter in this example!

So when the processor gets an instruction in mips, it will always grab 32 bits at a time. The ADDI came out as 0x2001000A which is exactly 32 bits, same as the ADD.

So the processor will take the information in those 32 bits, and use them as the instruction it executes. So, without doing any more work aside from fetching the 32bits of instruction, the "10" in our ADDI instruction is available to the processor. Since the processor doesn't have to do any more work, it is "immediately" available, and hence the name "immediate data".

But let's say we had a value stored in memory because say... a user typed in 346 using the keyboard. Clearly, that can't already be in the code as "immediate data", we have to get that data from somewhere else. So for these situations (and obviously many others) we have instructions which fetch data.

Take the code lw R1, 0x37 This will go to address 0x37 in memory, get the value stored there, and put it in R1. This data can then be used in ADD instructions, just like you would with the immediate.

I hope that explanation is helpful because I spent way too long writing it!