[AA] Make ModRefInfo a bitmask enum (NFC)

[nikic]

Summary

Mark ModRefInfo as a bitmask enum, which allows using normal & and | operators on it. This supersedes various functions like unionModRef() and intersectModRef(). I think this makes the code cleaner than going through helper functions...

[nikic]

Rebase over minor cleanup.

[fhahn]

LGTM, thanks! Might be good to wait with committing this a day or so in case there are additional thought on the change of style.

llvm/include/llvm/Analysis/AliasAnalysis.h

enum class ModRefInfo : uint8_t {
   /// 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,
+  LLVM_MARK_AS_BITMASK_ENUM(ModRef),
 };
 
 LLVM_NODISCARD inline bool isNoModRef(const ModRefInfo MRI) {
   return MRI == ModRefInfo::NoModRef;
 }
 LLVM_NODISCARD inline bool isModOrRefSet(const ModRefInfo MRI) {
   return MRI != ModRefInfo::NoModRef;
 }
 LLVM_NODISCARD inline bool isModAndRefSet(const ModRefInfo MRI) {
   return MRI == ModRefInfo::ModRef;
 }
 LLVM_NODISCARD inline bool isModSet(const ModRefInfo MRI) {
   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::Ref);
 }
 
+[[deprecated("Use operator | instead")]]
 LLVM_NODISCARD inline ModRefInfo setMod(const ModRefInfo MRI) {
-  return ModRefInfo(static_cast<int>(MRI) | static_cast<int>(ModRefInfo::Mod));
+  return MRI | ModRefInfo::Mod;
 }
+[[deprecated("Use operator | instead")]]
 LLVM_NODISCARD inline ModRefInfo setRef(const ModRefInfo MRI) {
-  return ModRefInfo(static_cast<int>(MRI) | static_cast<int>(ModRefInfo::Ref));
+  return MRI | ModRefInfo::Ref;
 }
+[[deprecated("Use operator & instead")]]
 LLVM_NODISCARD inline ModRefInfo clearMod(const ModRefInfo MRI) {
-  return ModRefInfo(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Ref));
+  return MRI & ModRefInfo::Ref;
 }
+[[deprecated("Use operator & instead")]]
 LLVM_NODISCARD inline ModRefInfo clearRef(const ModRefInfo MRI) {
-  return ModRefInfo(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Mod));
+  return MRI & ModRefInfo::Mod;
 }
+[[deprecated("Use operator | instead")]]
 LLVM_NODISCARD inline ModRefInfo unionModRef(const ModRefInfo MRI1,
                                              const ModRefInfo MRI2) {
-  return ModRefInfo(static_cast<int>(MRI1) | static_cast<int>(MRI2));
+  return MRI1 | MRI2;
 }
+[[deprecated("Use operator & instead")]]
 LLVM_NODISCARD inline ModRefInfo intersectModRef(const ModRefInfo MRI1,
                                                  const ModRefInfo MRI2) {
-  return ModRefInfo(static_cast<int>(MRI1) & static_cast<int>(MRI2));
+  return MRI1 & MRI2;
 }
 
 /// The locations at which a function might access memory.
 ///
 /// These are primarily used in conjunction with the \c AccessKind bits to
 /// describe both the nature of access and the locations of access for a
 /// function call.
 enum FunctionModRefLocation {

llvm/lib/Analysis/AliasAnalysis.cpp

bool AAResults::pointsToConstantMemory(const MemoryLocation &Loc,
 
   return false;
 }
 
 ModRefInfo AAResults::getArgModRefInfo(const CallBase *Call, unsigned ArgIdx) {
   ModRefInfo Result = ModRefInfo::ModRef;
 
   for (const auto &AA : AAs) {
-    Result = intersectModRef(Result, AA->getArgModRefInfo(Call, ArgIdx));
+    Result &= AA->getArgModRefInfo(Call, ArgIdx);
 
     // Early-exit the moment we reach the bottom of the lattice.
     if (isNoModRef(Result))
       return ModRefInfo::NoModRef;
   }
 
   return Result;
 }

 }
 
 ModRefInfo AAResults::getModRefInfo(const CallBase *Call,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   ModRefInfo Result = ModRefInfo::ModRef;
 
   for (const auto &AA : AAs) {
-    Result = intersectModRef(Result, AA->getModRefInfo(Call, Loc, AAQI));
+    Result &= AA->getModRefInfo(Call, Loc, AAQI);
 
     // Early-exit the moment we reach the bottom of the lattice.
     if (isNoModRef(Result))
       return ModRefInfo::NoModRef;
   }
 
   // Try to refine the mod-ref info further using other API entry points to the
   // aggregate set of AA results.
   auto MRB = getModRefBehavior(Call);
   if (onlyAccessesInaccessibleMem(MRB))
     return ModRefInfo::NoModRef;
 
   if (onlyReadsMemory(MRB))
-    Result = clearMod(Result);
+    Result &= ModRefInfo::Ref;
   else if (onlyWritesMemory(MRB))
-    Result = clearRef(Result);
+    Result &= ModRefInfo::Mod;
 
   if (onlyAccessesArgPointees(MRB) || onlyAccessesInaccessibleOrArgMem(MRB)) {
     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);
-        }
+        if (ArgAlias != AliasResult::NoAlias)
+          AllArgsMask |= getArgModRefInfo(Call, ArgIdx);
       }
     }
     // 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);
