[PATCH] D56568: [AliasSetTracker] Store AliasResult and pass it on mergeSetIn.

[Alina Sbirlea via Phabricator via llvm-commits]

asbirlea marked an inline comment as done.
asbirlea added inline comments.


================
Comment at: lib/Analysis/AliasSetTracker.cpp:60
 
-  if (Alias == SetMustAlias) {
-    // Check that these two merged sets really are must aliases.  Since both
-    // used to be must-alias sets, we can just check any pointer from each set
-    // for aliasing.
-    AliasAnalysis &AA = AST.getAliasAnalysis();
-    PointerRec *L = getSomePointer();
-    PointerRec *R = AS.getSomePointer();
-
-    // If the pointers are not a must-alias pair, this set becomes a may alias.
-    if (AA.alias(MemoryLocation(L->getValue(), L->getSize(), L->getAAInfo()),
-                 MemoryLocation(R->getValue(), R->getSize(), R->getAAInfo())) !=
-        MustAlias)
-      Alias = SetMayAlias;
-  }
+  if (Alias == SetMustAlias && AR != MustAlias)
+    Alias = SetMayAlias;
----------------
reames wrote:
> asbirlea wrote:
> > reames wrote:
> > > reames wrote:
> > > > asbirlea wrote:
> > > > > asbirlea wrote:
> > > > > > reames wrote:
> > > > > > > I don't believe this is correct.  The problem is that you're replacing an alias check between two sets with one between a one set and a pointer.  We know that the pointer must become a member of the set, and with your new API, we know that it's a member of that set.  However, we *don't* know it's a member of the other set.
> > > > > > > 
> > > > > > > Consider adding the pointer {p, 8} to the following sets:
> > > > > > > {{p, 16}}, and {{p, 8}}.
> > > > > > > 
> > > > > > > Your code would conclude that the result set {{p, 16}} is MustAlias, which is incorrect.
> > > > > > > 
> > > > > > > A cleanup which would fix this would be to add the pointer *before* merging alias sets, not after.
> > > > > > > 
> > > > > > On a second review, I think this is correct without the change I suggested below.
> > > > > > 
> > > > > > When deciding to merge 2 sets, we do check aliasing of the pointer, so we know it belongs to both sets. The issue that may come up, as you suggest, is that the merged set may no longer be `MustAlias`, because we don't check the first "FoundSet" at the callsite.
> > > > > > But when we do the actual adding, in addPointer, there is an alias check there against "any pointer" in that set, and a "downgrade" to `MayAlias` if that is not satisfied.
> > > > > > 
> > > > > > Now, after D56613, even that check will go away. But it's being replaced with the intersection of alias information of *all* sets that were merged, including that first "FoundSet". So, if `MustAlias` is not found for *all* merged sets, then the set is downgraded to `MayAlias`.
> > > > > > 
> > > > > > I believe that is correct. Did I miss something?
> > > > > Ping.
> > > > Reading back through the (original) code, I believe the problem was valid.  Here are two example codepaths:
> > > > addUknown->findAliasSetForUnknownInst-<mergeIn
> > > > getAliasSetFor->mergeAliasSetsForPointer->mergeIn
> > > > 
> > > > The core problem is that the first AS is never downgraded to MayAlias if the pointer added to it aliases, but does not may alias.  We never call mergeSetIn to that first set.
> > > > 
> > > > Note that in both cases, the instruction being queried for *has not* been added to any alias set before merging.  Also note that the alias result passed in is with respect to *one* of the two sets, not both.
> > > Refining this slightly, look specifically at the codepath in getAliasSetFor where we have an existing AS, but with the wrong Size and/or AA info.  We update the info on the set, and then call mergeAliasSetForPointer, but we never actually downgrade the AS which corresponds to the entry to MayAlias.  
> > > 
> > > Or to say it differently, the result of merging two alias sets is wrong when both are MustAlias w/the pointer, and this is a codepath which exposes that bug to it's caller in turn.  
> > Let me try to explain this back to see if we're on the same page.
> > 
> > When we call addUnknown, we always call addUnknownInst which sets the set to MayAlias always, so no issue here.
> > 
> > When we call `getAliasSetFor`, then call `mergeAliasSetsForPointer`, then follow a code path that also calls `addPointer` afterwards, all is good.
> > 
> > There is one call path where we don't call `addPointer` afterwards. That's when we update the size and/or AA, then attempt to merge sets. What can happen in this scenario:
> > 1. We update the pointer and the set is still MustAlias. We proceed to try to merge, find nothing, set remains MustAlias, all good.
> > 2. We update the pointer and the set is still MustAlias. We proceed to try to merge, find another set. Now since the first set is still MustAlias, if we find a MustAlias on the second set, passing that info to mergeSetIn should be valid.
> > 3. We update the pointer and the set is no longer MustAlias. There is no need to merge with any other set, but we should check any 2 pointers in the set to see if the set is still MustAlias. This never happens, set remains MustAlias.
> > 4. We update the pointer and the set is no longer MustAlias. We proceed to merge, find another set. Current mergeSetIn will do an alias() check, find MayAlias and downgrade the set. Passing AR to mergeSet, if MustAlias is found with the second set will not downgrade the set. This is the problem that you say this patch exposes. 
> > Is this right?
> > 
> > Assuming yes, is 3. valid behavior?
> > 
> > 
> > 
> The concern I have is about the codepath you describe as "When we call getAliasSetFor, then call mergeAliasSetsForPointer, then follow a code path that also calls addPointer afterwards, all is good."
> 
> I'm not at all sure that codepath is correct since it allows us to construct an incorrect intermediate result before calling addPointer.  
> 
> However, when trying to further write up an explanation for the case which concerns me, I think I've come to an interesting conclusion.  I think the piece of code you're trying to improve here is simply redundant and can be removed.  
> 
> For the must alias check in the original code to trigger, we must have constructed two alias sets (AS1, AS2) which are both individually mustalias and also at least mayalias w/respect to some memory location "ML".  In order for the result of merging these three values to mustalias, then "ML" must be mustalias w/both AS1 and AS2.    Given AS1 and AS2 are (by assumption of construction) noalias w/each other, that would seem to be a contradiction.  
> 
> I'm testing a patch at a moment w/an assertion of to test the previous theory.  I've run across what appears to be an unrelated bug though, so I need to fix that before confirming my theory.
SG, thank you for following up!

I'll remove this cleanup patch as dependency to unblock the others in the mean time.


Repository:
  rL LLVM

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D56568/new/

https://reviews.llvm.org/D56568