Add helper functions for computing the Location of load, store,

and vaarg instructions.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@118845 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Analysis/AliasAnalysis.h b/include/llvm/Analysis/AliasAnalysis.h
index f363f42541e1dc3df0006fdf8359ac77642a550f..53f0eea2beed6944eb7f6f5abf32df179716a00b 100644 (file)
--- a/include/llvm/Analysis/AliasAnalysis.h
+++ b/include/llvm/Analysis/AliasAnalysis.h
@@ -130,6 +130,12 @@ public:
     }
   };
 
+  /// getLocation - Fill in Loc with information about the memory reference by
+  /// the given instruction.
+  Location getLocation(const LoadInst *LI);
+  Location getLocation(const StoreInst *SI);
+  Location getLocation(const VAArgInst *VI);
+
   /// Alias analysis result - Either we know for sure that it does not alias, we
   /// know for sure it must alias, or we don't know anything: The two pointers
   /// _might_ alias.  This enum is designed so you can do things like:

diff --git a/lib/Analysis/AliasAnalysis.cpp b/lib/Analysis/AliasAnalysis.cpp
index 9c0bded3721254b65d849762b3dae8ecdbd6f83f..94a6d41872cf40adf8fb70be482144f177e37d12 100644 (file)
--- a/lib/Analysis/AliasAnalysis.cpp
+++ b/lib/Analysis/AliasAnalysis.cpp
@@ -194,6 +194,24 @@ AliasAnalysis::getModRefBehavior(const Function *F) {
 // AliasAnalysis non-virtual helper method implementation
 //===----------------------------------------------------------------------===//
 
+AliasAnalysis::Location AliasAnalysis::getLocation(const LoadInst *LI) {
+  return Location(LI->getPointerOperand(),
+                  getTypeStoreSize(LI->getType()),
+                  LI->getMetadata(LLVMContext::MD_tbaa));
+}
+
+AliasAnalysis::Location AliasAnalysis::getLocation(const StoreInst *SI) {
+  return Location(SI->getPointerOperand(),
+                  getTypeStoreSize(SI->getValueOperand()->getType()),
+                  SI->getMetadata(LLVMContext::MD_tbaa));
+}
+
+AliasAnalysis::Location AliasAnalysis::getLocation(const VAArgInst *VI) {
+  return Location(VI->getPointerOperand(),
+                  UnknownSize,
+                  VI->getMetadata(LLVMContext::MD_tbaa));
+}
+
 AliasAnalysis::ModRefResult
 AliasAnalysis::getModRefInfo(const LoadInst *L, const Location &Loc) {
   // Be conservative in the face of volatile.
@@ -202,10 +220,7 @@ AliasAnalysis::getModRefInfo(const LoadInst *L, const Location &Loc) {
 
   // If the load address doesn't alias the given address, it doesn't read
   // or write the specified memory.
-  if (!alias(Location(L->getOperand(0),
-                      getTypeStoreSize(L->getType()),
-                      L->getMetadata(LLVMContext::MD_tbaa)),
-             Loc))
+  if (!alias(getLocation(L), Loc))
     return NoModRef;
 
   // Otherwise, a load just reads.
@@ -220,10 +235,7 @@ AliasAnalysis::getModRefInfo(const StoreInst *S, const Location &Loc) {
 
   // If the store address cannot alias the pointer in question, then the
   // specified memory cannot be modified by the store.
-  if (!alias(Location(S->getOperand(1),
-                      getTypeStoreSize(S->getOperand(0)->getType()),
-                      S->getMetadata(LLVMContext::MD_tbaa)),
-             Loc))
+  if (!alias(getLocation(S), Loc))
     return NoModRef;
 
   // If the pointer is a pointer to constant memory, then it could not have been
@@ -239,10 +251,7 @@ AliasAnalysis::ModRefResult
 AliasAnalysis::getModRefInfo(const VAArgInst *V, const Location &Loc) {
   // If the va_arg address cannot alias the pointer in question, then the
   // specified memory cannot be accessed by the va_arg.
-  if (!alias(Location(V->getOperand(0),
-                      UnknownSize,
-                      V->getMetadata(LLVMContext::MD_tbaa)),
-             Loc))
+  if (!alias(getLocation(V), Loc))
     return NoModRef;
 
   // If the pointer is a pointer to constant memory, then it could not have been

diff --git a/lib/Analysis/MemDepPrinter.cpp b/lib/Analysis/MemDepPrinter.cpp
index 90a7c576f07e84d032b7cf68460b6c6eedf2e407..64d215c37cc772e74e0728cc19425f2d5f53b11b 100644 (file)
--- a/lib/Analysis/MemDepPrinter.cpp
+++ b/lib/Analysis/MemDepPrinter.cpp
@@ -102,22 +102,15 @@ bool MemDepPrinter::runOnFunction(Function &F) {
       SmallVector<NonLocalDepResult, 4> NLDI;
       if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
         // FIXME: Volatile is not handled properly here.
-        AliasAnalysis::Location Loc(LI->getPointerOperand(),
-                                    AA.getTypeStoreSize(LI->getType()),
-                                    LI->getMetadata(LLVMContext::MD_tbaa));
+        AliasAnalysis::Location Loc = AA.getLocation(LI);
         MDA.getNonLocalPointerDependency(Loc, !LI->isVolatile(),
                                          LI->getParent(), NLDI);
       } else if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
         // FIXME: Volatile is not handled properly here.
-        AliasAnalysis::Location Loc(SI->getPointerOperand(),
-                                    AA.getTypeStoreSize(SI->getValueOperand()
-                                                          ->getType()),
-                                    SI->getMetadata(LLVMContext::MD_tbaa));
+        AliasAnalysis::Location Loc = AA.getLocation(SI);
         MDA.getNonLocalPointerDependency(Loc, false, SI->getParent(), NLDI);
       } else if (VAArgInst *VI = dyn_cast<VAArgInst>(Inst)) {
-        AliasAnalysis::Location Loc(SI->getPointerOperand(),
-                                    AliasAnalysis::UnknownSize,
-                                    SI->getMetadata(LLVMContext::MD_tbaa));
+        AliasAnalysis::Location Loc = AA.getLocation(VI);
         MDA.getNonLocalPointerDependency(Loc, false, VI->getParent(), NLDI);
       } else {
         llvm_unreachable("Unknown memory instruction!");

diff --git a/lib/Analysis/MemoryDependenceAnalysis.cpp b/lib/Analysis/MemoryDependenceAnalysis.cpp
index 96af281c3958e86cf24107e6edf6ada5ff488e43..a16e334e020ef79380f3631d5557428bfcffcfc7 100644 (file)
--- a/lib/Analysis/MemoryDependenceAnalysis.cpp
+++ b/lib/Analysis/MemoryDependenceAnalysis.cpp
@@ -115,9 +115,7 @@ AliasAnalysis::ModRefResult GetLocation(const Instruction *Inst,
       Loc = AliasAnalysis::Location();
       return AliasAnalysis::ModRef;
     }
-    Loc = AliasAnalysis::Location(LI->getPointerOperand(),
-                                  AA->getTypeStoreSize(LI->getType()),
-                                  LI->getMetadata(LLVMContext::MD_tbaa));
+    Loc = AA->getLocation(LI);
     return AliasAnalysis::Ref;
   }
 
@@ -126,17 +124,12 @@ AliasAnalysis::ModRefResult GetLocation(const Instruction *Inst,
       Loc = AliasAnalysis::Location();
       return AliasAnalysis::ModRef;
     }
-    Loc = AliasAnalysis::Location(SI->getPointerOperand(),
-                                  AA->getTypeStoreSize(SI->getValueOperand()
-                                                         ->getType()),
-                                  SI->getMetadata(LLVMContext::MD_tbaa));
+    Loc = AA->getLocation(SI);
     return AliasAnalysis::Mod;
   }
 
   if (const VAArgInst *V = dyn_cast<VAArgInst>(Inst)) {
-    Loc = AliasAnalysis::Location(V->getPointerOperand(),
-                                  AA->getTypeStoreSize(V->getType()),
-                                  V->getMetadata(LLVMContext::MD_tbaa));
+    Loc = AA->getLocation(V);
     return AliasAnalysis::ModRef;
   }
 
@@ -288,10 +281,7 @@ getPointerDependencyFrom(const AliasAnalysis::Location &MemLoc, bool isLoad,
     // Values depend on loads if the pointers are must aliased.  This means that
     // a load depends on another must aliased load from the same value.
     if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
-      Value *Pointer = LI->getPointerOperand();
-      uint64_t PointerSize = AA->getTypeStoreSize(LI->getType());
-      MDNode *TBAATag = LI->getMetadata(LLVMContext::MD_tbaa);
-      AliasAnalysis::Location LoadLoc(Pointer, PointerSize, TBAATag);
+      AliasAnalysis::Location LoadLoc = AA->getLocation(LI);
       
       // If we found a pointer, check if it could be the same as our pointer.
       AliasAnalysis::AliasResult R = AA->alias(LoadLoc, MemLoc);
@@ -324,14 +314,10 @@ getPointerDependencyFrom(const AliasAnalysis::Location &MemLoc, bool isLoad,
 
       // Ok, this store might clobber the query pointer.  Check to see if it is
       // a must alias: in this case, we want to return this as a def.
-      Value *Pointer = SI->getPointerOperand();
-      uint64_t PointerSize = AA->getTypeStoreSize(SI->getOperand(0)->getType());
-      MDNode *TBAATag = SI->getMetadata(LLVMContext::MD_tbaa);
+      AliasAnalysis::Location StoreLoc = AA->getLocation(SI);
       
       // If we found a pointer, check if it could be the same as our pointer.
-      AliasAnalysis::AliasResult R =
-        AA->alias(AliasAnalysis::Location(Pointer, PointerSize, TBAATag),
-                  MemLoc);
+      AliasAnalysis::AliasResult R = AA->alias(StoreLoc, MemLoc);
       
       if (R == AliasAnalysis::NoAlias)
         continue;

diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp
index fe30381170dc5006fbf2080a98ef2b9f360c2bc5..17ef703ad36e8d996e0310f9ef6645147da3ea6a 100644 (file)
--- a/lib/Transforms/IPO/ArgumentPromotion.cpp
+++ b/lib/Transforms/IPO/ArgumentPromotion.cpp
@@ -433,10 +433,7 @@ bool ArgPromotion::isSafeToPromoteArgument(Argument *Arg, bool isByVal) const {
     LoadInst *Load = Loads[i];
     BasicBlock *BB = Load->getParent();
 
-    AliasAnalysis::Location Loc(Load->getPointerOperand(),
-                                AA.getTypeStoreSize(Load->getType()),
-                                Load->getMetadata(LLVMContext::MD_tbaa));
-
+    AliasAnalysis::Location Loc = AA.getLocation(Load);
     if (AA.canInstructionRangeModify(BB->front(), *Load, Loc))
       return false;  // Pointer is invalidated!
 

diff --git a/lib/Transforms/IPO/FunctionAttrs.cpp b/lib/Transforms/IPO/FunctionAttrs.cpp
index bb3ee465716e524a87c994513f587a4357a1cf49..95decec0f874c5e3bb23bd36dc557b0bd885d133 100644 (file)
--- a/lib/Transforms/IPO/FunctionAttrs.cpp
+++ b/lib/Transforms/IPO/FunctionAttrs.cpp
@@ -165,27 +165,20 @@ bool FunctionAttrs::AddReadAttrs(const CallGraphSCC &SCC) {
       } else if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
         // Ignore non-volatile loads from local memory.
         if (!LI->isVolatile()) {
-          AliasAnalysis::Location Loc(LI->getPointerOperand(),
-                                        AA->getTypeStoreSize(LI->getType()),
-                                        LI->getMetadata(LLVMContext::MD_tbaa));
+          AliasAnalysis::Location Loc = AA->getLocation(LI);
           if (AA->pointsToConstantMemory(Loc, /*OrLocal=*/true))
             continue;
         }
       } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
         // Ignore non-volatile stores to local memory.
         if (!SI->isVolatile()) {
-          const Type *StoredType = SI->getValueOperand()->getType();
-          AliasAnalysis::Location Loc(SI->getPointerOperand(),
-                                      AA->getTypeStoreSize(StoredType),
-                                      SI->getMetadata(LLVMContext::MD_tbaa));
+          AliasAnalysis::Location Loc = AA->getLocation(SI);
           if (AA->pointsToConstantMemory(Loc, /*OrLocal=*/true))
             continue;
         }
       } else if (VAArgInst *VI = dyn_cast<VAArgInst>(I)) {
         // Ignore vaargs on local memory.
-        AliasAnalysis::Location Loc(VI->getPointerOperand(),
-                                    AliasAnalysis::UnknownSize,
-                                    VI->getMetadata(LLVMContext::MD_tbaa));
+        AliasAnalysis::Location Loc = AA->getLocation(VI);
         if (AA->pointsToConstantMemory(Loc, /*OrLocal=*/true))
           continue;
       }

diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp
index e506d0efd7f91e0273833cf049830538093a9731..52791dd217d3ea79b49104dca8282894249b5696 100644 (file)
--- a/lib/Transforms/Scalar/GVN.cpp
+++ b/lib/Transforms/Scalar/GVN.cpp
@@ -1351,11 +1351,8 @@ bool GVN::processNonLocalLoad(LoadInst *LI,
                               SmallVectorImpl<Instruction*> &toErase) {
   // Find the non-local dependencies of the load.
   SmallVector<NonLocalDepResult, 64> Deps;
-  AliasAnalysis::Location Loc(LI->getPointerOperand(),
-                         VN.getAliasAnalysis()->getTypeStoreSize(LI->getType()),
-                              LI->getMetadata(LLVMContext::MD_tbaa));
-  MD->getNonLocalPointerDependency(Loc, true, LI->getParent(),
-                                   Deps);
+  AliasAnalysis::Location Loc = VN.getAliasAnalysis()->getLocation(LI);
+  MD->getNonLocalPointerDependency(Loc, true, LI->getParent(), Deps);
   //DEBUG(dbgs() << "INVESTIGATING NONLOCAL LOAD: "
   //             << Deps.size() << *LI << '\n');
 

diff --git a/lib/Transforms/Scalar/Sink.cpp b/lib/Transforms/Scalar/Sink.cpp
index a54ba8e0ae547973c0e05f1cbc8a131719db2525..705f44204900ff67225def19318e5bd6d689b0d5 100644 (file)
--- a/lib/Transforms/Scalar/Sink.cpp
+++ b/lib/Transforms/Scalar/Sink.cpp
@@ -15,7 +15,6 @@
 #define DEBUG_TYPE "sink"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/IntrinsicInst.h"
-#include "llvm/LLVMContext.h"
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/AliasAnalysis.h"
@@ -157,10 +156,7 @@ static bool isSafeToMove(Instruction *Inst, AliasAnalysis *AA,
   if (LoadInst *L = dyn_cast<LoadInst>(Inst)) {
     if (L->isVolatile()) return false;
 
-    Value *Ptr = L->getPointerOperand();
-    uint64_t Size = AA->getTypeStoreSize(L->getType());
-    const MDNode *TBAAInfo = L->getMetadata(LLVMContext::MD_tbaa);
-    AliasAnalysis::Location Loc(Ptr, Size, TBAAInfo);
+    AliasAnalysis::Location Loc = AA->getLocation(L);
     for (SmallPtrSet<Instruction *, 8>::iterator I = Stores.begin(),
          E = Stores.end(); I != E; ++I)
       if (AA->getModRefInfo(*I, Loc) & AliasAnalysis::Mod)