Brainfuck JIT

I have did that with AsmJit 4 years ago: https://github.com/miaout17/justfuck/blob/master/src/JustFuc...

Shame on me for using Visual Studio. I turned to pure Linux/Mac development environments in recent years.

Nice, but I should note that JITing does not improve performance greatly. Many basic arithmetic operations take O(n) or O(n^2) time, and as you cannot access arbitrary cells in the arbitrary order so most memory access operations also take at least O(n) time. There are handful optimizers that can optimize them provided that the program uses only a fixed amount of cells, but AFAIK there are no such optimizers in general.

If you plan to implement an optimization, I recommend a pointer propagation. This is very simple and still lots of optimizers ignore it. For example,

    mem += 3;
    while (mem[0]) { mem += 1; mem[0] -= 1; mem += 1; }
    mem -= 4;
    mem[0] = 0;

becomes:

    while (mem[3]) { mem[1] -= 1; mem += 2; }
    mem[-1] = 0;
    mem -= 1; /* you can safely ignore this at the end of file */

where every relative memory access has been adjusted. Since it only affects the relative memory access, it is safe to apply the optimization to unbalanced loops as long as you keep the stride (a net pointer adjustment) at the end of the loop body.

The main LLVM codebase includes a BF compiler as an example: https://llvm.org/svn/llvm-project/llvm/trunk/examples/BrainF...

See BrainF.cpp in particular.

It's a decent first illustration of the great level of abstraction LLVM offers.

Writing a Brainfuck interpreter is a superb optimization exercise. Basic version is trivial to write, and in 2-3 iterations it's possible to get speed ups of 100x or more. If you haven't tried it, I would highly recommended it as a brain stretcher.

Then try and see if it's faster than this one - http://mazonka.com/brainf/bff4.c