[AA] Do not track Must in ModRefInfo

[nikic]

Summary

getModRefInfo() queries currently track whether the result is a MustAlias on a best-effort basis. The only user of this functionality is the optimized memory access type in MemorySSA -- which in turn has no users. Given that this functionality has not found a user since it was introduced five years ago (in D38862), I think we should consider dropping it again.

The context is that I'm working to separate FunctionModRefBehavior to track mod/ref for different location kinds (like argmem or inaccessiblemem) separately, and the fact that ModRefInfo also has an unrelated Must flag makes this quite awkward, especially as this means that NoModRef is not a zero value. If we want to retain the functionality, I would probably split ModRefInfo into a part that just contains the ModRef information, and a separate part tracking the Must flag.

[jdoerfert]

I'm all for tracking on a more fine granular scope. I'd suggest an RFC and discussion about that, maybe we get enough support to do it right rather this time. It pops up again and again anyway.
Wrt. must alias, I don't think it's worth keeping if we don't use it.

[nikic]

Remove more dead code in AAEval.

[nikic]

In D130713#3685384, @jdoerfert wrote:

I'm all for tracking on a more fine granular scope. I'd suggest an RFC and discussion about that, maybe we get enough support to do it right rather this time. It pops up again and again anyway.
Wrt. must alias, I don't think it's worth keeping if we don't use it.

Right. I want to do some internal refactoring in AA first, but ultimately we need to change how we represent memory effects in IR attributes as well.

[asbirlea]

This is unfortunate, but your point is valid. If there hasn't been a use case so far in the passes that use MemorySSA, this cleanup makes sense.
If a use case does show up in the future we can discuss how re-adding Must info will look then, after your changes.

llvm/include/llvm/Analysis/AliasAnalysis.h

static_assert(sizeof(AliasResult) == 4,
               "AliasResult size is intended to be 4 bytes!");
 
 /// << operator for AliasResult.
 raw_ostream &operator<<(raw_ostream &OS, AliasResult AR);
 
 /// Flags indicating whether a memory access modifies or references memory.
 ///
 /// This is no access at all, a modification, a reference, or both
-/// a modification and a reference. These are specifically structured such that
-/// they form a three bit matrix and bit-tests for 'mod' or 'ref' or 'must'
-/// work with any of the possible values.
+/// a modification and a reference.
 enum class ModRefInfo : uint8_t {
-  /// Must is provided for completeness, but no routines will return only
-  /// Must today. See definition of Must below.
-  Must = 0,
-  /// The access may reference the value stored in memory,
-  /// a mustAlias relation was found, and no mayAlias or partialAlias found.
-  MustRef = 1,
-  /// The access may modify the value stored in memory,
-  /// a mustAlias relation was found, and no mayAlias or partialAlias found.
-  MustMod = 2,
-  /// The access may reference, modify or both the value stored in memory,
-  /// a mustAlias relation was found, and no mayAlias or partialAlias found.
-  MustModRef = MustRef | MustMod,
   /// The access neither references nor modifies the value stored in memory.
-  NoModRef = 4,
+  NoModRef = 0,
   /// The access may reference the value stored in memory.
-  Ref = NoModRef | MustRef,
+  Ref = 1,
   /// The access may modify the value stored in memory.
-  Mod = NoModRef | MustMod,
+  Mod = 2,
   /// The access may reference and may modify the value stored in memory.
   ModRef = Ref | Mod,
-
-  /// About Must:
-  /// Must is set in a best effort manner.
-  /// We usually do not try our best to infer Must, instead it is merely
-  /// another piece of "free" information that is presented when available.
-  /// Must set means there was certainly a MustAlias found. For calls,
-  /// where multiple arguments are checked (argmemonly), this translates to
-  /// only MustAlias or NoAlias was found.
-  /// Must is not set for RAR accesses, even if the two locations must
-  /// alias. The reason is that two read accesses translate to an early return
-  /// of NoModRef. An additional alias check to set Must may be
-  /// expensive. Other cases may also not set Must(e.g. callCapturesBefore).
-  /// We refer to Must being *set* when the most significant bit is *cleared*.
-  /// Conversely we *clear* Must information by *setting* the Must bit to 1.
 };
 
 LLVM_NODISCARD inline bool isNoModRef(const ModRefInfo MRI) {
-  return (static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef)) ==
-         static_cast<int>(ModRefInfo::Must);
+  return MRI == ModRefInfo::NoModRef;
 }
 LLVM_NODISCARD inline bool isModOrRefSet(const ModRefInfo MRI) {
-  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef);
+  return MRI != ModRefInfo::NoModRef;
 }
 LLVM_NODISCARD inline bool isModAndRefSet(const ModRefInfo MRI) {
-  return (static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef)) ==
-         static_cast<int>(ModRefInfo::MustModRef);
+  return MRI == ModRefInfo::ModRef;
 }
 LLVM_NODISCARD inline bool isModSet(const ModRefInfo MRI) {
-  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustMod);
+  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Mod);
 }
 LLVM_NODISCARD inline bool isRefSet(const ModRefInfo MRI) {
-  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustRef);
-}
-LLVM_NODISCARD inline bool isMustSet(const ModRefInfo MRI) {
-  return !(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::NoModRef));
+  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Ref);
 }
 
 LLVM_NODISCARD inline ModRefInfo setMod(const ModRefInfo MRI) {
   return ModRefInfo(static_cast<int>(MRI) |
-                    static_cast<int>(ModRefInfo::MustMod));
+                    static_cast<int>(ModRefInfo::Mod));
 }
 LLVM_NODISCARD inline ModRefInfo setRef(const ModRefInfo MRI) {
   return ModRefInfo(static_cast<int>(MRI) |
-                    static_cast<int>(ModRefInfo::MustRef));
-}
-LLVM_NODISCARD inline ModRefInfo setMust(const ModRefInfo MRI) {
-  return ModRefInfo(static_cast<int>(MRI) &
-                    static_cast<int>(ModRefInfo::MustModRef));
+                    static_cast<int>(ModRefInfo::Ref));
 }
 LLVM_NODISCARD inline ModRefInfo setModAndRef(const ModRefInfo MRI) {
-  return ModRefInfo(static_cast<int>(MRI) |
-                    static_cast<int>(ModRefInfo::MustModRef));
+  return ModRefInfo::ModRef;
 }
 LLVM_NODISCARD inline ModRefInfo clearMod(const ModRefInfo MRI) {
   return ModRefInfo(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Ref));
 }
 LLVM_NODISCARD inline ModRefInfo clearRef(const ModRefInfo MRI) {
   return ModRefInfo(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Mod));
 }
-LLVM_NODISCARD inline ModRefInfo clearMust(const ModRefInfo MRI) {
-  return ModRefInfo(static_cast<int>(MRI) |
-                    static_cast<int>(ModRefInfo::NoModRef));
-}
 LLVM_NODISCARD inline ModRefInfo unionModRef(const ModRefInfo MRI1,
                                              const ModRefInfo MRI2) {
   return ModRefInfo(static_cast<int>(MRI1) | static_cast<int>(MRI2));
 }
 LLVM_NODISCARD inline ModRefInfo intersectModRef(const ModRefInfo MRI1,
                                                  const ModRefInfo MRI2) {
   return ModRefInfo(static_cast<int>(MRI1) & static_cast<int>(MRI2));
 }
public:
   //===--------------------------------------------------------------------===//
   /// \name Simple mod/ref information
   /// @{
 
   /// Get the ModRef info associated with a pointer argument of a call. The
   /// result's bits are set to indicate the allowed aliasing ModRef kinds. Note
   /// that these bits do not necessarily account for the overall behavior of
   /// the function, but rather only provide additional per-argument
-  /// information. This never sets ModRefInfo::Must.
+  /// information.
   ModRefInfo getArgModRefInfo(const CallBase *Call, unsigned ArgIdx);
 
   /// Return the behavior of the given call site.
   FunctionModRefBehavior getModRefBehavior(const CallBase *Call);
 
   /// Return the behavior when calling the given function.
   FunctionModRefBehavior getModRefBehavior(const Function *F);
 
public:
   /// Return information about whether two call sites may refer to the same set
   /// of memory locations. See the AA documentation for details:
   ///   http://llvm.org/docs/AliasAnalysis.html#ModRefInfo
   ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2);
 
   /// Return information about whether a particular call site modifies
   /// or reads the specified memory location \p MemLoc before instruction \p I
   /// in a BasicBlock.
-  /// Early exits in callCapturesBefore may lead to ModRefInfo::Must not being
-  /// set.
   ModRefInfo callCapturesBefore(const Instruction *I,
                                 const MemoryLocation &MemLoc,
                                 DominatorTree *DT) {
     SimpleAAQueryInfo AAQIP;
     return callCapturesBefore(I, MemLoc, DT, AAQIP);
   }
 
   /// A convenience wrapper to synthesize a memory location.

llvm/include/llvm/Analysis/MemorySSA.h

public:
 
   /// Do we have an optimized use?
   inline bool isOptimized() const;
   /// Return the MemoryAccess associated with the optimized use, or nullptr.
   inline MemoryAccess *getOptimized() const;
   /// Sets the optimized use for a MemoryDef.
   inline void setOptimized(MemoryAccess *);
 
-  // Retrieve AliasResult type of the optimized access. Ideally this would be
-  // returned by the caching walker and may go away in the future.
-  Optional<AliasResult> getOptimizedAccessType() const {
-    return isOptimized() ? OptimizedAccessAlias : None;
-  }
-
   /// Reset the ID of what this MemoryUse was optimized to, causing it to
   /// be rewalked by the walker if necessary.
   /// This really should only be called by tests.
   inline void resetOptimized();
 
 protected:
   friend class MemorySSA;
   friend class MemorySSAUpdater;
 
   MemoryUseOrDef(LLVMContext &C, MemoryAccess *DMA, unsigned Vty,
                  DeleteValueTy DeleteValue, Instruction *MI, BasicBlock *BB,
                  unsigned NumOperands)
       : MemoryAccess(C, Vty, DeleteValue, BB, NumOperands),
