Make the AST interface a bit richer by returning whether an insertion caused

an insertion or not (because the pointer set already existed).

llvm-svn: 15064

include/llvm/Analysis/AliasSetTracker.h

@@ -255,12 +255,15 @@ public:
   ///   3. If the instruction aliases multiple sets, merge the sets, and add
   ///      the instruction to the result.
   ///
-  void add(LoadInst *LI);
-  void add(StoreInst *SI);
-  void add(CallSite CS);          // Call/Invoke instructions
-  void add(CallInst *CI)   { add(CallSite(CI)); }
-  void add(InvokeInst *II) { add(CallSite(II)); }
-  void add(Instruction *I);       // Dispatch to one of the other add methods...
+  /// These methods return true if inserting the instruction resulted in the
+  /// addition of a new alias set (i.e., the pointer did not alias anything).
+  ///
+  bool add(LoadInst *LI);
+  bool add(StoreInst *SI);
+  bool add(CallSite CS);          // Call/Invoke instructions
+  bool add(CallInst *CI)   { return add(CallSite(CI)); }
+  bool add(InvokeInst *II) { return add(CallSite(II)); }
+  bool add(Instruction *I);       // Dispatch to one of the other add methods...
   void add(BasicBlock &BB);       // Add all instructions in basic block
   void add(const AliasSetTracker &AST); // Add alias relations from another AST
 
@@ -275,8 +278,10 @@ public:
   const ilist<AliasSet> &getAliasSets() const { return AliasSets; }
 
   /// getAliasSetForPointer - Return the alias set that the specified pointer
-  /// lives in...
-  AliasSet &getAliasSetForPointer(Value *P, unsigned Size);
+  /// lives in.  If the New argument is non-null, this method sets the value to
+  /// true if a new alias set is created to contain the pointer (because the
+  /// pointer didn't alias anything).
+  AliasSet &getAliasSetForPointer(Value *P, unsigned Size, bool *New = 0);
 
   /// getAliasAnalysis - Return the underlying alias analysis object used by
   /// this tracker.
@@ -305,8 +310,10 @@ private:
                                             AliasSet::PointerRec())).first;
   }
 
-  AliasSet &addPointer(Value *P, unsigned Size, AliasSet::AccessType E) {
-    AliasSet &AS = getAliasSetForPointer(P, Size);
+  AliasSet &addPointer(Value *P, unsigned Size, AliasSet::AccessType E,
+                       bool &NewSet) {
+    NewSet = false;
+    AliasSet &AS = getAliasSetForPointer(P, Size, &NewSet);
     AS.AccessTy |= E;
     return AS;
   }

lib/Analysis/AliasSetTracker.cpp

@@ -189,7 +189,8 @@ AliasSet *AliasSetTracker::findAliasSetForCallSite(CallSite CS) {
 
 /// getAliasSetForPointer - Return the alias set that the specified pointer
 /// lives in...
-AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, unsigned Size){
+AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, unsigned Size,
+                                                 bool *New) {
   AliasSet::HashNodePair &Entry = getEntryFor(Pointer);
 
   // Check to see if the pointer is already known...
@@ -201,6 +202,7 @@ AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, unsigned Size){
     AS->addPointer(*this, Entry, Size);
     return *AS;
   } else {
+    if (New) *New = true;
     // Otherwise create a new alias set to hold the loaded pointer...
     AliasSets.push_back(AliasSet());
     AliasSets.back().addPointer(*this, Entry, Size);
@@ -208,45 +210,55 @@ AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, unsigned Size){
   }
 }
 
-void AliasSetTracker::add(LoadInst *LI) {
-  AliasSet &AS = 
-    addPointer(LI->getOperand(0),
-               AA.getTargetData().getTypeSize(LI->getType()), AliasSet::Refs);
+bool AliasSetTracker::add(LoadInst *LI) {
+  bool NewPtr;
+  AliasSet &AS = addPointer(LI->getOperand(0),
+                            AA.getTargetData().getTypeSize(LI->getType()),
+                            AliasSet::Refs, NewPtr);
   if (LI->isVolatile()) AS.setVolatile();
+  return NewPtr;
 }
 
-void AliasSetTracker::add(StoreInst *SI) {
-  AliasSet &AS = 
-    addPointer(SI->getOperand(1),
-               AA.getTargetData().getTypeSize(SI->getOperand(0)->getType()),
-               AliasSet::Mods);
+bool AliasSetTracker::add(StoreInst *SI) {
+  bool NewPtr;
+  Value *Val = SI->getOperand(0);
+  AliasSet &AS = addPointer(SI->getOperand(1),
+                            AA.getTargetData().getTypeSize(Val->getType()),
+                            AliasSet::Mods, NewPtr);
   if (SI->isVolatile()) AS.setVolatile();
+  return NewPtr;
 }
 
 
-void AliasSetTracker::add(CallSite CS) {
+bool AliasSetTracker::add(CallSite CS) {
+  bool NewPtr;
   if (Function *F = CS.getCalledFunction())
     if (AA.doesNotAccessMemory(F))
-      return;
+      return true; // doesn't alias anything
 
   AliasSet *AS = findAliasSetForCallSite(CS);
   if (!AS) {
     AliasSets.push_back(AliasSet());
     AS = &AliasSets.back();
+    AS->addCallSite(CS, AA);
+    return true;
+  } else {
+    AS->addCallSite(CS, AA);
+    return false;
   }
-  AS->addCallSite(CS, AA); 
 }
 
-void AliasSetTracker::add(Instruction *I) {
+bool AliasSetTracker::add(Instruction *I) {
   // Dispatch to one of the other add methods...
   if (LoadInst *LI = dyn_cast<LoadInst>(I))
-    add(LI);
+    return add(LI);
   else if (StoreInst *SI = dyn_cast<StoreInst>(I))
-    add(SI);
+    return add(SI);
   else if (CallInst *CI = dyn_cast<CallInst>(I))
-    add(CI);
+    return add(CI);
   else if (InvokeInst *II = dyn_cast<InvokeInst>(I))
-    add(II);
+    return add(II);
+  return true;
 }
 
 void AliasSetTracker::add(BasicBlock &BB) {
@@ -271,9 +283,10 @@ void AliasSetTracker::add(const AliasSetTracker &AST) {
 
       // Loop over all of the pointers in this alias set...
       AliasSet::iterator I = AS.begin(), E = AS.end();
+      bool X;
       for (; I != E; ++I)
         addPointer(I->first, I->second.getSize(),
-                   (AliasSet::AccessType)AS.AccessTy);
+                   (AliasSet::AccessType)AS.AccessTy, X);
     }
 }