[llvm] f278734 - [Loads] Restructure getAvailableLoadStore implementation (NFC)

[Nikita Popov via llvm-commits]

Author: Nikita Popov
Date: 2021-03-06T16:58:11+01:00
New Revision: f278734bf1dd8db64b62e009ce77432b62420684

URL: https://github.com/llvm/llvm-project/commit/f278734bf1dd8db64b62e009ce77432b62420684
DIFF: https://github.com/llvm/llvm-project/commit/f278734bf1dd8db64b62e009ce77432b62420684.diff

LOG: [Loads] Restructure getAvailableLoadStore implementation (NFC)

Separate out some conditions with early exits, to make it easier to
support additional cases.

Added: 
    

Modified: 
    llvm/lib/Analysis/Loads.cpp

Removed: 
    


################################################################################
diff  --git a/llvm/lib/Analysis/Loads.cpp b/llvm/lib/Analysis/Loads.cpp
index d82ed02a67bc..88e4c723331a 100644
--- a/llvm/lib/Analysis/Loads.cpp
+++ b/llvm/lib/Analysis/Loads.cpp
@@ -469,14 +469,16 @@ static Value *getAvailableLoadStore(Instruction *Inst, Value *Ptr,
   // (This is true even if the load is volatile or atomic, although
   // those cases are unlikely.)
   if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
-    if (AreEquivalentAddressValues(
-            LI->getPointerOperand()->stripPointerCasts(), Ptr) &&
-        CastInst::isBitOrNoopPointerCastable(LI->getType(), AccessTy, DL)) {
-      // We can value forward from an atomic to a non-atomic, but not the
-      // other way around.
-      if (LI->isAtomic() < AtLeastAtomic)
-        return nullptr;
+    // We can value forward from an atomic to a non-atomic, but not the
+    // other way around.
+    if (LI->isAtomic() < AtLeastAtomic)
+      return nullptr;
+
+    Value *LoadPtr = LI->getPointerOperand()->stripPointerCasts();
+    if (!AreEquivalentAddressValues(LoadPtr, Ptr))
+      return nullptr;
 
+    if (CastInst::isBitOrNoopPointerCastable(LI->getType(), AccessTy, DL)) {
       if (IsLoadCSE)
         *IsLoadCSE = true;
       return LI;
@@ -487,18 +489,20 @@ static Value *getAvailableLoadStore(Instruction *Inst, Value *Ptr,
   // (This is true even if the store is volatile or atomic, although
   // those cases are unlikely.)
   if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
+    // We can value forward from an atomic to a non-atomic, but not the
+    // other way around.
+    if (SI->isAtomic() < AtLeastAtomic)
+      return nullptr;
+
     Value *StorePtr = SI->getPointerOperand()->stripPointerCasts();
-    if (AreEquivalentAddressValues(StorePtr, Ptr) &&
-        CastInst::isBitOrNoopPointerCastable(SI->getValueOperand()->getType(),
-                                             AccessTy, DL)) {
-      // We can value forward from an atomic to a non-atomic, but not the
-      // other way around.
-      if (SI->isAtomic() < AtLeastAtomic)
-        return nullptr;
+    if (!AreEquivalentAddressValues(StorePtr, Ptr))
+      return nullptr;
 
+    Value *Val = SI->getValueOperand();
+    if (CastInst::isBitOrNoopPointerCastable(Val->getType(), AccessTy, DL)) {
       if (IsLoadCSE)
         *IsLoadCSE = false;
-      return SI->getOperand(0);
+      return Val;
     }
   }