Part B: Programs Demonstrating Addressing Modes - 5.2 | Experiment No. 4: Introduction to 8086 Microprocessor - Architecture and Addressing Modes | Microcontroller Lab
K12 Students

Academics

AI-Powered learning for Grades 8–12, aligned with major Indian and international curricula.

Professionals

Professional Courses

Industry-relevant training in Business, Technology, and Design to help professionals and graduates upskill for real-world careers.

Games

Interactive Games

Fun, engaging games to boost memory, math fluency, typing speed, and English skills—perfect for learners of all ages.

Typing
Memory
Math
English Adventures
Knowledge

5.2 - Part B: Programs Demonstrating Addressing Modes

Practice

Interactive Audio Lesson

Listen to a student-teacher conversation explaining the topic in a relatable way.

Understanding Immediate Addressing Mode

Unlock Audio Lesson

Signup and Enroll to the course for listening the Audio Lesson

0:00
Teacher
Teacher

Today, we will explore the immediate addressing mode. What do you think happens when an operand is included directly in an instruction?

Student 1
Student 1

I think it means the processor can load data without any memory retrieval.

Teacher
Teacher

Exactly! For example, in the instruction `MOV AX, 1234H`, `1234H` is directly moved into the `AX` register without accessing memory. Can anyone explain why this is fast?

Student 2
Student 2

Because it reduces the number of steps needed to access the data?

Teacher
Teacher

Correct! This leads to efficient processing. A quick tip to remember this is 'D.I.R.E.C.T' - Direct Immediate Retrieval Ensures Constant Time.

Student 3
Student 3

So, this means immediate addressing is often used for initializing values?

Teacher
Teacher

Yes, that's a great observation! Remember, the more immediate values we use, the faster the execution!

Teacher
Teacher

To recap, immediate addressing allows direct data load, making it swift. Always consider its role in initialization.

Exploring Register Addressing Mode

Unlock Audio Lesson

Signup and Enroll to the course for listening the Audio Lesson

0:00
Teacher
Teacher

Let's dive into register addressing mode. Can anyone share what happens in an instruction like `MOV AX, BX`?

Student 4
Student 4

It copies the data from `BX` to `AX`.

Teacher
Teacher

Correct! This mode allows for fast data transfers and admits no memory access delays. Why do you think this is useful?

Student 1
Student 1

It's useful for performing operations quickly, like calculations.

Teacher
Teacher

Exactly! The register's speed is crucial. A memory aid to remember this might be 'R.A.C.E' - Registers Allow Constant Exchanges.

Student 2
Student 2

So, it’s all about speed and efficiency in operations!

Teacher
Teacher

Absolutely! What we see here is how register addressing underpins programming efficiency. To sum up, register addressing mode ensures speed by allowing direct data transfers between registers without delay.

Understanding Direct Addressing Mode

Unlock Audio Lesson

Signup and Enroll to the course for listening the Audio Lesson

0:00
Teacher
Teacher

Moving on, direct addressing mode utilizes specific memory locations for operand access. Can someone give an example?

Student 3
Student 3

Like `MOV AX, [1234H]` where it loads data from a defined location?

Teacher
Teacher

Exactly! This retrieves data directly from memory. Importantly, what are the benefits of direct addressing?

Student 4
Student 4

It allows access to global variables and fixed memory locations.

Teacher
Teacher

Right! Remember, for direct addressing, think 'G.L.O.B.A.L' - Globally Located Operands Bypass Assembly Logic.

Student 2
Student 2

So it's a simple way to access known data locations directly?

Teacher
Teacher

Precisely! In summary, direct addressing enables straightforward access to fixed locations, which is essential for structured programming.

Register Indirect Addressing Mode

Unlock Audio Lesson

Signup and Enroll to the course for listening the Audio Lesson

0:00
Teacher
Teacher

Now, let’s talk about register indirect addressing mode. How does it differ from direct addressing?

Student 1
Student 1

It uses a register to hold the memory address instead of a fixed address.

Teacher
Teacher

