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

[Alina Sbirlea via Phabricator via llvm-commits]

asbirlea added a comment.

I'm sorry, I don't really understand your alternative approach.
If we're adding the pointer to *all* sets aliased *before* merging, we will have that pointer duplicated to the number of aliasing sets. We never remove pointers. And these are not real sets, they're lists. They're intentionally implemented this way to make merging fast. We can't remove duplicates without walking the whole list.
Could you clarify?

I've updated the patch to essentially avoid the problem on the code path which updates the size.  This should match existing behavior.



================
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:
> 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?





Repository:
  rL LLVM

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

https://reviews.llvm.org/D56568