[GVN] MemorySSA for GVN: eliminate redundant loads via MemorySSA

Introduce the main algorithm performing redundant load elimination
via MemorySSA in GVN. The entry point is `findReachingValuesForLoad`,
which, given as input a possibly redundant load `L`, it attempts to
provide as output a set of reaching memory values (`ReachingMemVal`),
i.e., which values (defs or equivalent reads) can reach `L` along at
least one path where that memory location is not modified meanwhile
(if non-local, PRE will establish whether the load may be eliminated).

Specifically, a reaching value may be of the following descriptor kind:
* Def: found a new instruction that produces exactly the bits the load
  would read. For example, a must-alias store (which defines the load
  memory location), or a must-alias read (exactly reads the same memory
  location, found, e.g., after a phi-translation fixup);
* Clobber: found a write that clobbers a superset of the bits the load
  would read. For example, a memset call over a memory region, whose
  value read overlaps such a region (and may be forwarded to the load),
  or a generic call clobbering the load that cannot be reused;
* Other: a precise instruction could not be found, but know the block
  where the dependency exists (e.g., a memory location already live at
  function entry).

We start off by looking for the users of the defining memory access of
the given load within the same block, searching for local dependencies.
We may need to iteratively follow the use-def chain of the defining
memory access to find the actual clobbering access, while staying within
the scope of the load. If an actual local def/clobber (or liveOnEntry)
is found, we are done and return that one. Otherwise, we move visiting
the predecessors of the load's block, considering the incoming value
from the MemoryPhi as a potential clobbering access. Hence, we search
for dependencies within the predecessor block itself. If the new
potential clobbering access is a MemoryPhi, we continue visiting the
transitive closure of the predecessor, recording its new potential
clobbering access. In this phase, as we are exploring non-local
definitions, the load itself may be considered a must-alias def as well
when being examined from a backedge path.

Author: momchil-velikov

llvm/include/llvm/Transforms/Scalar/GVN.h

@@ -19,6 +19,7 @@
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Analysis/PHITransAddr.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/PassManager.h"
@@ -37,8 +38,10 @@ class AAResults;
 class AssumeInst;
 class AssumptionCache;
 class BasicBlock;
+class BatchAAResults;
 class BranchInst;
 class CallInst;
+class EarliestEscapeAnalysis;
 class ExtractValueInst;
 class Function;
 class FunctionPass;
@@ -255,6 +258,7 @@ class GVNPass : public PassInfoMixin<GVNPass> {
   OptimizationRemarkEmitter *ORE = nullptr;
   ImplicitControlFlowTracking *ICF = nullptr;
   LoopInfo *LI = nullptr;
+  AAResults *AA = nullptr;
   MemorySSAUpdater *MSSAU = nullptr;
 
   ValueTable VN;
@@ -344,21 +348,91 @@ class GVNPass : public PassInfoMixin<GVNPass> {
   // List of critical edges to be split between iterations.
   SmallVector<std::pair<Instruction *, unsigned>, 4> ToSplit;
 
+  enum class DepKind {
+    Other = 0, // Unknown value.
+    Def,       // Exactly overlapping locations.
+    Clobber,   // Reaching value superset of needed bits.
+  };
+
+  // Describe a memory location value, such that there exists a path to a point
+  // in the program, along which that memory location is not modified.
+  struct ReachingMemVal {
+    DepKind Kind;
+    BasicBlock *Block;
+    const Value *Addr;
+    Instruction *Inst;
+    int32_t Offset;
+
+    static ReachingMemVal getUnknown(BasicBlock *BB, const Value *Addr,
+                                     Instruction *Inst = nullptr) {
+      return {DepKind::Other, BB, Addr, Inst, -1};
+    }
+
+    static ReachingMemVal getDef(const Value *Addr, Instruction *Inst) {
+      return {DepKind::Def, Inst->getParent(), Addr, Inst, -1};
+    }
+
+    static ReachingMemVal getClobber(const Value *Addr, Instruction *Inst,
+                                     int32_t Offset = -1) {
+      return {DepKind::Clobber, Inst->getParent(), Addr, Inst, Offset};
+    }
+  };
+
+  struct DependencyBlockInfo {
+    DependencyBlockInfo() = delete;
+    DependencyBlockInfo(const PHITransAddr &Addr, MemoryAccess *ClobberMA)
+        : Addr(Addr), InitialClobberMA(ClobberMA), ClobberMA(ClobberMA),
+          ForceUnknown(false), Visited(false) {}
+    PHITransAddr Addr;
+    MemoryAccess *InitialClobberMA;
+    MemoryAccess *ClobberMA;
+    std::optional<ReachingMemVal> MemVal;
+    bool ForceUnknown : 1;
+    bool Visited : 1;
+  };
+
+  using DependencyBlockSet = DenseMap<BasicBlock *, DependencyBlockInfo>;
+
+  std::optional<GVNPass::ReachingMemVal> scanMemoryAccessesUsers(
+      const MemoryLocation &Loc, bool IsInvariantLoad, BasicBlock *BB,
+      const SmallVectorImpl<MemoryAccess *> &ClobbersList, MemorySSA &MSSA,
+      BatchAAResults &AA, LoadInst *L = nullptr);
+
+  std::optional<GVNPass::ReachingMemVal>
+  accessMayModifyLocation(MemoryAccess *ClobberMA, const MemoryLocation &Loc,
+                          bool IsInvariantLoad, BasicBlock *BB, MemorySSA &MSSA,
+                          BatchAAResults &AA);
+
+  bool collectPredecessors(BasicBlock *BB, const PHITransAddr &Addr,
+                           MemoryAccess *ClobberMA, DependencyBlockSet &Blocks,
+                           SmallVectorImpl<BasicBlock *> &Worklist);
+
+  void collectClobberList(SmallVectorImpl<MemoryAccess *> &Clobbers,
+                          BasicBlock *BB, const DependencyBlockInfo &StartInfo,
+                          const DependencyBlockSet &Blocks, MemorySSA &MSSA);
+
+  bool findReachingValuesForLoad(LoadInst *Inst,
+                                 SmallVectorImpl<ReachingMemVal> &Values,
+                                 MemorySSA &MSSA, AAResults &AA);
+
   // Helper functions of redundant load elimination.
   bool processLoad(LoadInst *L);
   bool processMaskedLoad(IntrinsicInst *I);
   bool processNonLocalLoad(LoadInst *L);
+  bool processNonLocalLoad(LoadInst *L, SmallVectorImpl<ReachingMemVal> &Deps);
   bool processAssumeIntrinsic(AssumeInst *II);
 
   /// Given a local dependency (Def or Clobber) determine if a value is
   /// available for the load.
   std::optional<gvn::AvailableValue>
-  AnalyzeLoadAvailability(LoadInst *Load, MemDepResult DepInfo, Value *Address);
+  AnalyzeLoadAvailability(LoadInst *Load, const ReachingMemVal &Dep,
+                          Value *Address);
 
   /// Given a list of non-local dependencies, determine if a value is
   /// available for the load in each specified block.  If it is, add it to
   /// ValuesPerBlock.  If not, add it to UnavailableBlocks.
-  void AnalyzeLoadAvailability(LoadInst *Load, LoadDepVect &Deps,
+  void AnalyzeLoadAvailability(LoadInst *Load,
+                               SmallVectorImpl<ReachingMemVal> &Deps,
                                AvailValInBlkVect &ValuesPerBlock,
                                UnavailBlkVect &UnavailableBlocks);