Index: include/llvm/Analysis/AliasAnalysis.h
===================================================================
--- include/llvm/Analysis/AliasAnalysis.h
+++ include/llvm/Analysis/AliasAnalysis.h
@@ -98,15 +98,6 @@
 /// they form a three bit matrix and bit-tests for 'mod' or 'ref' or 'must'
 /// work with any of the possible values.
 enum class ModRefInfo {
-  /// The access neither references nor modifies the value stored in memory.
-  NoModRef = 0,
-  /// The access may reference the value stored in memory.
-  Ref = 1,
-  /// The access may modify the value stored in memory.
-  Mod = 2,
-  /// The access may reference and may modify the value stored in memory.
-  ModRef = Ref | Mod,
-
   /// [ About MRI_Must:
   /// MRI_Must is set in a best effort manner.
   /// We usually do not try our best to infer MRI_Must, instead it is merely
@@ -121,63 +112,72 @@
 
   /// MRI_Must is provided for completeness, but no routines will return only
   /// MRI_Must today.
-  Must = 4,
+  Must = 0,
   /// The access may reference the value stored in memory,
   /// a mustAlias relation was found, and no mayAlias or partialAlias found.
-  MustRef = Ref | Must,
+  MustRef = 1,
   /// The access may modify the value stored in memory,
   /// a mustAlias relation was found, and no mayAlias or partialAlias found.
-  MustMod = Mod | Must,
+  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 = ModRef | Must,
+  MustModRef = MustRef | MustMod,
+  /// The access neither references nor modifies the value stored in memory.
+  NoModRef = 4,
+  /// The access may reference the value stored in memory.
+  Ref = NoModRef | MustRef,
+  /// The access may modify the value stored in memory.
+  Mod = NoModRef | MustMod,
+  /// The access may reference and may modify the value stored in memory.
+  ModRef = Ref | Mod,
+
 };
 
 LLVM_NODISCARD inline bool isNoModRef(const ModRefInfo MRI) {
-  return (static_cast<int>(MRI) & static_cast<int>(ModRefInfo::ModRef)) ==
-         static_cast<int>(ModRefInfo::NoModRef);
+  return (static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef)) ==
+         static_cast<int>(ModRefInfo::Must);
 }
 LLVM_NODISCARD inline bool isModOrRefSet(const ModRefInfo MRI) {
-  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::ModRef);
+  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef);
 }
 LLVM_NODISCARD inline bool isModAndRefSet(const ModRefInfo MRI) {
-  return (static_cast<int>(MRI) & static_cast<int>(ModRefInfo::ModRef)) ==
-         static_cast<int>(ModRefInfo::ModRef);
+  return (static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef)) ==
+         static_cast<int>(ModRefInfo::MustModRef);
 }
 LLVM_NODISCARD inline bool isModSet(const ModRefInfo MRI) {
-  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Mod);
+  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustMod);
 }
 LLVM_NODISCARD inline bool isRefSet(const ModRefInfo MRI) {
-  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Ref);
+  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::Must);
+  return !(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::NoModRef));
 }
 
 LLVM_NODISCARD inline ModRefInfo setMod(const ModRefInfo MRI) {
-  return ModRefInfo(static_cast<int>(MRI) | static_cast<int>(ModRefInfo::Mod));
+  return ModRefInfo(static_cast<int>(MRI) | static_cast<int>(ModRefInfo::MustMod));
 }
 LLVM_NODISCARD inline ModRefInfo setRef(const ModRefInfo MRI) {
-  return ModRefInfo(static_cast<int>(MRI) | static_cast<int>(ModRefInfo::Ref));
+  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::Must));
+  return ModRefInfo(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef));
 }
 LLVM_NODISCARD inline ModRefInfo setModAndRef(const ModRefInfo MRI) {
   return ModRefInfo(static_cast<int>(MRI) |
-                    static_cast<int>(ModRefInfo::ModRef));
+                    static_cast<int>(ModRefInfo::MustModRef));
 }
 LLVM_NODISCARD inline ModRefInfo clearMod(const ModRefInfo MRI) {
   return ModRefInfo(static_cast<int>(MRI) &
-                    static_cast<int>(ModRefInfo::MustRef));
+                    static_cast<int>(ModRefInfo::Ref));
 }
 LLVM_NODISCARD inline ModRefInfo clearRef(const ModRefInfo MRI) {
   return ModRefInfo(static_cast<int>(MRI) &
-                    static_cast<int>(ModRefInfo::MustMod));
+                    static_cast<int>(ModRefInfo::Mod));
 }
 LLVM_NODISCARD inline ModRefInfo clearMust(const ModRefInfo MRI) {
-  return ModRefInfo(static_cast<int>(MRI) &
-                    static_cast<int>(ModRefInfo::ModRef));
+  return ModRefInfo(static_cast<int>(MRI) |
+                    static_cast<int>(ModRefInfo::NoModRef));
 }
 LLVM_NODISCARD inline ModRefInfo unionModRef(const ModRefInfo MRI1,
                                              const ModRefInfo MRI2) {
@@ -279,7 +279,7 @@
 // entry with all bits set to 1.
 LLVM_NODISCARD inline ModRefInfo
 createModRefInfo(const FunctionModRefBehavior FMRB) {
-  return ModRefInfo(FMRB & static_cast<int>(ModRefInfo::MustModRef));
+  return ModRefInfo(FMRB & static_cast<int>(ModRefInfo::ModRef));
 }
 
 class AAResults {
Index: lib/Analysis/GlobalsModRef.cpp
===================================================================
--- lib/Analysis/GlobalsModRef.cpp
+++ lib/Analysis/GlobalsModRef.cpp
@@ -91,9 +91,9 @@
   enum { MayReadAnyGlobal = 4 };
 
   /// Checks to document the invariants of the bit packing here.
-  static_assert((MayReadAnyGlobal & static_cast<int>(ModRefInfo::ModRef)) == 0,
+  static_assert((MayReadAnyGlobal & static_cast<int>(ModRefInfo::MustModRef)) == 0,
                 "ModRef and the MayReadAnyGlobal flag bits overlap.");
-  static_assert(((MayReadAnyGlobal | static_cast<int>(ModRefInfo::ModRef)) >>
+  static_assert(((MayReadAnyGlobal | static_cast<int>(ModRefInfo::MustModRef)) >>
                  AlignedMapPointerTraits::NumLowBitsAvailable) == 0,
                 "Insufficient low bits to store our flag and ModRef info.");
 
@@ -130,7 +130,8 @@
 
   /// This method must align in functionality with clearMust().
   inline ModRefInfo globalClearMust(int I) const {
-    return ModRefInfo(I & static_cast<int>(ModRefInfo::ModRef));
+    return ModRefInfo((I & static_cast<int>(ModRefInfo::ModRef)) |
+                       static_cast<int>(ModRefInfo::NoModRef));
   }
 
   /// Returns the \c ModRefInfo info for this function.
@@ -138,7 +139,7 @@
 
   /// Adds new \c ModRefInfo for this function to its state.
   void addModRefInfo(ModRefInfo NewMRI) {
-    Info.setInt(Info.getInt() | static_cast<int>(clearMust(NewMRI)));
+    Info.setInt(Info.getInt() | static_cast<int>(setMust(NewMRI)));
   }
 
   /// Returns whether this function may read any global variable, and we don't
Index: test/Analysis/BasicAA/call-attrs.ll
===================================================================
--- test/Analysis/BasicAA/call-attrs.ll
+++ test/Analysis/BasicAA/call-attrs.ll
@@ -31,12 +31,12 @@
   ret void
 }
 
-; CHECK:  Just Ref:  Ptr: i8* %p	<->  call void @readonly_attr(i8* %p)
+; CHECK:  Just Ref (MustAlias):  Ptr: i8* %p	<->  call void @readonly_attr(i8* %p)
 ; CHECK:  Just Ref:  Ptr: i8* %p	<->  call void @readonly_func(i8* %p)
-; CHECK:  Just Mod:  Ptr: i8* %p	<->  call void @writeonly_attr(i8* %p)
+; CHECK:  Just Mod (MustAlias):  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:  Ptr: i8* %p	<->  call void @func() [ "deopt"(i8* %p) ]
+; CHECK:  Just Ref (MustAlias):  Ptr: i8* %p	<->  call void @func() [ "deopt"(i8* %p) ]
 ; CHECK:  Both ModRef:  Ptr: i8* %p	<->  call void @writeonly_attr(i8* %p) [ "deopt"(i8* %p) ]