Merge branch 'main' into bitblt

This commit is contained in:
Michał Isalski
2026-09-07 01:46:43 +02:00
12 changed files with 1105 additions and 24 deletions
+13 -1
View File
@@ -16,10 +16,22 @@ All functions in the standard library should follow the following outline:
; Arguments: <which register contains what argument> ; Arguments: <which register contains what argument>
; Result: <what is the result, and where is it stored> ; Result: <what is the result, and where is it stored>
; Clobbers: <list of registers that are clobbered> ; Clobbers: <list of registers that are clobbered>
; Globals: <list of globals are accessed. OPTIONAL>
; Errors: <list of any status codes returned in flags. OPTIONAL>
<label>: <;SHOULD BE INLINED> <label>: <;SHOULD BE INLINED>
<CODE> <CODE>
``` ```
Functions should be in the appropriate asm file, if you are unsure where functionality fits make a seperate file and ask in the pull request Functions should be in the appropriate asm file, if you are unsure where functionality fits make a seperate file and ask in the pull request
Functions that are provided for convenience/reference but should be inlined in production code should be marked with `;SHOULD BE INLINED` after their label Functions that are provided for convenience/reference but should be inlined in production code should be marked with `;SHOULD BE INLINED` after their label.
If the function returns a status code in flags, the preamble should list all it might return.
## Globals
Any function that uses global variables should document this in the preamble comment, see above.
A file/module should check on intialisation that the address `globals.MAGIC_ADDRESS` contains the 16 bit value `globals.MAGIC_VALUE`, to ensure that the user has properly included [[src/start.asm]] and reservered the global variable area.
No opinion is offered on whether modules can assume globals variables are initialised to zero.
+7 -2
View File
@@ -3,7 +3,7 @@
This is a standard library for symphony. This is a standard library for symphony.
It is both intended as a practical toolkit to develop more complex software as well as a teaching resource. It is both intended as a practical toolkit to develop more complex software as well as a teaching resource.
If you just want to use the standard library [[src/stdlib.asm]] is your main header, include it after your code. If you just want to use the standard library [[src/stdlib.asm]] is your main header, include it after your code. Some modules also require [[src/start.asm]] at the very start of the program.
If you are using it as a learning resource have a look at the [teaching folder](teaching). If you are using it as a learning resource have a look at the [teaching folder](teaching).
@@ -20,7 +20,7 @@ If you are intersted in contributing have a look at [[CONTRIBUTING.md]]
| preserved | sp, r8 - r12 | | preserved | sp, r8 - r12 |
| scratch | flags, r1 - r7 | | scratch | flags, r1 - r7 |
| arguments | r1 - r7 | | arguments | r1 - r7 |
| result | r1-r7 | | result | flags, r1 - r7 |
| return address | r13 | | return address | r13 |
Arguments not fitting into the 7 registers should be passed on the top of the stack, meaning they should be the last values pushed before the function call. Arguments not fitting into the 7 registers should be passed on the top of the stack, meaning they should be the last values pushed before the function call.
@@ -32,9 +32,14 @@ Should a function return more values than fit into the 7 registers, the caller h
This reduces the amount of argument registers to 6 and all arguments above that shall go on the stack, the pointer to the result stack shall **always** be passed in an argument register. This reduces the amount of argument registers to 6 and all arguments above that shall go on the stack, the pointer to the result stack shall **always** be passed in an argument register.
This register points at the highest available address for results, with the 8th result being stored there, the 9th below it and so on. This register points at the highest available address for results, with the 8th result being stored there, the 9th below it and so on.
Some functions return a success/failure status code in flags. A set low bit will indicate some error condition, the function may return more than one possible value to report different errors. A flags value of 0 is set on success. No other even values are used. This can be checked with `je` or `jne` immediatly on return to the caller. All other functions clobber flags.
### Stack ### Stack
Grows downwards from 0xXXFE_0000 (so top of memory -0x1_0000). Grows downwards from 0xXXFE_0000 (so top of memory -0x1_0000).
### Globals
Global variables are stored near the bottom of RAM in the address range 0x0010..0x0100. Programs should `include src/start` as the first line before their own code and before other includes, or otherwise reserve this space, the first instruction should be a jump to user code.
### Types ### Types
#### String #### String
+43
View File
@@ -0,0 +1,43 @@
Symphony ISA specs for use in stdlib
# `default.isa`
The stock game ISA. Production code must comply to this. Taken from `symphony_11_functions` in game version 2.1.330A
# `test.isa`
ISA with additional instructions. These additional instructions may be used in
the tests directory only. Some of these instructions require hardware changes.
## Labels in more instructions
`cmp`, `load`, and `store` instructions (but not `pload` and `pstore`) now also accept labels.
## `qcall %a(label)`
Performs a jump-and-link function call, with label size up to 32 bits.
_HARDWARE:_ Store PC+4 in the result register when in jump mode.
## `li %a(register) %b:U32(immediate | label)`
Loads an immediate up to 32 bits long
_HARDWARE:_ No requirements
## `halt%c(condition)`
Halts if `flags` matches the condition.
_HARDWARE:_ Halt if instruction bit 31 is set AND the condition block is true.
```
condition
"" 1000
".all" 1000
".e" 0001
".ne" 1001
".b" 0010
".ae" 1010
".be" 0011
".a" 1011
".l" 0100
".ge" 1100
".le" 0101
".g" 1101
```
+316
View File
@@ -0,0 +1,316 @@
[settings]
name = "Symphony"
[fields]
register
zr 0000
r1 0001
r2 0010
r3 0011
r4 0100
r5 0101
r6 0110
r7 0111
r8 1000
r9 1001
r10 1010
r11 1011
r12 1100
r13 1101
sp 1110
flags 1111
[instructions]
nop
00000000 00000000 00000000 00000000
# (31337_88272577071256, `Does nothing.`)
in %a(register)
00000001 aaaa0000 00000000 00000000
# (31337_44524771082050, `Loads an input and stores it in %a.`)
out %b(register)
00000010 00000000 0000bbbb 00000000
# (31337_18254089726214, `Sends %b to output.`)
out %a:U16(immediate)
00010010 00000000 aaaaaaaa aaaaaaaa
# (31337_15915531259935, `Sends %a to output.`)
keyboard %a(register)
00000011 aaaa0000 00000000 00000000
# (31337_27868418224252, `Loads keyboard input and stores it to %a.`)
screen %a(register), %b(register)
00000100 0000aaaa 0000bbbb 00000000
# (31337_39857449355186, `Stores the value of %b in screen setting %a.`)
screen %a(register), %b:U16(immediate)
00010100 0000aaaa bbbbbbbb bbbbbbbb
# (31337_12835125621741, `Stores the value of %b in screen setting %a.`)
time_0 %a(register)
00000101 aaaa0000 00000000 00000000
# (31337_72551400437977, `Loads the lower four bytes of the time value and stores it to %a.`)
time_1 %a(register)
00000110 aaaa0000 00000000 00000000
# (31337_68219187873304, `Loads the upper four bytes of the time value and stores it to %a.`)
counter %a(register)
00000111 aaaa0000 00000000 00000000
# (31337_67376584796076, `Loads the counter value and stores it to %a.`)
nand %a(register), %b(register), %c(register)
00100000 aaaabbbb 0000cccc 00000000
# (31337_86705346481666, `NAND %b and %c and stores the result in %a.`)
or %a(register), %b(register), %c(register)
00100001 aaaabbbb 0000cccc 00000000
# (31337_40732211165530, `OR %b and %c and stores the result in %a.`)
and %a(register), %b(register), %c(register)
00100010 aaaabbbb 0000cccc 00000000
# (31337_85679146831122, `AND %b and %c and stores the result in %a.`)
nor %a(register), %b(register), %c(register)
00100011 aaaabbbb 0000cccc 00000000
# (31337_37333076617857, `NOR %b and %c and stores the result in %a.`)
add %a(register), %b(register), %c(register)
00100100 aaaabbbb 0000cccc 00000000
# (31337_51030225266712, `ADD %b and %c and stores the result in %a.`)
sub %a(register), %b(register), %c(register)
00100101 aaaabbbb 0000cccc 00000000
# (31337_28652904157569, `SUB %b and %c and stores the result in %a.`)
xor %a(register), %b(register), %c(register)
00100110 aaaabbbb 0000cccc 00000000
# (31337_46967848572964, `XOR %b and %c and stores the result in %a.`)
lsl %a(register), %b(register), %c(register)
00100111 aaaabbbb 0000cccc 00000000
# (31337_13576771671264, `Logical shifts left %b by %c and stores the result in %a.`)
lsr %a(register), %b(register), %c(register)
00101000 aaaabbbb 0000cccc 00000000
# (31337_67019902294705, `Logical shifts right %b by %c and stores the result in %a.`)
asr %a(register), %b(register), %c(register)
00101001 aaaabbbb 0000cccc 00000000
# (31337_42626144645228, `Arithmetic shift right %b by %c and stores the result in %a.`)
cmp %a(register), %b(register)
00101010 1111aaaa 0000bbbb 00000000
# (31337_54565380946620, `Compares %a and %b and stores the result in the 'flags' register.`)
nand %a(register), %b(register), %c:U16(immediate | label)
00110000 aaaabbbb cccccccc cccccccc
# (31337_75302656449127, `NAND %b and %c and stores the result in %a.`)
or %a(register), %b(register), %c:U16(immediate | label)
00110001 aaaabbbb cccccccc cccccccc
# (31337_30574433901064, `OR %b and %c and stores the result in %a.`)
nor %a(register), %b(register), %c:U16(immediate | label)
00110011 aaaabbbb cccccccc cccccccc
# (31337_46087142860391, `NOR %b and %c and stores the result in %a.`)
and %a(register), %b(register), %c:U16(immediate | label)
00110010 aaaabbbb cccccccc cccccccc
# (31337_86713121915282, `AND %b and %c and stores the result in %a.`)
add %a(register), %b(register), %c:U16(immediate | label)
00110100 aaaabbbb cccccccc cccccccc
# (31337_23349431010010, `ADD %b and %c and stores the result in %a.`)
sub %a(register), %b(register), %c:U16(immediate | label)
00110101 aaaabbbb cccccccc cccccccc
# (31337_67495552371225, `SUB %b and %c and stores the result in %a.`)
xor %a(register), %b(register), %c:U16(immediate | label)
00110110 aaaabbbb cccccccc cccccccc
# (31337_66785854415645, `XOR %b and %c and stores the result in %a.`)
lsl %a(register), %b(register), %c:U16(immediate | label)
00110111 aaaabbbb cccccccc cccccccc
# (31337_54577249258785, `Logical shifts left %b by %c and stores the result in %a.`)
lsr %a(register), %b(register), %c:U16(immediate | label)
00111000 aaaabbbb cccccccc cccccccc
# (31337_16685334571248, `Logical shifts right %b by %c and stores the result in %a.`)
asr %a(register), %b(register), %c:U16(immediate | label)
00111001 aaaabbbb cccccccc cccccccc
# (31337_55551510150818, `Arithmetic shifts right %b and %c and stores the result in %a.`)
cmp %a(register), %b:U16(immediate)
00111010 1111aaaa bbbbbbbb bbbbbbbb
# (31337_37102964808364, `Compares %a and %b and stores the result in the 'flags' register.`)
jmp %a(register)
01001000 00001111 0000aaaa 00000000
# (31337_74148826866592, `Jumps to %a.`)
jmp %a:U16(immediate | label)
01011000 00001111 aaaaaaaa aaaaaaaa
# (31337_90876214388280, `Jumps to %a.`)
je %a:U16(immediate | label)
01010001 00001111 aaaaaaaa aaaaaaaa
# (31337_88180305667389, `Jumps to %a if the values were equal (reading results from 'flags').`)
jne %a:U16(immediate | label)
01011001 00001111 aaaaaaaa aaaaaaaa
# (31337_67178948469318, `Jumps to %a if the values were not equal (reading results from 'flags').`)
jb %a:U16(immediate | label)
01010010 00001111 aaaaaaaa aaaaaaaa
# (31337_31763492459833, `Jumps to %a if the first value was below (unsigned) the second (reading results from 'flags').`)
jae %a:U16(immediate | label)
01011010 00001111 aaaaaaaa aaaaaaaa
# (31337_82087388048746, `Jumps to %a if the first value was above (unsigned) or equal to the second (reading results from 'flags').`)
jbe %a:U16(immediate | label)
01010011 00001111 aaaaaaaa aaaaaaaa
# (31337_26183125927881, `Jumps to %a if the First value was below (unsigned) or equal to the second (reading results from 'flags').`)
ja %a:U16(immediate | label)
01011011 00001111 aaaaaaaa aaaaaaaa
# (31337_11626177279992, `Jumps to %a if the first value was above (unsigned) the second (reading results from 'flags').`)
jl %a:U16(immediate | label)
01010100 00001111 aaaaaaaa aaaaaaaa
# (31337_71637103729391, `Jumps to %a if the first value was less (signed) than the second (reading results from 'flags').`)
jge %a:U16(immediate | label)
01011100 00001111 aaaaaaaa aaaaaaaa
# (31337_53499765587663, `Jumps to %a if the first value was greater (signed) or equal to the second (reading results from 'flags').`)
jle %a:U16(immediate | label)
01010101 00001111 aaaaaaaa aaaaaaaa
# (31337_77040234358389, `Jumps to %a if the first value was less (signed) or equal to the second (reading results from 'flags').`)
jg %a:U16(immediate | label)
01011101 00001111 aaaaaaaa aaaaaaaa
# (31337_71317192057126, `Jumps to %a if the first value was greater (signed) than the second (reading results from 'flags').`)
load_8 %dest(register), [%adr(register)]
01100000 dddd0000 0000aaaa 00000000
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
load_8 %dest(register), [%adr:U16(immediate)]
01110000 dddd0000 aaaaaaaa aaaaaaaa
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
load_16 %dest(register), [%adr(register)]
01100001 dddd0000 0000aaaa 00000000
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
load_16 %dest(register), [%adr:U16(immediate)]
01110001 dddd0000 aaaaaaaa aaaaaaaa
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
load_32 %dest(register), [%adr(register)]
01100010 dddd0000 0000aaaa 00000000
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
load_32 %dest(register), [%adr:U16(immediate)]
01110010 dddd0000 aaaaaaaa aaaaaaaa
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
pload %dest(register), [%adr(register)]
01100011 dddd0000 0000aaaa 00000000
# (31337_89257021109854, `Loads address %adr from persistent memory and stores it to %dest.`)
pload %dest(register), [%adr:U16(immediate)]
01110011 dddd0000 aaaaaaaa aaaaaaaa
# (31337_89257021109854, `Loads address %adr from persistent memory and stores it to %dest.`)
store_8 [%adr(register)], %value(register)
01100100 0000vvvv 0000aaaa 00000000
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
store_8 [%adr:U16(immediate)], %value(register)
01110100 0000vvvv aaaaaaaa aaaaaaaa
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
store_16 [%adr(register)], %value(register)
01100101 0000vvvv 0000aaaa 00000000
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
store_16 [%adr:U16(immediate)], %value(register)
01110101 0000vvvv aaaaaaaa aaaaaaaa
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
store_32 [%adr(register)], %value(register)
01100110 0000vvvv 0000aaaa 00000000
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
store_32 [%adr:U16(immediate)], %value(register)
01110110 0000vvvv aaaaaaaa aaaaaaaa
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
pstore [%adr(register)], %value(register)
01100111 0000vvvv 0000aaaa 00000000
# (31337_13110303123442, `Stores %value to address %adr in persistent memory.`)
pstore [%adr:U16(immediate)], %value(register)
01110111 0000vvvv aaaaaaaa aaaaaaaa
# (31337_13110303123442, `Stores %value to address %adr in persistent memory.`)
mov %a(register), %b(register)
00100001 aaaa0000 0000bbbb 00000000
# (31337_53941960758392, `Moves a value to %a from %b.`)
mov %a(register), %b:U16(immediate | label)
00110001 aaaa0000 bbbbbbbb bbbbbbbb
# (31337_34859363394334, `Moves a value to %a.`)
neg %a(register), %b(register)
00100101 aaaa0000 0000bbbb 00000000
# (31337_72894099288447, `Negates a %b and stores it in %a.`)
neg %a(register), %b:U16(immediate | label)
00110101 aaaa0000 bbbbbbbb bbbbbbbb
# (31337_57504570243305, `Negates a value and stores it in %a.`)
not %a(register), %b(register)
00100011 aaaa0000 0000bbbb 00000000
# (31337_55357258069734, `Toggles the bits of %b and stores it in %a.`)
not %a(register), %b:U16(immediate | label)
00110011 aaaa0000 bbbbbbbb bbbbbbbb
# (31337_40508048121543, `Toggles the bits of a value and stores it in %a.`)
push %a(register)
00110101 11101110 00000000 00000100 01100110 0000aaaa 00001110 00000000
# (31337_28545157055801, `Pushes %a onto the stack. This instruction is a synonym for: sub sp, sp, 4 store_32 [sp], %a`)
pop %a(register)
01100010 aaaa0000 00001110 00000000 00110100 11101110 00000000 00000100
# (31337_54469754973269, `Pops %a off the stack. This instruction is a synonym for: load_32 %a, [sp] add sp, sp, 4`)
call %a(label)
00000111 11110000 00000000 00000000 00110100 11111111 00000000 00010100 00110101 11101110 00000000 00000100 01100110 00001111 00001110 00000000 01011000 00001111 aaaaaaaa aaaaaaaa
# (31337_57788320241950, `Calls %a. Overwrites the flag register. This instruction is a synonym for: counter flags add flags, flags, 20 sub sp, sp, 4 store_32 [sp], flags jmp %a`)
ret
01100010 11110000 00001110 00000000 00110100 11101110 00000000 00000100 01001000 00001111 00001111 00000000
# (31337_48332460366102, `Returns from the last function call. Overwrites the flag register. This instruction is a synonym for: load_32 flags, [sp] add sp, sp, 4 jmp flags`)
+361
View File
@@ -0,0 +1,361 @@
[settings]
name = "Symphony"
[fields]
register
zr 0000
r1 0001
r2 0010
r3 0011
r4 0100
r5 0101
r6 0110
r7 0111
r8 1000
r9 1001
r10 1010
r11 1011
r12 1100
r13 1101
sp 1110
flags 1111
condition
"" 1000
".all" 1000
".e" 0001
".ne" 1001
".b" 0010
".ae" 1010
".be" 0011
".a" 1011
".l" 0100
".ge" 1100
".le" 0101
".g" 1101
[instructions]
nop
00000000 00000000 00000000 00000000
# (31337_88272577071256, `Does nothing.`)
in %a(register)
00000001 aaaa0000 00000000 00000000
# (31337_44524771082050, `Loads an input and stores it in %a.`)
out %b(register)
00000010 00000000 0000bbbb 00000000
# (31337_18254089726214, `Sends %b to output.`)
out %a:U16(immediate)
00010010 00000000 aaaaaaaa aaaaaaaa
# (31337_15915531259935, `Sends %a to output.`)
keyboard %a(register)
00000011 aaaa0000 00000000 00000000
# (31337_27868418224252, `Loads keyboard input and stores it to %a.`)
screen %a(register), %b(register)
00000100 0000aaaa 0000bbbb 00000000
# (31337_39857449355186, `Stores the value of %b in screen setting %a.`)
screen %a(register), %b:U16(immediate)
00010100 0000aaaa bbbbbbbb bbbbbbbb
# (31337_12835125621741, `Stores the value of %b in screen setting %a.`)
time_0 %a(register)
00000101 aaaa0000 00000000 00000000
# (31337_72551400437977, `Loads the lower four bytes of the time value and stores it to %a.`)
time_1 %a(register)
00000110 aaaa0000 00000000 00000000
# (31337_68219187873304, `Loads the upper four bytes of the time value and stores it to %a.`)
counter %a(register)
00000111 aaaa0000 00000000 00000000
# (31337_67376584796076, `Loads the counter value and stores it to %a.`)
nand %a(register), %b(register), %c(register)
00100000 aaaabbbb 0000cccc 00000000
# (31337_86705346481666, `NAND %b and %c and stores the result in %a.`)
or %a(register), %b(register), %c(register)
00100001 aaaabbbb 0000cccc 00000000
# (31337_40732211165530, `OR %b and %c and stores the result in %a.`)
and %a(register), %b(register), %c(register)
00100010 aaaabbbb 0000cccc 00000000
# (31337_85679146831122, `AND %b and %c and stores the result in %a.`)
nor %a(register), %b(register), %c(register)
00100011 aaaabbbb 0000cccc 00000000
# (31337_37333076617857, `NOR %b and %c and stores the result in %a.`)
add %a(register), %b(register), %c(register)
00100100 aaaabbbb 0000cccc 00000000
# (31337_51030225266712, `ADD %b and %c and stores the result in %a.`)
sub %a(register), %b(register), %c(register)
00100101 aaaabbbb 0000cccc 00000000
# (31337_28652904157569, `SUB %b and %c and stores the result in %a.`)
xor %a(register), %b(register), %c(register)
00100110 aaaabbbb 0000cccc 00000000
# (31337_46967848572964, `XOR %b and %c and stores the result in %a.`)
lsl %a(register), %b(register), %c(register)
00100111 aaaabbbb 0000cccc 00000000
# (31337_13576771671264, `Logical shifts left %b by %c and stores the result in %a.`)
lsr %a(register), %b(register), %c(register)
00101000 aaaabbbb 0000cccc 00000000
# (31337_67019902294705, `Logical shifts right %b by %c and stores the result in %a.`)
asr %a(register), %b(register), %c(register)
00101001 aaaabbbb 0000cccc 00000000
# (31337_42626144645228, `Arithmetic shift right %b by %c and stores the result in %a.`)
cmp %a(register), %b(register)
00101010 1111aaaa 0000bbbb 00000000
# (31337_54565380946620, `Compares %a and %b and stores the result in the 'flags' register.`)
nand %a(register), %b(register), %c:U16(immediate | label)
00110000 aaaabbbb cccccccc cccccccc
# (31337_75302656449127, `NAND %b and %c and stores the result in %a.`)
or %a(register), %b(register), %c:U16(immediate | label)
00110001 aaaabbbb cccccccc cccccccc
# (31337_30574433901064, `OR %b and %c and stores the result in %a.`)
nor %a(register), %b(register), %c:U16(immediate | label)
00110011 aaaabbbb cccccccc cccccccc
# (31337_46087142860391, `NOR %b and %c and stores the result in %a.`)
and %a(register), %b(register), %c:U16(immediate | label)
00110010 aaaabbbb cccccccc cccccccc
# (31337_86713121915282, `AND %b and %c and stores the result in %a.`)
add %a(register), %b(register), %c:U16(immediate | label)
00110100 aaaabbbb cccccccc cccccccc
# (31337_23349431010010, `ADD %b and %c and stores the result in %a.`)
sub %a(register), %b(register), %c:U16(immediate | label)
00110101 aaaabbbb cccccccc cccccccc
# (31337_67495552371225, `SUB %b and %c and stores the result in %a.`)
xor %a(register), %b(register), %c:U16(immediate | label)
00110110 aaaabbbb cccccccc cccccccc
# (31337_66785854415645, `XOR %b and %c and stores the result in %a.`)
lsl %a(register), %b(register), %c:U16(immediate | label)
00110111 aaaabbbb cccccccc cccccccc
# (31337_54577249258785, `Logical shifts left %b by %c and stores the result in %a.`)
lsr %a(register), %b(register), %c:U16(immediate | label)
00111000 aaaabbbb cccccccc cccccccc
# (31337_16685334571248, `Logical shifts right %b by %c and stores the result in %a.`)
asr %a(register), %b(register), %c:U16(immediate | label)
00111001 aaaabbbb cccccccc cccccccc
# (31337_55551510150818, `Arithmetic shifts right %b and %c and stores the result in %a.`)
cmp %a(register), %b:U16(immediate | label)
00111010 1111aaaa bbbbbbbb bbbbbbbb
# (31337_37102964808364, `Compares %a and %b and stores the result in the 'flags' register.`)
jmp %a(register)
01001000 00001111 0000aaaa 00000000
# (31337_74148826866592, `Jumps to %a.`)
jmp %a:U16(immediate | label)
01011000 00001111 aaaaaaaa aaaaaaaa
# (31337_90876214388280, `Jumps to %a.`)
je %a:U16(immediate | label)
01010001 00001111 aaaaaaaa aaaaaaaa
# (31337_88180305667389, `Jumps to %a if the values were equal (reading results from 'flags').`)
jne %a:U16(immediate | label)
01011001 00001111 aaaaaaaa aaaaaaaa
# (31337_67178948469318, `Jumps to %a if the values were not equal (reading results from 'flags').`)
jb %a:U16(immediate | label)
01010010 00001111 aaaaaaaa aaaaaaaa
# (31337_31763492459833, `Jumps to %a if the first value was below (unsigned) the second (reading results from 'flags').`)
jae %a:U16(immediate | label)
01011010 00001111 aaaaaaaa aaaaaaaa
# (31337_82087388048746, `Jumps to %a if the first value was above (unsigned) or equal to the second (reading results from 'flags').`)
jbe %a:U16(immediate | label)
01010011 00001111 aaaaaaaa aaaaaaaa
# (31337_26183125927881, `Jumps to %a if the First value was below (unsigned) or equal to the second (reading results from 'flags').`)
ja %a:U16(immediate | label)
01011011 00001111 aaaaaaaa aaaaaaaa
# (31337_11626177279992, `Jumps to %a if the first value was above (unsigned) the second (reading results from 'flags').`)
jl %a:U16(immediate | label)
01010100 00001111 aaaaaaaa aaaaaaaa
# (31337_71637103729391, `Jumps to %a if the first value was less (signed) than the second (reading results from 'flags').`)
jge %a:U16(immediate | label)
01011100 00001111 aaaaaaaa aaaaaaaa
# (31337_53499765587663, `Jumps to %a if the first value was greater (signed) or equal to the second (reading results from 'flags').`)
jle %a:U16(immediate | label)
01010101 00001111 aaaaaaaa aaaaaaaa
# (31337_77040234358389, `Jumps to %a if the first value was less (signed) or equal to the second (reading results from 'flags').`)
jg %a:U16(immediate | label)
01011101 00001111 aaaaaaaa aaaaaaaa
# (31337_71317192057126, `Jumps to %a if the first value was greater (signed) than the second (reading results from 'flags').`)
load_8 %dest(register), [%adr(register)]
01100000 dddd0000 0000aaaa 00000000
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
load_8 %dest(register), [%adr:U16(immediate | label)]
01110000 dddd0000 aaaaaaaa aaaaaaaa
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
load_16 %dest(register), [%adr(register)]
01100001 dddd0000 0000aaaa 00000000
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
load_16 %dest(register), [%adr:U16(immediate | label)]
01110001 dddd0000 aaaaaaaa aaaaaaaa
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
load_32 %dest(register), [%adr(register)]
01100010 dddd0000 0000aaaa 00000000
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
load_32 %dest(register), [%adr:U16(immediate | label)]
01110010 dddd0000 aaaaaaaa aaaaaaaa
# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
pload %dest(register), [%adr(register)]
01100011 dddd0000 0000aaaa 00000000
# (31337_89257021109854, `Loads address %adr from persistent memory and stores it to %dest.`)
pload %dest(register), [%adr:U16(immediate)]
01110011 dddd0000 aaaaaaaa aaaaaaaa
# (31337_89257021109854, `Loads address %adr from persistent memory and stores it to %dest.`)
store_8 [%adr(register)], %value(register)
01100100 0000vvvv 0000aaaa 00000000
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
store_8 [%adr:U16(immediate | label)], %value(register)
01110100 0000vvvv aaaaaaaa aaaaaaaa
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
store_16 [%adr(register)], %value(register)
01100101 0000vvvv 0000aaaa 00000000
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
store_16 [%adr:U16(immediate | label)], %value(register)
01110101 0000vvvv aaaaaaaa aaaaaaaa
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
store_32 [%adr(register)], %value(register)
01100110 0000vvvv 0000aaaa 00000000
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
store_32 [%adr:U16(immediate | label)], %value(register)
01110110 0000vvvv aaaaaaaa aaaaaaaa
# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
pstore [%adr(register)], %value(register)
01100111 0000vvvv 0000aaaa 00000000
# (31337_13110303123442, `Stores %value to address %adr in persistent memory.`)
pstore [%adr:U16(immediate)], %value(register)
01110111 0000vvvv aaaaaaaa aaaaaaaa
# (31337_13110303123442, `Stores %value to address %adr in persistent memory.`)
mov %a(register), %b(register)
00100001 aaaa0000 0000bbbb 00000000
# (31337_53941960758392, `Moves a value to %a from %b.`)
mov %a(register), %b:U16(immediate | label)
00110001 aaaa0000 bbbbbbbb bbbbbbbb
# (31337_34859363394334, `Moves a value to %a.`)
neg %a(register), %b(register)
00100101 aaaa0000 0000bbbb 00000000
# (31337_72894099288447, `Negates a %b and stores it in %a.`)
neg %a(register), %b:U16(immediate | label)
00110101 aaaa0000 bbbbbbbb bbbbbbbb
# (31337_57504570243305, `Negates a value and stores it in %a.`)
not %a(register), %b(register)
00100011 aaaa0000 0000bbbb 00000000
# (31337_55357258069734, `Toggles the bits of %b and stores it in %a.`)
not %a(register), %b:U16(immediate | label)
00110011 aaaa0000 bbbbbbbb bbbbbbbb
# (31337_40508048121543, `Toggles the bits of a value and stores it in %a.`)
push %a(register)
00110101 11101110 00000000 00000100 01100110 0000aaaa 00001110 00000000
# (31337_28545157055801, `Pushes %a onto the stack. This instruction is a synonym for: sub sp, sp, 4 store_32 [sp], %a`)
pop %a(register)
01100010 aaaa0000 00001110 00000000 00110100 11101110 00000000 00000100
# (31337_54469754973269, `Pops %a off the stack. This instruction is a synonym for: load_32 %a, [sp] add sp, sp, 4`)
call %a(label)
00000111 11110000 00000000 00000000 00110100 11111111 00000000 00010100 00110101 11101110 00000000 00000100 01100110 00001111 00001110 00000000 01011000 00001111 aaaaaaaa aaaaaaaa
# (31337_57788320241950, `Calls %a. Overwrites the flag register. This instruction is a synonym for: counter flags add flags, flags, 20 sub sp, sp, 4 store_32 [sp], flags jmp %a`)
ret
01100010 11110000 00001110 00000000 00110100 11101110 00000000 00000100 01001000 00001111 00001111 00000000
# (31337_48332460366102, `Returns from the last function call. Overwrites the flag register. This instruction is a synonym for: load_32 flags, [sp] add sp, sp, 4 jmp flags`)
li %r(register), %a:S33(immediate | label)
; assert(0 - 0x80000000 <= %a, "%a is too low")
; assert(%a <= 0xffffffff, "%a is too high")
%s = trailing_zeros(%a)
%sa = %a >> %s
%nota = %a ^ 0xffffffff
when %a <=u 0xffff : 00110001 %r[3:0]0000 %a[15:0] ; First 64k
when %nota <=u 0xffff: 00110001 %r[3:0]0000 %nota[15:0] 00100011 %r[3:0]0000 0000%r[3:0] 00000000 ; Last 64k
when %sa <=u 0xffff : 00110001 %r[3:0]0000 %sa[15:0] 00110111 %r[3:0]%r[3:0] 00000000 %s[7:0] ; Aligned
00110001 %r[3:0]0000 %a[31:16] 00110111 %r[3:0]%r[3:0] 00000000 00010000 00110001 %r[3:0]%r[3:0] %a[15:0] ; Any 32-bit
# Load 32-bit immediate %a into %r
qcall %a:U32(label)
; assert(0 - 0x80000000 <= %a, "%a is too low")
; assert(%a <= 0xffffffff, "%a is too high")
%r = 13
%f = 15
%s = trailing_zeros(%a)
%sa = %a >> %s
%nota = %a ^ 0xffffffff
when %a <=u 0xffff : 01011000 %r[3:0]ffff %a[15:0] ; First 64k
when %nota <=u 0xffff: 00110001 %r[3:0]0000 %nota[15:0] 00100011 %r[3:0]0000 0000%r[3:0] 00000000 01001000 %r[3:0]ffff 0000%r[3:0] 00000000 ; Last 64k
when %sa <=u 0xffff : 00110001 %r[3:0]0000 %sa[15:0] 00110111 %r[3:0]%r[3:0] 00000000 %s[7:0] 01001000 %r[3:0]ffff 0000%r[3:0] 00000000 ; Aligned
00110001 %r[3:0]0000 %a[31:16] 00110111 %r[3:0]%r[3:0] 00000000 00010000 00110001 %r[3:0]%r[3:0] %a[15:0] 01001000 %r[3:0]ffff 0000%r[3:0] 00000000 ; Any 32-bit
# Jump and link to 32-bit label
halt%c(condition)
1000cccc 00001111 00000000 00000000
# Halt on condition %c
Executable
+27
View File
@@ -0,0 +1,27 @@
; Error numbers should be 16 bit ODD numbers, so they can be loaded as immediates
; and can be checked with:
;
; qcall falible_function
; jne falible_ok ; Jump no error
; ; handle error
; falible_ok:
; ; Happy path
; ; ...
; OR
; qcall falible_function
; je handle_error ; Jump if error
; ; Happy path
; ; ...
; handle_error:
; ; handle error
pub const OK = 0x0000
pub const SCREEN_INVALID_MODE = 0x0001
pub const SCREEN_INVALID_WIDTH = 0x0003
pub const SCREEN_FB_TOO_SMALL = 0x0005
pub const SCREEN_OUTSIDE_FB = 0x0007
pub const MAGIC_BAD = 0x8001
; Extended error codes, these would require loading a 32 bit value.
pub const EXT_OK = 0x00000000
+30
View File
@@ -0,0 +1,30 @@
; Addresses of global variables
pub const MAGIC_ADDRESS_LONG = 0x0c ; U32 Location of the magic value
pub const MAGIC_VALUE_LONG = 0xb301534c ; U32 Full 32 bits of the magic value
pub const MAGIC_ADDRESS = 0x0e ; U16 Location of the low 16 bits of magic value
pub const MAGIC_VALUE = 0x534c ; U16 Low 16 bits of the magic value
; If not double buffering these point to the same buffer
; If double buffering they must the same size
pub const FB_DISPLAY_PTR = 0x10 ; U32 Currently displayed buffer
pub const FB_DISPLAY_STRIDE = 0x14 ; U16 Bytes in each row of the displayed buffer
pub const FB_DISPLAY_DEPTH = 0x16 ; U16 Bits per pixel of the display buffer
pub const FB_DRAW_PTR = 0x18 ; U32 Draw to this buffer
pub const FB_DRAW_STRIDE = 0x1c ; U16 Bytes in each row of the draw buffer == FB_DISPLAY_STRIDE
pub const FB_DRAW_DEPTH = 0x1e ; U16 Bits per pixel of the draw buffer == FB_DISPLAY_DEPTH
pub const FB_SIZE_BYTE = 0x20 ; U32 In bytes
pub const FB_WIDTH_PX = 0x24 ; U16 Width of screen in pixels
pub const FB_HEIGHT_PX = 0x26 ; U16 Height of screen in pixels
; Log2 of width in pixels, e.g.
; * 10 => 1024 * 768
; * 8 => 256 * 192
pub const FB_LOG_WIDTH = 0x28 ; U8
pub const FB_LOG_STRIDE = 0x29 ; U8 Log2 of FB_xxx_STRIDE in bytes
pub const FB_BYTES_PER_PIXEL = 0x2a ; U8 Specialisations should hardcode this
; Log2 of bytes per pixel
; * 0 => 8 bits per pixel
; * 2 => 32 bits per pixel
pub const FB_LOG_BPP = 0x2b ; U8 Specialisations should hardcode this
+41 -19
View File
@@ -4,29 +4,51 @@
; r2 - The second value ; r2 - The second value
; Result: ; Result:
; r1 - The lower 32 bits of the result ; r1 - The lower 32 bits of the result
; Clobbers: r2, r3, r4, r5 ; Clobbers: r2, r3, r4, r5, r6
pub mul_low: pub mul_low:
add r3, r2, r2 ; r3 = r2 * 2 cmp r1, r2
jbe mul_low_noswap
xor r1, r2, r1
xor r2, r1, r2
xor r1, r2, r1
; Passthrough
; Multiplies r1 and r2, returning the lower part of the result
; This method assumes r1 is smaller than r2, which results in faster execution
; Arguments:
; r1 - The first value
; r2 - The second value
; Result:
; r1 - The lower 32 bits of the result
; Clobbers: r2, r3, r4, r5, r6
pub mul_low_noswap:
mov r4, 0 ; r4 has the result mov r4, 0 ; r4 has the result
mov r6, mul_loop_end
add r3, r2, r2
mul_low_loop: mul_loop:
and r5, r1, 14 ; Taking the first four bits, discarding the odd
lsl r5, r5, 1 ; 0000 - 0, 0001 - 2, 0010 - 4, 0011 - 8, etc.
sub r5, r6, r5
jmp r5
and r5, r1, 1 ; a0 add r4, r4, r3
neg r5, r5 ; mask add r4, r4, r3
and r5, r2, r5 ; a0 ? r2 : 0 add r4, r4, r3
add r4, r4, r5 add r4, r4, r3
add r4, r4, r3
and r5, r1, 2 ; a1 is now 0 or 2 add r4, r4, r3
lsr r5, r5, 1 ; normalize to 0/1 add r4, r4, r3
neg r5, r5 ; mask mul_loop_end:
and r5, r3, r5 ; a1 ? r2 * 2 : 0 mov flags, r1
add r4, r4, r5 jne mul_skip_one
add r4, r4, r2
lsl r2, r2, 2 mul_skip_one:
lsl r3, r3, 2 lsl r2, r2, 4
lsr r1, r1, 2 lsl r3, r3, 4
cmp r1, zr lsr r1, r1, 4
jne mul_low_loop cmp r1, zr
jne mul_loop
mov r1, r4 mov r1, r4
jmp r13 jmp r13
Executable
+19
View File
@@ -0,0 +1,19 @@
;@0 ; Reserve space for globals
; First initialise the stack pointer
nor sp, zr, 0xffff
; Jump over the globals to user code
jmp 0x100
U32 0 ; 4 bytes
; MAGIC_VALUE
;@0x0c
U32 0xb301534c
; Pad with zeroes since the @addr feature is currently broken.
; * https://discord.com/channels/828292123936948244/1545010596246847568
;
U1920 0 ; 240 bytes
;@0x100 ; start of user code
+1
View File
@@ -3,6 +3,7 @@ pub include imath
pub include array pub include array
pub include console pub include console
pub include mem pub include mem
pub include string_to_int
; Needs to be last! ; Needs to be last!
pub include LUTs pub include LUTs
+188
View File
@@ -0,0 +1,188 @@
; Internal register assignments:
; r1 - Partially parsed output integer
; r2 - Parsing position
; r3 - Character being parsed
; r4 - Set to -1 if the input is negative
; Convert string to integer (akin to libc atoi(), strotoi())
; Arguments:
; r1 - Pointer to string
; Result:
; r1 - Parsed integer
; r2 - Pointer to first rejected input byte
; Clobbers:
; flags
; r3 - last character read
; r4 - Negative marker
; Note: Unless the input is "0", tail-calls into a base-specific specialization.
pub auto:
mov r2, r1
mov r1, 0
mov r4, 0
load_8 r3, [r2]
cmp r3, 0x2D ; '-'
jne auto_positive
sub r4, zr, 1 ; Set r4 to -1
add r2, r2, 1
auto_positive:
load_16 r3, [r2] ; 2-byte prefix "0b", "0o", "0x", etc.
or r3, r3, 0x20 ; 2nd char to lower case
add r2, r2, 2
cmp r3, 0x3062 ; "0b"
je bin_loop
cmp r3, 0x306F ; "0o"
je oct_loop
cmp r3, 0x3078 ; "0x"
je hex_loop
sub r2, r2, 2 ; no matching prefix, move pointer back
jmp dec_loop
; Epilogue
done:
add r1, r1, r4 ; If r4 is -1, negate r1. Else it's 0 and no effect.
xor r1, r1, r4
mov flags, 0 ; No error
jmp r13
; Convert decimal string to integer
; Arguments:
; r1 - Pointer to string
; Result:
; r1 - Parsed integer
; r2 - Pointer to first rejected input byte
; Clobbers:
; flags
; r3 - last character read
; r4 - Negative marker
pub dec:
mov r2, r1
mov r1, 0
mov r4, 0
load_8 r3, [r2]
cmp r3, 0x2D ; '-'
jne dec_positive
sub r4, zr, 1 ; Set r4 to -1
add r2, r2, 1
dec_loop:
load_8 r3, [r2]
dec_positive:
sub r3, r3, 0x30 ; '0'
cmp r3, 9
ja done
add r2, r2, 1
lsl flags, r1, 2 ; Use flags to help multiply by 10
add r1, r1, flags
lsl r1, r1, 1
add r1, r1, r3
jmp dec_loop
; Convert binary string to integer
; Arguments:
; r1 - Pointer to string
; Result:
; r1 - Parsed integer
; r2 - Pointer to first rejected input byte
; Clobbers:
; flags
; r3 - last character read
; r4 - Negative marker
pub bin:
mov r2, r1
mov r1, 0
mov r4, 0
load_8 r3, [r2]
cmp r3, 0x2D ; '-'
jne bin_positive
sub r4, zr, 1 ; Set r4 to -1
add r2, r2, 1
bin_positive:
load_16 r3, [r2] ; check for prefix
or r3, r3, 0x20 ; 2nd char to lower case
cmp r3, 0x3062 ; "0b"
jne bin_loop
add r2, r2, 2
bin_loop:
load_8 r3, [r2]
sub r3, r3, 0x30 ; '0'
cmp r3, 1
ja done
add r2, r2, 1
lsl r1, r1, 1
add r1, r1, r3
jmp bin_loop
; Convert octal string to integer
; Arguments:
; r1 - Pointer to string
; Result:
; r1 - Parsed integer
; r2 - Pointer to first rejected input byte
; Clobbers:
; flags
; r3 - last character read
; r4 - Negative marker
pub oct:
mov r2, r1
mov r1, 0
mov r4, 0
load_8 r3, [r2]
cmp r3, 0x2D ; '-'
jne oct_positive
sub r4, zr, 1 ; Set r4 to -1
add r2, r2, 1
oct_positive:
load_16 r3, [r2] ; check for prefix
or r3, r3, 0x20 ; 2nd char to lower case
cmp r3, 0x306F ; "0o"
jne oct_loop
add r2, r2, 2
oct_loop:
load_8 r3, [r2]
sub r3, r3, 0x30 ; '0'
cmp r3, 7
ja done
add r2, r2, 1
lsl r1, r1, 3
add r1, r1, r3
jmp oct_loop
; Convert hexadecimal string to integer
; Arguments:
; r1 - Pointer to string
; Result:
; r1 - Parsed integer
; r2 - Pointer to first rejected input byte
; Clobbers:
; flags
; r3 - last character read
; r4 - Negative marker
pub hex:
mov r2, r1
mov r1, 0
mov r4, 0
load_8 r3, [r2]
cmp r3, 0x2D ; '-'
jne hex_positive
sub r4, zr, 1 ; Set r4 to -1
add r2, r2, 1
hex_positive:
load_16 r3, [r2] ; check for prefix
or r3, r3, 0x20 ; 2nd char to lower case
cmp r3, 0x3078 ; "0x"
jne hex_loop
add r2, r2, 2
hex_loop:
load_8 r3, [r2]
sub r3, r3, 0x30 ; '0'
cmp r3, 10
jb hex_add
sub r3, r3, 0x11 ; 'A' - '0'
and r3, r3, 0xdf ; to lower case
cmp r3, 5 ; 0-5: 6 letters
ja done
add r3, r3, 10 ; Adjust for digits below
hex_add:
add r2, r2, 1
lsl r1, r1, 4
add r1, r1, r3
jmp hex_loop
+57
View File
@@ -0,0 +1,57 @@
; test harness for string_to_int
; Registers:
; r8 - test address
; r9 - expected result
; r10 - actual length
; r11 - expected length
li r8, tests
li r12, end_of_tests
next_test:
; Set up arguments and run test
add r1, r8, 5 ; Start of test string
mov r13, atoi_test_ret
jmp stdlib.string_to_int.auto
atoi_test_ret:
; Load reference data
load_32 r9, [r8] ; Expected result
sub r10, r2, r8
sub r10, r10, 5 ; Actual string length
add r11, r8, 4 ; Address of expected length
load_8 r11, [r11] ; Expected length
; Verify results
cmp r1, r9
incorrect_result: jne incorrect_result
cmp r10, r11
incorrect_length: jne incorrect_length
; Next test
add r8, r8, 0x10
cmp r8, r12
jl next_test
; Done
success: jmp success
include ../src/stdlib
@0x20000
tests:
; inlen is the number of input bytes the function is expected to consume
; addr result inlen instr
@0x20000 U32 0 U8 0 "\0"
@0x20010 U32 0 U8 1 "0\0"
@0x20020 U32 1 U8 1 "1\0"
@0x20030 U32 2 U8 1 "2:\0"
@0x20040 U32 42 U8 2 "42\0"
@0x20050 U32 67 U8 2 "67lol\0"
@0x20060 U32 0x69a U8 5 "0x69a@\0"
@0x20070 U32 0x4B4 U8 5 "0x4B4g\0"
@0x20080 U32 0o23 U8 4 "0o239\0"
@0x20090 U32 0b1011 U8 6 "0b1011\0"
@0x200a0 U32 0b10001 U8 7 "0b100012\0"
@0x200b0 U32 0xFFFFFFEB U8 3 "-21\0" ; Yuk
@0x200c0
end_of_tests: