[ModRefInfo] Reverse Must/NoModRef bit order.

[asbirlea]

Summary

Reordering bits in ModRefInfo get the correct behavior for union between multiple AA analysis.
Making this an add-on patch to D38862 to separate the changes needed.

[asbirlea]

Merged into D38862.

include/llvm/Analysis/AliasAnalysis.h

 
 /// 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.
 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
   /// another piece of "free" information that is presented when available.
   /// MRI_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.
   /// MRI_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 MRI_NoModRef. An additional alias check to set MRI_Must may be
   /// expensive. Other cases may also not set MRI_Must(e.g. callCapturesBefore).
 
   /// 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) {
   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));

 };
 
 // Wrapper method strips bits significant only in FunctionModRefBehavior,
 // to obtain a valid ModRefInfo. The benefit of using the wrapper is that if
 // ModRefInfo enum changes, the wrapper can be updated to & with the new enum
 // 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 {
 public:
   // Make these results default constructable and movable. We have to spell
   // these out because MSVC won't synthesize them.
   AAResults(const TargetLibraryInfo &TLI) : TLI(TLI) {}
   AAResults(AAResults &&Arg);

lib/Analysis/GlobalsModRef.cpp

class GlobalsAAResult::FunctionInfo {
   /// chosen to mix together with ModRefInfo bits.
   /// FIXME: This assumes ModRefInfo lattice will remain 4 bits!
   /// It overlaps with MRI_Must bit!
   /// FunctionInfo.getModRefInfo() masks out everything except MRI_ModRef so
   /// this remains correct, but the MRI_Must info is lost.
   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.");
 
 public:
   FunctionInfo() : Info() {}
   ~FunctionInfo() {
     delete Info.getPointer();
   }
FunctionInfo &operator=(FunctionInfo &&RHS) {
     delete Info.getPointer();
     Info.setPointerAndInt(RHS.Info.getPointer(), RHS.Info.getInt());
     RHS.Info.setPointerAndInt(nullptr, 0);
     return *this;
   }
 
   /// 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.
   ModRefInfo getModRefInfo() const { return globalClearMust(Info.getInt()); }
 
   /// 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
   /// 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); }

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:  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) ]