similar to: [LLVMdev] GSOC Adaptive Compilation Framework for LLVM JIT Compiler

On 29 March 2011 12:35, Xin Tong Utoronto <x.tong at utoronto.ca> wrote: > *Project Description:* > > * > * > > LLVM has gained much popularity in the programming languages and compiler > industry from the time it is developed. Lots of researchers have used LLVM > as frameworks for their researches and many languages have been ported to > LLVM IR and interpreted,

> > Project Outline: > > > > Currently, the LLVM JIT serves as a management layer for the executed LLVM IR, it manages the compiled code and calls the LLVM code generator to do the real work. There are levels of optimizations for the LLVM code generator, and depends on how much optimizations the code generator is asked to do, the time taken may vary significantly. The

sounds like a good idea to me. but one of the current issues of back-patching in the LLVM is that the back-patching is not done atomically on some of the architectures, i.e. Intel x86. and this makes LLVM JIT not thread-safe in lazy compilation mode. what we need to make sure is that the "updating the resolution for a given symbol" you mentioned is done in an atomic fashion. also, how

On Tue, Mar 29, 2011 at 4:45 PM, Eric Christopher <echristo at apple.com>wrote: > > > > Project Outline: > > > > > > > > Currently, the LLVM JIT serves as a management layer for the executed > LLVM IR, it manages the compiled code and calls the LLVM code generator to > do the real work. There are levels of optimizations for the LLVM code >

> >> So, one way that current projects use the JIT is via getPointerToFunction() which returns an address that can then be casted and called with the appropriate arguments. The compile task itself is often done on a separate thread. How would you deal with the updating problem in the calling application? What sort of use cases for the JIT have you looked at so far? >> > I

Do any of you have an idea as to what the Compilation Time vs Execution Time looks like in LLVM JIT with most aggressive optimizations on. Is adaptive compilation going to bring any benefits to the LLVM JIT ? -- Kind Regards Xin Tong -------------- next part -------------- An HTML attachment was scrubbed... URL:

On Thu, Mar 31, 2011 at 6:47 PM, Eric Christopher <echristo at apple.com>wrote: > > > >> So, one way that current projects use the JIT is via > getPointerToFunction() which returns an address that can then be casted and > called with the appropriate arguments. The compile task itself is often done > on a separate thread. How would you deal with the updating problem

I understand that we need to push the address to a register then branch using the register. But i am asking why there is a trampoline there such that a call to foo is first branched to an snippet and the snippet branches to the X86CompilationCallback. is this snippet necessary ? Thanks Xin On Tue, Feb 22, 2011 at 12:39 PM, Reid Kleckner <reid.kleckner at gmail.com>wrote: > The

I have a question on the LLVM JIT I did some brief memory reading one day and I found that a call to a non-library function is resolved by the X86CompilationCallback, but the X86CompilationCallback is reached through a trampoline. why can not the generated code jump to the X86CompilationCallback function directly ? 0x2b0a6a4d103b: mov $0x2b0a6a561010,%rax 0x2b0a6a4d1045:

On Thu, Mar 31, 2011 at 11:15 PM, Eric Christopher <echristo at apple.com> wrote: >> >> >> Then we would always have the location of the br B instruction in A, as it is pushed onto the stack or saved in link register when A calls B. >> > > Right, unless you wanted to go with direct calls in the JIT. I don't know that inspecting a running program's stack

On Apr 1, 2011, at 9:38 AM, Reid Kleckner wrote: > On Thu, Mar 31, 2011 at 11:15 PM, Eric Christopher <echristo at apple.com> wrote: >>> >>> >>> Then we would always have the location of the br B instruction in A, as it is pushed onto the stack or saved in link register when A calls B. >>> >> >> Right, unless you wanted to go with

The address of the callee may be more than 2 GB away in memory, which cannot be encoded as an immediate offset in the call instruction. So, the value is first materialized with a mov instruction which can encode the immediate and then jumped to through a register. Reid On Tue, Feb 22, 2011 at 12:03 PM, Xin Tong Utoronto <x.tong at utoronto.ca> wrote: > I have a question on the LLVM JIT

If I turn on one of the llvm interprocedural optimizations without turning on the analysis it uses. will the analysis be turned on automatically ? Thanks Xin

On Fri, Apr 1, 2011 at 1:26 PM, Eric Christopher <echristo at apple.com> wrote: > > On Apr 1, 2011, at 9:38 AM, Reid Kleckner wrote: > > > On Thu, Mar 31, 2011 at 11:15 PM, Eric Christopher <echristo at apple.com> > wrote: > >>> > >>> > >>> Then we would always have the location of the br B instruction in A, as > it is pushed

> > > No we will always have control over where the parent calls the functions that we are recompiling. As explained in the example below > > Original Code > > Binary for A: Binary for B: > > ... ... > ... ... > br B ... > ... ... >

I would like to generate a branch/jump to a native instruction address (set up in the JIT runtime) in LLVM IR. It seems all the branch instructions (except indirect branch) takes a LLVM BasicBlock. What would be the best way to achieve this ? Thanks Xin

There is/are implicit dependency for the optimization on its analysis. So, if you run the optimization, the analysis will be turned on implicitly, through the PassManager. Chuck On 2/12/2012 10:10 AM, Xin Tong wrote: > If I turn on one of the llvm interprocedural optimizations without > turning on the analysis it uses. will the analysis be turned on > automatically ? > > Thanks

2012/2/24 Xin Tong <xerox.time.tech at gmail.com>: > Hopefully you mean sometime in the evening on 29th. If this is the > case, count me in. Good point, I forgot to select a time :-) What about 19:00? > Thanks Cheers, Rafael

On Thu, Mar 31, 2011 at 11:07 PM, Eric Christopher <echristo at apple.com>wrote: > > > > > > No we will always have control over where the parent calls the functions > that we are recompiling. As explained in the example below > > > > Original Code > > > > Binary for A: Binary for B: > > > > ... ...

Should not the 4.0.0 release be March _2017_ in the "Release Emails" section on http://llvm.org/ ? -Xin