[LLVMdev] GSoC project questions.

Alex L arphaman at gmail.com
Fri Apr 12 04:22:21 PDT 2013

Hello everyone, I have a couple of questions about good project ideas for
GSoC because I'm kind of stuck thinking what I should do.

First of all, allow me to introduce myself - I'm Alex Lorenz, a Comp Sci
student from Ireland. I would like to participate in GSoC this year, and I
would love to do something for LLVM, because it's a great project. I am
familiar with LLVM api, as last year I wrote a compiler(for fun/education)
for my own language which used LLVM as a backend. I have a good experience
with C++(started self taught, more than 5 years ago), and I have used it in
several freelance projects and many of my own.

However, I am not sure what my project should be. It would be interesting
to work on optimizations and/or code generation for LLVM, but I have no
idea what a good project for that would be. The Open Projects page
mentioned LLVM Superoptimizer, so would this be a viable project that would
benefit LLVM? It also mentions writing a frontend for another language, and
I think this would be a really good project, but there are so many
languages that I'm not sure which one to choose - perhaps Go or maybe even

Another idea that I had for the project would be live editing/compilation -
probably for C/C++. The application is compiled using clang and ran with an
injected initialization code. Then, when a source file is modified, a
filesystem watcher or an IDE plugin notices this change. After that a diff
is performed on the file and clang is used(somehow) to see if this edit can
be injectected into the running application - basically it checks if the
edit is inside a non-inlined non-lamba function(s). The code that was
injected at the initialization of the application started an IPC thread to
communicate with the hypervisor which does the modification watch and file
diff. After the diff the hypervisor uses clang and LLVM to compile the
modified function(s) with relative addressing and sends it to the
application IPC thread which copies the instructions into memory which is
then marked as executable. The application also receives addresses of the
modified functions which are somehow obtained from the initial compilation.
Then the IPC thread pauses all other threads in this process and writes a
jump to new address at the start of each modified function. It sounds quite
complicated and ambitious, and I'm not sure if it really can be done, so
maybe someone can correct me?

I'm open to any other suggestions as well, so if you have any please post
Thanks in advance.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20130412/d7fa2cee/attachment.html>

More information about the llvm-dev mailing list