x86 FASM assembly Reverse FizzBuzz
Since you are writing FizzBuzz in assembler, you are obviously concerned about performance and code size.

For performance, div is one of the worst instructions. Since the divisibility repeats modulo 15, you could define some constants:

const divisible_by_3 = 0b1001001001001001
const divisible_by_5 = 0b1000010000100001


To test the divisibility, have an extra register that is initialized with i mod 15 and adjusted whenever i changes. The basic idea is:

dec i
dec i_mod_15
cmovs i_mod_15, 14   ; the maximum value mod 15


You can also combine divisible_by_3 and divisible_by_5 into a bit vector of two-bit entries (divisible) and define a jump table based on that. To do the actual testing, use bit-shifting.

const divisible_by_3 = 0b_1_0_0_1_0_0_1_0_0_1_0_0_1_0_0_1
const divisible_by_5 = 0b1_0_0_0_0_1_0_0_0_0_1_0_0_0_0_1_
const divisible      = 0b11000001001001000001100001000011


Another idea is to use unroll the loop by using Duff's Device.

Right now, your code is a really boring, straight-forward translation of some higher-level language, probably C. In assembler, you have much more potential to compress the code (DRY principle). For example, you can jmp do_printf instead of writing push ecx; call printf; pop ecx several times.



… 90 minutes later …



Based on the above ideas, the code might look like this, tested and works.

format PE console
entry main

include 'macro/import32.inc'

section '.rdata' data readable

; Each of these messages takes exactly 8 bytes,
; except for the last one.
; This is important for addressing them efficiently.
messages db '%d', 13, 10, 0, 0, 0, 0
         db 'Fizz', 13, 10, 0, 0
         db 'Buzz', 13, 10, 0, 0
         db 'FizzBuzz', 13, 10, 0

; This bit mask selects one of the above messages
; to be printed. The counter is always passed to
; printf, and in 8/15 cases it is ignored.
; The uu entry at the end is unused.
;
;                0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
; div3 mask =    1  0  0  1  0  0  1  0  0  1  0  0  1  0  0  u
; div5 mask =   1  0  0  0  0  1  0  0  0  0  1  0  0  0  0  u
div_mask =      11_00_00_01_00_10_01_00_00_01_10_00_01_00_00_00b

section '.text' code readable

main:
        push ebp
        mov ebp, esp

        mov ecx, 100            ; ecx = the counter
        mov eax, ecx
        xor edx, edx
        mov ebx, 15
        div ebx                 ; edx = counter mod 15

        mov ebx, div_mask       ; ebx = bit mask for selecting the message
        rol ebx, 2
        xchg edx, ecx           ; Variable-width rotation is only possible
        rol ebx, cl             ; with cl, therefore the temporary swap
        rol ebx, cl             ; of edx and ecx.
        xchg edx, ecx           ;

.again:
        mov eax, ebx            ; Select the message format for printf.
        and eax, 11b
        shl eax, 3
        add eax, messages

        push ebx                ; save registers before printf
        push ecx
        push edx

        push ecx                ; actually call printf
        push eax
        call [printf]
        add esp, 8

        pop edx                 ; restore registers after printf
        pop ecx
        pop ebx

        dec edx                 ; Adjust counter, counter mod 15
        jns .normal             ; and bit mask.
        add edx, 15
        ror ebx, 2              ; Rotate one extra time since
.normal:                        ; the bit mask has 16 entries.
        ror ebx, 2

        dec ecx
        jnz .again

        xor eax, eax
        pop ebp
        ret

section '.idata' import data readable

library msvcrt, 'msvcrt.dll'

import msvcrt, printf, 'printf', system, 'system'


Some more things I took care of:


The code must not be in a writeable section.
Since the program can return from main, it should do so. To make that work, I had to add the pop ebp that corresponds to the push ebp at the very top; in your code that was missing.
I carefully avoided many branching statements, since they are poisonous to performance. See Why is it faster to process a sorted array.
The one remaining conditional behaves well in that it follows the jump in 14/15 cases, which is easily predictable.
Of course, using printf and the C stdio for output ruins all performance effects. But that's outside the scope for this little fun experiment.
All arguments to printf may be modified by printf. There's no guarantee that you get your ecx back at the point where you commented ; Get the counter back into ecx. To hide the counter from printf, you must push it once more to the stack. That's why I explicitly commented on this saving/calling/restoring in my code.


A nice thing is that you can play with the bit mask, which feels just like an ordinary configuration file.