-        MemoryInstruction(MI), OptimizedAccessAlias(AliasResult::MayAlias) {
+        MemoryInstruction(MI) {
     setDefiningAccess(DMA);
   }
 
   // Use deleteValue() to delete a generic MemoryUseOrDef.
   ~MemoryUseOrDef() = default;
 
-  void setOptimizedAccessType(Optional<AliasResult> AR) {
-    OptimizedAccessAlias = AR;
-  }
-
   void setDefiningAccess(
-      MemoryAccess *DMA, bool Optimized = false,
-      Optional<AliasResult> AR = AliasResult(AliasResult::MayAlias)) {
+      MemoryAccess *DMA, bool Optimized = false) {
     if (!Optimized) {
       setOperand(0, DMA);
       return;
     }
     setOptimized(DMA);
-    setOptimizedAccessType(AR);
   }
 
 private:
   Instruction *MemoryInstruction;
-  Optional<AliasResult> OptimizedAccessAlias;
 };
 
 /// Represents read-only accesses to memory
 ///
 /// In particular, the set of Instructions that will be represented by
 /// MemoryUse's is exactly the set of Instructions for which
 /// AliasAnalysis::getModRefInfo returns "Ref".
 class MemoryUse final : public MemoryUseOrDef {

llvm/lib/Analysis/AliasAnalysis.cpp

if (onlyAccessesInaccessibleMem(MRB))
     return ModRefInfo::NoModRef;
 
   if (onlyReadsMemory(MRB))
     Result = clearMod(Result);
   else if (onlyWritesMemory(MRB))
     Result = clearRef(Result);
 
   if (onlyAccessesArgPointees(MRB) || onlyAccessesInaccessibleOrArgMem(MRB)) {
-    bool IsMustAlias = true;
     ModRefInfo AllArgsMask = ModRefInfo::NoModRef;
     if (doesAccessArgPointees(MRB)) {
       for (const auto &I : llvm::enumerate(Call->args())) {
         const Value *Arg = I.value();
         if (!Arg->getType()->isPointerTy())
           continue;
         unsigned ArgIdx = I.index();
         MemoryLocation ArgLoc =
             MemoryLocation::getForArgument(Call, ArgIdx, TLI);
         AliasResult ArgAlias = alias(ArgLoc, Loc, AAQI);
         if (ArgAlias != AliasResult::NoAlias) {
           ModRefInfo ArgMask = getArgModRefInfo(Call, ArgIdx);
           AllArgsMask = unionModRef(AllArgsMask, ArgMask);
         }
-        // Conservatively clear IsMustAlias unless only MustAlias is found.
-        IsMustAlias &= (ArgAlias == AliasResult::MustAlias);
       }
     }
     // Return NoModRef if no alias found with any argument.
     if (isNoModRef(AllArgsMask))
       return ModRefInfo::NoModRef;
     // Logical & between other AA analyses and argument analysis.
     Result = intersectModRef(Result, AllArgsMask);
-    // If only MustAlias found above, set Must bit.
-    Result = IsMustAlias ? setMust(Result) : clearMust(Result);
   }
 
   // If Loc is a constant memory location, the call definitely could not
   // modify the memory location.
   if (isModSet(Result) && pointsToConstantMemory(Loc, AAQI, /*OrLocal*/ false))
     Result = clearMod(Result);
 
   return Result;
ModRefInfo AAResults::getModRefInfo(const CallBase *Call1,
 
   // If Call2 only access memory through arguments, accumulate the mod/ref
   // information from Call1's references to the memory referenced by
   // Call2's arguments.
   if (onlyAccessesArgPointees(Call2B)) {
     if (!doesAccessArgPointees(Call2B))
       return ModRefInfo::NoModRef;
     ModRefInfo R = ModRefInfo::NoModRef;
-    bool IsMustAlias = true;
     for (auto I = Call2->arg_begin(), E = Call2->arg_end(); I != E; ++I) {
       const Value *Arg = *I;
       if (!Arg->getType()->isPointerTy())
         continue;
       unsigned Call2ArgIdx = std::distance(Call2->arg_begin(), I);
       auto Call2ArgLoc =
           MemoryLocation::getForArgument(Call2, Call2ArgIdx, TLI);
 
for (auto I = Call2->arg_begin(), E = Call2->arg_end(); I != E; ++I) {
       else if (isRefSet(ArgModRefC2))
         ArgMask = ModRefInfo::Mod;
 
       // ModRefC1 indicates what Call1 might do to Call2ArgLoc, and we use
       // above ArgMask to update dependence info.
       ModRefInfo ModRefC1 = getModRefInfo(Call1, Call2ArgLoc, AAQI);
       ArgMask = intersectModRef(ArgMask, ModRefC1);
 
-      // Conservatively clear IsMustAlias unless only MustAlias is found.
-      IsMustAlias &= isMustSet(ModRefC1);
-
       R = intersectModRef(unionModRef(R, ArgMask), Result);
-      if (R == Result) {
-        // On early exit, not all args were checked, cannot set Must.
-        if (I + 1 != E)
-          IsMustAlias = false;
+      if (R == Result)
         break;
-      }
-    }
-
-    if (isNoModRef(R))
-      return ModRefInfo::NoModRef;
 
-    // If MustAlias found above, set Must bit.
-    return IsMustAlias ? setMust(R) : clearMust(R);
+    return R;
   }
 
   // If Call1 only accesses memory through arguments, check if Call2 references
   // any of the memory referenced by Call1's arguments. If not, return NoModRef.
   if (onlyAccessesArgPointees(Call1B)) {
     if (!doesAccessArgPointees(Call1B))
       return ModRefInfo::NoModRef;
     ModRefInfo R = ModRefInfo::NoModRef;
-    bool IsMustAlias = true;
     for (auto I = Call1->arg_begin(), E = Call1->arg_end(); I != E; ++I) {
       const Value *Arg = *I;
       if (!Arg->getType()->isPointerTy())
         continue;
       unsigned Call1ArgIdx = std::distance(Call1->arg_begin(), I);
       auto Call1ArgLoc =
           MemoryLocation::getForArgument(Call1, Call1ArgIdx, TLI);
 
       // ArgModRefC1 indicates what Call1 might do to Call1ArgLoc; if Call1
       // might Mod Call1ArgLoc, then we care about either a Mod or a Ref by
       // Call2. If Call1 might Ref, then we care only about a Mod by Call2.
       ModRefInfo ArgModRefC1 = getArgModRefInfo(Call1, Call1ArgIdx);
       ModRefInfo ModRefC2 = getModRefInfo(Call2, Call1ArgLoc, AAQI);
       if ((isModSet(ArgModRefC1) && isModOrRefSet(ModRefC2)) ||
           (isRefSet(ArgModRefC1) && isModSet(ModRefC2)))
         R = intersectModRef(unionModRef(R, ArgModRefC1), Result);
 
-      // Conservatively clear IsMustAlias unless only MustAlias is found.
-      IsMustAlias &= isMustSet(ModRefC2);
-
-      if (R == Result) {
-        // On early exit, not all args were checked, cannot set Must.
-        if (I + 1 != E)
-          IsMustAlias = false;
+      if (R == Result)
         break;
-      }
-    }
 
-    if (isNoModRef(R))
-      return ModRefInfo::NoModRef;
-
-    // If MustAlias found above, set Must bit.
-    return IsMustAlias ? setMust(R) : clearMust(R);
+    return R;
   }
 
   return Result;
 }
 
 FunctionModRefBehavior AAResults::getModRefBehavior(const CallBase *Call) {
   FunctionModRefBehavior Result = FMRB_UnknownModRefBehavior;
 
if (isStrongerThan(L->getOrdering(), AtomicOrdering::Unordered))
     return ModRefInfo::ModRef;
 
   // If the load address doesn't alias the given address, it doesn't read
   // or write the specified memory.
   if (Loc.Ptr) {
     AliasResult AR = alias(MemoryLocation::get(L), Loc, AAQI);
     if (AR == AliasResult::NoAlias)
       return ModRefInfo::NoModRef;
-    if (AR == AliasResult::MustAlias)
-      return ModRefInfo::MustRef;
   }
   // Otherwise, a load just reads.
   return ModRefInfo::Ref;
 }
 
 ModRefInfo AAResults::getModRefInfo(const StoreInst *S,
                                     const MemoryLocation &Loc) {
   SimpleAAQueryInfo AAQIP;
if (Loc.Ptr) {
     // specified memory cannot be modified by the store.
     if (AR == AliasResult::NoAlias)
       return ModRefInfo::NoModRef;
 
     // If the pointer is a pointer to constant memory, then it could not have
     // been modified by this store.
     if (pointsToConstantMemory(Loc, AAQI))
       return ModRefInfo::NoModRef;
-
-    // If the store address aliases the pointer as must alias, set Must.
-    if (AR == AliasResult::MustAlias)
-      return ModRefInfo::MustMod;
   }
 
   // Otherwise, a store just writes.
   return ModRefInfo::Mod;
 }
 
 ModRefInfo AAResults::getModRefInfo(const FenceInst *S, const MemoryLocation &Loc) {
   SimpleAAQueryInfo AAQIP;
if (Loc.Ptr) {
     // specified memory cannot be accessed by the va_arg.
     if (AR == AliasResult::NoAlias)
       return ModRefInfo::NoModRef;
 
     // If the pointer is a pointer to constant memory, then it could not have
     // been modified by this va_arg.
     if (pointsToConstantMemory(Loc, AAQI))
       return ModRefInfo::NoModRef;
-
-    // If the va_arg aliases the pointer as must alias, set Must.
-    if (AR == AliasResult::MustAlias)
-      return ModRefInfo::MustModRef;
   }
 
   // Otherwise, a va_arg reads and writes.
   return ModRefInfo::ModRef;
 }
 
 ModRefInfo AAResults::getModRefInfo(const CatchPadInst *CatchPad,
                                     const MemoryLocation &Loc) {
if (isStrongerThanMonotonic(CX->getSuccessOrdering()))
     return ModRefInfo::ModRef;
 
   if (Loc.Ptr) {
     AliasResult AR = alias(MemoryLocation::get(CX), Loc, AAQI);
     // If the cmpxchg address does not alias the location, it does not access
     // it.
     if (AR == AliasResult::NoAlias)
       return ModRefInfo::NoModRef;
-
-    // If the cmpxchg address aliases the pointer as must alias, set Must.
-    if (AR == AliasResult::MustAlias)
-      return ModRefInfo::MustModRef;
   }
 
   return ModRefInfo::ModRef;
 }
 
 ModRefInfo AAResults::getModRefInfo(const AtomicRMWInst *RMW,
                                     const MemoryLocation &Loc) {
   SimpleAAQueryInfo AAQIP;
   return getModRefInfo(RMW, Loc, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const AtomicRMWInst *RMW,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   // Acquire/Release atomicrmw has properties that matter for arbitrary addresses.
   if (isStrongerThanMonotonic(RMW->getOrdering()))
     return ModRefInfo::ModRef;
 
   if (Loc.Ptr) {
     AliasResult AR = alias(MemoryLocation::get(RMW), Loc, AAQI);
     // If the atomicrmw address does not alias the location, it does not access
     // it.
     if (AR == AliasResult::NoAlias)
       return ModRefInfo::NoModRef;
-
-    // If the atomicrmw address aliases the pointer as must alias, set Must.
-    if (AR == AliasResult::MustAlias)
-      return ModRefInfo::MustModRef;
   }
 
   return ModRefInfo::ModRef;
 }
 
 ModRefInfo AAResults::getModRefInfo(const Instruction *I,
                                     const Optional<MemoryLocation> &OptLoc,
                                     AAQueryInfo &AAQIP) {
ModRefInfo AAResults::callCapturesBefore(const Instruction *I,
 
   if (PointerMayBeCapturedBefore(Object, /* ReturnCaptures */ true,
                                  /* StoreCaptures */ true, I, DT,
                                  /* include Object */ true))
     return ModRefInfo::ModRef;
 
   unsigned ArgNo = 0;
   ModRefInfo R = ModRefInfo::NoModRef;
-  bool IsMustAlias = true;
   // Set flag only if no May found and all operands processed.
   for (auto CI = Call->data_operands_begin(), CE = Call->data_operands_end();
        CI != CE; ++CI, ++ArgNo) {
     // Only look at the no-capture or byval pointer arguments.  If this
     // pointer were passed to arguments that were neither of these, then it
     // couldn't be no-capture.
     if (!(*CI)->getType()->isPointerTy() ||
         (!Call->doesNotCapture(ArgNo) && ArgNo < Call->arg_size() &&
          !Call->isByValArgument(ArgNo)))
       continue;
 
     AliasResult AR = alias(
         MemoryLocation::getBeforeOrAfter(*CI),
         MemoryLocation::getBeforeOrAfter(Object), AAQI);
     // If this is a no-capture pointer argument, see if we can tell that it
     // is impossible to alias the pointer we're checking.  If not, we have to
     // assume that the call could touch the pointer, even though it doesn't
     // escape.
-    if (AR != AliasResult::MustAlias)
-      IsMustAlias = false;
     if (AR == AliasResult::NoAlias)
       continue;
     if (Call->doesNotAccessMemory(ArgNo))
       continue;
     if (Call->onlyReadsMemory(ArgNo)) {
       R = ModRefInfo::Ref;
       continue;
     }
-    // Not returning MustModRef since we have not seen all the arguments.
     return ModRefInfo::ModRef;
   }
-  return IsMustAlias ? setMust(R) : clearMust(R);
+  return R;
 }
 
 /// canBasicBlockModify - Return true if it is possible for execution of the
 /// specified basic block to modify the location Loc.
 ///
 bool AAResults::canBasicBlockModify(const BasicBlock &BB,
                                     const MemoryLocation &Loc) {
   return canInstructionRangeModRef(BB.front(), BB.back(), Loc, ModRefInfo::Mod);

llvm/lib/Analysis/AliasAnalysisEvaluator.cpp

 static cl::opt<bool> PrintMayAlias("print-may-aliases", cl::ReallyHidden);
 static cl::opt<bool> PrintPartialAlias("print-partial-aliases", cl::ReallyHidden);
 static cl::opt<bool> PrintMustAlias("print-must-aliases", cl::ReallyHidden);
 
 static cl::opt<bool> PrintNoModRef("print-no-modref", cl::ReallyHidden);
 static cl::opt<bool> PrintRef("print-ref", cl::ReallyHidden);
 static cl::opt<bool> PrintMod("print-mod", cl::ReallyHidden);
 static cl::opt<bool> PrintModRef("print-modref", cl::ReallyHidden);
-static cl::opt<bool> PrintMust("print-must", cl::ReallyHidden);
-static cl::opt<bool> PrintMustRef("print-mustref", cl::ReallyHidden);
-static cl::opt<bool> PrintMustMod("print-mustmod", cl::ReallyHidden);
-static cl::opt<bool> PrintMustModRef("print-mustmodref", cl::ReallyHidden);
 
 static cl::opt<bool> EvalAAMD("evaluate-aa-metadata", cl::ReallyHidden);
 
 static void PrintResults(AliasResult AR, bool P,
                          std::pair<const Value *, Type *> Loc1,
                          std::pair<const Value *, Type *> Loc2,
                          const Module *M) {
   if (PrintAll || P) {
for (const auto &Pointer : Pointers) {
         PrintModRefResults("Just Ref", PrintRef, Call, Pointer, F.getParent());
         ++RefCount;
         break;
       case ModRefInfo::ModRef:
         PrintModRefResults("Both ModRef", PrintModRef, Call, Pointer,
                            F.getParent());
         ++ModRefCount;
         break;
-      case ModRefInfo::Must:
-        PrintModRefResults("Must", PrintMust, Call, Pointer, F.getParent());
-        ++MustCount;
-        break;
-      case ModRefInfo::MustMod:
-        PrintModRefResults("Just Mod (MustAlias)", PrintMustMod, Call, Pointer,
-                           F.getParent());
-        ++MustModCount;
-        break;
-      case ModRefInfo::MustRef:
-        PrintModRefResults("Just Ref (MustAlias)", PrintMustRef, Call, Pointer,
-                           F.getParent());
-        ++MustRefCount;
-        break;
-      case ModRefInfo::MustModRef:
-        PrintModRefResults("Both ModRef (MustAlias)", PrintMustModRef, Call,
-                           Pointer, F.getParent());
-        ++MustModRefCount;
-        break;
       }
     }
   }
 
   // Mod/ref alias analysis: compare all pairs of calls
   for (CallBase *CallA : Calls) {
     for (CallBase *CallB : Calls) {
       if (CallA == CallB)
for (CallBase *CallB : Calls) {
         PrintModRefResults("Just Ref", PrintRef, CallA, CallB, F.getParent());
         ++RefCount;
         break;
       case ModRefInfo::ModRef:
         PrintModRefResults("Both ModRef", PrintModRef, CallA, CallB,
                            F.getParent());
         ++ModRefCount;
         break;
-      case ModRefInfo::Must:
-        PrintModRefResults("Must", PrintMust, CallA, CallB, F.getParent());
-        ++MustCount;
-        break;
-      case ModRefInfo::MustMod:
-        PrintModRefResults("Just Mod (MustAlias)", PrintMustMod, CallA, CallB,
-                           F.getParent());
-        ++MustModCount;
-        break;
-      case ModRefInfo::MustRef:
-        PrintModRefResults("Just Ref (MustAlias)", PrintMustRef, CallA, CallB,
-                           F.getParent());
-        ++MustRefCount;
-        break;
-      case ModRefInfo::MustModRef:
-        PrintModRefResults("Both ModRef (MustAlias)", PrintMustModRef, CallA,
-                           CallB, F.getParent());
-        ++MustModRefCount;
-        break;
       }
     }
   }
 }
 
 static void PrintPercent(int64_t Num, int64_t Sum) {
   errs() << "(" << Num * 100LL / Sum << "." << ((Num * 1000LL / Sum) % 10)
          << "%)\n";

llvm/lib/Analysis/BasicAliasAnalysis.cpp

ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call,
   // then the call can not mod/ref the pointer unless the call takes the pointer
   // as an argument, and itself doesn't capture it.
   if (!isa<Constant>(Object) && Call != Object &&
       AAQI.CI->isNotCapturedBeforeOrAt(Object, Call)) {
 
     // Optimistically assume that call doesn't touch Object and check this
     // assumption in the following loop.
     ModRefInfo Result = ModRefInfo::NoModRef;
-    bool IsMustAlias = true;
 
     unsigned OperandNo = 0;
     for (auto CI = Call->data_operands_begin(), CE = Call->data_operands_end();
          CI != CE; ++CI, ++OperandNo) {
       // Only look at the no-capture or byval pointer arguments.  If this
       // pointer were passed to arguments that were neither of these, then it
       // couldn't be no-capture.
       if (!(*CI)->getType()->isPointerTy() ||
           (!Call->doesNotCapture(OperandNo) && OperandNo < Call->arg_size() &&
            !Call->isByValArgument(OperandNo)))
         continue;
 
       // Call doesn't access memory through this operand, so we don't care
       // if it aliases with Object.
       if (Call->doesNotAccessMemory(OperandNo))
         continue;
 
       // If this is a no-capture pointer argument, see if we can tell that it
       // is impossible to alias the pointer we're checking.
       AliasResult AR = getBestAAResults().alias(
           MemoryLocation::getBeforeOrAfter(*CI),
           MemoryLocation::getBeforeOrAfter(Object), AAQI);
-      if (AR != AliasResult::MustAlias)
-        IsMustAlias = false;
       // Operand doesn't alias 'Object', continue looking for other aliases
       if (AR == AliasResult::NoAlias)
         continue;
       // Operand aliases 'Object', but call doesn't modify it. Strengthen
       // initial assumption and keep looking in case if there are more aliases.
       if (Call->onlyReadsMemory(OperandNo)) {
         Result = setRef(Result);
         continue;
       }
       // Operand aliases 'Object' but call only writes into it.
       if (Call->onlyWritesMemory(OperandNo)) {
         Result = setMod(Result);
         continue;
       }
       // This operand aliases 'Object' and call reads and writes into it.
       // Setting ModRef will not yield an early return below, MustAlias is not
       // used further.
       Result = ModRefInfo::ModRef;
       break;
     }
 
-    // No operand aliases, reset Must bit. Add below if at least one aliases
-    // and all aliases found are MustAlias.
-    if (isNoModRef(Result))
-      IsMustAlias = false;
-
     // Early return if we improved mod ref information
-    if (!isModAndRefSet(Result)) {
-      if (isNoModRef(Result))
-        return ModRefInfo::NoModRef;
-      return IsMustAlias ? setMust(Result) : clearMust(Result);
-    }
+    if (!isModAndRefSet(Result))
+      return Result;
   }
 
   // If the call is malloc/calloc like, we can assume that it doesn't
   // modify any IR visible value.  This is only valid because we assume these
   // routines do not read values visible in the IR.  TODO: Consider special
   // casing realloc and strdup routines which access only their arguments as
   // well.  Or alternatively, replace all of this with inaccessiblememonly once
   // that's implemented fully.

llvm/lib/Analysis/GlobalsModRef.cpp

struct AlignedMapPointerTraits {
     static constexpr int NumLowBitsAvailable = 3;
     static_assert(alignof(AlignedMap) >= (1 << NumLowBitsAvailable),
                   "AlignedMap insufficiently aligned to have enough low bits.");
   };
 
   /// The bit that flags that this function may read any global. This is
   /// chosen to mix together with ModRefInfo bits.
   /// FIXME: This assumes ModRefInfo lattice will remain 4 bits!
-  /// It overlaps with ModRefInfo::Must bit!
   /// FunctionInfo.getModRefInfo() masks out everything except ModRef so
-  /// this remains correct, but the Must info is lost.
+  /// this remains correct.
   enum { MayReadAnyGlobal = 4 };
 
   /// Checks to document the invariants of the bit packing here.
-  static_assert((MayReadAnyGlobal & static_cast<int>(ModRefInfo::MustModRef)) ==
+  static_assert((MayReadAnyGlobal & static_cast<int>(ModRefInfo::ModRef)) ==
                     0,
                 "ModRef and the MayReadAnyGlobal flag bits overlap.");
   static_assert(((MayReadAnyGlobal |
-                  static_cast<int>(ModRefInfo::MustModRef)) >>
+                  static_cast<int>(ModRefInfo::ModRef)) >>
                  AlignedMapPointerTraits::NumLowBitsAvailable) == 0,
                 "Insufficient low bits to store our flag and ModRef info.");
 
 public:
   FunctionInfo() = default;
   ~FunctionInfo() {
     delete Info.getPointer();
   }
public:
   FunctionInfo &operator=(FunctionInfo &&RHS) {
     delete Info.getPointer();
     Info.setPointerAndInt(RHS.Info.getPointer(), RHS.Info.getInt());
     RHS.Info.setPointerAndInt(nullptr, 0);
     return *this;
   }
 
   /// This method clears MayReadAnyGlobal bit added by GlobalsAAResult to return
-  /// the corresponding ModRefInfo. It must align in functionality with
-  /// clearMust().
+  /// the corresponding ModRefInfo.
   ModRefInfo globalClearMayReadAnyGlobal(int I) const {
-    return ModRefInfo((I & static_cast<int>(ModRefInfo::ModRef)) |
-                      static_cast<int>(ModRefInfo::NoModRef));
+    return ModRefInfo(I & static_cast<int>(ModRefInfo::ModRef));
   }
 
   /// Returns the \c ModRefInfo info for this function.
   ModRefInfo getModRefInfo() const {
     return globalClearMayReadAnyGlobal(Info.getInt());
   }
 
   /// Adds new \c ModRefInfo for this function to its state.
   void addModRefInfo(ModRefInfo NewMRI) {
-    Info.setInt(Info.getInt() | static_cast<int>(setMust(NewMRI)));
+    Info.setInt(Info.getInt() | static_cast<int>(NewMRI));
   }
 
   /// Returns whether this function may read any global variable, and we don't
   /// know which global.
   bool mayReadAnyGlobal() const { return Info.getInt() & MayReadAnyGlobal; }
 
   /// Sets this function as potentially reading from any global.
   void setMayReadAnyGlobal() { Info.setInt(Info.getInt() | MayReadAnyGlobal); }

llvm/lib/Analysis/MemoryDependenceAnalysis.cpp

if (FenceInst *FI = dyn_cast<FenceInst>(Inst))
       if (isLoad && FI->getOrdering() == AtomicOrdering::Release)
         continue;
 
     // See if this instruction (e.g. a call or vaarg) mod/ref's the pointer.
     ModRefInfo MR = BatchAA.getModRefInfo(Inst, MemLoc);
     // If necessary, perform additional analysis.
     if (isModAndRefSet(MR))
       MR = BatchAA.callCapturesBefore(Inst, MemLoc, &DT);
-    switch (clearMust(MR)) {
+    switch (MR) {
     case ModRefInfo::NoModRef:
       // If the call has no effect on the queried pointer, just ignore it.
       continue;
     case ModRefInfo::Mod:
       return MemDepResult::getClobber(Inst);
     case ModRefInfo::Ref:
       // If the call is known to never store to the pointer, and if this is a
       // load query, we can safely ignore it (scan past it).

llvm/lib/Analysis/MemorySSA.cpp

static bool areLoadsReorderable(const LoadInst *Use,
   // Note that this explicitly *does* allow the free reordering of monotonic (or
   // weaker) loads of the same address.
   bool SeqCstUse = Use->getOrdering() == AtomicOrdering::SequentiallyConsistent;
   bool MayClobberIsAcquire = isAtLeastOrStrongerThan(MayClobber->getOrdering(),
                                                      AtomicOrdering::Acquire);
   return !(SeqCstUse || MayClobberIsAcquire);
 }
 
-namespace {
-
-struct ClobberAlias {
-  bool IsClobber;
-  Optional<AliasResult> AR;
-};
-
-} // end anonymous namespace
-
-// Return a pair of {IsClobber (bool), AR (AliasResult)}. It relies on AR being
-// ignored if IsClobber = false.
 template <typename AliasAnalysisType>
-static ClobberAlias
+static bool
 instructionClobbersQuery(const MemoryDef *MD, const MemoryLocation &UseLoc,
                          const Instruction *UseInst, AliasAnalysisType &AA) {
   Instruction *DefInst = MD->getMemoryInst();
   assert(DefInst && "Defining instruction not actually an instruction");
-  Optional<AliasResult> AR;
 
   if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(DefInst)) {
     // These intrinsics will show up as affecting memory, but they are just
     // markers, mostly.
     //
     // FIXME: We probably don't actually want MemorySSA to model these at all
     // (including creating MemoryAccesses for them): we just end up inventing
     // clobbers where they don't really exist at all. Please see D43269 for
     // context.
     switch (II->getIntrinsicID()) {
     case Intrinsic::invariant_start:
     case Intrinsic::invariant_end:
     case Intrinsic::assume:
     case Intrinsic::experimental_noalias_scope_decl:
     case Intrinsic::pseudoprobe:
-      return {false, AliasResult(AliasResult::NoAlias)};
+      return false;
     case Intrinsic::dbg_addr:
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_label:
     case Intrinsic::dbg_value:
       llvm_unreachable("debuginfo shouldn't have associated defs!");
     default:
       break;
     }
   }
 
   if (auto *CB = dyn_cast_or_null<CallBase>(UseInst)) {
     ModRefInfo I = AA.getModRefInfo(DefInst, CB);
-    AR = isMustSet(I) ? AliasResult::MustAlias : AliasResult::MayAlias;
-    return {isModOrRefSet(I), AR};
+    return isModOrRefSet(I);
   }
 
   if (auto *DefLoad = dyn_cast<LoadInst>(DefInst))
     if (auto *UseLoad = dyn_cast_or_null<LoadInst>(UseInst))
-      return {!areLoadsReorderable(UseLoad, DefLoad),
-              AliasResult(AliasResult::MayAlias)};
+      return !areLoadsReorderable(UseLoad, DefLoad);
 
   ModRefInfo I = AA.getModRefInfo(DefInst, UseLoc);
-  AR = isMustSet(I) ? AliasResult::MustAlias : AliasResult::MayAlias;
-  return {isModSet(I), AR};
+  return isModSet(I);
 }
 
 template <typename AliasAnalysisType>
-static ClobberAlias instructionClobbersQuery(MemoryDef *MD,
-                                             const MemoryUseOrDef *MU,
-                                             const MemoryLocOrCall &UseMLOC,
-                                             AliasAnalysisType &AA) {
+static bool instructionClobbersQuery(MemoryDef *MD, const MemoryUseOrDef *MU,
   // FIXME: This is a temporary hack to allow a single instructionClobbersQuery
   // to exist while MemoryLocOrCall is pushed through places.
   if (UseMLOC.IsCall)
     return instructionClobbersQuery(MD, MemoryLocation(), MU->getMemoryInst(),
                                     AA);
   return instructionClobbersQuery(MD, UseMLOC.getLoc(), MU->getMemoryInst(),
                                   AA);
 }
 
 // Return true when MD may alias MU, return false otherwise.
 bool MemorySSAUtil::defClobbersUseOrDef(MemoryDef *MD, const MemoryUseOrDef *MU,
                                         AliasAnalysis &AA) {
-  return instructionClobbersQuery(MD, MU, MemoryLocOrCall(MU), AA).IsClobber;
+  return instructionClobbersQuery(MD, MU, MemoryLocOrCall(MU), AA);
 }
 
 namespace {
 
 struct UpwardsMemoryQuery {
   // True if our original query started off as a call
   bool IsCall = false;
   // The pointer location we started the query with. This will be empty if
for (const auto *MA : def_chain(MAP.first)) {
         if (const auto *MD = dyn_cast<MemoryDef>(MA)) {
           // instructionClobbersQuery isn't essentially free, so don't use `|=`,
           // since it won't let us short-circuit.
           //
           // Also, note that this can't be hoisted out of the `Worklist` loop,
           // since MD may only act as a clobber for 1 of N MemoryLocations.
           FoundClobber = FoundClobber || MSSA.isLiveOnEntryDef(MD);
           if (!FoundClobber) {
-            ClobberAlias CA =
-                instructionClobbersQuery(MD, MAP.second, Query.Inst, AA);
-            if (CA.IsClobber) {
+            if (instructionClobbersQuery(MD, MAP.second, Query.Inst, AA))
               FoundClobber = true;
-              // Not used: CA.AR;
-            }
           }
         }
         break;
       }
 
       // We should never hit liveOnEntry, unless it's the clobber.
       assert(!MSSA.isLiveOnEntryDef(MA) && "Hit liveOnEntry before clobber?");
 
template <class AliasAnalysisType> class ClobberWalker {
   }
 
   /// Result of calling walkToPhiOrClobber.
   struct UpwardsWalkResult {
     /// The "Result" of the walk. Either a clobber, the last thing we walked, or
     /// both. Include alias info when clobber found.
     MemoryAccess *Result;
     bool IsKnownClobber;
-    Optional<AliasResult> AR;
   };
 
   /// Walk to the next Phi or Clobber in the def chain starting at Desc.Last.
   /// This will update Desc.Last as it walks. It will (optionally) also stop at
   /// StopAt.
   ///
   /// This does not test for whether StopAt is a clobber
   UpwardsWalkResult
walkToPhiOrClobber(DefPath &Desc, const MemoryAccess *StopAt = nullptr,
     if (!*UpwardWalkLimit) {
       *UpwardWalkLimit = 1;
       LimitAlreadyReached = true;
     }
 
     for (MemoryAccess *Current : def_chain(Desc.Last)) {
       Desc.Last = Current;
       if (Current == StopAt || Current == SkipStopAt)
-        return {Current, false, AliasResult(AliasResult::MayAlias)};
+        return {Current, false};
 
       if (auto *MD = dyn_cast<MemoryDef>(Current)) {
         if (MSSA.isLiveOnEntryDef(MD))
-          return {MD, true, AliasResult(AliasResult::MustAlias)};
+          return {MD, true};
 
         if (!--*UpwardWalkLimit)
-          return {Current, true, AliasResult(AliasResult::MayAlias)};
+          return {Current, true};
 
-        ClobberAlias CA =
-            instructionClobbersQuery(MD, Desc.Loc, Query->Inst, AA);
-        if (CA.IsClobber)
-          return {MD, true, CA.AR};
+        if (instructionClobbersQuery(MD, Desc.Loc, Query->Inst, AA))
+          return {MD, true};
       }
     }
 
     if (LimitAlreadyReached)
       *UpwardWalkLimit = 0;
 
     assert(isa<MemoryPhi>(Desc.Last) &&
            "Ended at a non-clobber that's not a phi?");
-    return {Desc.Last, false, AliasResult(AliasResult::MayAlias)};
+    return {Desc.Last, false};
   }
 
   void addSearches(MemoryPhi *Phi, SmallVectorImpl<ListIndex> &PausedSearches,
                    ListIndex PriorNode) {
     auto UpwardDefsBegin = upward_defs_begin({Phi, Paths[PriorNode].Loc}, DT,
                                              &PerformedPhiTranslation);
     auto UpwardDefs = make_range(UpwardDefsBegin, upward_defs_end());
     for (const MemoryAccessPair &P : UpwardDefs) {
MemoryAccess *findClobber(MemoryAccess *Start, UpwardsMemoryQuery &Q,
 
     DefPath FirstDesc(Q.StartingLoc, Current, Current, None);
     // Fast path for the overly-common case (no crazy phi optimization
     // necessary)
     UpwardsWalkResult WalkResult = walkToPhiOrClobber(FirstDesc);
     MemoryAccess *Result;
     if (WalkResult.IsKnownClobber) {
       Result = WalkResult.Result;
-      Q.AR = WalkResult.AR;
     } else {
       OptznResult OptRes = tryOptimizePhi(cast<MemoryPhi>(FirstDesc.Last),
                                           Current, Q.StartingLoc);
       verifyOptResult(OptRes);
       resetPhiOptznState();
       Result = OptRes.PrimaryClobber.Clobber;
     }
 
if (!MU) {
       ++StackEpoch;
       continue;
     }
 
     if (MU->isOptimized())
       continue;
 
     if (isUseTriviallyOptimizableToLiveOnEntry(*AA, MU->getMemoryInst())) {
-      MU->setDefiningAccess(MSSA->getLiveOnEntryDef(), true, None);
+      MU->setDefiningAccess(MSSA->getLiveOnEntryDef(), true);
       continue;
     }
 
     MemoryLocOrCall UseMLOC(MU);
     auto &LocInfo = LocStackInfo[UseMLOC];
     // If the pop epoch changed, it means we've removed stuff from top of
     // stack due to changing blocks. We may have to reset the lower bound or
     // last kill info.
if (LocInfo.PopEpoch != PopEpoch) {
       // new things on the stack, because we've checked everything before.  In
       // this case, the lower bound of things to check remains the same.
       LocInfo.PopEpoch = PopEpoch;
       LocInfo.StackEpoch = StackEpoch;
     }
     if (!LocInfo.LastKillValid) {
       LocInfo.LastKill = VersionStack.size() - 1;
       LocInfo.LastKillValid = true;
-      LocInfo.AR = AliasResult::MayAlias;
     }
 
     // At this point, we should have corrected last kill and LowerBound to be
     // in bounds.
     assert(LocInfo.LowerBound < VersionStack.size() &&
            "Lower bound out of range");
     assert(LocInfo.LastKill < VersionStack.size() &&
            "Last kill info out of range");
while (UpperBound > LocInfo.LowerBound) {
           assert(UpperBound != 0);
           --UpperBound;
         }
         FoundClobberResult = true;
         break;
       }
 
       MemoryDef *MD = cast<MemoryDef>(VersionStack[UpperBound]);
-      ClobberAlias CA = instructionClobbersQuery(MD, MU, UseMLOC, *AA);
-      if (CA.IsClobber) {
+      if (instructionClobbersQuery(MD, MU, UseMLOC, *AA)) {
         FoundClobberResult = true;
-        LocInfo.AR = CA.AR;
         break;
       }
       --UpperBound;
     }
 
     // Note: Phis always have AliasResult AR set to MayAlias ATM.
 
     // At the end of this loop, UpperBound is either a clobber, or lower bound
     // PHI walking may cause it to be < LowerBound, and in fact, < LastKill.
     if (FoundClobberResult || UpperBound < LocInfo.LastKill) {
-      // We were last killed now by where we got to
-      if (MSSA->isLiveOnEntryDef(VersionStack[UpperBound]))
-        LocInfo.AR = None;
-      MU->setDefiningAccess(VersionStack[UpperBound], true, LocInfo.AR);
+      MU->setDefiningAccess(VersionStack[UpperBound], true);
       LocInfo.LastKill = UpperBound;
     } else {
       // Otherwise, we checked all the new ones, and now we know we can get to
       // LastKill.
-      MU->setDefiningAccess(VersionStack[LocInfo.LastKill], true, LocInfo.AR);
+      MU->setDefiningAccess(VersionStack[LocInfo.LastKill], true);
     }
     LocInfo.LowerBound = VersionStack.size() - 1;
     LocInfo.LowerBoundBlock = BB;
   }
 }
 
 /// Optimize uses to point to their actual clobbering definitions.
 void MemorySSA::OptimizeUses::optimizeUses() {
void MemoryDef::print(raw_ostream &OS) const {
 
   OS << getID() << " = MemoryDef(";
   printID(UO);
   OS << ")";
 
   if (isOptimized()) {
     OS << "->";
     printID(getOptimized());
-
-    if (Optional<AliasResult> AR = getOptimizedAccessType())
-      OS << " " << *AR;
   }
 }
 
 void MemoryPhi::print(raw_ostream &OS) const {
   ListSeparator LS(",");
   OS << getID() << " = MemoryPhi(";
   for (const auto &Op : operands()) {
     BasicBlock *BB = getIncomingBlock(Op);

 void MemoryUse::print(raw_ostream &OS) const {
   MemoryAccess *UO = getDefiningAccess();
   OS << "MemoryUse(";
   if (UO && UO->getID())
     OS << UO->getID();
   else
     OS << LiveOnEntryStr;
   OS << ')';
-
-  if (Optional<AliasResult> AR = getOptimizedAccessType())
-    OS << " " << *AR;
 }
 
 void MemoryAccess::dump() const {
 // Cannot completely remove virtual function even in release mode.
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   print(dbgs());
   dbgs() << "\n";
 #endif
MemorySSA::ClobberWalkerBase<AliasAnalysisType>::getClobberingMemoryAccessBase(
   if (!isa<CallBase>(I) && I->isFenceLike())
     return StartingAccess;
 
   UpwardsMemoryQuery Q(I, StartingAccess);
 
   if (isUseTriviallyOptimizableToLiveOnEntry(*Walker.getAA(), I)) {
     MemoryAccess *LiveOnEntry = MSSA->getLiveOnEntryDef();
     StartingAccess->setOptimized(LiveOnEntry);
-    StartingAccess->setOptimizedAccessType(None);
     return LiveOnEntry;
   }
 
   MemoryAccess *OptimizedAccess;
   if (!IsOptimized) {
     // Start with the thing we already think clobbers this location
     MemoryAccess *DefiningAccess = StartingAccess->getDefiningAccess();
 
     // At this point, DefiningAccess may be the live on entry def.
     // If it is, we will not get a better result.
     if (MSSA->isLiveOnEntryDef(DefiningAccess)) {
       StartingAccess->setOptimized(DefiningAccess);
-      StartingAccess->setOptimizedAccessType(None);
       return DefiningAccess;
     }
 
     OptimizedAccess = Walker.findClobber(DefiningAccess, Q, UpwardWalkLimit);
     StartingAccess->setOptimized(OptimizedAccess);
-    if (MSSA->isLiveOnEntryDef(OptimizedAccess))
-      StartingAccess->setOptimizedAccessType(None);
-    else if (Q.AR && *Q.AR == AliasResult::MustAlias)
-      StartingAccess->setOptimizedAccessType(
-          AliasResult(AliasResult::MustAlias));
   } else
     OptimizedAccess = StartingAccess->getOptimized();
 
   LLVM_DEBUG(dbgs() << "Starting Memory SSA clobber for " << *I << " is ");
   LLVM_DEBUG(dbgs() << *StartingAccess << "\n");
   LLVM_DEBUG(dbgs() << "Optimized Memory SSA clobber for " << *I << " is ");
   LLVM_DEBUG(dbgs() << *OptimizedAccess << "\n");
 

llvm/test/Analysis/BasicAA/atomic-memory-intrinsics.ll

 ; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 %s | FileCheck %s
 
 declare void @llvm.memset.element.unordered.atomic.p0i8.i32(i8*, i8, i64, i32)
 
 define void @test_memset_element_unordered_atomic_const_size(i8* noalias %a) {
 ; CHECK-LABEL: Function: test_memset_element_unordered_atomic_const_size
-; CHECK:       Just Mod (MustAlias):  Ptr: i8* %a <->  call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 4, i32 1)
+; CHECK:       Just Mod:  Ptr: i8* %a <->  call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 4, i32 1)
 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.1 <->  call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 4, i32 1)
 ; CHECK-NEXT:  NoModRef:  Ptr: i8* %a.gep.5 <->  call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 4, i32 1)
 ;
 entry:
   load i8, i8* %a
   call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 1 %a, i8 0, i64 4, i32 1)
   %a.gep.1 = getelementptr i8, i8* %a, i32 1
   store i8 0, i8* %a.gep.1
   %a.gep.5 = getelementptr i8, i8* %a, i32 5
   store i8 1, i8* %a.gep.5
   ret void
 }
 
 define void @test_memset_element_unordered_atomic_variable_size(i8* noalias %a, i64 %n) {
 ; CHECK-LABEL: Function: test_memset_element_unordered_atomic_variable_size
-; CHECK:       Just Mod (MustAlias):  Ptr: i8* %a <->  call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 %n, i32 1)
+; CHECK:       Just Mod:  Ptr: i8* %a <->  call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 %n, i32 1)
 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.1 <->  call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 %n, i32 1)
 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.5 <->  call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 %n, i32 1)
 ;
 entry:
   load i8, i8* %a
   call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 1 %a, i8 0, i64 %n, i32 1)
   %a.gep.1 = getelementptr i8, i8* %a, i32 1
   store i8 0, i8* %a.gep.1

llvm/test/Analysis/BasicAA/call-attrs.ll

entry:
   call void @read_write(i8* %p, i8* %p, i8* %p)
 
   call void @func() ["deopt" (i8* %p)]
   call void @writeonly_attr(i8* %p) ["deopt" (i8* %p)]
 
   ret void
 }
 
-; CHECK:  Just Ref (MustAlias):  Ptr: i8* %p  <->  call void @readonly_attr(i8* %p)
+; CHECK:  Just Ref:  Ptr: i8* %p  <->  call void @readonly_attr(i8* %p)
 ; CHECK:  Just Ref:  Ptr: i8* %p  <->  call void @readonly_func(i8* %p)
-; CHECK:  Just Mod (MustAlias):  Ptr: i8* %p  <->  call void @writeonly_attr(i8* %p)
+; CHECK:  Just Mod:  Ptr: i8* %p  <->  call void @writeonly_attr(i8* %p)
 ; CHECK:  Just Mod:  Ptr: i8* %p  <->  call void @writeonly_func(i8* %p)
 ; CHECK:  NoModRef:  Ptr: i8* %p  <->  call void @readnone_attr(i8* %p)
 ; CHECK:  NoModRef:  Ptr: i8* %p  <->  call void @readnone_func(i8* %p)
 ; CHECK:  Both ModRef:  Ptr: i8* %p <->  call void @read_write(i8* %p, i8* %p, i8* %p)
-; CHECK:  Just Ref (MustAlias):  Ptr: i8* %p  <->  call void @func() [ "deopt"(i8* %p) ]
+; CHECK:  Just Ref:  Ptr: i8* %p  <->  call void @func() [ "deopt"(i8* %p) ]
 ; CHECK:  Both ModRef:  Ptr: i8* %p <->  call void @writeonly_attr(i8* %p) [ "deopt"(i8* %p) ]

llvm/test/Analysis/BasicAA/cs-cs.ll

define void @test4(i8* %P, i8* noalias %Q) #3 {
   load i8, i8* %Q
   tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false)
   tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
   ret void
 
 ; CHECK-LABEL: Function: test4:
 
 ; CHECK: NoAlias:      i8* %P, i8* %Q
-; CHECK: Just Mod (MustAlias):  Ptr: i8* %P        <->  tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false)
+; CHECK: Just Mod:  Ptr: i8* %P        <->  tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false)
 ; CHECK: NoModRef:  Ptr: i8* %Q        <->  tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false)
 ; CHECK: Just Mod:  Ptr: i8* %P        <->  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
 ; CHECK: Just Ref:  Ptr: i8* %Q        <->  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
 ; CHECK: Just Mod:   tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false) <->   tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
 ; CHECK: Just Mod:   tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <->   tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false)
 }
 
 define void @test5(i8* %P, i8* %Q, i8* %R) #3 {

 define void @test6(i8* %P) #3 {
   load i8, i8* %P
   call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false)
   call void @a_readonly_func(i8* %P)
   ret void
 
 ; CHECK-LABEL: Function: test6:
 
