L1VM - status

I did write two encryption modules. One for “ciphersaber” algorithm and one with the “libsodium” library. And the file module got a read/write array function. There are other recent changes.

I did make Brackets variable type safe. And did insert range checks to the “set” variable definitions: 

(set byte 1 foobar 256)

This will result into an error message:

error: line 10: byte value out of range!
>     (set byte 1 foobar 256)

The range for byte goes from 0 to 255!

I did some benchmarks, which showed that my L1VM can be faster as Node.js: Primes benchmark posting This benchmark was ran without the L1VM JIT-compiler!

Here is the Benchmark 04 where my VM is as fast as Node.js running a double floating point math test.
It uses the new “(no-var-pull-on)” flag to optimize the programs assembly output:

// double-test-optimized.l1com
//
// (no-var-pull-on) (no-var-pull-off) optimization demo
//
(main func)
    (set int64 1 zero 0)
    (set double 1 zerod 0.0)
    (set double 1 x 23.0)
    (set double 1 y 42.0)
    (set int64 1 max 10000000Q)
    (set int64 1 loop 0)
    (set int64 1 one 1)
    (set double 1 count 1.0)
    (set int64 1 f 0)
    (optimize-if)
    (:loop)
    (no-var-pull-on)

    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}

    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}
    {count = (count + x)}

    {count = (count + y)}
    {count = (count + y)}
    {count = (count + y)}
    {count = (count + y)}
    {count = (count + y)}

    {count = (count + y)}
    {count = (count + y)}
    {count = (count + y)}
    {count = (count + y)}
    {count = (count + y)}

    (no-var-pull-off)
    ((count zerod +d) count =)

    ((loop one +) loop =)
    (((loop max <=) f =) f if)
        (:loop jmp)
    (endif)

    (5 count 0 0 intr0)
    (7 0 0 0 intr0)
    (255 0 0 0 intr0)
(funcend)

This program compiles to this assembly code:

.data
Q, 1, zero
@, 0Q, 0
F, 1, zerod
@, 8Q, 0.0
F, 1, x
@, 16Q, 23.0
F, 1, y
@, 24Q, 42.0
Q, 1, max
@, 32Q, 10000000Q
Q, 1, loop
@, 40Q, 0
Q, 1, one
@, 48Q, 1
F, 1, count
@, 56Q, 1.0
Q, 1, f
@, 64Q, 0
.dend
.code
:main
loada zero, 0, 0
:loop
loadd count, 0, 1
loadd x, 0, 2
addd 1, 2, 3
addd 3, 2, 1
addd 1, 2, 3
addd 3, 2, 1
addd 1, 2, 3
addd 3, 2, 1
addd 1, 2, 3
addd 3, 2, 1
addd 1, 2, 3
addd 3, 2, 1
addd 1, 2, 3
addd 3, 2, 1
addd 1, 2, 3
addd 3, 2, 1
addd 1, 2, 3
addd 3, 2, 1
addd 1, 2, 3
addd 3, 2, 1
addd 1, 2, 3
addd 3, 2, 1
loadd y, 0, 3
addd 1, 3, 4
addd 4, 3, 1
addd 1, 3, 4
addd 4, 3, 1
addd 1, 3, 4
addd 4, 3, 1
addd 1, 3, 4
addd 4, 3, 1
addd 1, 3, 4
addd 4, 3, 1
loadd zerod, 0, 4
addd 1, 4, 5
load count, 0, 6
pulld 5, 6, 0
loada loop, 0, 1
loada one, 0, 2
addi 1, 2, 3
load loop, 0, 4
pullqw 3, 4, 0
loada loop, 0, 1
loada max, 0, 5
lseqi 1, 5, 6
jmpi 6, :if_0
jmp :endif_0
:if_0
jmp :loop
:endif_0
loadd count, 0, 1
intr0 5, 1, 0, 0
intr0 7, 0, 0, 0
intr0 255, 0, 0, 0
rts
.cend

In the Brackets code:

{count = (count + x)}

We get this assembly code:

addd 1, 2, 3

That is as good as hand written assembly code, done by the compiler!
Don’t forget to do: “(no-var-pull-off)” to make it turned off after your code block!