Brainfuck JIT

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;

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

This reminds me of Awib ( http://awib.googlecode.com/svn/builds/awib-0.3.b ), an optimizing brainfuck compiler written in brainfuck that can produce Linux executables (for i386), Tcl, Ruby, Go or C.

    ++++++++++[>++++++++<-]>--. N
    -----.                      I
    ------.                     C
    ++.                         E
    <++++++[>------<-]>.        !

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.

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

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.