-; CHECK: Just Mod (MustAlias):  Ptr: i8* %P        <->  call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false)
+; CHECK: Just Mod:  Ptr: i8* %P        <->  call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false)
 ; CHECK: Just Ref:  Ptr: i8* %P        <->  call void @a_readonly_func(i8* %P)
 ; CHECK: Just Mod:   call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false) <->   call void @a_readonly_func(i8* %P)
 ; CHECK: Just Ref:   call void @a_readonly_func(i8* %P) <->   call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false)
 }
 
 define void @test7(i8* %P) #3 {
   load i8, i8* %P
   call void @a_writeonly_func(i8* %P)
entry:
   call void @an_inaccessibleorargmemonly_func(i8* %q)
   call void @an_argmemonly_func(i8* %q)
   ret void
 
 ; CHECK-LABEL: Function: test8
 ; CHECK: NoModRef:  Ptr: i8* %p <->  call void @an_inaccessiblememonly_func()
 ; CHECK: NoModRef:  Ptr: i8* %q <->  call void @an_inaccessiblememonly_func()
 ; CHECK: Both ModRef:  Ptr: i8* %p <->  call void @an_inaccessibleorargmemonly_func(i8* %q)
-; CHECK: Both ModRef (MustAlias):  Ptr: i8* %q <->  call void @an_inaccessibleorargmemonly_func(i8* %q)
+; CHECK: Both ModRef:  Ptr: i8* %q <->  call void @an_inaccessibleorargmemonly_func(i8* %q)
 ; CHECK: Both ModRef:  Ptr: i8* %p <->  call void @an_argmemonly_func(i8* %q)
