The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Loops and Iteration

Next ►
►

In this section, we will explore how to implement loops and iteration in Assembly language. Loops are fundamental constructs in programming that allow you to execute a block of code multiple times. Understanding how to create and control loops in Assembly is crucial for writing efficient and effective programs.

Key Concepts

  1. Loop Types:

    • Count-Controlled Loops: Execute a set number of times.
    • Condition-Controlled Loops: Continue executing as long as a condition is true.

  2. Loop Instructions:

    • JMP (Jump): Unconditional jump to a specified address.
    • LOOP: Decrement the counter and jump if the counter is not zero.
    • Conditional Jumps: JZ (Jump if Zero), JNZ (Jump if Not Zero), etc.

  3. Registers:

    • CX/ECX/RCX: Commonly used as a counter in loops.

Basic Loop Structure

Count-Controlled Loop

A count-controlled loop executes a specific number of times. Here’s a simple example using the LOOP instruction:

section .data
    msg db 'Hello, World!', 0

section .bss

section .text
    global _start

_start:
    mov ecx, 5          ; Set loop counter to 5

loop_start:
    ; Code to execute in the loop
    ; For example, printing a message
    mov eax, 4          ; sys_write
    mov ebx, 1          ; file descriptor (stdout)
    mov edx, 13         ; message length
    lea ecx, [msg]      ; load address of msg
    int 0x80            ; call kernel

    loop loop_start     ; Decrement ECX and jump if ECX != 0

    ; Exit the program
    mov eax, 1          ; sys_exit
    xor ebx, ebx        ; exit code 0
    int 0x80            ; call kernel

Condition-Controlled Loop

A condition-controlled loop continues executing as long as a condition is true. Here’s an example using JNZ (Jump if Not Zero):

section .data
    msg db 'Counting down: ', 0

section .bss

section .text
    global _start

_start:
    mov ecx, 5          ; Set initial value

loop_start:
    ; Code to execute in the loop
    ; For example, printing a message
    mov eax, 4          ; sys_write
    mov ebx, 1          ; file descriptor (stdout)
    mov edx, 15         ; message length
    lea ecx, [msg]      ; load address of msg
    int 0x80            ; call kernel

    dec ecx             ; Decrement ECX
    jnz loop_start      ; Jump to loop_start if ECX != 0

    ; Exit the program
    mov eax, 1          ; sys_exit
    xor ebx, ebx        ; exit code 0
    int 0x80            ; call kernel

Practical Exercise

Exercise 1: Sum of First N Natural Numbers

Write an Assembly program to calculate the sum of the first N natural numbers using a loop.

Solution

section .data
    sum db 0            ; Variable to store the sum

section .bss

section .text
    global _start

_start:
    mov ecx, 10         ; Set N to 10
    xor eax, eax        ; Clear EAX (sum)

loop_start:
    add eax, ecx        ; Add ECX to EAX
    dec ecx             ; Decrement ECX
    jnz loop_start      ; Jump to loop_start if ECX != 0

    ; Store the result in the sum variable
    mov [sum], eax

    ; Exit the program
    mov eax, 1          ; sys_exit
    xor ebx, ebx        ; exit code 0
    int 0x80            ; call kernel

Exercise 2: Factorial of a Number

Write an Assembly program to calculate the factorial of a number using a loop.

Solution

section .data
    result db 1         ; Variable to store the result

section .bss

section .text
    global _start

_start:
    mov ecx, 5          ; Set the number to calculate factorial (5)
    mov eax, 1          ; Initialize EAX to 1 (factorial result)

loop_start:
    mul ecx             ; Multiply EAX by ECX
    dec ecx             ; Decrement ECX
    jnz loop_start      ; Jump to loop_start if ECX != 0

    ; Store the result in the result variable
    mov [result], eax

    ; Exit the program
    mov eax, 1          ; sys_exit
    xor ebx, ebx        ; exit code 0
    int 0x80            ; call kernel

Common Mistakes and Tips

  • Off-by-One Errors: Ensure your loop counter is correctly initialized and decremented.
  • Infinite Loops: Make sure your loop has a terminating condition.
  • Register Usage: Be mindful of which registers you use and ensure they are not overwritten unintentionally.

Conclusion

In this section, we covered the basics of loops and iteration in Assembly language. We explored count-controlled and condition-controlled loops, provided practical examples, and included exercises to reinforce the concepts. Understanding loops is essential for writing efficient Assembly programs, and mastering these constructs will significantly enhance your programming skills. In the next section, we will delve into subroutines and procedures, which will further expand your ability to write modular and reusable code.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved