---
title: "Symbolic microprogram for fetch and add routines"
subject: "Computer Organization and Architecture"
chapter: 3
key: "semester_5/computer_organization_and_architecture:microprogram-fetch-add"
source: https://www.bctengineer.com/q/semester_5/computer_organization_and_architecture/microprogram-fetch-add
site: BCT Engineering
---

# Symbolic microprogram for fetch and add routines

Computer Organization and Architecture · Chapter 3: Control Unit

- Asked in: 2078 Kartik, 4 marks
- Video: [Design of Control Unit || Microprogrammed Control || Computer Organization Architecture](https://www.youtube.com/watch?v=n2bC_Rh1YIA) — Sudhakar Atchala
- Answer checked by Claude Opus 5.5 (high effort) on 2026-10-14
- Page: https://www.bctengineer.com/q/semester_5/computer_organization_and_architecture/microprogram-fetch-add
- Whole chapter: https://www.bctengineer.com/md/semester_5/computer_organization_and_architecture/chapter-3

## Question

Write down the symbolic microprogram for fetch routine and addition execute routine.

## Short answer

Fetch: AR←PC; DR←M[AR]&PC←PC+1; AR←DR(addr)&MAP. ADD: if I=1 CALL INDRCT; DR←M[AR]; AC←AC+DR&JMP FETCH. Indirect subroutine (INDRCT): DR←M[AR]; AR←DR(addr)&RET.

## Answer

A microprogram is written in symbolic form using the microinstruction fields (microoperations, condition CD, branch BR and address AD). The fetch routine starts at address 64 and the ADD routine at 0. Notation: AR = address register, DR = data register, PC = program counter.

```text
        ORG 0
ADD:    NOP              I  CALL  INDRCT   ; handle indirect address
        READ             U  JMP   NEXT     ; DR <- M[AR]
        ADD              U  JMP   FETCH    ; AC <- AC + DR

        ORG 64
FETCH:  PCTAR            U  JMP   NEXT     ; AR <- PC
        READ, INCPC      U  JMP   NEXT     ; DR <- M[AR], PC <- PC + 1
        DRTAR            U  MAP            ; AR <- DR(0-10), go to routine
INDRCT: READ             U  JMP   NEXT     ; DR <- M[AR]
        DRTAR            U  RET            ; AR <- DR(0-10), return
```
Fetch needs three microinstructions. The ADD routine executes three microinstructions; if the instruction is indirect, the CALL to INDRCT adds two more (READ and DRTAR of the indirect routine), making five. It then jumps back to FETCH.

## Check yourself

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

1. How many microinstructions in fetch?
   A. 3
   B. 2
   C. 4
   D. 5
   Answer: A. PCTAR; READ,INCPC; DRTAR with MAP. (Key point: Fetch length)

2. How does fetch end?
   A. READ U RET
   B. DRTAR U MAP
   C. ADD U JMP FETCH
   D. NOP I CALL
   Answer: B. MAP goes to opcode routine. (Key point: Fetch end)

3. What is ADD's final microinstruction?
   A. DRTAR U RET
   B. PCTAR U MAP
   C. ADD U JMP FETCH
   D. READ U CALL
   Answer: C. AC<-AC+DR then fetch next. (Key point: ADD routine)

4. How does INDRCT return?
   A. MAP
   B. JMP FETCH
   C. CALL
   D. DRTAR U RET
   Answer: D. RET loads SBR to CAR. (Key point: INDRCT end)

## Related in Computer Organization and Architecture

- [Microinstruction format and fetch microprogram](https://www.bctengineer.com/question.md?key=semester_5%2Fcomputer_organization_and_architecture%3Amicroinstr-format-fetch) — Computer Organization and Architecture, chapter 3, asked 2×
- [Microinstruction format and microprogram design](https://www.bctengineer.com/question.md?key=semester_5%2Fcomputer_organization_and_architecture%3Amicroprogram-fetch-indirect-add) — Computer Organization and Architecture, chapter 3

## Related in other subjects

- [8255A at B0H: add port A and B, show on port C](https://www.bctengineer.com/question.md?key=semester_5%2Finstrumentation_ii%3Appi-b0h-addition) — Instrumentation II, chapter 2
- [Matrix addition by overloading +](https://www.bctengineer.com/question.md?key=semester_3%2Fobject_oriented_programming%3Amatrix-add-overload) — Object Oriented Programming, chapter 5
- [Polynomial representation and addition algorithm](https://www.bctengineer.com/question.md?key=semester_4%2Fdata_structure_and_algorithm%3Apolynomial-representation-addition-algorithm) — Data Structure and Algorithm, chapter 4