Incrementing from 0 to 100 in assembly language

This is kinda oddball, but I was poking around with the GNU assembler today (I want to be able to at least read the syntax), and was trying to get this little contrived example of mine to work. Namely I just want to go from 0 to 100, printing out numbers all the while. So a few minutes later I come up with this:

# 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:
# Display the current value.
pushl %eax
pushl $string
call _printf
addl $8, %esp

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

# Increment the current value.
incl %eax
jmp _loop

_end:

All I get from this is 3 printed over and over again. Like I said, just a little contrived example, so don't worry too much about it, it's not a life or death problem.

(The formatting's a little messed up, but nothing major).

I'm not too familiar with _printf, but could it be that it modifies eax? Printf should return the number of chars printed, which in this case is two: '0' and '\n'. I think it returns this in eax, and when you increment it, you get 3, which is what you proceed to print.
You might be better off using a different register for the counter.

You can't trust what any called procedure does to any of the registers.
Either push the registers onto the stack and pop them back off after calling printf or have the increment and end point values held in memory and read/written into registers as you need them.

I hope the following works. I'm assuming that pushl has an equivalant popl and you can push an extra couple of numbers onto the stack.

# 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:

Nathan is on the right track. You can't assume that register values will be unmodified after calling a subroutine. In fact, it's best to assume they will be modified, else the subroutine wouldn't be able to do it's work (at least for low register count architectures like x86). If you want to preserve a value you should store it in memory (e.g. push it onto the stack and keep track of it's location).

You'll need to do the same for any other variable you have. Using registers to store local variables is pretty much reserved to architectures with enough registers to support it (e.g. EPIC, amd64, etc.)

Well written functions will usually push all the registers onto the stack and then pop them when they're done so that they remain unchanged during the function. The exception would be eax that contains the return value. Library functions like printf are most likely written this way, so I wouldn't do as Wedge suggests:
>You'll need to do the same for any other variable you have. Using registers to store local variables is pretty much reserved to architectures with enough registers to support it (e.g. EPIC, amd64, etc.)

In fact, from what I know, compilers usually compile functions that way to deal exactly with this issue.

@seanyboy, your solution is overkill. All that's needed is to replace eax with some other register like ecx.

You can safely use registers that are "callee-saved" without having to save them yourself. On x86 these are edi, esi, and ebx; other architectures have more.

These are documented in the ABI references: [

[To see links please register here]

][1]


[1]:

[To see links please register here]