we have to assume that there is no stack pointer register, So first of all what it means is, we have to understand what is the use of stack pointer, so i think we know that stack pointer points the top element of the stack but now the problem is what is stack here, so stack is nothing but memory stack, we will use some part of main memory as a stack, along that we know that there is no fixed size of stack in real implementation but here in some questions of GATE they have been used as some 100-200 bytes.So in order to keep track of what is the thing we have to push or pop, we generally use stack pointer registers.
So basically the question comes in mind that why we use memory stack right!! whenever we call any subroutine in our main program, we have to store the current PC and save the starting address of subroutine and execute the subroutine and then return to our main program. So I mean we have to store the return address somewhere so that after finishing code of subroutine, i can continue my main program.
So in order to store the return address, there are various other mechanisms too like;
1. Temporary Register
2. Store the return address in the starting location of subroutine itself.
3. Fixed memory location (maybe at the starting location: 0000h)
4. Memory stack (It is the best one)
How stack pointer works in memory stack?? hope u are visualizing stack here
Suppose we are in the main program "A" and in the middle, there is some function has been done and we have to jump to the subroutine "B".So the first thing we need to do is, the instruction which is responsible for jumping to subroutine B,at that time when we fetch and decode that instruction, PC already got incremented, right!!!
PC<--- subroutine address ie; B
Execute the code of subroutine B
After finishing subroutine,
and by doing this we will get the return address means now we are in the normal mode of execution in our main program A.
This is how CALL instruction is implemented in general purpose processors.
Now coming back to this question;
A is False because we can implement CALL instruction via other mechanisms (like temporary register, storing address at fixed location etc..) but it is not efficient.
C is False because Interrupts can be possible in the same way as A option because interrupts also something that we have to execute the ISR and then come back to the normal flow of the program by storing a return address
D is False because all subroutines and interrupts are not possible because there are some subroutines which can be implemented without memory stack(or stack pointer register) like A is calling B and in this case we can store the PC in the temporary register and after finishing the code of B, I can come back to A and start executing with the help of temporary register.
But if we call like this, from A to call B and then in the subroutine B, we are calling to C(nested subroutine), here we cannot execute this type by the temporary register, here we need stack and stack pointers
option B is correct