

LLILC – LLVM-Based Compiler for .NET CoreCLR - mjsabby
https://github.com/dotnet/llilc

======
mjsabby
Mailing list post:
[http://lists.cs.uiuc.edu/pipermail/llvmdev/2015-April/084459...](http://lists.cs.uiuc.edu/pipermail/llvmdev/2015-April/084459.html)

And also check out LLVMSharp --
[http://www.llvmsharp.org](http://www.llvmsharp.org) which gives LLVM access
to .NET

Disclaimer: I'm involved in both projects.

~~~
pflanze
I'm not a .NET user (yet) and have found the readme to be somewhat cryptic:

> LLILC is an LLVM based MSIL Compiler - we pronounce it 'lilac' \- with a
> goal of producing a set of cross-platform .NET code generation tools. Today
> LLILC is being developed against dotnet/CoreCLR for use as a JIT, but an
> ahead of time (AOT) compiler is planned for the future.

The mailing list post is a bit clearer to my mind, and I'm now rewording the
above in "layman's language" as follows, but I may still be wrong (please
correct me):

"Today, LLILC is a modified version of CoreCLR (= .NET Core, which is the part
of .NET which was open sourced by Microsoft in November 2014) where the code
generation backend is replaced with LLVM (but still working as a JIT). We're
also planning to implement an ahead of time compiler for MSIL (= CIL, which is
what the .NET bytecode is a form of), also using LLVM, but then perhaps
forgoing the use of (most of?) CoreCLR. The aim is also to make it possible to
use the wide array of tools available in the LLVM ecosystem, such as code
analyzers."

------
drawkbox
This is somewhat similar to IL2CPP from Unity[1] with AOT is currently what is
used on iOS and WebGL builds. It is still buggy and has been in development
for a few years or over a year, but it does essentially the same thing, take
IL and port it to C++ per platform with AOT compiling. They largely did this
to go around Mono licensing from Xamarin and the export is now C++ so there
can be no platform limitations or it is minimal that C++ tech would be blocked
by Apple for any reason for instance like they did with JIT and Flash etc.

Maybe when this has AOT it can also be useable in the same way Unity IL2CPP
and Xamarin Mono are used.

[1] [http://blogs.unity3d.com/2014/05/20/the-future-of-
scripting-...](http://blogs.unity3d.com/2014/05/20/the-future-of-scripting-in-
unity/)

~~~
Torn
I hope it gives the IL2CPP guys some incentive to go faster. I've been waiting
so long for Unity to support a more modern .NET, and to get faster

------
jevinskie
I wonder how this will affect Mono/Xamarian, given that LLILC has commited to
providing an AoT compiler. It would nice to see a CLR frontend for LLVM that
cooperates more closely with LLVM upstream. Mono's fork of LLVM is about a
3.4k line diff (mostly EH additions, few -/\+ modifications) but they don't
seem to actively try to upstream much.

Edit: I gave up trying to build a Linux-x86_64 to Android-ARM cross-compiled
Mono a year ago. The configure script didn't even think of handling bitness
differences between host and target... The commerical Xamarian toolchain for
AoT iOS compilation seems more mature than what is released in Mono.

~~~
mjsabby
LLILC is absolutely interested in upstreaming and in fact, at least one big
change (prelim COFF support for MCJIT) is already upstreamed
([http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-
Mon-...](http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-
Mon-20150216/261289.html)) in addition to a few smaller ones.

Diffing upstream with
[http://github.com/Microsoft/llvm](http://github.com/Microsoft/llvm) will let
you track what Microsoft is currently doing in its repo.

~~~
jevinskie
I'm elated to hear that. I'm eager to browse the repo tomorrow. Thanks for the
feedback! =)

------
ksec
It seems the pace of .Net improvement is moving much faster then the JVM land.

What are the chances of Enterprise switching to .Net instead of Java?

~~~
dragonwriter
> What are the chances of Enterprise switching to .Net instead of Java?

Plenty of enterprise shops _are_ Microsoft full-stack shops (Windows
Server/.NET/SQL Server/IIS). I get the impression -- though I haven't seen
systematic data -- that .NET has been making gains against JVM as an
Enterprise platform.

~~~
zamalek
It mostly depends on perspective. I work .Net enterprise and _NEVER_ hear of
Java - giving me the obvious false impression that it is Java that is unused.
The only thing under the Sun that we really hear of is Oracle: that's one or
two customers.

Both Java and .Net are viable, relevant and widespread technologies. It all
depends on which segment of the market you happen to be catering to.

~~~
ksec
It just seems that Google, Twitter, Facebook or many other big Data companies
will have some / many pieces of tech dependent on JVM. But I never heard
anyone them using .Net

~~~
zamalek
Big data isn't even analogous to enterprise. I don't even think if Google,
Twitter and Facebook should be considered to be classically enterprise.
However, what you say about big data is certainly true - that's not something
.Net is competent at: keep in mind that doesn't make it wholly incompetent.
The corollary is true: .Net does things some things really well that Java is
dreadful at (e.g. last time I played with Java the UI situation was a complete
joke).

That doesn't make either language/runtime bad or better than the other. Their
strengths aren't static, either. They are merely different tools suited for
different tasks. Both have some extremely large names using them.

------
taspeotis
I'm surprised it's hosted by the .NET Foundation. I feel the .NET Foundation
operates _somewhat_ independently from Microsoft, but there is a large
alignment with what Microsoft wants. Using LLVM feels like a departure from
some of the things they're working on now.

Some blog posts I have read on the MSDN Developer Tools Blogs suggested
Microsoft was already working on their own AOT compiler, this statement seems
to suggest LLILC has not been developed for this purpose _yet_. So it's an
independent project?

> Today LLILC is being developed against dotnet/CoreCLR for use as a JIT, but
> an ahead of time (AOT) compiler is planned for the future

Which doesn't make much sense to me, unless Microsoft is planning on ditching
their existing AOT work for LLVM. (Fine by me, LLVM is quite nice.)

~~~
mjsabby
Having multiple code generators is not mutually exclusive, and this effort
does not mean MSFT is ditching any existing AOT (or for that matter JIT)
compiler projects.

One of LLILC's major objective is give the community an MSIL frontend for
LLVM.

This allows a JIT or an AOT compiler to take any C# program written for the
.NET Core class libraries to run on any platform that CoreCLR can be ported to
and that LLVM will target.

~~~
BruceM
This seems like it would be an interesting alternative to il2cpp from the
Unity folks as a path towards compiling C# code to run on asm.js in the
browser.

~~~
rescendent
very interesting :)