Correct! For example, `MOV AX, [BX]` retrieves data using whatever address `BX` points to. What advantages does this give us?

Student 3
Student 3

It allows for more dynamic memory access for arrays or lists!

Teacher
Teacher

Exactly! Use 'R.I.D.E' - Register Indirection Drives Efficient access, to help you remember this concept. Keep in mind that flexibility is key with register indirect addressing.

Student 4
Student 4

So, could we handle varying data structures more easily with this mode?

Teacher
Teacher

Absolutely! In conclusion, register indirect addressing enhances data access flexibility, especially useful for dynamic data structures.

Based and Indexed Addressing Modes

Unlock Audio Lesson

Signup and Enroll to the course for listening the Audio Lesson

0:00
Teacher
Teacher

Finally, let's explore based and indexed addressing modes. How do these combine elements for data access?

Student 2
Student 2

They allow for both a base address and an offset which can be useful in accessing structured data.

Teacher
Teacher

Exactly! An example would be `MOV AX, [BX + SI]`. What scenarios do you think would make this advantageous?

Student 1
Student 1

It’s great for accessing arrays or structures, especially when their sizes are variable!

Teacher
Teacher

Spot on! A good memory aid could be 'B.A.S.E' - Base Addresses Simplify Elements, ensuring you remember the concept. In summary, using both base and index allows for efficient data retrieval in flexible structures.

Introduction & Overview

Read a summary of the section's main ideas. Choose from Basic, Medium, or Detailed.

Quick Overview

This section focuses on introducing various addressing modes utilized in the 8086 microprocessor through practical assembly language programs.

Standard

The section outlines the significance of addressing modes in the 8086 architecture and provides a series of assembly code examples demonstrating how these modes facilitate data access. By exploring practical applications, students will observe the execution flow and impacts these addressing modes have on programming.

Detailed

Programs Demonstrating Addressing Modes

This section is dedicated to showcasing practical applications of different addressing modes within the 8086 microprocessor architecture. Addressing modes are crucial as they define how the CPU accesses data. The programs are not only essential for understanding basic functionality but also for demonstrating how each mode influences data retrieval and manipulation during the execution of assembly language programs.

Key Addressing Modes Covered

  1. Immediate Addressing Mode: Directly embeds the operand in the instruction. For example, MOV AX, 1234H loads a constant value directly into the accumulator.
  2. Register Addressing Mode: Involves accessing data from one of the CPU's internal registers, such as MOV AX, BX.
  3. Direct Addressing Mode: Uses direct offsets to retrieve values from memory locations, like MOV AX, [1234H].
  4. Register Indirect Addressing Mode: Accesses data stored in memory via an address held in a register, for example, MOV AX, [BX].
  5. Based Addressing Mode: Combines a base register's value with a displacement, optimizing data structure handling, such as in records.
  6. Indexed Addressing Mode: Utilizes an index register combined with a displacement to access elements in arrays.
  7. Based-Indexed Addressing Mode: Offers a combined approach using both a base register and an index register for maximum flexibility in data access.
  8. String Addressing Mode: Special instructions for string manipulation, leveraging implicit addressing for efficiency.

The document provides well-commented assembly code for each mode, along with observed results after execution, aimed at reinforcing learning through hands-on practice.

Audio Book

Dive deep into the subject with an immersive audiobook experience.

Overview of Addressing Modes

Unlock Audio Book

Signup and Enroll to the course for listening the Audio Book

For each addressing mode, write the assembly code, assemble/compile it, and execute it using the simulator/trainer kit. Observe the changes in registers and memory.

Detailed Explanation

This section introduces the practical aspect of the experiment where students will write assembly code for different addressing modes of the 8086 microprocessor. They will use either a simulator or a trainer kit to compile and run these programs. While executing the programs, students are encouraged to observe how the values in registers and memory change as a result of their code. This allows for a tangible understanding of how addressing modes function in practice.

Examples & Analogies

Think of this as conducting a science experiment in a lab where you mix chemicals. Just as the experiment requires you to observe color changes or reactions, here, you will observe how executing code results in changes to the register and memory states, helping you understand the effects of different addressing modes in real-time.

