17.4.3. Return from Function

We have also seen that when we were discussing about some kind of a subroutine call when we were looking at interrupts. So, every time we have seen that before we jump to a function or a sub interrupt subroutine service. So, what we do we save the value of the program counter we save the value of all the intermediate registers and all this stuff which we are doing in one function was temporary scratchpad or temporary memory, go and service the interrupt go or finish the procedure and again come back and again pick up all the values of the temporary registers which we have saved and start executing.

In programming, when a function (or subroutine) is called, we need to remember where we came from in case we want to return later. This is done by saving the current position of the program counter (PC), which points to the next instruction to execute. Along with the PC, intermediate register values may also be saved temporarily, allowing the program to pause and switch to executing a different task, such as handling an interrupt. After the new task is completed, we can return to the original task using the saved PC to resume execution from where it left off.

Imagine you're reading a book and your friend calls you. To answer the call, you place a bookmark at your current page so you can easily return after the call. When you're done talking, you pick up the book and resume reading from where you left off, thanks to the bookmark. In programming, the process is similar: we use the program counter as the bookmark to return to our place in the code.

First very important is that we save the PC. We save the PC because when we will come back, we have to have to read out the value of the program counter and start executing from there. So, we have to always save the value of the PC in a stack.

When calling a function, it's crucial to save the current program counter (PC) value to a stack. This stack is a data structure where we can store temporary data. By saving the PC to the stack, we can remember where to return after the function executes. The program counter indicates what instruction follows the function call, so by saving it, we are prepared to continue executing the main program once the function is completed.

Consider a chef in the kitchen who’s cooking several dishes at once. If the chef needs to step away to help a guest, they write down their current position in the recipe book – the next step they were going to take. This way, when they finish helping the guest, they can return to the recipe and pick up right where they left, ensuring no steps are missed. The stack functions similarly for a program, keeping track of where to continue after a function call.

For example, call is that we are calling function 1 and function 1 memory let us say that 3200, that means what we are calling the call 3200. 3200 memory location actually have the first instruction of that function. So, our job is to jump to 3200, but before that that means, you have to load the value of program counter to 3200, but before that it is very important maybe you are at program counter is maybe at 30. So, at 30 memory location 30 if you are calling it as memory location 30, memory location number 30 is having the function call that will jump to 3200.

When a function is called, the program needs to transition to a different part of the code. For instance, if we want to call a function located at memory address 3200, we first need to save the current position of the program counter (let's say it’s currently at address 30), which points to the next instruction after the call. This is done before jumping to the function address (3200) to ensure that we can return to continue processing after the function completes.

Think of it as if you're watching a movie but need to take a quick break for a phone call. Before you step away, you pause the movie (which acts like saving your current position). Later, when you return, you know exactly where to start watching again, ensuring you don’t miss any important scenes. In programming, this ensures the application runs smoothly by knowing where to return after the function call.

Now, already we know that when we are executing microinstruction number three, program counter has been incremented equal to program counter plus constant. So, this has to be stored in a stack. So, what we are doing. So, basically program counter that is fourth stage PC that is the after that value of program counter we are putting it in memory data register that is simple, because whatever you want to write it to the memory we have to put it into the memory data register.

After deciding to call a function, the program counter (PC) is updated to point to the new function's first instruction. However, before jumping to this new function, we first need to save the updated PC – the address of the next instruction after the function call – into the memory data register. This ensures that we can later push this updated address onto the stack for future retrieval when we return.

Imagine a student who's been assigned to a group project. Before starting work on the project, the student notes down where they left off in their individual study (the updated PC). This note goes into their pocket so they can easily retrieve it later after they finish their group work. The memory data register acts like that pocket, temporarily holding their 'note' until they can store it in a safer place (the stack).

Now, once it is done, of course, the value of the program counter will be saved into the PC. So, this stage SP out, memory data register in, address register in means the program count stack pointer value will be saved to the memory address register, and there we will be saving the value of the program counter as simple as that.

After saving the program counter value onto the stack, we can now safely update the PC to the function we are calling, which is memory address 3200. This is a crucial step because it signifies the program’s transition to execute the function. The stack pointer (SP), which tracks where the last saved PC is in the stack, directs the program on where to write this PC value before executing the function.

Consider an actor in a play who must memorize their next line before entering the stage. They take a peek at their cue card (the stack), noting where they left off, before stepping onto the stage (the function call). Entering the stage means they're now performing the next act, fully aware of where they can return later thanks to their preparations.

Return is as important as call. So, basically we will say return. In this case, but return will not specify basically any address, but where it will go basically let this be the stack, stack will be pointing to some address, some content may be say 11, because we say jump from memory location 10. So, we will say return.

The return operation is crucial as it completes the function call. When the function execution ends, it doesn't specify a new address for the next instruction – instead, it refers back to the value saved in the stack. This saved value reflects the previous address, which is where the program will continue its execution once the function has finished.

Returning from a function can be likened to finishing a phone call and resuming your movie. After hanging up, you pick up the remote and press play, continuing exactly where you last stopped without having to search for that point. The stack provides the necessary reference for the program to resume after completing the function call.

--