similar to: [LLVMdev] Regarding Inter Procedural Constant Propagation

Hi, I used the following commands on the program attached below: llvm-gcc --emit-llvm main.c -c -o main.bc opt -ipconstprop main.bc -o main1.bc diff main.bc main1.bc no difference was o/p :( The Program Segment is as shown below: #include <stdio.h> void f1(int a) { a=a+1; printf("%d",a); } void f2() { int b; b=1; f1(b); } int main() { int

Sean Silva via llvm-dev <llvm-dev at lists.llvm.org> writes: > No tests fail with the patch below, so I would say it's pretty useless. It > seems that the C bindings are the only user but we can probably just have them > return IPSCCP instead. I don't necessarily think your conclusion is wrong, but the patch isn't proving what you think it's proving. In fact, the

---------------------------- Original Message ---------------------------- Subject: [Fwd: Re: [Fwd: Regarding alias analysis pass]] From: netra at cse.iitb.ac.in Date: Sat, April 16, 2011 8:38 am To: -------------------------------------------------------------------------- Hi, Actually i wanted to study the kind of aliases recognized by basicaa pass. aa-eval only gives the # of aliases

The pass is pretty rudimental (as the comment at the top of the file hints), and it seems LLVM already has IPSCCP (which should do a better job at interprocedural constant propagation). I'm also not entirely sure it's used anywhere. Is there any reason to keep it around? Thanks, -- Davide "There are no solved problems; there are only problems that are more or less solved" --

Okay thanks for the info. The term program termination was probably a poor choice of words. I'm really just trying to build an inter-procedural BasicBlock graph, and then look for postdominance as Scott suggested. I'll go about making my own since it doesn't sound like there is one out there already. Thanks, -Stephen On Tue, Oct 2, 2012 at 5:06 PM, Scott Moore <sdmoore at

Hi, I am a Mtech student at IIT,Bombay and presently studying llvm as a part of my Seminar work.Currently,i am writing a simple pass that would detect function pointer call,use and declarations in the src program. I could detect function pointer calls using the getCalledFunction(). However,i am stuck in identifying function pointer declaration and use. is there a way one can distinguish between

I think you're looking for an inter-procedural post dominator analysis. I don't think there is one in LLVM already, but it should be relatively straightforward. This gives a sound approximation (i.e. no false positives) of something sort-of equivalent to the halting problem: if the program terminates, then block Y was executed. Cheers, Scott On Tue, Oct 2, 2012 at 7:43 PM, Jim Grosbach

Apologies: didn't notice how old this thread is before replying. On Tue, Mar 22, 2016 at 5:24 PM, Sanjoy Das <sanjoy at playingwithpointers.com> wrote: > Hi Vivek, > > [+CC Matthias, Quentin] > > Inter-procedural register allocation can be a big win, but my estimate > is that it will be challenging to complete within one summer unless > you're already familiar

David Is this true for static heuristics as well ? If the bb freqs are scaled wrt to the entry block freq and a) use such scaled freqs for the bb's that have calls b) propagate this info topologically over the call graph, how representative will be the info if one just wants to use in a comparative sense ? -Dibyendu Sent from my Windows Phone ________________________________ From: Xinliang

The BlockFrequency analysis has been useful for machine block placement, register allocation and other function-level optimizations. How could we extend it for use in an inter-procedural (whole-program) context? For example, if we would like to compare the hotness of two call sites in different functions, or calculate the hotness of two global variables referenced in multiple functions. If the

No need to apologize this thread surely deserved some answers :) From my perspective this project sounds doable. I would expect the register allocation parts to be not too hard: I imagine this being just distilling a new clobber regmask after allocating a function. I would expect the challenging (or annoying) part to get a machine module pass (or a similar mechanism to influence the order in

Hi all, My name is Fahad Nayyar. I am an undergraduate student from India. I am interested to participate in GSOC under the project “Improve inter-procedural analyses and optimizations”. I have been using LLVM for the past 8 months. I have written various intra-procedural analysis in LLVM as FunctionPass for my course projects and research projects. But I’ve not contributed to the LLVM

Hi, I'm writing a pass that collects some information from functions, but this requires constant propagation/constant folding to be done on those functions beforehand. However some of these functions have an integer argument that can take certain constant values, and the functions are always called with these constant values at their various call sites. What I'm trying to do is to look at

Hi all, I read the setup at http://www.blackh0le.net/articles/vpn-dun-howto.html to setup my VPN. However, I'm having a problem which I think is proxy-ARP not working. I like to ask you to see if you know what's going on. When I ping 10.77.1.1 from windows XP machine the packets get to the 10.77.1.1 machine, but they don't have a return path to get back. When I do ping the windows

Hi All, I have installed llvm-gcc4 patch to enable various llvm optimizations at -O1/-O2/-O3. This means instead of $ llvm-gcc4 --emit-llvm foo.c -o foo.bc $ opt foo.bc -o foo_optimized.bc $ llc foo_optimized.bc -o foo.o One can directly use $ llvm-gcc4 -O2 foo.c -o foo.o to get optimized foo.o - Devang + + if (optimize > 0) { + + +

Hi Fahad, > > Improve dynamic memory related capabilities of Attributor. For example > Improve HeapToStackConversions. Maybe such deductions can help safety > (dis)provers. For example, can we improve the use-after-free bug detection > using some attributes? > Stefan should know more about H2S. Regarding the use-after-free, I don't > think there's currently any plans

Hello Community, I would like to know status of the project and also importance of it. If the project is still open I would like to work on GSoC 2016 proposal for Inter-procedural Register Allocation, in that case please also suggest possible mentor or let me know if anyone is willing to be mentor for this. Sincerely, *Vivek Pandya* -------------- next part -------------- An HTML attachment was

> On Mar 22, 2016, at 6:04 PM, Matthias Braun via llvm-dev <llvm-dev at lists.llvm.org> wrote: > > No need to apologize this thread surely deserved some answers :) > > From my perspective this project sounds doable. I would expect the register allocation parts to be not too hard: I imagine this being just distilling a new clobber regmask after allocating a function. I would

I'm wondering what is the best way to handle constant propagation for complex types in LLVM. For example, my language needs to be able to simplify expressions involving strings by precomputing (in my own constant propagation pass) various external function calls. Here's an example program: ---------------- ; ModuleID = 'LFunction' declare i8* @"set at SS"([5 x

Isn't this effectively the halting problem? Consider the case where block Y is the exit block of main() and block X is the entry block of main(). Jim On Oct 2, 2012, at 4:29 PM, Stephen Schiffli <sschiffli at gmail.com> wrote: > Is there any inter-procedural analysis that could tell me if some BasicBlock Y is guaranteed to execute based on my knowledge that BasicBlock X will