+    Result &= AllArgsMask;
   }
 
   // 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);
+    Result &= ModRefInfo::Ref;
 
   return Result;
 }
 
 ModRefInfo AAResults::getModRefInfo(const CallBase *Call1,
                                     const CallBase *Call2) {
   SimpleAAQueryInfo AAQIP;
   return getModRefInfo(Call1, Call2, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const CallBase *Call1,
                                     const CallBase *Call2, AAQueryInfo &AAQI) {
   ModRefInfo Result = ModRefInfo::ModRef;
 
   for (const auto &AA : AAs) {
-    Result = intersectModRef(Result, AA->getModRefInfo(Call1, Call2, AAQI));
+    Result &= AA->getModRefInfo(Call1, Call2, AAQI);
 
     // Early-exit the moment we reach the bottom of the lattice.
     if (isNoModRef(Result))
       return ModRefInfo::NoModRef;
   }
 
   // Try to refine the mod-ref info further using other API entry points to the
   // aggregate set of AA results.
ModRefInfo AAResults::getModRefInfo(const CallBase *Call1,
 
   // If they both only read from memory, there is no dependence.
   if (onlyReadsMemory(Call1B) && onlyReadsMemory(Call2B))
     return ModRefInfo::NoModRef;
 
   // If Call1 only reads memory, the only dependence on Call2 can be
   // from Call1 reading memory written by Call2.
   if (onlyReadsMemory(Call1B))
-    Result = clearMod(Result);
+    Result &= ModRefInfo::Ref;
   else if (onlyWritesMemory(Call1B))
-    Result = clearRef(Result);
+    Result &= ModRefInfo::Mod;
 
   // 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;
for (auto I = Call2->arg_begin(), E = Call2->arg_end(); I != E; ++I) {
       ModRefInfo ArgMask = ModRefInfo::NoModRef;
       if (isModSet(ArgModRefC2))
         ArgMask = ModRefInfo::ModRef;
       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);
+      ArgMask &= getModRefInfo(Call1, Call2ArgLoc, AAQI);
 
-      R = intersectModRef(unionModRef(R, ArgMask), Result);
+      R = (R | ArgMask) & Result;
       if (R == Result)
         break;
     }
 
     return R;
   }
 
   // If Call1 only accesses memory through arguments, check if Call2 references
for (auto I = Call1->arg_begin(), E = Call1->arg_end(); I != E; ++I) {
 
       // 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);
+        R = (R | ArgModRefC1) & Result;
 
       if (R == Result)
         break;
     }
 
     return R;
   }
 
bool AAResults::canInstructionRangeModRef(const Instruction &I1,
                                           const ModRefInfo Mode) {
   assert(I1.getParent() == I2.getParent() &&
          "Instructions not in same basic block!");
   BasicBlock::const_iterator I = I1.getIterator();
   BasicBlock::const_iterator E = I2.getIterator();
   ++E;  // Convert from inclusive to exclusive range.
 
   for (; I != E; ++I) // Check every instruction in range
-    if (isModOrRefSet(intersectModRef(getModRefInfo(&*I, Loc), Mode)))
+    if (isModOrRefSet(getModRefInfo(&*I, Loc) & Mode))
       return true;
   return false;
 }
 
 // Provide a definition for the root virtual destructor.
 AAResults::Concept::~Concept() = default;
 
 // Provide a definition for the static object used to identify passes.

llvm/lib/Analysis/AliasSetTracker.cpp

if (Call->onlyAccessesArgMemory()) {
       ModRefInfo CallMask = createModRefInfo(AA.getModRefBehavior(Call));
 
       // Some intrinsics are marked as modifying memory for control flow
       // modelling purposes, but don't actually modify any specific memory
       // location.
       using namespace PatternMatch;
       if (Call->use_empty() &&
           match(Call, m_Intrinsic<Intrinsic::invariant_start>()))
-        CallMask = clearMod(CallMask);
+        CallMask &= ModRefInfo::Ref;
 
       for (auto IdxArgPair : enumerate(Call->args())) {
         int ArgIdx = IdxArgPair.index();
         const Value *Arg = IdxArgPair.value();
         if (!Arg->getType()->isPointerTy())
           continue;
         MemoryLocation ArgLoc =
             MemoryLocation::getForArgument(Call, ArgIdx, nullptr);
         ModRefInfo ArgMask = AA.getArgModRefInfo(Call, ArgIdx);
-        ArgMask = intersectModRef(CallMask, ArgMask);
+        ArgMask &= CallMask;
         if (!isNoModRef(ArgMask))
           addPointer(ArgLoc, getAccessFromModRef(ArgMask));
       }
       return;
     }
 
   return addUnknown(I);
 }

llvm/lib/Analysis/BasicAliasAnalysis.cpp

for (auto CI = Call->data_operands_begin(), CE = Call->data_operands_end();
           MemoryLocation::getBeforeOrAfter(*CI),
           MemoryLocation::getBeforeOrAfter(Object), AAQI);
       // 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);
+        Result |= ModRefInfo::Ref;
         continue;
       }
       // Operand aliases 'Object' but call only writes into it.
       if (Call->onlyWritesMemory(OperandNo)) {
-        Result = setMod(Result);
+        Result |= ModRefInfo::Mod;
         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;
     }
ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call,
   if (auto *Inst = dyn_cast<AnyMemTransferInst>(Call)) {
     AliasResult SrcAA =
         getBestAAResults().alias(MemoryLocation::getForSource(Inst), Loc, AAQI);
     AliasResult DestAA =
         getBestAAResults().alias(MemoryLocation::getForDest(Inst), Loc, AAQI);
     // It's also possible for Loc to alias both src and dest, or neither.
     ModRefInfo rv = ModRefInfo::NoModRef;
     if (SrcAA != AliasResult::NoAlias || Call->hasReadingOperandBundles())
-      rv = setRef(rv);
+      rv |= ModRefInfo::Ref;
     if (DestAA != AliasResult::NoAlias || Call->hasClobberingOperandBundles())
-      rv = setMod(rv);
+      rv |= ModRefInfo::Mod;
     return rv;
   }
 
   // Guard intrinsics are marked as arbitrarily writing so that proper control
   // dependencies are maintained but they never mods any particular memory
   // location.
   //
   // *Unlike* assumes, guard intrinsics are modeled as reading memory since the

llvm/lib/Analysis/GlobalsModRef.cpp