Immediate Addressing Mode

Unlock Audio Book

Signup and Enroll to the course for listening the Audio Book

Aim: Load immediate values into registers.

Assembly Code:

.MODEL SMALL
.STACK 100H
.DATA
; No data defined for this example as values are immediate
.CODE
MAIN PROC FAR
MOV AX, 4C00H ; Exit to DOS (standard termination for .COM/.EXE)
INT 21H
MOV AX, 1234H ; Load immediate word 1234H into AX
MOV BL, 56H ; Load immediate byte 56H into BL
MOV CX, 789AH ; Load immediate word 789AH into CX
HLT ; Halt instruction (or use standard exit)
MAIN ENDP
END MAIN

Execution & Observation:
- Set breakpoints after each MOV instruction or single-step.
- Observe AX register content becomes 1234H.

Detailed Explanation

In the immediate addressing mode, values are directly specified within the instruction code and do not require access to memory. For example, MOV AX, 1234H directly loads the constant value 1234H into the AX register. After executing the code, observers are encouraged to check the AX register value to confirm that it has correctly updated to 1234H as defined in the instruction. This manipulation occurs quickly, showcasing one of the simplest ways to input data into registers.

Examples & Analogies

Imagine you have a personal diary where you write down your goals directly. Writing Run 5 km every day is like using immediate addressing: the goal is clear, defined, and set in stone without needing to reference any other source. Similarly, in programming, the instruction specifies an immediate value that gets directly 'written' to a register.

Register Addressing Mode

Unlock Audio Book

Signup and Enroll to the course for listening the Audio Book

Aim: Transfer data between registers.

Assembly Code:

.MODEL SMALL
.STACK 100H
.DATA
.CODE
MAIN PROC FAR
MOV AX, 4C00H
INT 21H
MOV AX, 0001H ; Initialize AX with 0001H
MOV BX, 0002H ; Initialize BX with 0002H
MOV CX, AX ; Copy content of AX to CX (CX becomes 0001H)
ADD DX, BX ; Add content of BX to DX (DX = DX + 0002H)
HLT
MAIN ENDP
END MAIN

Execution & Observation:
- After MOV CX, AX, observe CX becomes 0001H.

Detailed Explanation

In register addressing mode, the instruction operates using registers to transfer data. For instance, after initializing AX and BX, the command MOV CX, AX copies the value from AX into CX. This mode leverages the speed of register operations without needing memory access, making it efficient for internal calculations or temporary storage. Subsequently, an ADD operation combines values in DX and BX, further demonstrating how data manipulations are handled entirely within registers.

Examples & Analogies

Think of this as passing notes between friends in class. If you write down your math answers on a piece of paper (which represents a register), passing that paper to a friend means they instantly see your answers (like copying AX to CX). The more you can keep the information on paper rather than going back to the textbook (memory), the faster the sharing and calculations can happen.

Direct Addressing Mode

Unlock Audio Book

Signup and Enroll to the course for listening the Audio Book

Aim: Access data from a specific memory location using its direct offset.

Assembly Code:

.MODEL SMALL
.STACK 100H
.DATA
MY_VAR WORD 1234H ; Define a word variable initialized with 1234H
MY_BYTE BYTE 56H ; Define a byte variable initialized with 56H
.CODE
MAIN PROC FAR
MOV AX, 4C00H
INT 21H
MOV AX, @DATA ; Load segment address of data segment into AX
MOV DS, AX ; Initialize DS with the data segment address
MOV BX, MY_VAR ; Load content of MY_VAR (1234H) into BX
; Equivalent to MOV BX, [OFFSET MY_VAR]
MOV CL, MY_BYTE ; Load content of MY_BYTE (56H) into CL
; Equivalent to MOV CL, [OFFSET MY_BYTE]
HLT
MAIN ENDP
END MAIN

Execution & Observation:
- After MOV BX, MY_VAR, observe BX becomes 1234H.

Detailed Explanation