-; CHECK: Both ModRef (MustAlias):  Ptr: i8* %q <->  call void @an_argmemonly_func(i8* %q)
+; CHECK: Both ModRef:  Ptr: i8* %q <->  call void @an_argmemonly_func(i8* %q)
 ; CHECK: Just Ref: call void @a_readonly_func(i8* %p) <-> call void @an_inaccessiblememonly_func()
 ; CHECK: Just Ref: call void @a_readonly_func(i8* %p) <-> call void @an_inaccessibleorargmemonly_func(i8* %q)
 ; CHECK: Just Ref: call void @a_readonly_func(i8* %p) <-> call void @an_argmemonly_func(i8* %q)
 ; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @a_readonly_func(i8* %p)
 ; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @a_writeonly_func(i8* %q)
 ; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @an_inaccessiblememonly_func()
 ; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @an_inaccessibleorargmemonly_func(i8* %q)
 ; CHECK: NoModRef: call void @an_inaccessiblememonly_func() <-> call void @an_argmemonly_func(i8* %q)
 ; CHECK: Just Mod: call void @a_writeonly_func(i8* %q) <-> call void @an_inaccessiblememonly_func()
 ; CHECK: Just Mod: call void @a_writeonly_func(i8* %q) <-> call void @an_inaccessibleorargmemonly_func(i8* %q)
 ; CHECK: Just Mod: call void @a_writeonly_func(i8* %q) <-> call void @an_argmemonly_func(i8* %q)
 ; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(i8* %q) <-> call void @a_readonly_func(i8* %p)
 ; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(i8* %q) <-> call void @a_writeonly_func(i8* %q)
 ; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(i8* %q) <-> call void @an_inaccessiblememonly_func()
-; CHECK: Both ModRef (MustAlias): call void @an_inaccessibleorargmemonly_func(i8* %q) <-> call void @an_argmemonly_func(i8* %q)
+; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(i8* %q) <-> call void @an_argmemonly_func(i8* %q)
 ; CHECK: Both ModRef: call void @an_argmemonly_func(i8* %q) <-> call void @a_readonly_func(i8* %p)
 ; CHECK: Both ModRef: call void @an_argmemonly_func(i8* %q) <-> call void @a_writeonly_func(i8* %q)
 ; CHECK: NoModRef: call void @an_argmemonly_func(i8* %q) <-> call void @an_inaccessiblememonly_func()
-; CHECK: Both ModRef (MustAlias): call void @an_argmemonly_func(i8* %q) <-> call void @an_inaccessibleorargmemonly_func(i8* %q)
+; CHECK: Both ModRef: call void @an_argmemonly_func(i8* %q) <-> call void @an_inaccessibleorargmemonly_func(i8* %q)
 }
 
 ;; test that MustAlias is set for calls when no MayAlias is found.
 declare void @another_argmemonly_func(i8*, i8*) #0
 define void @test8a(i8* noalias %p, i8* noalias %q) {
 entry:
   load i8, i8* %p
   load i8, i8* %q
entry:
   call void @an_argmemonly_func(i8* %q) #9 [ "unknown"() ]
   ret void
 
 ; CHECK: Just Ref:  Ptr: i8* %p        <->  call void @a_readonly_func(i8* %p) #9 [ "unknown"() ]
 ; CHECK: Just Ref:  Ptr: i8* %q        <->  call void @a_readonly_func(i8* %p) #9 [ "unknown"() ]
 ; CHECK: NoModRef:  Ptr: i8* %p        <->  call void @an_inaccessiblememonly_func() #10 [ "unknown"() ]
 ; CHECK: NoModRef:  Ptr: i8* %q        <->  call void @an_inaccessiblememonly_func() #10 [ "unknown"() ]
 ; CHECK: Both ModRef:  Ptr: i8* %p        <->  call void @an_inaccessibleorargmemonly_func(i8* %q) #11 [ "unknown"() ]
-; CHECK: Both ModRef (MustAlias):  Ptr: i8* %q     <->  call void @an_inaccessibleorargmemonly_func(i8* %q) #11 [ "unknown"() ]
+; CHECK: Both ModRef:  Ptr: i8* %q     <->  call void @an_inaccessibleorargmemonly_func(i8* %q) #11 [ "unknown"() ]
 ; CHECK: Both ModRef:  Ptr: i8* %p        <->  call void @an_argmemonly_func(i8* %q) #12 [ "unknown"() ]
-; CHECK: Both ModRef (MustAlias):  Ptr: i8* %q     <->  call void @an_argmemonly_func(i8* %q) #12 [ "unknown"() ]
+; CHECK: Both ModRef:  Ptr: i8* %q     <->  call void @an_argmemonly_func(i8* %q) #12 [ "unknown"() ]
 ; CHECK: Just Ref:   call void @a_readonly_func(i8* %p) #9 [ "unknown"() ] <->   call void @an_inaccessiblememonly_func() #10 [ "unknown"() ]
 ; CHECK: Just Ref:   call void @a_readonly_func(i8* %p) #9 [ "unknown"() ] <->   call void @an_inaccessibleorargmemonly_func(i8* %q) #11 [ "unknown"() ]
 ; CHECK: Just Ref:   call void @a_readonly_func(i8* %p) #9 [ "unknown"() ] <->   call void @an_argmemonly_func(i8* %q) #12 [ "unknown"() ]
 ; CHECK: Both ModRef:   call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] <->   call void @a_readonly_func(i8* %p) #9 [ "unknown"() ]
 ; CHECK: Both ModRef:   call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] <->   call void @an_inaccessibleorargmemonly_func(i8* %q) #11 [ "unknown"() ]
 ; CHECK: NoModRef:   call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] <->   call void @an_argmemonly_func(i8* %q) #12 [ "unknown"() ]
 ; CHECK: Both ModRef:   call void @an_inaccessibleorargmemonly_func(i8* %q) #11 [ "unknown"() ] <->   call void @a_readonly_func(i8* %p) #9 [ "unknown"() ]
 ; CHECK: Both ModRef:   call void @an_inaccessibleorargmemonly_func(i8* %q) #11 [ "unknown"() ] <->   call void @an_inaccessiblememonly_func() #10 [ "unknown"() ]
