## compute the factorial of 5, and return the result in the exit code
#
# To run:
#   $ subx translate apps/factorial.subx apps/factorial
#   $ subx run apps/factorial
# Expected result:
#   $ echo $?
#   120

== code
# instruction                     effective address                                                   operand     displacement    immediate
# op          subop               mod             rm32          base        index         scale       r32
# 1-3 bytes   3 bits              2 bits          3 bits        3 bits      3 bits        2 bits      2 bits      0/1/2/4 bytes   0/1/2/4 bytes

# main:
  # prepare to make a call
  55/push                         .               .             .           .             .           .           .               .                 # push EBP
  89/copy                         3/mod/direct    5/rm32/EBP    .           .             .           4/r32/ESP   .               .                 # copy ESP to EBP
  # factorial(5)
  68/push                         .               .             .           .             .           .           .               5/imm32           # push 5
  e8/call                         .               .             .           .             .           .           factorial/disp32
  # discard arg
  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add 4 to ESP
  # clean up after call
  89/copy                         3/mod/direct    4/rm32/ESP    .           .             .           5/r32/EBP   .               .                 # copy EBP to ESP
  5d/pop                          .               .             .           .             .           .           .               .                 # pop to EBP

  # exit(EAX)
  89/copy                         3/mod/direct    3/rm32/EBX    .           .             .           0/r32/EAX   .               .                 # copy EAX to EBX
  b8/copy                         .               .             .           .             .           .           .               1/imm32           # copy 1 to EAX
  cd/syscall                      .               .             .           .             .           .           .               0x80/imm8         # int 80h

# factorial(n)
factorial:
  # initialize EAX to 1 (base case)
  b8/copy                         .               .             .           .             .           .           .               1/imm32           # copy 1 to EAX
  # if (n <= 1) jump exit
  81          7/subop/compare     1/mod/*+disp8   4/rm32/sib    4/base/ESP  4/index/none  .           .           4/disp8         1/imm32           # compare *(ESP+4) with 1
  7e/jump-if-<=                   .               .             .           .             .           .           $factorial:exit/disp8             # jump if <= to $factorial:exit
  # EBX: n-1
  8b/copy                         1/mod/*+disp8   4/rm32/sib    4/base/ESP  4/index/none              3/r32/EBX   4/disp8         .                 # copy *(ESP+4) to EBX
  81          5/subop/subtract    3/mod/direct    3/rm32/EBX    .           .             .           .           .               1/imm32           # subtract 1 from EBX
  # prepare call
  55/push                         .               .             .           .             .           .           .               .                 # push EBP
  89/copy                         3/mod/direct    5/rm32/EBP    .           .             .           4/r32/ESP   .               .                 # copy ESP to EBP
  # EAX: factorial(n-1)
  53/push                         .               .             .           .             .           .           .               .                 # push EBX
  e8/call                         .               .             .           .             .           .           factorial/disp32
  # discard arg
  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add 4 to ESP
  # clean up after call
  89/copy                         3/mod/direct    4/rm32/ESP    .           .             .           5/r32/EBP   .               .                 # copy EBP to ESP
  5d/pop                          .               .             .           .             .           .           .               .                 # pop to EBP
  # refresh n
  8b/copy                         1/mod/*+disp8   4/rm32/sib    4/base/ESP  4/index/none              2/r32/EDX   4/disp8         .                 # copy *(ESP+4) to EDX
  # return n * factorial(n-1)
  f7          4/subop/multiply    1/mod/*+disp8   4/rm32/sib    4/base/ESP  4/index/none                          4/disp8         .                 # multiply *(ESP+4) (n) into EAX (factorial(n-1))
  # TODO: check for overflow
$factorial:exit:
  c3/return

# vim:ft=subx:nowrap:so=0