mu/subx/apps/crenshaw2-1.subx

## port of https://github.com/akkartik/crenshaw/blob/master/tutor2.1.pas
# corresponds to the section "single digits" in https://compilers.iecc.com/crenshaw/tutor2.txt
#
# To run (from the subx directory):
#   $ subx translate *.subx apps/crenshaw2.1.subx -o crenshaw 2.1
#   $ echo '3'  |subx run apps/crenshaw2.1  |xxd -
# Expected output:
#   TODO
#
# The output is the code a function would need to include, returning the
# result in EAX.
#
# Major note: byte strings are not null-terminated. Instead they're prefixed
# with a 32-bit length.

== 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:
  # abort("Integer")
    # push args
  68/push  "Integer"/imm32
    # call
  e8/call  abort/disp32
    # discard arg
  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
  # exit(0)
  bb/copy                         .               .             .           .             .           .           .               0/imm32           # copy to EBX
  b8/copy                         .               .             .           .             .           .           .               1/imm32/exit      # copy to EAX
  cd/syscall  0x80/imm8

## helpers

# print error message and exit
# really maps to the 'Expected' function in Crenshaw
abort:  # s : (address array byte) -> <void>
  # error(s)
    # push args
  ff          6/subop/push        1/mod/*+disp8   4/rm32/sib    4/base/ESP  4/index/none  .           .           4/disp8         .                 # push *(ESP+4)
    # call
  e8/call  error/disp32
    # discard arg
  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
  # exit(1)
  bb/copy                         .               .             .           .             .           .           .               1/imm32           # copy to EBX
  b8/copy                         .               .             .           .             .           .           .               1/imm32/exit      # copy to EAX
  cd/syscall  0x80/imm8

# print out "Error: #{s} expected\n" to stderr
error:  # s : (address array byte) -> <void>
  # write-stderr("Error: ")
    # push args
  68/push  "Error: "/imm32
    # call
  e8/call  write-stderr/disp32
    # discard arg
  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
  # write-stderr(s)
    # push args
  ff          6/subop/push        1/mod/*+disp8   4/rm32/sib    4/base/ESP  4/index/none  .           .           4/disp8         .                 # push *(ESP+4)
    # call
  e8/call  write-stderr/disp32
    # discard arg
  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
  # write-stderr(" expected")
    # push args
  68/push  " expected"/imm32
    # call
  e8/call  write-stderr/disp32
    # discard arg
  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
  # write-stderr("\n")
    # push args
  68/push  Newline/imm32
    # call
  e8/call  write-stderr/disp32
    # discard arg
  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
  # end
  c3/return

write-stdout:  # s : (address array byte) -> <void>
  # prolog
  55/push-EBP
  89/copy                         3/mod/direct    5/rm32/EBP    .           .             .           4/r32/ESP   .               .                 # copy ESP to EBP
  # save registers
  50/push-EAX
  51/push-ECX
  52/push-EDX
  53/push-EBX
  # write(1/stdout, (data) s+4, (size) *s)
    # fd = 1 (stdout)
  bb/copy                         .               .             .           .             .           .           .               1/imm32           # copy to EBX
    # x = s+4
  8b/copy                         1/mod/*+disp8   4/rm32/sib    5/base/EBP  4/index/none  .           1/r32/ECX   8/disp8         .                 # copy *(EBP+8) to ECX
  81          0/subop/add         3/mod/direct    1/rm32/ECX    .           .             .           .           .               4/imm32           # add to ECX
    # size = *s
  8b/copy                         1/mod/*+disp8   4/rm32/sib    5/base/EBP  4/index/none  .           2/r32/EDX   8/disp8         .                 # copy *(EBP+8) to EDX
  8b/copy                         0/mod/indirect  2/rm32/EDX    .           .             .           2/r32/EDX   .               .                 # copy *EDX to EDX
    # call write()
  b8/copy                         .               .             .           .             .           .           .               4/imm32/write     # copy to EAX
  cd/syscall  0x80/imm8
  # restore registers
  5b/pop-to-EBX
  5a/pop-to-EDX
  59/pop-to-ECX
  58/pop-to-EAX
  # end
  89/copy                         3/mod/direct    4/rm32/ESP    .           .             .           5/r32/EBP   .               .                 # copy EBP to ESP
  5d/pop-to-EBP
  c3/return

# vim:nowrap:textwidth=0
4553 Start of a new example program. 2018-09-20 21:06:09 +00:00			`## port of https://github.com/akkartik/crenshaw/blob/master/tutor2.1.pas`
			`# corresponds to the section "single digits" in https://compilers.iecc.com/crenshaw/tutor2.txt`
			`#`
4638 - extract some common libraries from apps I'm still trying to figure out what the defaults should be. At the moment you have to explicitly pass in every file you want loaded into the output binary. Maybe that control is a good thing. The examples need no libraries so far. 2018-10-01 19:22:59 +00:00			`# To run (from the subx directory):`
			`# $ subx translate *.subx apps/crenshaw2.1.subx -o crenshaw 2.1`
4553 Start of a new example program. 2018-09-20 21:06:09 +00:00			`# $ echo '3' \|subx run apps/crenshaw2.1 \|xxd -`
			`# Expected output:`
			`# TODO`
			`#`
4560 2018-09-20 23:32:37 +00:00			`# The output is the code a function would need to include, returning the`
			`# result in EAX.`
			`#`
4553 Start of a new example program. 2018-09-20 21:06:09 +00:00			`# Major note: byte strings are not null-terminated. Instead they're prefixed`
			`# with a 32-bit length.`

			`== 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:`
4509 Back to the Crenshaw compiler. Start by using string literals. 2018-09-24 04:04:32 +00:00			`# abort("Integer")`
4553 Start of a new example program. 2018-09-20 21:06:09 +00:00			`# push args`
4509 Back to the Crenshaw compiler. Start by using string literals. 2018-09-24 04:04:32 +00:00			`68/push "Integer"/imm32`
4553 Start of a new example program. 2018-09-20 21:06:09 +00:00			`# call`
4576 2018-09-21 22:28:11 +00:00			`e8/call abort/disp32`
4555 2018-09-20 22:51:24 +00:00			`# discard arg`
4644 2018-10-01 22:35:56 +00:00			`81 0/subop/add 3/mod/direct 4/rm32/ESP . . . . . 4/imm32 # add to ESP`
4553 Start of a new example program. 2018-09-20 21:06:09 +00:00			`# exit(0)`
4644 2018-10-01 22:35:56 +00:00			`bb/copy . . . . . . . 0/imm32 # copy to EBX`
			`b8/copy . . . . . . . 1/imm32/exit # copy to EAX`
4581 Even more cuddling. We want to keep lines short where the opcode and operands are self-explanatory. If there are any implicit registers, etc., we'll continue to do the table layout. The first two columns look messy now; let's see how this goes. Maybe I'll give up on the tabular layout altogether, just string args with a single space. 2018-09-21 23:55:46 +00:00			`cd/syscall 0x80/imm8`
4553 Start of a new example program. 2018-09-20 21:06:09 +00:00
4638 - extract some common libraries from apps I'm still trying to figure out what the defaults should be. At the moment you have to explicitly pass in every file you want loaded into the output binary. Maybe that control is a good thing. The examples need no libraries so far. 2018-10-01 19:22:59 +00:00			`## helpers`
4510 Add the test harness to the crenshaw compiler. Though we aren't calling it yet. But that's because we aren't actually doing anything useful yet. 2018-09-24 04:12:39 +00:00
4557 2018-09-20 23:23:51 +00:00			`# print error message and exit`
			`# really maps to the 'Expected' function in Crenshaw`
4556 2018-09-20 23:11:39 +00:00			`abort: # s : (address array byte) -> <void>`
			`# error(s)`
			`# push args`
			`ff 6/subop/push 1/mod/+disp8 4/rm32/sib 4/base/ESP 4/index/none . . 4/disp8 . # push (ESP+4)`
			`# call`
4576 2018-09-21 22:28:11 +00:00			`e8/call error/disp32`
4556 2018-09-20 23:11:39 +00:00			`# discard arg`
4644 2018-10-01 22:35:56 +00:00			`81 0/subop/add 3/mod/direct 4/rm32/ESP . . . . . 4/imm32 # add to ESP`
4556 2018-09-20 23:11:39 +00:00			`# exit(1)`
4644 2018-10-01 22:35:56 +00:00			`bb/copy . . . . . . . 1/imm32 # copy to EBX`
			`b8/copy . . . . . . . 1/imm32/exit # copy to EAX`
4581 Even more cuddling. We want to keep lines short where the opcode and operands are self-explanatory. If there are any implicit registers, etc., we'll continue to do the table layout. The first two columns look messy now; let's see how this goes. Maybe I'll give up on the tabular layout altogether, just string args with a single space. 2018-09-21 23:55:46 +00:00			`cd/syscall 0x80/imm8`
4556 2018-09-20 23:11:39 +00:00
4557 2018-09-20 23:23:51 +00:00			`# print out "Error: #{s} expected\n" to stderr`
4553 Start of a new example program. 2018-09-20 21:06:09 +00:00			`error: # s : (address array byte) -> <void>`
4667 Standardize on hyphens in all names. And we'll use colons for namespacing labels in functions. 2018-10-06 02:49:47 +00:00			`# write-stderr("Error: ")`
4556 2018-09-20 23:11:39 +00:00			`# push args`
4509 Back to the Crenshaw compiler. Start by using string literals. 2018-09-24 04:04:32 +00:00			`68/push "Error: "/imm32`
4556 2018-09-20 23:11:39 +00:00			`# call`
4667 Standardize on hyphens in all names. And we'll use colons for namespacing labels in functions. 2018-10-06 02:49:47 +00:00			`e8/call write-stderr/disp32`
4556 2018-09-20 23:11:39 +00:00			`# discard arg`
4644 2018-10-01 22:35:56 +00:00			`81 0/subop/add 3/mod/direct 4/rm32/ESP . . . . . 4/imm32 # add to ESP`
4667 Standardize on hyphens in all names. And we'll use colons for namespacing labels in functions. 2018-10-06 02:49:47 +00:00			`# write-stderr(s)`
4556 2018-09-20 23:11:39 +00:00			`# push args`
			`ff 6/subop/push 1/mod/+disp8 4/rm32/sib 4/base/ESP 4/index/none . . 4/disp8 . # push (ESP+4)`
			`# call`
4667 Standardize on hyphens in all names. And we'll use colons for namespacing labels in functions. 2018-10-06 02:49:47 +00:00			`e8/call write-stderr/disp32`
4556 2018-09-20 23:11:39 +00:00			`# discard arg`
4644 2018-10-01 22:35:56 +00:00			`81 0/subop/add 3/mod/direct 4/rm32/ESP . . . . . 4/imm32 # add to ESP`
4667 Standardize on hyphens in all names. And we'll use colons for namespacing labels in functions. 2018-10-06 02:49:47 +00:00			`# write-stderr(" expected")`
4557 2018-09-20 23:23:51 +00:00			`# push args`
4509 Back to the Crenshaw compiler. Start by using string literals. 2018-09-24 04:04:32 +00:00			`68/push " expected"/imm32`
4557 2018-09-20 23:23:51 +00:00			`# call`
4667 Standardize on hyphens in all names. And we'll use colons for namespacing labels in functions. 2018-10-06 02:49:47 +00:00			`e8/call write-stderr/disp32`
4557 2018-09-20 23:23:51 +00:00			`# discard arg`
4644 2018-10-01 22:35:56 +00:00			`81 0/subop/add 3/mod/direct 4/rm32/ESP . . . . . 4/imm32 # add to ESP`
4667 Standardize on hyphens in all names. And we'll use colons for namespacing labels in functions. 2018-10-06 02:49:47 +00:00			`# write-stderr("\n")`
4556 2018-09-20 23:11:39 +00:00			`# push args`
4581 Even more cuddling. We want to keep lines short where the opcode and operands are self-explanatory. If there are any implicit registers, etc., we'll continue to do the table layout. The first two columns look messy now; let's see how this goes. Maybe I'll give up on the tabular layout altogether, just string args with a single space. 2018-09-21 23:55:46 +00:00			`68/push Newline/imm32`
4556 2018-09-20 23:11:39 +00:00			`# call`
4667 Standardize on hyphens in all names. And we'll use colons for namespacing labels in functions. 2018-10-06 02:49:47 +00:00			`e8/call write-stderr/disp32`
4556 2018-09-20 23:11:39 +00:00			`# discard arg`
4644 2018-10-01 22:35:56 +00:00			`81 0/subop/add 3/mod/direct 4/rm32/ESP . . . . . 4/imm32 # add to ESP`
4556 2018-09-20 23:11:39 +00:00			`# end`
			`c3/return`

4667 Standardize on hyphens in all names. And we'll use colons for namespacing labels in functions. 2018-10-06 02:49:47 +00:00			`write-stdout: # s : (address array byte) -> <void>`
4516 More calling convention tweaks. Use EBP to get consistently at parameters and locals. Always put the first function argument closest to EBP. 2018-09-25 01:48:41 +00:00			`# prolog`
			`55/push-EBP`
			`89/copy 3/mod/direct 5/rm32/EBP . . . 4/r32/ESP . . # copy ESP to EBP`
4510 Add the test harness to the crenshaw compiler. Though we aren't calling it yet. But that's because we aren't actually doing anything useful yet. 2018-09-24 04:12:39 +00:00			`# save registers`
			`50/push-EAX`
			`51/push-ECX`
			`52/push-EDX`
			`53/push-EBX`
4559 2018-09-20 23:30:40 +00:00			`# write(1/stdout, (data) s+4, (size) *s)`
			`# fd = 1 (stdout)`
4644 2018-10-01 22:35:56 +00:00			`bb/copy . . . . . . . 1/imm32 # copy to EBX`
4559 2018-09-20 23:30:40 +00:00			`# x = s+4`
4655 2018-10-03 03:58:39 +00:00			`8b/copy 1/mod/+disp8 4/rm32/sib 5/base/EBP 4/index/none . 1/r32/ECX 8/disp8 . # copy (EBP+8) to ECX`
4644 2018-10-01 22:35:56 +00:00			`81 0/subop/add 3/mod/direct 1/rm32/ECX . . . . . 4/imm32 # add to ECX`
4559 2018-09-20 23:30:40 +00:00			`# size = *s`
4655 2018-10-03 03:58:39 +00:00			`8b/copy 1/mod/+disp8 4/rm32/sib 5/base/EBP 4/index/none . 2/r32/EDX 8/disp8 . # copy (EBP+8) to EDX`
4553 Start of a new example program. 2018-09-20 21:06:09 +00:00			`8b/copy 0/mod/indirect 2/rm32/EDX . . . 2/r32/EDX . . # copy *EDX to EDX`
			`# call write()`
4644 2018-10-01 22:35:56 +00:00			`b8/copy . . . . . . . 4/imm32/write # copy to EAX`
4581 Even more cuddling. We want to keep lines short where the opcode and operands are self-explanatory. If there are any implicit registers, etc., we'll continue to do the table layout. The first two columns look messy now; let's see how this goes. Maybe I'll give up on the tabular layout altogether, just string args with a single space. 2018-09-21 23:55:46 +00:00			`cd/syscall 0x80/imm8`
4510 Add the test harness to the crenshaw compiler. Though we aren't calling it yet. But that's because we aren't actually doing anything useful yet. 2018-09-24 04:12:39 +00:00			`# restore registers`
4517 2018-09-25 06:01:38 +00:00			`5b/pop-to-EBX`
			`5a/pop-to-EDX`
			`59/pop-to-ECX`
			`58/pop-to-EAX`
4556 2018-09-20 23:11:39 +00:00			`# end`
4516 More calling convention tweaks. Use EBP to get consistently at parameters and locals. Always put the first function argument closest to EBP. 2018-09-25 01:48:41 +00:00			`89/copy 3/mod/direct 4/rm32/ESP . . . 5/r32/EBP . . # copy EBP to ESP`
			`5d/pop-to-EBP`
4556 2018-09-20 23:11:39 +00:00			`c3/return`
4553 Start of a new example program. 2018-09-20 21:06:09 +00:00
4662 2018-10-05 17:42:16 +00:00			`# vim:nowrap:textwidth=0`