Gnu Assembler Assembly

Understanding `Incrementing from 0 to 100 in Assembly Language`

When diving into assembly language programming, especially with the GNU assembler, you may encounter various challenges. One common exercise is to write a program that counts from 0 to 100 and prints each number. This task may seem straightforward, but it can quickly become complicated if you aren’t careful with your use of registers and the function calls you make. In this blog post, we’ll break down the problem and provide a solution that ensures you get the expected output without unintended results.

The Problem

While experimenting with assembly code to print numbers from 0 to 100, many beginners run into an issue where their program prints the same number repeatedly or gets stuck in an unexpected loop. This can be frustrating as it often stems from a misunderstanding of how the assembly language handles registers, particularly when calling functions like printf.

In our case, the initial attempt led to the program printing 3 over and over. Why does this happen? The issue lies in the handling of the registers that store the value of your current number and your end limit.

The Solution

The solution to this problem involves effectively managing the registers through the use of stack operations. Let’s explore this step-by-step.

Understanding Register Management

Push and Pop: The registers in the assembly language may be altered by the functions you call (like printf). Therefore, it’s important to “remember” the state of your registers before making a call and restore them afterward.
Use of Stack: You can use the stack to save registers before calling a function. This way, you can ensure that your values are preserved.

Here’s an improved version of the assembly code that properly manages the registers:

# count.s: print the numbers from 0 to 100.
    .text
string: .asciz "%d\n"
    .globl _main

_main:
    movl    $0, %eax   # The starting point/current value.
    movl    $100, %ebx # The ending point.

_loop:
    # Remember your registers.
    pushl   %eax
    pushl   %ebx

    # Display the current value.
    pushl   %eax
    pushl   $string
    call     _printf
    addl     $8, %esp

    # Reinstate registers.
    popl    %ebx
    popl    %eax

    # Check against the ending value.
    cmpl    %eax, %ebx
    je      _end

    # Increment the current value.
    incl    %eax
    jmp     _loop

_end:

Code Explanation

Defining the Strings: We begin by defining a string format for printing integers. This helps us format our output correctly when we print each number.
Setting Up Initial Values: We initialize our count at 0 and set our limit at 100.
The Loop: This is where most of the action happens. We:
- Push the values of the registers onto the stack to preserve them.
- Call printf to print the current value stored in %eax.
- After the print operation, we pop the registers back to restore their previous state.
- We then compare the current value with the limit and either continue incrementing or exit the loop.
Ending the Program: Once the count reaches 100, the program exits.

Conclusion

By following this structured approach to managing your registers in assembly language, you can avoid the pitfalls that often cause confusion. Next time you need to implement a counting program in assembly, remember to protect your register values with stack operations. This will ensure that your program runs smoothly and delivers the expected output.