[GlobalsAA] Set MayReadAnyGlobal as a separate bit from ModRefInfo.

[asbirlea]

Summary

When changing ModRefInfo to use the Must bit, the MRI lattice was extended by 1 bit.
This meant that the Must bit now overlaps with the MayReadAnyGlobal in GlobalsAA.
While this is acceptable assuming the Must bit is ignored in this AA, a safer approach is using another bit.

llvm/lib/Analysis/GlobalsModRef.cpp

 ///
 /// We collect information about mod/ref behavior of a function here, both in
 /// general and as pertains to specific globals. We only have this detailed
 /// information when we know *something* useful about the behavior. If we
 /// saturate to fully general mod/ref, we remove the info for the function.
 class GlobalsAAResult::FunctionInfo {
   typedef SmallDenseMap<const GlobalValue *, ModRefInfo, 16> GlobalInfoMapType;
 
-  /// Build a wrapper struct that has 8-byte alignment. All heap allocations
+  /// Build a wrapper struct that has 16-byte alignment. All heap allocations
   /// should provide this much alignment at least, but this makes it clear we
   /// specifically rely on this amount of alignment.
-  struct alignas(8) AlignedMap {
+  struct alignas(16) AlignedMap {
     AlignedMap() {}
     AlignedMap(const AlignedMap &Arg) : Map(Arg.Map) {}
     GlobalInfoMapType Map;
   };
 
   /// Pointer traits for our aligned map.
   struct AlignedMapPointerTraits {
     static inline void *getAsVoidPointer(AlignedMap *P) { return P; }
     static inline AlignedMap *getFromVoidPointer(void *P) {
       return (AlignedMap *)P;
     }
-    enum { NumLowBitsAvailable = 3 };
+    enum { NumLowBitsAvailable = 4 };
     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.
-  enum { MayReadAnyGlobal = 4 };
+  /// this remains correct.
+  enum { MayReadAnyGlobal = 8 };
 
   /// 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() : Info() {}
   ~FunctionInfo() {
     delete Info.getPointer();
   }
public:
 
   /// 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); }
public:
   /// Clear a global's ModRef info. Should be used when a global is being
   /// deleted.
   void eraseModRefInfoForGlobal(const GlobalValue &GV) {
     if (AlignedMap *P = Info.getPointer())
       P->Map.erase(&GV);
   }
 
 private:
-  /// All of the information is encoded into a single pointer, with a three bit
-  /// integer in the low three bits. The high bit provides a flag for when this
-  /// function may read any global. The low two bits are the ModRefInfo. And
+  /// All of the information is encoded into a single pointer, with a four bit
+  /// integer in the low four bits. The high bit provides a flag for when this
+  /// function may read any global. The low three bits are the ModRefInfo. And
   /// the pointer, when non-null, points to a map from GlobalValue to
   /// ModRefInfo specific to that GlobalValue.
-  PointerIntPair<AlignedMap *, 3, unsigned, AlignedMapPointerTraits> Info;
+  PointerIntPair<AlignedMap *, 4, unsigned, AlignedMapPointerTraits> Info;
 };
 
 void GlobalsAAResult::DeletionCallbackHandle::deleted() {
   Value *V = getValPtr();
   if (auto *F = dyn_cast<Function>(V))
     GAR->FunctionInfos.erase(F);
 
   if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {