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.
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.
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.
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,
becomes: 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.