------
quarkzelem
How does the GC integration work? I've heard various (bad things) about LLVM's
support for integrating a GC ..

~~~
mjsabby
This wiki page details what LLILC will be doing to get GC Support as required
by the CoreCLR:

[https://github.com/dotnet/llilc/blob/master/Documentation/ll...](https://github.com/dotnet/llilc/blob/master/Documentation/llilc-
gc.md#gc-support-in-llvm)

Andy Ayers from the LLILC team will be presenting this exact topic at the
EuroLLVM developer meeting:
[http://llvm.org/devmtg/2015-04](http://llvm.org/devmtg/2015-04)

I imagine the LLVM folks will put the meeting videos up on their website like
they have in the past, and it would be an interesting video to watch if you're
looking for GC specific details in LLILC.

------
ksherlock
llvm used to (removed with release 2.8?) include a .net msil backend -- Maybe
they could add it back and go full circle -- use LLILC to load your MSIL and
compile it back to... MSIL.

[https://github.com/llvm-mirror/llvm/tree/svn-
tags/RELEASE_27...](https://github.com/llvm-mirror/llvm/tree/svn-
tags/RELEASE_27/lib/Target/MSIL)

------
dsfsdfd
When will I be able to get my MVC websites running in node?

~~~
ziahamza
On a side note there is already the Edge project that allows NodeJS and .Net
to run in the same process. So you can run Asp.Net MVC websites with NodeJS
side by side. And it runs on all platforms using Mono Runtime

[https://github.com/tjanczuk/edge](https://github.com/tjanczuk/edge)

