4.1.1. Instruction: Procedure CALL/RETURN

So, as a pedagogical format so what we are going to study, what is the unit summary. So, basically as we have told that procedure is a self-contained computer program which is a part of a larger program. So, whenever a procedure is called basically it invokes a jump to the memory location or where the first instruction of the procedure is placed. So, it is some form of an unconditional jump. But sometimes you can also have a procedure whose call may be depending on some condition. In that case you have to call the procedure based on some conditional instruction. But in a very general sense we generally have an unconditional jump or unconditional call to the procedure.

In computer programming, a procedure (also known as a function or subroutine) is a self-contained block of code designed to perform a specific task. When we talk about invoking a procedure, it means transferring control from the current point in the program to the beginning of this procedure, hence the term 'jump.' Such jumps can either be unconditional, meaning they happen automatically, or conditional, meaning the jump only occurs if certain criteria are met.

Think of a procedure like a recipe in a cookbook. When you want to make a dish, you 'jump' to the specific recipe, which provides you with the steps to prepare it. If you decide to make the dish only if you have all the ingredients (conditional jump), that's like a conditional procedure call.

Then again as we are jumping to a new procedure, so we will be reusing all the temporal registers the accumulators, the program counter, program counter actually gets changed from the current programming location to the location of the first instruction of the procedure, but again when you want to return back you have to again come back to the point where I have left the main program... when you are calling a procedure. And when we are returning to the returning from the procedure all the values of the context like the value of the program counter, the value of the registers etcetera are fed back to the corresponding registers and the program and the program counter so that you gain the real context from what I have left in the main program and you can start re executing.

Whenever a procedure is invoked, the program counter (PC) – which keeps track of where the program currently is – is updated to point to the procedure’s starting address. Once the procedure completes its tasks, we need to return control back to where it was interrupted in the main program. For this, all relevant data, including the PC and register values, must be saved in a stack—a special memory area. Once we are ready to return, this saved data is retrieved from the stack to restore the previous state.

Consider a bookmark in a book. When you leave the book to do something else, you place your bookmark to remember where you left off. The process of saving your current spot in the book is like saving the context before a procedure is called, so you can return to that exact location once you're done with other tasks.

So, they are two very important concepts jump and before you jump you store everything like the return address, the program status word, the value of the registers etcetera or the temporary variables or the temporary context of the procedure or the main function which calls another procedure are saved in a stack. And when you have returned back after completing the called procedure you have to regain back the values and you can start executing.

When a procedure is called, the system saves not just where to return but also the current state of the program, including the program status word (PSW), which contains processor state information. This data is stored in a structure called a 'stack.' When the procedure completes execution and control returns to the calling function, the stored context is retrieved from the stack, allowing the main program to resume exactly where it left off.

Imagine a team passing around a baton in a relay race. Each runner has to remember their position and pace, which is like the context of a procedure. When the baton is passed (the procedure call), the current runner (the main program) saves all their details (what lap they're on, their speed) so they can pick up exactly where they left off after the baton is passed back (the procedure return).

Now, where is the stack implemented? So, the group of main memory is used to implement the stack that is very important you can save a particular part of the main memory to implement the stack ... there is a special stack pointer which will actually locate that where the top element of the stack is.

The stack is implemented in a designated area of the main memory. A special register called the stack pointer keeps track of the top of the stack, simplifying the process of pushing and popping data to and from the stack. This organization helps ensure that when procedures are called and return, the relevant data is easily accessible and manageable.

Think of the stack in computing like a stack of plates at a buffet. Each time you add a plate (push onto the stack), it goes on top. If you want to take one away (pop from the stack), you always take the top plate first. The stack pointer is like someone keeping an eye on the top plate, so you know exactly where to grab when you need one!

--