-; CHECK: Both ModRef (MustAlias):   call void @an_inaccessibleorargmemonly_func(i8* %q) #11 [ "unknown"() ] <->   call void @an_argmemonly_func(i8* %q) #12 [ "unknown"() ]
+; CHECK: Both ModRef:   call void @an_inaccessibleorargmemonly_func(i8* %q) #11 [ "unknown"() ] <->   call void @an_argmemonly_func(i8* %q) #12 [ "unknown"() ]
 ; CHECK: Both ModRef:   call void @an_argmemonly_func(i8* %q) #12 [ "unknown"() ] <->   call void @a_readonly_func(i8* %p) #9 [ "unknown"() ]
 ; CHECK: NoModRef:   call void @an_argmemonly_func(i8* %q) #12 [ "unknown"() ] <->   call void @an_inaccessiblememonly_func() #10 [ "unknown"() ]
-; CHECK: Both ModRef (MustAlias):   call void @an_argmemonly_func(i8* %q) #12 [ "unknown"() ] <->   call void @an_inaccessibleorargmemonly_func(i8* %q) #11 [ "unknown"() ]
+; CHECK: Both ModRef:   call void @an_argmemonly_func(i8* %q) #12 [ "unknown"() ] <->   call void @an_inaccessibleorargmemonly_func(i8* %q) #11 [ "unknown"() ]
 }
 
 
 ; CHECK:      attributes #0 = { argmemonly nocallback nofree nounwind willreturn writeonly }
 ; CHECK-NEXT: attributes #1 = { argmemonly nocallback nofree nounwind willreturn }
 ; CHECK-NEXT: attributes #2 = { argmemonly nosync nounwind willreturn }
 ; CHECK-NEXT: attributes #3 = { noinline nounwind readonly }
 ; CHECK-NEXT: attributes #4 = { noinline nounwind writeonly }

llvm/test/Analysis/BasicAA/libfuncs.ll

entry:
   store i8 3, i8* %b.gep.5
   ret i8* %res
 }
 
 declare i8* @__memset_chk(i8* writeonly, i32, i64, i64)
 
 ; CHECK-LABEL: Function: test_memset_chk_const_size
 define i8* @test_memset_chk_const_size(i8* noalias %a, i64 %n) {
-; CHECK:       Just Mod (MustAlias):  Ptr: i8* %a <->  %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n)
+; CHECK:       Just Mod:  Ptr: i8* %a <->  %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n)
 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %res <->  %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n)
 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.1 <->  %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n)
 ; CHECK-NEXT:  NoModRef:  Ptr: i8* %a.gep.5 <->  %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n)
 ;
 entry:
   load i8, i8* %a
   %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n)
   load i8, i8* %res
   %a.gep.1 = getelementptr i8, i8* %a, i32 1
   store i8 0, i8* %a.gep.1
   %a.gep.5 = getelementptr i8, i8* %a, i32 5
   store i8 1, i8* %a.gep.5
   ret i8* %res
 }
 
 define i8* @test_memset_chk_variable_size(i8* noalias %a, i64 %n.1, i64 %n.2) {
 ; CHECK-LABEL: Function: test_memset_chk_variable_size
-; CHECK:       Just Mod (MustAlias):  Ptr: i8* %a <->  %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2)
+; CHECK:       Just Mod:  Ptr: i8* %a <->  %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2)
 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %res <->  %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2)
 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.1 <->  %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2)
 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.5 <->  %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2)
 ;
 entry:
   load i8, i8* %a
   %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2)
   load i8, i8* %res
   %a.gep.1 = getelementptr i8, i8* %a, i32 1
   store i8 0, i8* %a.gep.1
   %a.gep.5 = getelementptr i8, i8* %a, i32 5
   store i8 1, i8* %a.gep.5
   ret i8* %res
 }

