Hello Duncan,<br><br>I compiled LLVM without optimizations (because maybe I have to look to memory accesses in the future). <br>Maybe some of these optimizations I can enable when I am running my pass with opt ?<br><br>It is still one thing that I don't understand. If the memory accesses will be eliminated, and I have the following situation:<br>
<br>%i = alloca i32, align 4 <br>%j = alloca i32, align 4<br>.....<br>%2 = load i32* %i, align 4<br>%3 = load i32* %j, align 4<br>%add = add nsw i32 %2, %3<br>%cmp2 = icmp sgt i32 %add, 2<br><br>How can I check that %cmp2 is dependent on both allocas?<br>
<br>Sorry if the question was asked without any testing with optimizations enabled. <br><br>Basically, my plan is :<br><br>if (Inst->getOpcode()==Instruction::Load)<br>    {<br>        LoadInst *LD10 = cast<LoadInst>(Inst);<br>
        Value *C10 = LD10->getPointerOperand();<br>    }<br><br>so I get all the good allocas. Then my plan is to check for each ICMP (thats what i have to do) the first or second operand and recursively proceed till I find only Load instructions and then get the corresponding allocas.<br>
<br>Thank you for your response !<br><div class="gmail_quote"><br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class="im"><br></div>
if the above is all that is happening with your alloca then the optimizers will<br>
eliminate the alloca altogether.  In optimized code you will pretty much only<br>
have an alloca if the address of the alloca escapes the function.  I suggest you<br>
assume you are analysing optimized code, because it is much much easier to do<br>
analysis with registers and phi nodes than to analyse memory accesses, and in<br>
most cases the optimizers will do all the analysis for you and eliminate the<br>
memory accesses.<br>
<br>
Ciao, Duncan.<br>
<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class="im">
<br>
I think it is better to check dependencies also between loads (for the case when<br>
a Load is not directly linked to an Alloca), so I can identify :<br>
<br>
if (  ( I2 is dependent on I1 ) and ( I3 is dependent on I4 )  )   => I can<br>
check if I3 and I2 are dependent => indirectly I4 is dependent on I1<br>
<br>
<br>
<br>
On Thu, Jan 24, 2013 at 6:03 PM, Preston Briggs <<a href="mailto:preston.briggs@gmail.com" target="_blank">preston.briggs@gmail.com</a><br></div><div><div class="h5">
<mailto:<a href="mailto:preston.briggs@gmail.com" target="_blank">preston.briggs@gmail.<u></u>com</a>>> wrote:<br>
<br>
     > I tried methods related to point 1) suggested by you,<br>
     > but I still have problems of finding dependencies.<br>
     > What exactly I want to do:<br>
     ><br>
     > I have a chain like : Alloca -> Load(1) -> ... -> Computation<br>
     > where the variable might be changed -> Store(new_var) -> ... -> Load(n)<br>
<br>
    Your example is not very clear.<br>
    I don't understand what's involved in the "chain".<br>
<br>
     > Computation where the variable is changed = means that :<br>
     > I might have Alloca(a),  c=a+7000*b[32], Load(c)...ICMP(c, ...)<br>
     ><br>
     > I want to get the corresponding Alloca from every Load<br>
     > (corresponding from the point of view of the variable used,<br>
     > meaning that the Load is using a variables based/dependent on the Alloca<br>
    or Allocas).<br>
<br>
    I don't know any magical LLVM way to get all the answers.<br>
    My approach would be to do some ordinary data-flow analysis,<br>
    chasing back along def-use chains to find instructions that define<br>
    the registers used in the load, recursively, to the beginning.<br>
    If you hit an alloca, stop.<br>
<br>
     > I tried to use methods from DependencyAnalysis class.<br>
<br>
    DependenceAnalysis. Seems like a bad start.<br>
    Dependence analysis is used to determine how two<br>
    array references may interact. Nothing to do with alloca.<br>
<br>
     > 1. if (DA.depends(loadInstrArray[i],<u></u>loadInstrArray[j],false)) - no result<br>
<br>
    I can't say if this is correct or not without a more complete example.<br>
    For instance, in the code<br>
<br>
         for (i = 0; i < n; i += 2) {<br>
             loadInstr[i] = 0;<br>
             j = i + 1;<br>
             loadInstr[j] = 1;<br>
         }<br>
<br>
    there is no dependence between the two stores to loadInstr.<br>
    The two stores write entirely disjoint areas of memory.<br>
    On the other hand, if we have<br>
<br>
         for (i = 0; i < n; i++) {<br>
             loadInstr[i] = 0;<br>
             j = 2*i;<br>
             loadInstr[j] = 1;<br>
         }<br>
<br>
    we expect to find a more interesting pattern.<br>
<br>
    Preston<br>
<br>
<br>
</div></div></blockquote></blockquote></div>