[DA] Pass TBAA info to the AA in dependency analysis

[dmgreen]

Summary

This passes the tbaa info though to AA as we check for
dependencies, as we will know they will not alias.

[dmgreen]

Rebase and simplify.

Adding a number of reviewers who may know what they are talking about here.

[dmgreen]

Was folded into D42381.

lib/Analysis/DependenceAnalysis.cpp

else {
     OS << "]";
     if (Splitable)
       OS << " splitable";
   }
   OS << "!\n";
 }
 
 static AliasResult underlyingObjectsAlias(AliasAnalysis *AA,
-                                          const DataLayout &DL, const Value *A,
+                                          const DataLayout &DL,
+                                          const Instruction *AI, const Value *A,
+                                          const Instruction *BI,
                                           const Value *B) {
   const Value *AObj = GetUnderlyingObject(A, DL);
   const Value *BObj = GetUnderlyingObject(B, DL);
-  return AA->alias(AObj, BObj);
+
+  MemoryLocation MAObj(AObj);
+  MemoryLocation MBObj(BObj);
+  AI->getAAMetadata(MAObj.AATags);
+  BI->getAAMetadata(MBObj.AATags);
+
+  return AA->alias(MAObj, MBObj);
 }
 
 
 // Returns true if the load or store can be analyzed. Atomic and volatile
 // operations have properties which this analysis does not understand.
 static
 bool isLoadOrStore(const Instruction *I) {
   if (const LoadInst *LI = dyn_cast<LoadInst>(I))
if (!isLoadOrStore(Src) || !isLoadOrStore(Dst)) {
     return make_unique<Dependence>(Src, Dst);
   }
 
   assert(isLoadOrStore(Src) && "instruction is not load or store");
   assert(isLoadOrStore(Dst) && "instruction is not load or store");
   Value *SrcPtr = getLoadStorePointerOperand(Src);
   Value *DstPtr = getLoadStorePointerOperand(Dst);
 
-  switch (underlyingObjectsAlias(AA, F->getParent()->getDataLayout(), DstPtr,
-                                 SrcPtr)) {
+  switch (underlyingObjectsAlias(AA, F->getParent()->getDataLayout(), Dst,
+                                 DstPtr, Src, SrcPtr)) {
   case MayAlias:
   case PartialAlias:
     // cannot analyse objects if we don't understand their aliasing.
     DEBUG(dbgs() << "can't analyze may or partial alias\n");
     return make_unique<Dependence>(Src, Dst);
   case NoAlias:
     // If the objects noalias, they are distinct, accesses are independent.
     DEBUG(dbgs() << "no alias\n");
const SCEV *DependenceInfo::getSplitIteration(const Dependence &Dep,
   Instruction *Src = Dep.getSrc();
   Instruction *Dst = Dep.getDst();
   assert(Src->mayReadFromMemory() || Src->mayWriteToMemory());
   assert(Dst->mayReadFromMemory() || Dst->mayWriteToMemory());
   assert(isLoadOrStore(Src));
   assert(isLoadOrStore(Dst));
   Value *SrcPtr = getLoadStorePointerOperand(Src);
   Value *DstPtr = getLoadStorePointerOperand(Dst);
-  assert(underlyingObjectsAlias(AA, F->getParent()->getDataLayout(), DstPtr,
-                                SrcPtr) == MustAlias);
+  assert(underlyingObjectsAlias(AA, F->getParent()->getDataLayout(), Dst,
+                                DstPtr, Src, SrcPtr) == MustAlias);
 
   // establish loop nesting levels
   establishNestingLevels(Src, Dst);
 
   FullDependence Result(Src, Dst, false, CommonLevels);
 
   unsigned Pairs = 1;
   SmallVector<Subscript, 2> Pair(Pairs);

test/Analysis/DependenceAnalysis/TBAA.ll

+; RUN: opt < %s -analyze -basicaa -tbaa -da | FileCheck %s
+
+; CHECK-LABEL: test
+; CHECK: da analyze - input [* *]!
+; CHECK: da analyze - none!
+; CHECK: da analyze - output [*]!
+
+define void @test(i32 %I, i32 %J, i32* nocapture %A, i16* nocapture readonly %B) {
+entry:
+  %cmp = icmp ne i32 %J, 0
+  %cmp122 = icmp ne i32 %I, 0
+  %or.cond = and i1 %cmp, %cmp122
+  br i1 %or.cond, label %for.outer.preheader, label %for.end
+
+for.outer.preheader:
+  br label %for.outer
+
+for.outer:
+  %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
+  br label %for.inner
+
+for.inner:
+  %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
+  %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
+  %arrayidx.us = getelementptr inbounds i16, i16* %B, i32 %j.us
+  %0 = load i16, i16* %arrayidx.us, align 4, !tbaa !9
+  %sext = sext i16 %0 to i32
+  %add.us = add i32 %sext, %sum1.us
+  %inc.us = add nuw i32 %j.us, 1
+  %exitcond = icmp eq i32 %inc.us, %J
+  br i1 %exitcond, label %for.latch, label %for.inner
+
+for.latch:
+  %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
+  %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
+  store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
+  %add8.us = add nuw i32 %i.us, 1
+  %exitcond25 = icmp eq i32 %add8.us, %I
+  br i1 %exitcond25, label %for.end.loopexit, label %for.outer
+
+for.end.loopexit:
+  br label %for.end
+
+for.end:
+  ret void
+}
+
+!5 = !{!6, !6, i64 0}
+!6 = !{!"int", !7, i64 0}
+!7 = !{!"omnipotent char", !8, i64 0}
+!8 = !{!"Simple C/C++ TBAA"}
+!9 = !{!10, !10, i64 0}
+!10 = !{!"short", !7, i64 0}
 No newline at end of file