llvm/test/Analysis/MemorySSA/basicaa-memcpy.ll

 ; RUN: opt -disable-output -passes='print<memoryssa>' %s 2>&1 | FileCheck %s
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 
 define void @source_clobber(i8* %a, i8* %b) {
 ; CHECK-LABEL: @source_clobber(
 ; CHECK-NEXT:  ; 1 = MemoryDef(liveOnEntry)
 ; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 128, i1 false)
-; CHECK-NEXT:  ; MemoryUse(1) MayAlias
+; CHECK-NEXT:  ; MemoryUse(1)
 ; CHECK-NEXT:    [[X:%.*]] = load i8, i8* %b
 ; CHECK-NEXT:    ret void
 ;
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 128, i1 false)
   %x = load i8, i8* %b
   ret void
 }

llvm/test/Analysis/MemorySSA/call-bitcast.ll

 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; Ensures that MemorySSA leverages the ground truth of the function being called when wrapped in a bitcast.
 
 declare i1 @opaque_true(i1) nounwind readonly
 
 define i1 @foo(i32* %ptr, i1 %cond) {
   %cond_wide = zext i1 %cond to i32
-; CHECK: MemoryUse(liveOnEntry) MayAlias
+; CHECK: MemoryUse(liveOnEntry)
 ; CHECK-NEXT: call i32 bitcast
   %cond_hidden_wide = call i32 bitcast (i1 (i1)* @opaque_true to i32 (i32)*)(i32 %cond_wide)
   %cond_hidden = trunc i32 %cond_hidden_wide to i1
   ret i1 %cond_hidden
 }

llvm/test/Analysis/MemorySSA/optimize-use.ll

; CHECK-NEXT:   %call1 = call noalias i8* @_Znwm(i64 4)
   %call1 = call noalias i8* @_Znwm(i64 4)
   %1 = bitcast i8* %call1 to i32*
 ; CHECK: 3 = MemoryDef(2)
 ; CHECK-NEXT:   store i32 5, i32* %0, align 4
   store i32 5, i32* %0, align 4
 ; CHECK: 4 = MemoryDef(3)
 ; CHECK-NEXT:   store i32 7, i32* %1, align 4
   store i32 7, i32* %1, align 4
-; NOLIMIT: MemoryUse(3) MustAlias
+; NOLIMIT: MemoryUse(3)
 ; NOLIMIT-NEXT:   %2 = load i32, i32* %0, align 4
 ; LIMIT: MemoryUse(4)
 ; LIMIT-NEXT:   %2 = load i32, i32* %0, align 4
   %2 = load i32, i32* %0, align 4
-; NOLIMIT: MemoryUse(4) MustAlias
+; NOLIMIT: MemoryUse(4)
 ; NOLIMIT-NEXT:   %3 = load i32, i32* %1, align 4
 ; LIMIT: MemoryUse(4)
 ; LIMIT-NEXT:   %3 = load i32, i32* %1, align 4
   %3 = load i32, i32* %1, align 4
-; NOLIMIT: MemoryUse(3) MustAlias
+; NOLIMIT: MemoryUse(3)
 ; NOLIMIT-NEXT:   %4 = load i32, i32* %0, align 4
 ; LIMIT: MemoryUse(4)
 ; LIMIT-NEXT:   %4 = load i32, i32* %0, align 4
   %4 = load i32, i32* %0, align 4
-; NOLIMIT: MemoryUse(4) MustAlias
+; NOLIMIT: MemoryUse(4)
 ; NOLIMIT-NEXT:   %5 = load i32, i32* %1, align 4
 ; LIMIT: MemoryUse(4)
 ; LIMIT-NEXT:   %5 = load i32, i32* %1, align 4
   %5 = load i32, i32* %1, align 4
   %add = add nsw i32 %3, %5
   ret i32 %add
 }
 
 
 declare noalias i8* @_Znwm(i64)

llvm/test/Analysis/MemorySSA/phi-translation.ll

if.then:
   %p2 = getelementptr inbounds i8, i8* %ptr, i32 1
 ; CHECK: 2 = MemoryDef(1)
 ; CHECK-NEXT: store i8 0, i8* %p2, align 1
   store i8 0, i8* %p2, align 1
   br label %if.end
 
 if.end:
 ; CHECK: 3 = MemoryPhi({entry,1},{if.then,2})
-; NOLIMIT: MemoryUse(1) MayAlias
+; NOLIMIT: MemoryUse(1)
 ; NOLIMIT-NEXT: load i8, i8* %local, align 1
 ; LIMIT: MemoryUse(3)
 ; LIMIT-NEXT: load i8, i8* %local, align 1
   load i8, i8* %local, align 1
   ret void
 }
 
 ; CHECK-LABEL: define void @check2

 ; CHECK-NEXT: store i8 4, i8* %local2
   store i8 4, i8* %local2
   br label %phi.1
 
 phi.1:
 ; Order matters here; phi.2 needs to come before phi.3, because that's the order
 ; they're visited in.
 ; CHECK: 6 = MemoryPhi({phi.2,4},{phi.3,3})
-; NOLIMIT: MemoryUse(1) MayAlias
+; NOLIMIT: MemoryUse(1)
 ; NOLIMIT-NEXT: load i8, i8* %local
 ; LIMIT: MemoryUse(6)
 ; LIMIT-NEXT: load i8, i8* %local
   load i8, i8* %local
   ret void
 }
 
 ; CHECK-LABEL: define void @cross_phi
 define void @cross_phi(i8* noalias %p1, i8* noalias %p2) {
 ; CHECK: 1 = MemoryDef(liveOnEntry)
 ; CHECK-NEXT: store i8 0, i8* %p1
   store i8 0, i8* %p1
-; NOLIMIT: MemoryUse(1) MustAlias
+; NOLIMIT: MemoryUse(1)
 ; NOLIMIT-NEXT: load i8, i8* %p1
 ; LIMIT: MemoryUse(1)
 ; LIMIT-NEXT: load i8, i8* %p1
   load i8, i8* %p1
   br i1 undef, label %a, label %b
 
 a:
 ; CHECK: 2 = MemoryDef(1)

 ; CHECK: 7 = MemoryPhi({a,2},{b,3})
 ; CHECK: 5 = MemoryDef(7)
 ; CHECK-NEXT: store i8 3, i8* %p2
   store i8 3, i8* %p2
   br label %e
 
 e:
 ; 8 = MemoryPhi({c,4},{d,5})
-; NOLIMIT: MemoryUse(1) MustAlias
+; NOLIMIT: MemoryUse(1)
 ; NOLIMIT-NEXT: load i8, i8* %p1
 ; LIMIT: MemoryUse(8)
 ; LIMIT-NEXT: load i8, i8* %p1
   load i8, i8* %p1
   ret void
 }
 
 ; CHECK-LABEL: define void @looped
; CHECK-NEXT: store i8 1, i8* %p2
   store i8 1, i8* %p2
   br label %loop.3
 
 loop.3:
 ; CHECK: 7 = MemoryPhi({loop.1,2},{loop.2,3})
 ; CHECK: 4 = MemoryDef(7)
 ; CHECK-NEXT: store i8 2, i8* %p2
   store i8 2, i8* %p2
-; NOLIMIT: MemoryUse(1) MayAlias
+; NOLIMIT: MemoryUse(1)
 ; NOLIMIT-NEXT: load i8, i8* %p1
 ; LIMIT: MemoryUse(4)
 ; LIMIT-NEXT: load i8, i8* %p1
   load i8, i8* %p1
   br i1 undef, label %loop.2, label %loop.1
 }
 
 ; CHECK-LABEL: define void @looped_visitedonlyonce

 if.end:
 ; CHECK: 4 = MemoryPhi({while.cond,5},{if.then,1},{if.then2,2})
 ; CHECK: MemoryUse(4)
 ; CHECK-NEXT: load i8, i8* %p1
   load i8, i8* %p1
 ; CHECK: 3 = MemoryDef(4)
 ; CHECK-NEXT: store i8 2, i8* %p2
   store i8 2, i8* %p2
-; NOLIMIT: MemoryUse(4) MayAlias
+; NOLIMIT: MemoryUse(4)
 ; NOLIMIT-NEXT: load i8, i8* %p1
 ; LIMIT: MemoryUse(3)
 ; LIMIT-NEXT: load i8, i8* %p1
   load i8, i8* %p1
   br label %while.cond
 }
 
 ; CHECK-LABEL: define i32 @use_not_optimized_due_to_backedge

llvm/test/Analysis/MemorySSA/print-walker.ll

 ; RUN: opt -passes='print<memoryssa-walker>' -disable-output < %s 2>&1 | FileCheck %s
 
 ; CHECK: define void @test
 ; CHECK: 1 = MemoryDef(liveOnEntry)->liveOnEntry - clobbered by liveOnEntry
 ; CHECK: store i8 42, i8* %a1
 ; CHECK: 2 = MemoryDef(1)->liveOnEntry - clobbered by liveOnEntry
 ; CHECK: store i8 42, i8* %a2
-; CHECK: MemoryUse(1) MustAlias - clobbered by 1 = MemoryDef(liveOnEntry)->liveOnEntry
+; CHECK: MemoryUse(1) - clobbered by 1 = MemoryDef(liveOnEntry)->liveOnEntry
 ; CHECK: %l1 = load i8, i8* %a1
-; CHECK: MemoryUse(2) MustAlias - clobbered by 2 = MemoryDef(1)->liveOnEntry
+; CHECK: MemoryUse(2) - clobbered by 2 = MemoryDef(1)->liveOnEntry
 ; CHECK: %l2 = load i8, i8* %a2
 ; CHECK: 3 = MemoryDef(2)->liveOnEntry - clobbered by liveOnEntry
 ; CHECK: store i8 42, i8* %p
-; CHECK: 4 = MemoryDef(3)->3 MustAlias - clobbered by 3 = MemoryDef(2)->liveOnEntry
+; CHECK: 4 = MemoryDef(3)->3 - clobbered by 3 = MemoryDef(2)->liveOnEntry
 ; CHECK: store i8 42, i8* %p
-; CHECK: MemoryUse(4) MustAlias - clobbered by 4 = MemoryDef(3)->3 MustAlias
+; CHECK: MemoryUse(4) - clobbered by 4 = MemoryDef(3)->3
 ; CHECK: %p1 = load i8, i8* %p
