

Brainfuck JIT - ErikD
http://blog.dubbelboer.com/2012/11/18/brainfuck-jit.html

======
lifthrasiir
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.

------
billiob
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.

~~~
minikomi
Amazing! Thank you for sharing this.

------
minikomi

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

------
miaout
I have did that with AsmJit 4 years ago:
[https://github.com/miaout17/justfuck/blob/master/src/JustFuc...](https://github.com/miaout17/justfuck/blob/master/src/JustFuck/main.cpp)

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

------
latitude
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>

------
eschaton
The main LLVM codebase includes a BF compiler as an example:
[https://llvm.org/svn/llvm-
project/llvm/trunk/examples/BrainF...](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.

