akkartik
/
mu
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
mu/subx/examples/ex7.subx

104 lines
3.7 KiB
Plaintext
Raw Normal View History

4530 - create an apps/ directory
2018-09-01 17:04:58 +00:00
## example showing file syscalls
# Create a file, open it for writing, write a character to it, close it, open
# it for reading, read a character from it, close it, delete it, and return
# the character read.
4456 - example with function calls: factorial I found a bug with multiply in the process; another case (after the swap of call/jump opcodes in 4453) where there's no point improving testing. Unit tests can only tell us if our instructions are internally consistent. Validating against a real machine has to be manual. I'm definitely feeling the pain of debugging machine code now, that's for sure. Going over an instruction trace, comparing the state of registers line by line.
2018-07-30 18:23:23 +00:00
#
4639
2018-10-01 19:28:30 +00:00
# To run (from the subx directory):
4643
2018-10-01 22:18:00 +00:00
# $ subx translate examples/ex7.subx -o examples/ex7
# $ subx run examples/ex7
4456 - example with function calls: factorial I found a bug with multiply in the process; another case (after the swap of call/jump opcodes in 4453) where there's no point improving testing. Unit tests can only tell us if our instructions are internally consistent. Validating against a real machine has to be manual. I'm definitely feeling the pain of debugging machine code now, that's for sure. Going over an instruction trace, comparing the state of registers line by line.
2018-07-30 18:23:23 +00:00
# Expected result:
# $ echo $?
4530 - create an apps/ directory
2018-09-01 17:04:58 +00:00
# 97
4456 - example with function calls: factorial I found a bug with multiply in the process; another case (after the swap of call/jump opcodes in 4453) where there's no point improving testing. Unit tests can only tell us if our instructions are internally consistent. Validating against a real machine has to be manual. I'm definitely feeling the pain of debugging machine code now, that's for sure. Going over an instruction trace, comparing the state of registers line by line.
2018-07-30 18:23:23 +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
4456 - example with function calls: factorial I found a bug with multiply in the process; another case (after the swap of call/jump opcodes in 4453) where there's no point improving testing. Unit tests can only tell us if our instructions are internally consistent. Validating against a real machine has to be manual. I'm definitely feeling the pain of debugging machine code now, that's for sure. Going over an instruction trace, comparing the state of registers line by line.
2018-07-30 18:23:23 +00:00
4698
2018-10-14 19:53:50 +00:00
# syscall(creat, filename)
4668
2018-10-06 04:30:22 +00:00
bb/copy-to-EBX filename/imm32
b9/copy-to-ECX 0x180/imm32/fixed-perms
b8/copy-to-EAX 8/imm32/creat
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
4456 - example with function calls: factorial I found a bug with multiply in the process; another case (after the swap of call/jump opcodes in 4453) where there's no point improving testing. Unit tests can only tell us if our instructions are internally consistent. Validating against a real machine has to be manual. I'm definitely feeling the pain of debugging machine code now, that's for sure. Going over an instruction trace, comparing the state of registers line by line.
2018-07-30 18:23:23 +00:00
4698
2018-10-14 19:53:50 +00:00
# stream = syscall(open, filename, O_WRONLY, 0) # we can't use 'fd' because it looks like a hex byte
4668
2018-10-06 04:30:22 +00:00
bb/copy-to-EBX filename/imm32
b9/copy-to-ECX 1/imm32/wronly
ba/copy-to-EDX 0x180/imm32/fixed-perms
b8/copy-to-EAX 5/imm32/open
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
4561
2018-09-21 04:34:56 +00:00
# save stream
4668
2018-10-06 04:30:22 +00:00
bb/copy-to-EBX stream/imm32
4669
2018-10-06 04:50:20 +00:00
89/copy 0/mod/indirect 3/rm32/EBX . . . 0/r32/EAX . . # copy EAX to *EBX
4456 - example with function calls: factorial I found a bug with multiply in the process; another case (after the swap of call/jump opcodes in 4453) where there's no point improving testing. Unit tests can only tell us if our instructions are internally consistent. Validating against a real machine has to be manual. I'm definitely feeling the pain of debugging machine code now, that's for sure. Going over an instruction trace, comparing the state of registers line by line.
2018-07-30 18:23:23 +00:00
4698
2018-10-14 19:53:50 +00:00
# syscall(write, stream, "a", 1)
4561
2018-09-21 04:34:56 +00:00
# load stream
4668
2018-10-06 04:30:22 +00:00
bb/copy-to-EBX stream/imm32
4669
2018-10-06 04:50:20 +00:00
8b/copy 0/mod/indirect 3/rm32/EBX . . . 3/r32/EBX . . # copy *EBX to EBX
4561
2018-09-21 04:34:56 +00:00
#
4668
2018-10-06 04:30:22 +00:00
b9/copy-to-ECX a/imm32
ba/copy-to-EDX 1/imm32/size
b8/copy-to-EAX 4/imm32/write
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
4456 - example with function calls: factorial I found a bug with multiply in the process; another case (after the swap of call/jump opcodes in 4453) where there's no point improving testing. Unit tests can only tell us if our instructions are internally consistent. Validating against a real machine has to be manual. I'm definitely feeling the pain of debugging machine code now, that's for sure. Going over an instruction trace, comparing the state of registers line by line.
2018-07-30 18:23:23 +00:00
4698
2018-10-14 19:53:50 +00:00
# syscall(close, stream)
4561
2018-09-21 04:34:56 +00:00
# load stream
4668
2018-10-06 04:30:22 +00:00
bb/copy-to-EBX stream/imm32
4669
2018-10-06 04:50:20 +00:00
8b/copy 0/mod/indirect 3/rm32/EBX . . . 3/r32/EBX . . # copy *EBX to EBX
4561
2018-09-21 04:34:56 +00:00
#
4668
2018-10-06 04:30:22 +00:00
b8/copy-to-EAX 6/imm32/close
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
4530 - create an apps/ directory
2018-09-01 17:04:58 +00:00
4698
2018-10-14 19:53:50 +00:00
# stream = syscall(open, filename, O_RDONLY, 0)
4668
2018-10-06 04:30:22 +00:00
bb/copy-to-EBX filename/imm32
b9/copy-to-ECX 0/imm32/rdonly
ba/copy-to-EDX 0x180/imm32/fixed-perms
b8/copy-to-EAX 5/imm32/open
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
4561
2018-09-21 04:34:56 +00:00
# save stream
4668
2018-10-06 04:30:22 +00:00
bb/copy-to-EBX stream/imm32
4669
2018-10-06 04:50:20 +00:00
89/copy 0/mod/indirect 3/rm32/EBX . . . 0/r32/EAX . . # copy EAX to *EBX
4530 - create an apps/ directory
2018-09-01 17:04:58 +00:00
4698
2018-10-14 19:53:50 +00:00
# syscall(read, stream, b, 1)
4561
2018-09-21 04:34:56 +00:00
# load stream
4668
2018-10-06 04:30:22 +00:00
bb/copy-to-EBX stream/imm32
4669
2018-10-06 04:50:20 +00:00
8b/copy 0/mod/indirect 3/rm32/EBX . . . 3/r32/EBX . . # copy *EBX to EBX
4561
2018-09-21 04:34:56 +00:00
#
4668
2018-10-06 04:30:22 +00:00
b9/copy-to-ECX b/imm32
ba/copy-to-EDX 1/imm32/size
b8/copy-to-EAX 3/imm32/read
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
4530 - create an apps/ directory
2018-09-01 17:04:58 +00:00
4698
2018-10-14 19:53:50 +00:00
# syscall(close, stream)
4561
2018-09-21 04:34:56 +00:00
# load stream
4668
2018-10-06 04:30:22 +00:00
bb/copy-to-EBX stream/imm32
4669
2018-10-06 04:50:20 +00:00
8b/copy 0/mod/indirect 3/rm32/EBX . . . 3/r32/EBX . . # copy *EBX to EBX
4561
2018-09-21 04:34:56 +00:00
#
4668
2018-10-06 04:30:22 +00:00
b8/copy-to-EAX 6/imm32/close
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
4530 - create an apps/ directory
2018-09-01 17:04:58 +00:00
4698
2018-10-14 19:53:50 +00:00
# syscall(unlink, filename)
4668
2018-10-06 04:30:22 +00:00
bb/copy-to-EBX filename/imm32
b8/copy-to-EAX 0xa/imm32/unlink
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
4530 - create an apps/ directory
2018-09-01 17:04:58 +00:00
4698
2018-10-14 19:53:50 +00:00
# syscall(exit, b)
4561
2018-09-21 04:34:56 +00:00
# load b
4668
2018-10-06 04:30:22 +00:00
bb/copy-to-EBX b/imm32
4669
2018-10-06 04:50:20 +00:00
8b/copy 0/mod/indirect 3/rm32/EBX . . . 3/r32/EBX . . # copy *EBX to EBX
4561
2018-09-21 04:34:56 +00:00
#
4668
2018-10-06 04:30:22 +00:00
b8/copy-to-EAX 1/imm32/exit
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
4530 - create an apps/ directory
2018-09-01 17:04:58 +00:00
4535 - support for global variable names
2018-09-02 06:03:50 +00:00
== data
stream:
4564
2018-09-21 04:54:13 +00:00
00 00 00 00
4535 - support for global variable names
2018-09-02 06:03:50 +00:00
a:
4564
2018-09-21 04:54:13 +00:00
61 00 00 00
4535 - support for global variable names
2018-09-02 06:03:50 +00:00
b:
4564
2018-09-21 04:54:13 +00:00
00 00 00 00
4535 - support for global variable names
2018-09-02 06:03:50 +00:00
filename:
4564
2018-09-21 04:54:13 +00:00
2e 66 6f 6f 00 00 00 00
4530 - create an apps/ directory
2018-09-01 17:04:58 +00:00
4662
2018-10-05 17:42:16 +00:00
# vim:nowrap:textwidth=0