similar to: [LLVMdev] RE: repeated recursion with "frozen" arguments

> I see more precisely what you mean, but I don't think it is that > straightforward to generalise the benefits multiple CPU on single host > programming to multiple CPU at multiple hosts. I don't think that both > cases involve the same techniques. you are right, just think of shared memory. > For example, in "single host" configuration you get a very low

The optimization you are describing is called procedure cloning, where the body of a procedure is copied and then specialized for particular call sites. It is usually driven by interprocedural constant propagation, and often by profiling to find which cases are frequent enough to make it worthwhile (here the recursive calls would make both cases -- x=1 and x=2 -- worthwhile). LLVM would be very

Hi LLVM-devels, > Yup, I think I completely missed your point. :) funny, that if even so, I got two similar and concrete answers already: "it is suitable for LLVM, though not implemented yet" :) > > generally you are right. But only generally :) > > In particular, my example showed a feature of typical lexical closure. > > Can you explain more about what you

Hi llvm-devels, there is a very simple using case concerning LLVM and I am wondering whether it might be optimized at LLVM layer: //----------- int rec_func(int x, int y) { if(y<0) return x; return y + rec_func(x, y-1); // should we really push x? } void main() { rec_func(1, 1000); rec_func(2, 2000); } //----------- Guys, don't focus on a stupid mathematics beyond this function

Hello Chris, Tuesday, August 26, 2003, 11:02:45 PM, you wrote: >> there is a very simple using case concerning LLVM and I am wondering >> whether it might be optimized at LLVM layer: >> >> //----------- >> int rec_func(int x, int y) { >> if(y<0) return x; >> return y + rec_func(x, y-1); // should we really push x? >> } CL> Probably not,

> there is a very simple using case concerning LLVM and I am wondering > whether it might be optimized at LLVM layer: > > //----------- > int rec_func(int x, int y) { > if(y<0) return x; > return y + rec_func(x, y-1); // should we really push x? > } Probably not, at least not in the near future. At some point I have had thoughts about implementing a tail recursion

On Wed, 27 Aug 2003, [koi8-r] "������� ������" wrote: > funny, that if even so, I got two similar and concrete > answers already: > "it is suitable for LLVM, though not implemented yet" > :) :) > S2. Theoretically this redundant copy might be eliminated. > The idea is simple: at first (i.e. non-recursive) call > generate `rec_func' code which

Hi , I got a few for writing a pass. 1) Is it possible to use input parameters in command line ? For example, we got our own pass, ie. HELLO opt -load ../../Debug/lib/libHELLO.so -HELLO < hello.bc From the above command line, could we use some input parameter and we can read those parameter in Pass routine? 2) For splitting BB, the way what I did is to pick up instruction

Hi, it looks like the IntervalPartition does not work as expected when constructed from another interval partition. Say, I have built an interval partition from function, and the first interval has two basic blocks. When I create second order partition and print all intervals, the second basic block of the function is not seen anywhere. Here's what's going on in IntervalIterator.h:

Hello again Valery, Valery A.Khamenya wrote: > All benefits, what one could obtain from "LLVM supporting multiple CPU > at single host", one might obtaine from "LLVM supporting multiple CPU > at multiple hosts". Isn't that logical? I see more precisely what you mean, but I don't think it is that straightforward to generalise the benefits multiple CPU on

> Interesting email address there :) > On Thu, 2004-01-08 at 01:18, =?koi8-r?Q?=22?=Valery > A.Khamenya=?koi8-r?Q?=22=20?= wrote: unfortunally some email parsers and email clients deny to work correctly with international conventions :( follow this URL for more details: http://www.python.org/doc/current/lib/module-email.Header.html > On the same machine, LLVM definitely needs to

On Wed, May 05, 2004 at 03:35:46PM +0200, Anders Alexandersson wrote: > %tmpFunction = load int ()** %puts_kernelPTR > ... > %tmpFunction = load int ()** %puts_kernelPTR > > generates > > Redefinition of value named 'tmpFunction' in the 'int () *' type plane! > > Is it not allowed to reuse variables? Is there some way to do it? LLVM uses the Static

Hello, guys. I am trying to construct higher-level 'for' from the low-level LLVM bitcode(ver 1.9). It's partly successful thanks to David A. Greene's advice suggested to use Control Dependence Graph(CDG). I could find which BB contributes to form which loop with CDG. For example, for this simple function: ----------------------------------------------------------- void bsloop(int

Hello everybody, On the documentation page for the tailcallelim pass you can read: "This pass transforms functions that are prevented from being tail recursive by an associative expression to use an accumulator variable, thus compiling the typical naive factorial or fib implementation into efficient code” However, I don’t see this behavior when trying to compile this variant of the

Hello, guys. I just tested -reg2mem pass to see how it changes my bitcode. E.g., for the following simple C code: ------------------------------------------------------------- int foo() { int i,j; int sum = 0; for (i=0; i<10; i++) { sum += i; for (j=0; j<3; j++) sum += 2; } return sum; } ------------------------------------------------------------- I could get the

FAIL: /usr/home/jeffc/llvm/obj/../test/Regression/Transforms/InstCombine/2004-11-27-SetCCForCastLargerAndConstant.ll: %Y = cast sbyte %SB to uint ; <uint> [#uses=1] %Y = cast sbyte %SB to int ; <int> [#uses=1] %Y = cast sbyte %SB to int ; <int> [#uses=1] %Y = cast ubyte %SB to uint ; <uint> [#uses=1] %Y = cast ubyte %SB to

This is from 'early JIT tests' thread on comp.lang.misc. Given :- int ltst(int x) { int i, j; j=0; for(i=0; i<x; i++)j++; return(j); } This is from the online LLVM compiler. AND It does not seem to optimize it down ! ; ModuleID = '/tmp/webcompile/_24843_0.bc' target datalayout = "e-p:32:32" target endian = little target pointersize = 32 target triple =

Hello, guys. I just wonder if there is any way to spit out LLVM assembly without any basic block division. E.g., If I emit LLVM assembly for the following simple code: ------------------------------------------------------------ void f_loop(long* c, long sz) { long i; for (i = 0; i < sz; i++) { long offset = i * sz; long* out = c + offset; out[i] = 0; } }

Hi, guys. Is there any easy way to know the leaf BB node in the CFG which is not terminated by such a 'br' instruction? E.g., for the following LLVM assembly: ----------------------------------------------------------- int %foo2(int %k) { entry: br label %bb bb: ; preds = %bb, %entry %indvar = phi uint [ 0, %entry ], [ %indvar.next, %bb ] ;

On Mon, 21 Feb 2005, Jeff Cohen wrote: > Sorry, I thought I was running selection dag isel but I screwed up when > trying out the really big array. You're right, it does clean it up except > for the multiplication. > > So LoopStrengthReduce is not ready for prime time and doesn't actually get > used? I don't know what the status of it is. You could try it out,