Examples to try

The factorial, recursive

n! = n · (n−1)!, and 0! = 1! = 1. The function calls itself: func makes the frame, if / else the comparison and the jumps. File: examples\func\func_fact.asm.

func Fact(n) uses ebx
begin
  if unsigned n > 1
    mov ebx, n
    dec ebx
    call Fact(ebx)
    imul eax, n
  else
    mov eax, 1
  endif
end

Fact:
  push ebp
  mov ebp, esp
  push ebx
  cmp dword [ebp+8], 1
  jbe else1
  mov ebx, dword [ebp+8]
  dec ebx
  push ebx
  call Fact
  imul eax, dword [ebp+8]
  jmp end1
else1:
  mov eax, 1
end1:
  pop ebx
  pop ebp
  ret 4

Three things are written that way on purpose. There are no expressions and no calls inside a call: call Fact(n-1) is not possible, so dec ebx counts down first and call Fact(ebx) gets the result. n stays in the frame of the function, so imul eax, n after the call works with its own n. ebx is in uses so the caller gets it back unchanged. An ordered comparison says signed or unsigned.

The same calculation as a loop

func FactLoop(n)
begin
  mov ecx, n
  mov eax, 1
  if unsigned ecx > 1
    do
      imul eax, ecx
      dec ecx
    while unsigned ecx > 1
  endif
end

FactLoop:
  push ebp
  mov ebp, esp
  mov ecx, dword [ebp+8]
  mov eax, 1
  cmp ecx, 1
  jbe end1
loop1:
  imul eax, ecx
  dec ecx
  cmp ecx, 1
  ja loop1
end1:
  pop ebp
  ret 4

The if around the loop skips it for 0 and 1; while jumps back to the do as long as ecx is greater than 1. The call in the main part and the output:

start:
  call Fact(10)
  call [printf](fmt, 10, eax)
  call FactLoop(5)
  call [printf](fmt, 5, eax)
  call [ExitProcess](0)

10! = 3628800
5! = 120

.import msvcrt.dll cdecl printf says that printf does not remove the arguments itself; call [printf](...) cleans up afterwards. The arguments are in the order of the function: the format first.

if on x64, ARM 64 and Thumb

if, else and do … while exist for .arch x64, .arch arm64 and .arch thumb too (func and call Name(args) not yet). You write the operands as the architecture knows them; the assembler makes cmp (or tst) and the jump with the opposite condition around the block of it.

if w1 == 5
  add w0, w0, #1
endif

if signed w1 < 3
  add w0, w0, #100
else
  add w0, w0, #2
endif

if unsigned w2 > w1
  add w0, w0, #4
endif

  cmp w1, #5
  b.ne endif1
  add w0, w0, #1
endif1:
  cmp w1, #3
  b.ge else2
  add w0, w0, #100
  b end2
else2:
  add w0, w0, #2
end2:
  cmp w2, w1
  b.ls endif3
  add w0, w0, #4
endif3:

A word like signed or unsigned says how to compare (see course, lesson 3); if w3 & w4 is tst; if zero uses the flags of the instruction before it. On ARM there are no memory operands in if: load into a register first. The complete programs: examples\windows_intel\if_x64.asm, examples\windows_arm\if_arm64.asm and examples\windows_arm\if_arm32.asm. Each ends with the exit code 31 (= 1 + 2 + 4 + 8 + 16): every block that runs adds its number, so the exit code shows which conditions were true.

All examples

Folder examples\func: functions, calls, if and loops for 32-bit Windows. The result is the output or the exit code (echo %errorlevel%).

More folders

Try it

Open a file from examples in Asmonite (Ctrl+O) and press F9: assemble and start in the debugger. F8 goes one step on; with func, if and call one line of your text is one step, not the generated instructions. Without the window: asmoc func_fact.asm writes the .exe next to the file.

Next