mu/subx/examples/ex5.subx

## read a character from stdin, save it to a local on the stack, write it to stdout
#
# To run:
#   $ subx translate ex5.subx -o ex5
#   $ subx run ex5

== 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:
  # allocate x on the stack
  81          5/subop/subtract    3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # subtract 4 bytes from ESP

  # read(stdin, x, 1)
    # fd = 0 (stdin)
  bb/copy                         .               .             .           .             .           .           .               0/imm32           # copy 0 to EBX
    # initialize x (location to write result to)
  8d/copy-address                 1/mod/*+disp8   4/rm32/sib    4/base/ESP  4/index/none              1/r32/ECX   4/disp8         .                 # copy ESP+4 to ECX
    # size = 1 character
  ba/copy                         .               .             .           .             .           .           .               1/imm32           # copy 1 to EDX
    # read(fd, x, size)
  b8/copy                         .               .             .           .             .           .           .               3/imm32/read      # copy 3 to EAX
  cd/syscall  0x80/imm8

  # write(stdout, x, 1)
    # fd = 1 (stdout)
  bb/copy                         .               .             .           .             .           .           .               1/imm32           # copy 1 to EBX
    # initialize x (location to read from)
  8d/copy-address                 1/mod/*+disp8   4/rm32/sib    4/base/ESP  4/index/none              1/r32/ECX   4/disp8         .                 # copy ESP+4 to ECX
    # size = 1 character
  ba/copy                         .               .             .           .             .           .           .               1/imm32           # copy 1 to EDX
    # write(fd, x, size)
  b8/copy                         .               .             .           .             .           .           .               4/imm32/write     # copy 4 to EAX
  cd/syscall  0x80/imm8

  # exit(EBX)
  b8/copy                         .               .             .           .             .           .           .               1/imm32/exit      # copy 1 to EAX
  cd/syscall  0x80/imm8

# vim:ft=subx:nowrap
4363 - subx: first program using the stack segment We allocate space for a local variable, read() a character from stdin to it, and write() it out to stdout. 2018-07-17 05:18:18 +00:00			`## read a character from stdin, save it to a local on the stack, write it to stdout`
4392 2018-07-24 18:53:45 +00:00			`#`
			`# To run:`
4624 Start requiring a '-o' flag to designate the output binary when translating. Things currently get funky if you pass in multiple inputs, but that's ok. This is the first step to supporting multiple input files for a single output binary. 2018-10-01 05:49:24 +00:00			`# $ subx translate ex5.subx -o ex5`
4392 2018-07-24 18:53:45 +00:00			`# $ subx run ex5`
4363 - subx: first program using the stack segment We allocate space for a local variable, read() a character from stdin to it, and write() it out to stdout. 2018-07-17 05:18:18 +00:00
4531 - automatically compute segment addresses 2018-09-01 22:58:53 +00:00			`== code`
4467 2018-08-04 06:23:39 +00:00			`# 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`
4363 - subx: first program using the stack segment We allocate space for a local variable, read() a character from stdin to it, and write() it out to stdout. 2018-07-17 05:18:18 +00:00
4561 2018-09-21 04:34:56 +00:00			`# main:`
4363 - subx: first program using the stack segment We allocate space for a local variable, read() a character from stdin to it, and write() it out to stdout. 2018-07-17 05:18:18 +00:00			`# allocate x on the stack`
4589 2018-09-22 17:29:12 +00:00			`81 5/subop/subtract 3/mod/direct 4/rm32/ESP . . . . . 4/imm32 # subtract 4 bytes from ESP`
4363 - subx: first program using the stack segment We allocate space for a local variable, read() a character from stdin to it, and write() it out to stdout. 2018-07-17 05:18:18 +00:00
4561 2018-09-21 04:34:56 +00:00			`# read(stdin, x, 1)`
			`# fd = 0 (stdin)`
4589 2018-09-22 17:29:12 +00:00			`bb/copy . . . . . . . 0/imm32 # copy 0 to EBX`
4561 2018-09-21 04:34:56 +00:00			`# initialize x (location to write result to)`
4503 Include LEA (load effective address) in the SubX subset of x86 ISA. 2018-09-23 06:19:39 +00:00			`8d/copy-address 1/mod/*+disp8 4/rm32/sib 4/base/ESP 4/index/none 1/r32/ECX 4/disp8 . # copy ESP+4 to ECX`
4561 2018-09-21 04:34:56 +00:00			`# size = 1 character`
4589 2018-09-22 17:29:12 +00:00			`ba/copy . . . . . . . 1/imm32 # copy 1 to EDX`
4561 2018-09-21 04:34:56 +00:00			`# read(fd, x, size)`
4589 2018-09-22 17:29:12 +00:00			`b8/copy . . . . . . . 3/imm32/read # copy 3 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`
4363 - subx: first program using the stack segment We allocate space for a local variable, read() a character from stdin to it, and write() it out to stdout. 2018-07-17 05:18:18 +00:00
4561 2018-09-21 04:34:56 +00:00			`# write(stdout, x, 1)`
			`# fd = 1 (stdout)`
4589 2018-09-22 17:29:12 +00:00			`bb/copy . . . . . . . 1/imm32 # copy 1 to EBX`
4561 2018-09-21 04:34:56 +00:00			`# initialize x (location to read from)`
4503 Include LEA (load effective address) in the SubX subset of x86 ISA. 2018-09-23 06:19:39 +00:00			`8d/copy-address 1/mod/*+disp8 4/rm32/sib 4/base/ESP 4/index/none 1/r32/ECX 4/disp8 . # copy ESP+4 to ECX`
4561 2018-09-21 04:34:56 +00:00			`# size = 1 character`
4589 2018-09-22 17:29:12 +00:00			`ba/copy . . . . . . . 1/imm32 # copy 1 to EDX`
4561 2018-09-21 04:34:56 +00:00			`# write(fd, x, size)`
4589 2018-09-22 17:29:12 +00:00			`b8/copy . . . . . . . 4/imm32/write # copy 4 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`
4363 - subx: first program using the stack segment We allocate space for a local variable, read() a character from stdin to it, and write() it out to stdout. 2018-07-17 05:18:18 +00:00
4561 2018-09-21 04:34:56 +00:00			`# exit(EBX)`
4589 2018-09-22 17:29:12 +00:00			`b8/copy . . . . . . . 1/imm32/exit # copy 1 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`
4363 - subx: first program using the stack segment We allocate space for a local variable, read() a character from stdin to it, and write() it out to stdout. 2018-07-17 05:18:18 +00:00
			`# vim:ft=subx:nowrap`