Recently I've been wondering a bit about ways to get more 'native' speed out of Espruino. While it's fast enough for most things, sometimes you still notice problems - when doing things like manipulating images or decoding raw waveforms from the radio.

So, right now the solutions seem to fall into:

• Download the Espruino source, compile it yourself and write C/C++ (works right now, perfectly)
• Use the inline assembler (here now, although the assembler doesn't support a bunch of opcodes)
• Have some way to compile C code in the Web IDE (not done, and raises issues about how to integrate it with native Espruino functionality)
• Faster JS interpreter/JIT compile (none of which seem easy to get in the memory footprint we have)
• ASM.JS

I've been talking to a few people about this, and another option has come up that's kind of a hybrid of the last 3 approaches... What if we could compile JavaScript to assembler inside the Web IDE, where there's more memory available?

It wouldn't have to be 100% full JS coverage - just enough that the stuff that needs to run quickly can do.

I just did a very quick proof of concept of this using acorn for the parsing. It's 150 lines so far, and if you type the following code:

  function foo(a,b) {
    "compiled";
    foo = foo + 1;
    return "Hello"+(a-b)+foo;
  }

Then when you click 'upload' it'll get parsed and will be converted to the following 'pseudo-assembler':

 ] MOVL r0, const_0
] BL jspeiFindInScopes
] PUSH {r0}
] MOVL r0, const_0
] BL jspeiFindInScopes
] PUSH {r0}
] MOVL r0, const_1
] BL jsvNewFromInteger
] PUSH {r0}
] POP {r0}
] POP {r1}
] MOVL r2, 43/* + */
] BL jsvMathsOp
] PUSH {r0}
] POP {r0}
] POP {r1}
] BL jspReplaceWith
] PUSH {r0}
] POP {r0}
] BL jsvUnLock
] MOVL r0, const_2
] BL jsvNewFromString
] PUSH {r0}
] MOVL r0, const_3
] BL jspeiFindInScopes
] PUSH {r0}
] MOVL r0, const_4
] BL jspeiFindInScopes
] PUSH {r0}
] POP {r0}
] POP {r1}
] MOVL r2, 45/* - */
] BL jsvMathsOp
] PUSH {r0}
] POP {r0}
] POP {r1}
] MOVL r2, 43/* + */
] BL jsvMathsOp
] PUSH {r0}
] MOVL r0, const_0
] BL jspeiFindInScopes
] PUSH {r0}
] POP {r0}
] POP {r1}
] MOVL r2, 43/* + */
] BL jsvMathsOp
] PUSH {r0}
] POP {r0}
] BX LR
] const_0:
]   .word 0x6f6f66 ; "foo\u0000"
] const_1:
]   .word 0x1 ; "\u0001\u0000\u0000\u0000"
] const_2:
]   .word 0x6c6c6548 ; "Hell"
]   .word 0x6f ; "o\u0000"
] const_3:
]   .word 0x61 ; "a\u0000"
] const_4:
]   .word 0x62 ; "b\u0000"

There's obviously still a bit to do before it's useful, but it's surprisingly close. While the generated code isn't super-fast, it'll still be a massive improvement over interpreting.

TODO

• Work out a way of 'exporting' jsvMathsOp/jspeiFindInScopes/etc from the interpreter. This could just be a struct somewhere in memory with this stuff in a predefined order.
• handle jsvUnLock properly when calling functions
• Have a special case for function parameters, which will need to be taken out of reg0-3 and stored on the stack
• Generate actual Thumb assembler that can be parsed by the assembler.js
• Remove the original JS function declaration from the source and replace it with the assembler's output

And a few obvious optimisations

• Peephole optimise push/pop to the same register
• Make sure a referenced global variable is only looked up once
• Peephole optimise constant expressions
• Optimise stack push/pop into registers where possible
• It should be possible to work out what variables are numbers/integers, and then to do the relevant operations right on them

Anyway, the hacky proof of concept is in https://github.com/espruino/EspruinoTools/tree/js_compiler. To use it, just add plugins/compiler.js to the Web IDE's main.html file and it'll spring into life