[Gambas-user] Replacing the JIT component

[Benoît Minisini]

Hi,

This is just an idea in the fly. There is nothing concrete at the moment.

As you may know, there is a JIT component in Gambas (not made by me) 
based on LLVM. Alas it does not work with recent versions of LLVM, 
because apparently this huge project is not able to keep backward 
compatibility between minor versions. (Worse than GTK+, I couldn't 
imagine it was possible!)

What to do now?

1) Rewriting the JIT compiler for newer versions of LLVM. Alas the 
original author does not give any news, and I have no knowledge about 
LLVM, and its C++ interface looks horrible to me.

2) gcc has now a JIT library, but it is an alpha version with a big 
warning that everything may change between releases, even if it is 
apparently relatively stable. Moreover, no idea about how many bugs the 
library has.

3) Writing a Gambas -> C translator.

My idea is that the compiler, or maybe an external program eventually 
written in Gambas, takes a class/module source code, and transform it 
into a C source file.

That C source file will call the interpreter functions when needed 
through a dedicated interpreter API.

Then the C source file will be transform into a shared library loaded at 
runtime by the interpreter (calling the C compiler that hence must be 
installed).

The advantages are:

- C syntax is thousand times more stable than a JIT compiler library 
that changes at each version.

- Maybe better optimizations.

The disadvantages are:

- You need the compiler. But the JIT library needs most of it too, so...

- Compiling is slower than calling a JIT library.

- JIT library can compile at the function level. This is not practical 
with a compiler (we won't make a shared library for each JIT function!). 
One shared library for each class, or even one for the entire project 
may be the solution.

Now I'm waiting for your comments!

Regards,

-- 
Benoît Minisini