---
title: "Compare CALL/RET with PUSH/POP"
subject: "Microprocessor"
chapter: 2
key: "semester_4/microprocessor:call-ret-vs-push-pop"
source: https://www.bctengineer.com/q/semester_4/microprocessor/call-ret-vs-push-pop
site: BCT Engineering
---

# Compare CALL/RET with PUSH/POP

Microprocessor · Chapter 2: Programming with 8085 Microprocessor

- Asked in: 2069 Bhadra, 4+4 marks
- Video: [CALL and RET Instructions in 8085 Microprocessor Explained with Example in Hindi](https://www.youtube.com/watch?v=zCCTJzblFq8) — 5 Minutes Engineering
- Answer checked by Claude Opus 5.5 (high effort) on 2026-10-14
- Page: https://www.bctengineer.com/q/semester_4/microprocessor/call-ret-vs-push-pop
- Whole chapter: https://www.bctengineer.com/md/semester_4/microprocessor/chapter-2

## Question

Compare CALL and RET instructions with PUSH and POP instructions for 8085. Illustrate their usages with appropriate examples.

## Short answer

CALL/RET transfer control by pushing/popping the return address to/from the stack; PUSH/POP only save/restore register pair data. CALL is 3 bytes/18 T-states, RET 1 byte/10 T-states; PUSH and POP are 1 byte, 12 and 10 T-states.

## Answer

Both pairs use the stack (LIFO area in RAM pointed to by SP), but CALL/RET transfer program control and save/restore the return address, while PUSH/POP only save/restore data.

| Point | CALL / RET | PUSH / POP |
|---|---|---|
| Purpose | Go to a subroutine and come back | Save and restore register pair contents |
| Data stored | Return address (PC) | Contents of BC, DE, HL or PSW (A + flags) |
| Effect on PC | CALL loads PC with the subroutine address; RET loads PC from the stack | PC only advances normally |
| Instruction length | CALL 3 bytes, RET 1 byte | 1 byte each |
| T-states | CALL 18 (conditional 18/9), RET 10 | PUSH 12, POP 10 |
| SP change | CALL: SP-2, RET: SP+2 | PUSH: SP-2, POP: SP+2 |
| Who does the saving | Done automatically by CPU | Done by programmer explicitly |
| Pairing | Every CALL needs a RET | Every PUSH needs a matching POP in reverse order |

#### Illustration
Delay subroutine that must keep the caller's BC:

```asm
        LXI SP,27FFH    ; initialise stack
        MVI B,05H
        CALL DELAY      ; return address (next instruction) -> stack
        MOV A,B         ; B is still 05H
        HLT
DELAY:  PUSH B          ; save BC
        LXI B,0FFFFH
LP:     DCX B
        MOV A,B
        ORA C
        JNZ LP
        POP B           ; restore BC
        RET             ; PC <- return address from stack
```

- `CALL DELAY`: PC (address of `MOV A,B`) is pushed, SP = 27FDH, PC = address of DELAY.
- `PUSH B`: B and C go to the stack, SP = 27FBH.
- `POP B`: B and C come back, SP = 27FDH.
- `RET`: return address popped to PC, SP = 27FFH, execution continues at `MOV A,B`.

Note the order: the last item pushed must be the first popped, otherwise RET gets a wrong address.

## Check yourself

The answer's key points as multiple-choice questions, with the correct option and why.

1. What is the main difference between CALL/RET and PUSH/POP?
   A. CALL/RET use the stack but PUSH/POP use general purpose registers
   B. CALL/RET change program flow and save/restore the return address; PUSH/POP only save/restore register pair data
   C. PUSH/POP change the PC, but CALL/RET do not
   D. CALL/RET increase SP and PUSH/POP decrease it
   Answer: B. Both pairs use the stack. CALL saves the return address and jumps, RET loads it back into PC, while PUSH/POP only store and restore register pair contents. (Key point: CALL/RET transfer control and save the return address; PUSH/POP save data only)

2. SP = 27FFH and the program executes CALL DELAY. What is SP after the CALL?
   A. 27FFH
   B. 2800H
   C. 2801H
   D. 27FDH
   Answer: D. CALL pushes the 2-byte return address onto the stack, so SP decreases by 2, from 27FFH to 27FDH. (Key point: CALL pushes PC (2 bytes): SP decreases by 2)

3. What does PUSH PSW save on the stack?
   A. The accumulator and the flag register
   B. The program counter
   C. The stack pointer
   D. The HL pair
   Answer: A. PSW (program status word) is the accumulator plus the flags, so PUSH PSW saves A and the flags as a pair. (Key point: PUSH PSW saves A and the flags)

4. A subroutine does PUSH B at the start but forgets POP B before RET. What happens?
   A. Nothing; RET always finds the return address, whatever was pushed
   B. The CPU halts with an error
   C. RET pops the saved BC contents into PC, so the program returns to a wrong address
   D. BC is restored automatically by RET
   Answer: C. The stack is LIFO, so the top now holds BC, not the return address. RET loads BC into PC and jumps to the wrong place. (Key point: Unmatched PUSH/POP makes RET pop a wrong address)

## Related in Microprocessor

- [PC and SP in CALL, RET, PUSH, POP](https://www.bctengineer.com/question.md?key=semester_4%2Fmicroprocessor%3Apc-sp-call-ret-push-pop) — Microprocessor, chapter 2
- [Classification of 8085 instructions](https://www.bctengineer.com/question.md?key=semester_4%2Fmicroprocessor%3A8085-instruction-classification) — Microprocessor, chapter 2
- [RST instructions in 8085](https://www.bctengineer.com/question.md?key=semester_4%2Fmicroprocessor%3Arst-instructions) — Microprocessor, chapter 2

## Related in other subjects

- [Push and pop on stack as linked list](https://www.bctengineer.com/question.md?key=semester_4%2Fdata_structure_and_algorithm%3Astack-push-pop-linked-list) — Data Structure and Algorithm, chapter 4
- [IRQ, ISR, IVT, PUSH, POP, latency](https://www.bctengineer.com/question.md?key=semester_6%2Fembedded_system%3Ainterrupt-terms-irq-isr-ivt) — Embedded System, chapter 5