public:
   /// Returns the \c ModRefInfo info for this function w.r.t. a particular
   /// global, which may be more precise than the general information above.
   ModRefInfo getModRefInfoForGlobal(const GlobalValue &GV) const {
     ModRefInfo GlobalMRI =
         mayReadAnyGlobal() ? ModRefInfo::Ref : ModRefInfo::NoModRef;
     if (AlignedMap *P = Info.getPointer()) {
       auto I = P->Map.find(&GV);
       if (I != P->Map.end())
-        GlobalMRI = unionModRef(GlobalMRI, I->second);
+        GlobalMRI |= I->second;
     }
     return GlobalMRI;
   }
 
   /// Add mod/ref info from another function into ours, saturating towards
   /// ModRef.
   void addFunctionInfo(const FunctionInfo &FI) {
     addModRefInfo(FI.getModRefInfo());
 
     if (FI.mayReadAnyGlobal())
       setMayReadAnyGlobal();
 
     if (AlignedMap *P = FI.Info.getPointer())
       for (const auto &G : P->Map)
         addModRefInfoForGlobal(*G.first, G.second);
   }
 
   void addModRefInfoForGlobal(const GlobalValue &GV, ModRefInfo NewMRI) {
     AlignedMap *P = Info.getPointer();
     if (!P) {
       P = new AlignedMap();
       Info.setPointer(P);
     }
     auto &GlobalMRI = P->Map[&GV];
-    GlobalMRI = unionModRef(GlobalMRI, NewMRI);
+    GlobalMRI |= NewMRI;
   }
 
   /// 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);
   }
ModRefInfo GlobalsAAResult::getModRefInfo(const CallBase *Call,
   if (const GlobalValue *GV =
           dyn_cast<GlobalValue>(getUnderlyingObject(Loc.Ptr)))
     // If GV is internal to this IR and there is no function with local linkage
     // that has had their address taken, keep looking for a tighter ModRefInfo.
     if (GV->hasLocalLinkage() && !UnknownFunctionsWithLocalLinkage)
       if (const Function *F = Call->getCalledFunction())
         if (NonAddressTakenGlobals.count(GV))
           if (const FunctionInfo *FI = getFunctionInfo(F))
-            Known = unionModRef(FI->getModRefInfoForGlobal(*GV),
-                                getModRefInfoForArgument(Call, GV, AAQI));
+            Known = FI->getModRefInfoForGlobal(*GV) |
+                    getModRefInfoForArgument(Call, GV, AAQI);
 
   return Known;
 }
 
 GlobalsAAResult::GlobalsAAResult(
     const DataLayout &DL,
     std::function<const TargetLibraryInfo &(Function &F)> GetTLI)
     : DL(DL), GetTLI(std::move(GetTLI)) {}

llvm/lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

mayLoopAccessLocation(Value *Ptr, ModRefInfo Access, Loop *L,
   // operand in the store.  Store to &A[i] of 100 will always return may alias
   // with store of &A[100], we need to StoreLoc to be "A" with size of 100,
   // which will then no-alias a store to &A[100].
   MemoryLocation StoreLoc(Ptr, AccessSize);
 
   for (auto *B : L->blocks())
     for (auto &I : *B)
       if (Ignored.count(&I) == 0 &&
-          isModOrRefSet(
-              intersectModRef(AA.getModRefInfo(&I, StoreLoc), Access)))
+          isModOrRefSet(AA.getModRefInfo(&I, StoreLoc) & Access))
         return true;
 
   return false;
 }
 
 void HexagonLoopIdiomRecognize::collectStores(Loop *CurLoop, BasicBlock *BB,
       SmallVectorImpl<StoreInst*> &Stores) {
   Stores.clear();

llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp

mayLoopAccessLocation(Value *Ptr, ModRefInfo Access, Loop *L,
   // operand in the store.  Store to &A[i] of 100 will always return may alias
   // with store of &A[100], we need to StoreLoc to be "A" with size of 100,
   // which will then no-alias a store to &A[100].
   MemoryLocation StoreLoc(Ptr, AccessSize);
 
   for (BasicBlock *B : L->blocks())
     for (Instruction &I : *B)
       if (!IgnoredInsts.contains(&I) &&
-          isModOrRefSet(
-              intersectModRef(AA.getModRefInfo(&I, StoreLoc), Access)))
+          isModOrRefSet(AA.getModRefInfo(&I, StoreLoc) & Access))
         return true;
   return false;
 }
 
 // If we have a negative stride, Start refers to the end of the memory location
 // we're trying to memset.  Therefore, we need to recompute the base pointer,
 // which is just Start - BECount*Size.
 static const SCEV *getStartForNegStride(const SCEV *Start, const SCEV *BECount,