LLVMdev Digest, Vol 112, Issue 59

Send LLVMdev mailing list submissions to

To subscribe or unsubscribe via the World Wide Web, visit
or, via email, send a message with subject or body 'help' to

You can reach the person managing the list at

When replying, please edit your Subject line so it is more specific
than "Re: Contents of LLVMdev digest..."

Today's Topics:

  1. Fwd: Re: [lldb-dev] Has Fast register allocation been
     finished in 3.3 version? (??? (Yonggang Luo))
  2. Re: Contribute a new precise pointer analysis to LLVM (lian li)
  3. Re: Feature request for include llvm-mc in llvm.org/builds
     (??? (Yonggang Luo))
  4. How to use clang -intergrated-as to compile cross-(os/target)
     assembly file. (??? (Yonggang Luo))
  5. Size limitations in MCJIT / ELF Dynamic Linker/ ELF codegen?
     (Yaron Keren)
  6. Removing function params. (James Courtier-Dutton)
  7. Re: Removing function params. (John Criswell)
  8. Re: Size limitations in MCJIT / ELF Dynamic Linker/ ELF
     codegen? (Kaylor, Andrew)
  9. Re: [RFC] Stackmap and Patchpoint Intrinsic Proposal (Philip R)
10. Re: Contribute a new precise pointer analysis to LLVM (Hal Finkel)
11. Re: Contribute a new precise pointer analysis to LLVM
     (Chandler Carruth)
12. Re: Size limitations in MCJIT / ELF Dynamic Linker/ ELF
     codegen? (Yaron Keren)
13. Re: Contribute a new precise pointer analysis to LLVM (Hal Finkel)


Message: 1
Date: Tue, 22 Oct 2013 20:03:40 +0800
From: ???(Yonggang Luo) <luoyonggang@gmail.com>
To: LLVM Dev <llvmdev@cs.uiuc.edu>
Subject: [LLVMdev] Fwd: Re: [lldb-dev] Has Fast register allocation
  been finished in 3.3 version?
Content-Type: text/plain; charset="utf-8"

Forward to llvmdev
---------- ??? ----------
???"Chris Lattner" <clattner@apple.com>
???2013?10?22? ??7:33
???Re: [lldb-dev] Has Fast register allocation been finished in 3.3 version?
??? <wansheg@gmail.com>
??? <lldb-dev@cs.uiuc.edu>

When I use llc command with --regalloc=fast , get error

In addition, is lli use fast register allocation?

You should probably ask about this on the llvmdev mailing list, you'll
reach the right audience there.


lldb-dev mailing list
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.cs.uiuc.edu/pipermail/llvmdev/attachments/20131022/58d8b6ee/attachment-0001.html>


Message: 2
Date: Tue, 22 Oct 2013 23:35:08 +1000
From: lian li <lianli@gmail.com>
To: Evan Cheng <evan.cheng@apple.com>
Cc: LLVM Developers Mailing List <llvmdev@cs.uiuc.edu>
Subject: Re: [LLVMdev] Contribute a new precise pointer analysis to
Content-Type: text/plain; charset=ISO-8859-1

Hi Evan,

We did an experiment using the LLVM test suite: we compare the
overhead of using our analysis to the LLVM default, both with -O2

The overall overhead of compiling the whole test suite using our
analysis is 36.5%.
The biggest overhead is observed in
"SingleSource/Benchmarks/Misc/flops-5", where we are 5 times slower:
0.07s (with our analysis) compared to 0.0133s(default).
This may not be accurate as the compilation time in both cases are quite small.

Remind that the compilation time is reported by running our analysis
over individual files, the compilation time overhead will be larger if
we link all individual compilation units together and run the
analysis over the whole application.


Thanks, Chris.

We are interested in contributing it to LLVM itself. Our manager
agrees to commit resources for maintenance needs if it is accepted by
the community.

This is great. Please make sure Oracle legal sign off on explicitly granting LLVM the use of the patents associated with the work.

On the compile time front, can you do a comparison with the LLVM default and your new AA? You can just build the LLVM test suite.




Hi All,

This is Lian Li from Oracle Labs in Brisbane Australia.

We have developed a precise and highly efficient pointer analysis
framework on top of LLVM, The approach is flow, context, and field
sensitive, details are described in the two papers below:

"Boosting the performance of flow-sensitive points-to analysis using
value flow" (in ESEC-FSE 2011), and
"Precise and scalable context-sensitive pointer analysis via value
flow graph" (in ISMM 2013).

The analysis was initially developed for the purpose of bug checking,
and is now extended to support compiler optimizations. We have tested
it with existing compiler optimizations in LLVM, and have seen
promising results.

We are now considering to make this analysis available to the LLVM
community, and contribute resources for future maintenance needs,
provided that there is enough interest. We think that a new precise
pointer analysis in LLVM can enable more new optimization and analysis
techniques to be developed in LLVM.

Any people interested in seeing a new precise pointer analysis in LLVM?

This sounds very interesting. Even if it isn't fast enough to be used with
(for example) clang -O2 or -O3, having such a precise analysis would be a
great baseline for doing other alias analysis work.

Are you interested in contributing this to LLVM itself, or just asking if
people would be interested to see the code in some other form?


// Copyright @ 2011 Authorized by ** LIAN LI **
LLVM Developers mailing list
LLVMdev@cs.uiuc.edu http://llvm.cs.uiuc.edu

Interesting. And I am interested in that. If you can compare it with others technology,

would be greater.