Remove trailing whitespace

[oota-llvm.git] / lib / Analysis / AliasSetTracker.cpp

diff --git a/lib/Analysis/AliasSetTracker.cpp b/lib/Analysis/AliasSetTracker.cpp
index b3f1a6d1612035259bb058906efd26ff814c838b..9ae4044b0e01297aa78f350a67d814c5d0b594de 100644 (file)
--- a/lib/Analysis/AliasSetTracker.cpp
+++ b/lib/Analysis/AliasSetTracker.cpp
@@ -1,29 +1,30 @@
 //===- AliasSetTracker.cpp - Alias Sets Tracker implementation-------------===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
 // This file implements the AliasSetTracker and AliasSet classes.
-// 
+//
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/AliasSetTracker.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Instructions.h"
 #include "llvm/Pass.h"
+#include "llvm/Type.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Assembly/Writer.h"
 #include "llvm/Support/InstIterator.h"
 #include <iostream>
 using namespace llvm;
 
-/// mergeSetIn - Merge the specified alias set into this alias set...
+/// mergeSetIn - Merge the specified alias set into this alias set.
 ///
-void AliasSet::mergeSetIn(AliasSet &AS) {
+void AliasSet::mergeSetIn(AliasSet &AS, AliasSetTracker &AST) {
   assert(!AS.Forward && "Alias set is already forwarding!");
   assert(!Forward && "This set is a forwarding set!!");
 
@@ -31,6 +32,20 @@ void AliasSet::mergeSetIn(AliasSet &AS) {
   AccessTy |= AS.AccessTy;
   AliasTy  |= AS.AliasTy;
 
+  if (AliasTy == MustAlias) {
+    // 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();
+    HashNodePair *L = getSomePointer();
+    HashNodePair *R = AS.getSomePointer();
+
+    // If the pointers are not a must-alias pair, this set becomes a may alias.
+    if (AA.alias(L->first, L->second.getSize(), R->first, R->second.getSize())
+        != AliasAnalysis::MustAlias)
+      AliasTy = MayAlias;
+  }
+
   if (CallSites.empty()) {            // Merge call sites...
     if (!AS.CallSites.empty())
       std::swap(CallSites, AS.CallSites);
@@ -38,7 +53,7 @@ void AliasSet::mergeSetIn(AliasSet &AS) {
     CallSites.insert(CallSites.end(), AS.CallSites.begin(), AS.CallSites.end());
     AS.CallSites.clear();
   }
-  
+
   AS.Forward = this;  // Forward across AS now...
   addRef();           // AS is now pointing to us...
 
@@ -99,9 +114,10 @@ void AliasSet::addCallSite(CallSite CS, AliasAnalysis &AA) {
   CallSites.push_back(CS);
 
   if (Function *F = CS.getCalledFunction()) {
-    if (AA.doesNotAccessMemory(F))
+    AliasAnalysis::ModRefBehavior Behavior = AA.getModRefBehavior(F, CS);
+    if (Behavior == AliasAnalysis::DoesNotAccessMemory)
       return;
-    else if (AA.onlyReadsMemory(F)) {
+    else if (Behavior == AliasAnalysis::OnlyReadsMemory) {
       AliasTy = MayAlias;
       AccessTy |= Refs;
       return;
@@ -179,24 +195,36 @@ AliasSet *AliasSetTracker::findAliasSetForPointer(const Value *Ptr,
   AliasSet *FoundSet = 0;
   for (iterator I = begin(), E = end(); I != E; ++I)
     if (!I->Forward && I->aliasesPointer(Ptr, Size, AA)) {
-      if (FoundSet == 0) {  // If this is the first alias set ptr can go into...
+      if (FoundSet == 0) {  // If this is the first alias set ptr can go into.
         FoundSet = I;       // Remember it.
-      } else {              // Otherwise, we must merge the sets...
-        FoundSet->mergeSetIn(*I);     // Merge in contents...
+      } else {              // Otherwise, we must merge the sets.
+        FoundSet->mergeSetIn(*I, *this);     // Merge in contents.
       }
     }
 
   return FoundSet;
 }
 
+/// containsPointer - Return true if the specified location is represented by
+/// this alias set, false otherwise.  This does not modify the AST object or
+/// alias sets.
+bool AliasSetTracker::containsPointer(Value *Ptr, unsigned Size) const {
+  for (const_iterator I = begin(), E = end(); I != E; ++I)
+    if (!I->Forward && I->aliasesPointer(Ptr, Size, AA))
+      return true;
+  return false;
+}
+
+
+
 AliasSet *AliasSetTracker::findAliasSetForCallSite(CallSite CS) {
   AliasSet *FoundSet = 0;
   for (iterator I = begin(), E = end(); I != E; ++I)
     if (!I->Forward && I->aliasesCallSite(CS, AA)) {
-      if (FoundSet == 0) {  // If this is the first alias set ptr can go into...
+      if (FoundSet == 0) {  // If this is the first alias set ptr can go into.
         FoundSet = I;       // Remember it.
-      } else if (!I->Forward) {     // Otherwise, we must merge the sets...
-        FoundSet->mergeSetIn(*I);     // Merge in contents...
+      } else if (!I->Forward) {     // Otherwise, we must merge the sets.
+        FoundSet->mergeSetIn(*I, *this);     // Merge in contents.
       }
     }
 
@@ -260,12 +288,14 @@ bool AliasSetTracker::add(FreeInst *FI) {
   bool NewPtr;
   AliasSet &AS = addPointer(FI->getOperand(0), ~0,
                             AliasSet::Mods, NewPtr);
+
+  // Free operations are volatile ops (cannot be moved).
+  AS.setVolatile();
   return NewPtr;
 }
 
 
 bool AliasSetTracker::add(CallSite CS) {
-  bool NewPtr;
   if (Function *F = CS.getCalledFunction())
     if (AA.doesNotAccessMemory(F))
       return true; // doesn't alias anything
@@ -476,7 +506,7 @@ void AliasSet::print(std::ostream &OS) const {
     for (unsigned i = 0, e = CallSites.size(); i != e; ++i) {
       if (i) OS << ", ";
       WriteAsOperand(OS, CallSites[i].getCalledValue());
-    }      
+    }
   }
   OS << "\n";
 }
@@ -514,7 +544,7 @@ namespace {
     }
 
     /// print - Convert to human readable form
-    virtual void print(std::ostream &OS) const {
+    virtual void print(std::ostream &OS, const Module* = 0) const {
       Tracker->print(OS);
     }