[LLVMdev] Google Summer of Code Idea
sabre at nondot.org
Sat Mar 1 11:24:09 PST 2008
On Mar 1, 2008, at 3:40 AM, Richard Warburton wrote:
>> Also, LLVM benefits quite a bit from mod/ref info for function. I
>> don't know if you've thought about it at all, but it is an important
>> problem. If you're interested, my thesis describes these issues in
> I'll peruse this, are there any other relevant, LLVM specific texts
> that are appropriate for this, and not linked from the documentation
> page ?
Not that I know of.
>>> 1. Is this too ambitious for a google summer of code project?
>> It depends on your familiarity with the domain. If you haven't
>> in the area of alias analysis (and applications) it probably is.
>> There are lot of smaller subprojects that would be useful for llvm
> In order that I may be to gauge what options there are, can you
> suggest some examples of these subprojects.
There are lots of mini projects, revolving around use of better alias
1. The alias analysis API supports the getModRefBehavior method, which
allows the implementation to give details analysis of the functions.
For example, we could implement full knowledge of printf/scanf side
effects, which would be useful (PR1604).
2. We need some way to reason about errno. Consider a loop like this:
x += sqrt(loopinvariant);
We'd like to transform this into:
t = sqrt(loopinvariant);
x += t;
This transformation is safe, because the value of errno isn't
otherwise changed in the loop and the exit value of errno from the
loop is the same. We currently can't do this, because sqrt clobbers
errno, so it isn't "readonly" or "readnone" and we don't have a good
way to model this.
The hard part of this project is figuring out how to describe errno
in the optimizer: each libc #defines errno to something different it
seems. Maybe the solution is to have a __builtin_errno_addr() or
something and change sys headers to use it.
3. An easy project is to add the 'nocapture' attribute to the LLVM IR
(PR2055) and have passes infer and propagate it around. Its presence
can significantly improve local alias analysis at very low cost.
4. The globals mod/ref pass basically does really simple and cheap
bottom-up context sensitive alias analysis. It being simple and cheap
are really important, but there are simple things that we could do to
better capture the effects of functions that access pointer
arguments. This can be really important for C++ methods, which spend
lots of time accessing pointers off 'this'.
5. There are lots of ways to optimize out and improve handling of
6. It would be excellent to replace loops with scalar stores in them
into memset/memcpy calls. This dramatically speeds up programs like
'viterbi' in the testsuite.
7. There may still be some ideas in PR1373 left.
More information about the llvm-dev