[Gambas-user] Replacing the JIT component

[Zainudin Ahmad]

sorry I reported JIT bugs in here.
you can watch this video
(https://drive.google.com/open?id=19eHA8r0i6qg5v2sM_UYQO1T2N0EyQDHL )  for
to know a few bugs in JIT.
there is any incompatible thing (in that video function DateAdd not only
have a bug but incompatible(not raise an error if use JIT) too) how it's
work between gambas+JIT an without JIT. I am not test JIT when write each
TestCase(test class) for my "gambas test suite" (the test suite (I used my
own auto test tool) still not complete only some function + a few class) so
it's possible any bug or maybe incompatible thing in other function. IIRC I
get that bug from last year I am not report it in Gambas bug tracker
because there is any report in where it's related with JIT still not fix.
and it's seem no people report that bugs. this just for an info related
with JIT.

On Mon, May 7, 2018 at 2:43 AM, Benoît Minisini <g4mba5 at gmail.com> wrote:

> 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
>
> --------------------------------------------------
>
> This is the Gambas Mailing List:
> https://lists.gambas-basic.org/listinfo/user
>
> Search the list:
> https://lists.gambas-basic.org/cgi-bin/search.cgi
>
> Hosted by https://www.hostsharing.net
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.gambas-basic.org/pipermail/user/attachments/20180515/c56adc8c/attachment.html>