-; CHECK: MemoryUse(4) MustAlias - clobbered by 4 = MemoryDef(3)->3 MustAlias
+; CHECK: MemoryUse(4) - clobbered by 4 = MemoryDef(3)->3
 ; CHECK: %p2 = load i8, i8* %p
 
 define void @test(i8* %p) {
   %a1 = alloca i8
   %a2 = alloca i8
   store i8 42, i8* %a1
   store i8 42, i8* %a2
   %l1 =  load i8, i8* %a1

llvm/test/Analysis/MemorySSA/scalable-vec.ll

 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>' -verify-memoryssa -disable-output < %s 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: define <vscale x 4 x i32> @f(
 ; CHECK: 1 = MemoryDef(liveOnEntry)
-; CHECK: MemoryUse(1) MustAlias
+; CHECK: MemoryUse(1)
 define <vscale x 4 x i32> @f(<vscale x 4 x i32> %z) {
   %a = alloca <vscale x 4 x i32>
   store <vscale x 4 x i32> %z, <vscale x 4 x i32>* %a
   %zz = load <vscale x 4 x i32>, <vscale x 4 x i32>* %a
   ret <vscale x 4 x i32> %zz
 }
 
 ; CHECK-LABEL: define i32 @g(
 ; CHECK: 1 = MemoryDef(liveOnEntry)
-; CHECK: MemoryUse(1) MayAlias
+; CHECK: MemoryUse(1)
 declare i32* @gg(<vscale x 4 x i32>* %a)
 define i32 @g(i32 %z, i32 *%bb) {
   %a = alloca <vscale x 4 x i32>
   %aa = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %a, i32 0, i32 0
   store i32 %z, i32* %aa
   %bbb = call i32* @gg(<vscale x 4 x i32>* %a) readnone
   %zz = load i32, i32* %bbb
   ret i32 %zz
 }

llvm/unittests/Analysis/MemorySSATest.cpp

TEST_F(MemorySSATest, RemovingDefInvalidatesCache) {
   StoreX1->eraseFromParent();
 
   EXPECT_EQ(DefX2->getDefiningAccess(), DefY);
   EXPECT_EQ(MSSA.getWalker()->getClobberingMemoryAccess(DefX2),
             MSSA.getLiveOnEntryDef())
       << "(DefX1 = " << DefX1 << ")";
 }
 
-// Test Must alias for optimized uses
-TEST_F(MemorySSATest, TestLoadMustAlias) {
-  F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
-                       GlobalValue::ExternalLinkage, "F", &M);
-  B.SetInsertPoint(BasicBlock::Create(C, "", F));
-  Type *Int8 = Type::getInt8Ty(C);
-  Value *AllocaA = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
-  Value *AllocaB = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "B");
-
-  B.CreateStore(ConstantInt::get(Int8, 1), AllocaB);
-  // Check load from LOE
-  LoadInst *LA1 = B.CreateLoad(Int8, AllocaA, "");
-  // Check load alias cached for second load
-  LoadInst *LA2 = B.CreateLoad(Int8, AllocaA, "");
-
-  B.CreateStore(ConstantInt::get(Int8, 1), AllocaA);
-  // Check load from store/def
-  LoadInst *LA3 = B.CreateLoad(Int8, AllocaA, "");
-  // Check load alias cached for second load
-  LoadInst *LA4 = B.CreateLoad(Int8, AllocaA, "");
-
-  setupAnalyses();
-  MemorySSA &MSSA = *Analyses->MSSA;
-  MSSA.ensureOptimizedUses();
-
-  unsigned I = 0;
-  for (LoadInst *V : {LA1, LA2}) {
-    MemoryUse *MemUse = dyn_cast_or_null<MemoryUse>(MSSA.getMemoryAccess(V));
-    EXPECT_EQ(MemUse->getOptimizedAccessType(), None)
-        << "Load " << I << " doesn't have the correct alias information";
-    // EXPECT_EQ expands such that if we increment I above, it won't get
-    // incremented except when we try to print the error message.
-    ++I;
-  }
-  for (LoadInst *V : {LA3, LA4}) {
-    MemoryUse *MemUse = dyn_cast_or_null<MemoryUse>(MSSA.getMemoryAccess(V));
-    EXPECT_EQ(*MemUse->getOptimizedAccessType(), AliasResult::MustAlias)
-        << "Load " << I << " doesn't have the correct alias information";
-    // EXPECT_EQ expands such that if we increment I above, it won't get
-    // incremented except when we try to print the error message.
-    ++I;
-  }
-}
-
 // Test Must alias for optimized defs.
 TEST_F(MemorySSATest, TestStoreMustAlias) {
   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
                        GlobalValue::ExternalLinkage, "F", &M);
   B.SetInsertPoint(BasicBlock::Create(C, "", F));
   Type *Int8 = Type::getInt8Ty(C);
   Value *AllocaA = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
   Value *AllocaB = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "B");
   StoreInst *SA1 = B.CreateStore(ConstantInt::get(Int8, 1), AllocaA);
   StoreInst *SB1 = B.CreateStore(ConstantInt::get(Int8, 1), AllocaB);
   StoreInst *SA2 = B.CreateStore(ConstantInt::get(Int8, 2), AllocaA);
   StoreInst *SB2 = B.CreateStore(ConstantInt::get(Int8, 2), AllocaB);
   StoreInst *SA3 = B.CreateStore(ConstantInt::get(Int8, 3), AllocaA);
   StoreInst *SB3 = B.CreateStore(ConstantInt::get(Int8, 3), AllocaB);
 
   setupAnalyses();
   MemorySSA &MSSA = *Analyses->MSSA;
   MemorySSAWalker *Walker = Analyses->Walker;
 
   unsigned I = 0;
   for (StoreInst *V : {SA1, SB1, SA2, SB2, SA3, SB3}) {
     MemoryDef *MemDef = dyn_cast_or_null<MemoryDef>(MSSA.getMemoryAccess(V));
     EXPECT_EQ(MemDef->isOptimized(), false)
         << "Store " << I << " is optimized from the start?";
-    EXPECT_EQ(MemDef->getOptimizedAccessType(), None)
-        << "Store " << I
-        << " has correct alias information before being optimized?";
     if (V == SA1)
       Walker->getClobberingMemoryAccess(V);
     else {
       MemoryAccess *Def = MemDef->getDefiningAccess();
       MemoryAccess *Clob = Walker->getClobberingMemoryAccess(V);
       EXPECT_NE(Def, Clob) << "Store " << I
                            << " has Defining Access equal to Clobbering Access";
     }
     EXPECT_EQ(MemDef->isOptimized(), true)
         << "Store " << I << " was not optimized";
-    if (I == 0 || I == 1)
-      EXPECT_EQ(MemDef->getOptimizedAccessType(), None)
-          << "Store " << I << " doesn't have the correct alias information";
-    else
-      EXPECT_EQ(*MemDef->getOptimizedAccessType(), AliasResult::MustAlias)
-          << "Store " << I << " doesn't have the correct alias information";
-    // EXPECT_EQ expands such that if we increment I above, it won't get
-    // incremented except when we try to print the error message.
-    ++I;
-  }
-}
-
-// Test May alias for optimized uses.
-TEST_F(MemorySSATest, TestLoadMayAlias) {
-  F = Function::Create(FunctionType::get(B.getVoidTy(),
-                                         {B.getInt8PtrTy(), B.getInt8PtrTy()},
-                                         false),
-                       GlobalValue::ExternalLinkage, "F", &M);
-  B.SetInsertPoint(BasicBlock::Create(C, "", F));
-  Type *Int8 = Type::getInt8Ty(C);
-  auto *ArgIt = F->arg_begin();
-  Argument *PointerA = &*ArgIt;
-  Argument *PointerB = &*(++ArgIt);
-  B.CreateStore(ConstantInt::get(Int8, 1), PointerB);
-  LoadInst *LA1 = B.CreateLoad(Int8, PointerA, "");
-  B.CreateStore(ConstantInt::get(Int8, 0), PointerA);
-  LoadInst *LB1 = B.CreateLoad(Int8, PointerB, "");
-  B.CreateStore(ConstantInt::get(Int8, 0), PointerA);
-  LoadInst *LA2 = B.CreateLoad(Int8, PointerA, "");
-  B.CreateStore(ConstantInt::get(Int8, 0), PointerB);
-  LoadInst *LB2 = B.CreateLoad(Int8, PointerB, "");
-
-  setupAnalyses();
-  MemorySSA &MSSA = *Analyses->MSSA;
-  MSSA.ensureOptimizedUses();
-
-  unsigned I = 0;
-  for (LoadInst *V : {LA1, LB1}) {
-    MemoryUse *MemUse = dyn_cast_or_null<MemoryUse>(MSSA.getMemoryAccess(V));
-    EXPECT_EQ(*MemUse->getOptimizedAccessType(), AliasResult::MayAlias)
-        << "Load " << I << " doesn't have the correct alias information";
-    // EXPECT_EQ expands such that if we increment I above, it won't get
-    // incremented except when we try to print the error message.
-    ++I;
-  }
-  for (LoadInst *V : {LA2, LB2}) {
-    MemoryUse *MemUse = dyn_cast_or_null<MemoryUse>(MSSA.getMemoryAccess(V));
-    EXPECT_EQ(*MemUse->getOptimizedAccessType(), AliasResult::MustAlias)
-        << "Load " << I << " doesn't have the correct alias information";
     // EXPECT_EQ expands such that if we increment I above, it won't get
     // incremented except when we try to print the error message.
     ++I;
   }
 }
 
 // Test May alias for optimized defs.
 TEST_F(MemorySSATest, TestStoreMayAlias) {
TEST_F(MemorySSATest, TestStoreMayAlias) {
   MemorySSA &MSSA = *Analyses->MSSA;
   MemorySSAWalker *Walker = Analyses->Walker;
 
   unsigned I = 0;
   for (StoreInst *V : Sts) {
     MemoryDef *MemDef = dyn_cast_or_null<MemoryDef>(MSSA.getMemoryAccess(V));
     EXPECT_EQ(MemDef->isOptimized(), false)
         << "Store " << I << " is optimized from the start?";
-    EXPECT_EQ(MemDef->getOptimizedAccessType(), None)
-        << "Store " << I
-        << " has correct alias information before being optimized?";
     ++I;
   }
 
   for (StoreInst *V : Sts)
     Walker->getClobberingMemoryAccess(V);
 
   I = 0;
   for (StoreInst *V : Sts) {
     MemoryDef *MemDef = dyn_cast_or_null<MemoryDef>(MSSA.getMemoryAccess(V));
     EXPECT_EQ(MemDef->isOptimized(), true)
         << "Store " << I << " was not optimized";
-    if (I == 1 || I == 3 || I == 4)
-      EXPECT_EQ(MemDef->getOptimizedAccessType().value(), AliasResult::MayAlias)
-          << "Store " << I << " doesn't have the correct alias information";
-    else if (I == 0 || I == 2)
-      EXPECT_EQ(MemDef->getOptimizedAccessType(), None)
-          << "Store " << I << " doesn't have the correct alias information";
-    else
-      EXPECT_EQ(MemDef->getOptimizedAccessType().value(),
-                AliasResult::MustAlias)
-          << "Store " << I << " doesn't have the correct alias information";
     // EXPECT_EQ expands such that if we increment I above, it won't get
     // incremented except when we try to print the error message.
     ++I;
   }
 }
 
 TEST_F(MemorySSATest, LifetimeMarkersAreClobbers) {
   // Example code: