134 lines
8.1 KiB
Markdown
134 lines
8.1 KiB
Markdown
# ASCII Rendered, Compiled Target Invocation Code
|
|
|
|
Like the JVM, but the "binaries" consist of printable ASCII characters and the
|
|
result can be more easily precompiled for native execution.
|
|
|
|
## Opcodes
|
|
|
|
```{=todo}
|
|
Notate that immediates can be: …###, …###.###, …$name, or …v (for abcinxyz)
|
|
for most operations that take immediates.
|
|
```
|
|
|
|
### Summary
|
|
|
|
| -0 | -1 | -2 | -3 | -4 | -5 | -6 | -7
|
|
---:|:------:|:------:|:------:|:------:|:------:|:------:|:------:|:------:
|
|
000-|`0 BNEZ`|`1 LDAB`|`2 LDAS`|`3 LDAI`|`4 LDAW`|`5 STAB`|`6 STAS`|`7 STAI`
|
|
001-|`8 STAW`|`9 CASS`|`A PUTA`|`B PUTB`|`C PUTC`|`D MCLR`|`E FTOI`|`F FREE`
|
|
010-|`G LDOI`|`H LDOS`|`I PUTI`|`J MOFF`|`K MCPY`|`L ROLL`|`M MNEW`|`N PUTN`
|
|
011-|`O ITOC`|`P PICK`|`Q LDOW`|`R MALL`|`S ITOS`|`T ????`|`U CMPU`|`V B_OR`
|
|
100-|`W ITOW`|`X PUTX`|`Y PUTY`|`Z PUTZ`|`a GETA`|`b GETB`|`c GETC`|`d MSET`
|
|
101-|`e SROT`|`f FMOD`|`g FINV`|`h OVER`|`i GETI`|`j FNEG`|`k SPOP`|`l BITC`
|
|
110-|`m FSUB`|`n GETN`|`o LDOB`|`p FMUL`|`q FDIV`|`r FREM`|`s FADD`|`t SWAP`
|
|
111-|`u USHR`|`v FABS`|`w SDUP`|`x GETX`|`y GETY`|`z GETZ`|`_ INEG`|`. ITOF`
|
|
200-|`+ IADD`|`- ISUB`|`* IMUL`|`/ IDIV`|`% IMOD`|`\ IREM`|`| IABS`|`$ VALU`
|
|
201-|`@ CALL`|`< BLTZ`|`{ BLEZ`|`= BEQZ`|`} BGEZ`|`> BGTZ`|`, JUMP`|`; RTRN`
|
|
210-|`& BAND`|`^ BXOR`|`! BNOT`|`[ BSHL`|`] BSHR`|`? CMPI`|`~ CMPF`|`: LABL`
|
|
211-|`( DPTH`|`) PACK`|`' IMP1`|`" IMP2`|`\` BKPT`|`␣ NOP`|`# COMM`|`¶ BEAT`
|
|
[Operations by code][ops-by-code]
|
|
|
|
In this table x, y, and z are integers; a, b, and c are floating point numbers;
|
|
p and q are memory pointers; and f is a function pointer. Additionally
|
|
→ indicates a basic operation, while ⇒ indicates an operation using an immediate
|
|
value, and ↔ indicates a meta operation.
|
|
|
|
Code | Stack | Description
|
|
-----:|:-------------------:|:--------------------------------------------------
|
|
0 BNEZ| … x ⇒ … | branch to immediate if x not zero
|
|
1 LDAB| … p → … x | load byte x from p
|
|
2 LDAS| … p → … x | load short x from p
|
|
3 LDAI| … p → … x | load int x from p
|
|
4 LDAW| … p → … x | load word x from p
|
|
5 STAB| … p x → … | store byte x to p
|
|
6 STAS| … p x → … | store short x to p
|
|
7 STAI| … p x → … | store int x to p
|
|
8 STAW| … p x → … | store word x to p
|
|
9 CASS| … p x y → … z | compare and swap x and y at p, return success
|
|
A PUTA| … x → … | store x in rA
|
|
B PUTB| … x → … | store x in rB
|
|
C PUTC| … x → … | store x in rC
|
|
D MCLR| … p x → … | memclear x bytes from p
|
|
E FTOI| … a → … x | round a to integer and store in x
|
|
F FREE| … p → … | free memory at p
|
|
G LDOI| … p ⇒ … x | load int at p plus immediate offset in x
|
|
H LDOS| … p ⇒ … x | load short at p plus immediate offset in x
|
|
I PUTI| … x → … | store x in rI
|
|
J MOFF| … p x → … q | set q to memory pointer p shifted by x bytes
|
|
K MCPY| … p q x → … | copy x bytes of memory from p to q
|
|
L ROLL| … x y ‥ z ⇒ … y ‥ z x | roll stack by immediate places
|
|
M MNEW| … ⇒ … p | allocate memory for immediate bytes at p
|
|
N PUTN| … x → … | store x in rN
|
|
O ITOC| … x → … x | truncate x to 8 bits, then sign extend
|
|
P PICK| … x ‥ z ⇒ … x ‥ z x | pick stack element at immediate place
|
|
Q LDOW| … p ⇒ … x | load word at p plus immediate offset in x
|
|
R MALL| … x → … p | allocate memory for x bytes at p
|
|
S ITOS| … x → … x | truncate x to 16 bits, then sign extend
|
|
T ????| | reserved for future instruction
|
|
U CMPU| … x y → … z | compare x to y unsigned and set z such that x o y is z o 0
|
|
V B_OR| … x y → … z | bitwise OR x and y and store in z
|
|
W ITOW| … x → … x | truncate x to 32 bits, then sign extend
|
|
X PUTX| … x → … | store x in rX
|
|
Y PUTY| … x → … | store x in rY
|
|
Z PUTZ| … x → … | store x in rZ
|
|
a GETA| … → … x | load x from rA
|
|
b GETB| … → … x | load x from rB
|
|
c GETC| … → … x | load x from rC
|
|
d MSET| … p x ⇒ … | set x bytes of memory to immediate value at p
|
|
e SROT| … x y z → … y z x | rotate stack
|
|
f FMOD| … a b → … c | set c to the modulo of a by b
|
|
g FINV| … f → f … | invoke f, saving return address on stack
|
|
h OVER| … x y → … x y x | stack over
|
|
i GETI| … → … x | load x from rI
|
|
j FNEG| … a → … a | negate a
|
|
k SPOP| … x → … | stack pop
|
|
l BITC| … x y → … z | bit clear y from x to z (z = x and not y)
|
|
m FSUB| … a b → … c | set c to the difference between a and b (a - b)
|
|
n GETN| … → … x | load x from rN
|
|
o LDOB| … p ⇒ … x | load byte at p plus immediate offset in x
|
|
p FMUL| … a b → … c | set c to the product of a and b
|
|
q FDIV| … a b → … c | set c to the quotient of a by b
|
|
r FREM| … a b → … c | set c to the remainder of a by b
|
|
s FADD| … a b → … c | set c to the sum of a and b
|
|
t SWAP| … x y → … y x | stack swap
|
|
u USHR| … x ⇒ … x | logical shift x by immediate bits right
|
|
v FABS| … a → … a | take the absolute value of a
|
|
w SDUP| … x → … x x | stack duplicate
|
|
x GETX| … → … x | load x from rX
|
|
y GETY| … → … x | load x from rY
|
|
z GETZ| … → … x | load x from rZ
|
|
_ INEG| … x → … x | negate x
|
|
. ITOF| … x → … a | convert x to a floating point number
|
|
\+ IADD|… x y → … z | set z to the sum of x and y
|
|
\- ISUB|… x y → … z | set z to the difference between x and y (x - y)
|
|
\* IMUL|… x y → … z | set z to the product of x and y
|
|
/ IDIV| … x y → … z | set z to the quotient of x by y
|
|
% IMOD| … x y → … z | set z to the modulo of x by y
|
|
\ IREM| … x y → … z | set z to the remainder of x by y
|
|
\| IABS|… x → … x | take the absolute value of x
|
|
$ VALU| … ↔ … * | load constant value
|
|
@ CALL| … ↔ … | call immediate name
|
|
< BLTZ| … x ⇒ … | branch to immediate if x less than zero
|
|
{ BLEZ| … x ⇒ … | branch to immediate if x is less than or equal to zero
|
|
\= BEQZ|… x ⇒ … | branch to immediate if x is zero
|
|
} BGEZ| … x ⇒ … | branch to immediate if x is greater or equal to zero
|
|
\> BGTZ|… x ⇒ … | branch to immediate if x is greater than zero
|
|
, JUMP| … ⇒ … | jump to immediate without pushing return address
|
|
; RETN| … f ⇒ … | return from subroutine (jump but for stack)
|
|
& BAND| … x y → … z | set z to the bitwise and of x and y
|
|
^ BXOR| … x y → … z | set z to the bitwise xor of x and y
|
|
! BNOT| … x → y | set y to the bitwise not of x
|
|
[ BSHL| … x ⇒ … x | left shift x by immediate bits
|
|
] BSHR| … x ⇒ … x | arithmetic right shift x by immediate bits
|
|
? CMPI| … x y → … z | compare x to y and set z such that x o y is z o 0
|
|
~ CMPF| … a b ⇒ … c | compare a to b and set c such that a o b is z o c within an immediate error
|
|
\: LABL|… f ↔ … | label code location
|
|
( DPTH| … → … x | set x to depth of stack (before x)
|
|
) PACK| … p x → … | pack x elements of stack (before p) into array p
|
|
' IMP1| | implementation defined reserved operation 1 (no immediate)
|
|
" IMP2| | implementation defined reserved operation 2 (immediate)
|
|
\` BKPT| … ↔ … | trigger breakpoint, or exit if not debugging
|
|
␣ NOOP| … ↔ … | do nothing, maybe end identifier definition
|
|
¶ BEAT| … ↔ … | mark a beat for relative branching
|
|
[Operations in order][ops-in-order]
|