In direct addressing mode, the effective address of the operand is directly specified in the instruction. By executing MOV BX, MY_VAR, the program directly accesses MY_VAR in memory. This essentially translates to MOV BX, [OFFSET MY_VAR], which retrieves the value stored at that address in the data segment. Observing the value in BX after executing this instruction confirms the correct data was accessed from the memory location.

Examples & Analogies

Consider this like obtaining a specific book from a library. If you say, 'Please give me the book titled The Great Gatsby,' that title corresponds directly to a specific location in the library. When you go directly to that book, you are utilizing its exact address, similar to how direct addressing accesses a known memory location in computing.

Register Indirect Addressing Mode

Unlock Audio Book

Signup and Enroll to the course for listening the Audio Book

Aim: Access data using the address stored in a register.

Assembly Code:

.MODEL SMALL
.STACK 100H
.DATA
MY_ARRAY WORD 10H, 20H, 30H ; Define an array of words
.CODE
MAIN PROC FAR
MOV AX, 4C00H
INT 21H
MOV AX, @DATA
MOV DS, AX ; Initialize DS
MOV BX, OFFSET MY_ARRAY ; Load the offset address of MY_ARRAY into BX
MOV AX, [BX] ; Load word from DS:BX (10H) into AX
INC BX ; Increment BX by 1 (points to next byte)
INC BX ; Increment BX by 1 (points to next word)
MOV CX, [BX] ; Load word from DS:BX (20H) into CX
HLT
MAIN ENDP
END MAIN

Execution & Observation:
- After MOV BX, OFFSET MY_ARRAY, observe BX holds the offset of MY_ARRAY.

Detailed Explanation

Using register indirect addressing mode, the address of the data is stored in a register (in this case, BX). Commands like MOV AX, [BX] take the value located at the memory address held by BX and load it into AX. After executing this instruction, you can increment BX to access the next elements in the array without needing to know their absolute addresses; this method allows for dynamic data manipulation, particularly useful in loops or collections of data.

Examples & Analogies

Imagine you have a drawer filled with files representing different documents (data). Instead of memorizing the exact location of each document, you simply remember that one particular file is in the second drawer (register). When you retrieve document1 from the second drawer, it's as simple as saying ‘Get document1 from my drawer,’ much like accessing the data at the address pointed to by a register.

Based Addressing Mode

Unlock Audio Book

Signup and Enroll to the course for listening the Audio Book

Aim: Access data using a base register (BX/BP) plus a displacement.

Assembly Code:

.MODEL SMALL
.STACK 100H
.DATA
MY_RECORD LABEL WORD
FIELD1 WORD 1111H
FIELD2 WORD 2222H
FIELD3 BYTE 33H
.CODE
MAIN PROC FAR
MOV AX, 4C00H
INT 21H
MOV AX, @DATA
MOV DS, AX ; Initialize DS
MOV BX, OFFSET MY_RECORD ; BX points to the start of MY_RECORD
MOV AX, [BX + 0] ; Load FIELD1 (1111H) into AX (displacement 0)
MOV DX, [BX + 2] ; Load FIELD2 (2222H) into DX (displacement 2 bytes from start)
MOV CL, [BX + 4] ; Load FIELD3 (33H) into CL (displacement 4 bytes from start)
HLT
MAIN ENDP
END MAIN

Execution & Observation:
- After MOV AX, [BX + 0], observe AX becomes 1111H.

Detailed Explanation

In based addressing mode, you access data using a base register (such as BX) with an added offset. This mode is useful when dealing with structured data like records. For instance, using MOV AX, [BX + 0] accesses FIELD1 directly, while MOV DX, [BX + 2] points two bytes ahead to access FIELD2. This approach provides a flexible way to navigate through related data fields without hardcoding addresses, allowing for more dynamic programming techniques.

Examples & Analogies

Imagine living in an apartment building where each unit has a different number: Apartment 1 might be your friend’s place, Apartment 2 another, and so on. If you say ‘I want to go to Apartment 1,’ it’s clear where you head (0 offset). But if you tell someone to go to Apartment 1 plus 2 (which means go forward to Apartment 3), they know to add to the apartment number. Similarly, based addressing lets programmers calculate locations based on known offsets.

Indexed Addressing Mode

Unlock Audio Book

Signup and Enroll to the course for listening the Audio Book

Aim: Access data using an index register (SI/DI) plus a displacement.

Assembly Code:

.MODEL SMALL
.STACK 100H
.DATA
GRADE_ARRAY BYTE 90, 85, 70, 95, 60
.CODE
MAIN PROC FAR
MOV AX, 4C00H
INT 21H
MOV AX, @DATA
MOV DS, AX ; Initialize DS
MOV SI, 0 ; SI points to the first element (offset 0)
MOV AL, GRADE_ARRAY[SI + 0] ; Load 90 into AL (direct indexed)
MOV BL, [SI + 1] ; Load 85 into BL (offset 1 from base address)
MOV CL, [SI + 3] ; Load 95 into CL (offset 3 from base address)
HLT
MAIN ENDP
END MAIN

Execution & Observation:
- After MOV AL, GRADE_ARRAY[SI + 0], observe AL becomes 90H.

Detailed Explanation

In indexed addressing mode, you access an operand by adding a displacement to the value in an index register (like SI). For instance, MOV AL, GRADE_ARRAY[SI + 0] points directly to the first element in the GRADE_ARRAY. This mode is particularly advantageous for iterating through arrays, as you can increment SI to navigate through elements sequentially with ease.

Examples & Analogies

Think of it like counting apples in a grocery store where the arrangement of the apples is so that the first apple is marked as ‘0’. If you want apple number 2, you look for 0 + 2. Each apple's position is like an index that you can use to easily find any fruit in line, making your searching efficient.

Based-Indexed Addressing Mode

Unlock Audio Book

Signup and Enroll to the course for listening the Audio Book

Aim: Access data using a base register (BX/BP) and an index register (SI/DI), with an optional displacement.

Assembly Code:

.MODEL SMALL
.STACK 100H
.DATA
MATRIX LABEL WORD ; Represents a 2x3 matrix of words
ROW1 DW 10H, 20H, 30H
ROW2 DW 40H, 50H, 60H
.CODE
MAIN PROC FAR
MOV AX, 4C00H
INT 21H
MOV AX, @DATA
MOV DS,AX ; Initialize DS
MOV BX, OFFSET MATRIX ; BX points to the start of the matrix (e.g., ROW1)
MOV SI, 2 * 2 ; SI = 4 (offset to the start of ROW2 if each word is 2 bytes and row 1 has 2 words)
MOV DI, 2 ; DI represents the offset to the 2nd element within a row (1 word * 2 bytes/word = 2 bytes)
MOV AX, [BX + SI + DI] ; Access element at MATRIX[ROW2_OFFSET + ELEMENT_OFFSET]
HLT
MAIN ENDP
END MAIN

Execution & Observation:
- After MOV AX, [BX + SI + DI], observe AX becomes 0050H.

Detailed Explanation

In based-indexed addressing mode, a combination of a base register and an index register, along with a potential displacement, allows for highly flexible data access patterns. For example, if you're accessing an element in a 2D array (like a matrix), the base register might point to the beginning of the matrix while the index calculates the row and column. This powerful method accommodates complex data structures while enabling adjustments to indices easily.

Examples & Analogies

Imagine organizing your school books in stacks based on subjects, with each subject having its own shelf. If you want a book on math from the second math shelf, the base is the subject shelf (math), and you decide how many shelves to move based on your class level. The method allows you to access any book systematically just like addressing aids in locating data within arrays or matrices.

String Addressing Mode

Unlock Audio Book

Signup and Enroll to the course for listening the Audio Book

Aim: Demonstrate basic string operation with implicit addressing.

Assembly Code:

.MODEL SMALL
.STACK 100H
.DATA
SOURCE_STR DB 'HELLO', 0 ; Source string, null-terminated
DEST_STR DB 10 DUP(?) ; Destination buffer
.CODE
MAIN PROC FAR
MOV AX, 4C00H
INT 21H
MOV AX, @DATA
MOV DS, AX ; Initialize DS
MOV ES, AX ; Initialize ES (for destination)
MOV SI, OFFSET SOURCE_STR ; SI points to source string
MOV DI, OFFSET DEST_STR ; DI points to destination string
CLD ; Clear Direction Flag (DF=0, auto-increment SI, DI)
MOV CX, 6 ; Number of bytes to move (5 letters + null terminator)
REP MOVSB ; Repeat Move String Byte until CX is zero
HLT
MAIN ENDP
END MAIN

Execution & Observation:
- Before REP MOVSB, observe content of DEST_STR (random).

Detailed Explanation

In string addressing mode, the movement of strings into and out of memory is handled automatically through implicit addressing of source and destination registers (SI and DI). Using REP MOVSB, the program moves a specified number of bytes from the source to the destination automatically using the string registers. The advantage of this mode is the efficiency it provides for bulk operations on strings without hard-coding each character's address.

Examples & Analogies

Imagine an assembly line in a factory where workers (the processor) are assigned to move products from one place to another. Instead of each worker asking for directions on how to move every single product, they have a clear line of assembly that indicates the starting point and endpoint, allowing for a fast and orderly process just like how the string addressing mode efficiently moves segments of data.

Definitions & Key Concepts

Learn essential terms and foundational ideas that form the basis of the topic.

Key Concepts

  • Immediate Addressing: Efficient for direct loading of constants.

  • Register Addressing: Facilitates quick data transfers between registers.

  • Direct Addressing: Accesses specified memory locations directly.

  • Register Indirect Addressing: Allows for more dynamic data accesses via registers.

  • Based Addressing: Combines base registers with offsets for structured data.

  • Indexed Addressing: Optimizes access to arrays and lists.

  • String Addressing: Special modes for string manipulation ensuring efficiency.

Examples & Real-Life Applications

See how the concepts apply in real-world scenarios to understand their practical implications.

Examples

  • Using immediate addressing in an instruction: MOV AX, 1A3H loads 1A3H directly into AX.

  • In register addressing MOV BX, AX, transfers the value in AX to BX without any memory overhead.

  • Direct addressing example: MOV AX, [0040H] directly references memory location 0040H.

Memory Aids

Use mnemonics, acronyms, or visual cues to help remember key information more easily.

🎵 Rhymes Time

  • Immediate addressing is so neat,

📖 Fascinating Stories

  • Imagine a programmer, John, who needed a constant value right away. He simply wrote MOV AX, 15 in his code, and boom! The value was loaded directly - this is the magic of immediate addressing.

🧠 Other Memory Gems

  • Remember 'R.A.C.E' for Register Addressing: Registers Allow Constant Exchanges.

🎯 Super Acronyms

In Direct Addressing, 'G.L.O.B.A.L' helps you remember

  • Globally Located Operands Bypass Assembly Logic.

Flash Cards

Review key concepts with flashcards.

Glossary of Terms

Review the Definitions for terms.

  • Term: Addressing Mode

    Definition:

    A method used by a CPU to access data stored in memory.

  • Term: Immediate Addressing Mode

    Definition:

    An addressing mode where the operand is a constant value embedded within the instruction.

  • Term: Register Addressing Mode

    Definition:

    An addressing mode that uses registers to access operands.

  • Term: Direct Addressing Mode

    Definition:

    An addressing mode in which the effective address of the operand is explicitly specified in the instruction.

  • Term: Register Indirect Addressing Mode

    Definition:

    An addressing mode where the address of the operand is held in a register.

  • Term: Based Addressing Mode

    Definition:

    An addressing mode that calculates the effective address by adding a displacement to the contents of a base register.

  • Term: Indexed Addressing Mode

    Definition:

    An addressing mode that calculates the effective address by adding an index register's contents to a displacement.

  • Term: BasedIndexed Addressing Mode

    Definition:

    An addressing mode that combines the features of both base and indexed addressing modes.

  • Term: String Addressing Mode

    Definition:

    An addressing mode used for efficiently handling string operations with implicit address handling.