[AA] Tracking per-location ModRef info in FunctionModRefBehavior (NFCI)

[nikic]

Summary

Currently, FunctionModRefBehavior tracks whether the function reads or writes memory (ModRefInfo) and which locations it can access (argmem, inaccessiblemem and other). This patch changes it to track ModRef information per-location instead.

To give two examples of why this is useful:

• D117095 highlights a weakness of ModRef modelling in the presence of operand bundled. For a memcpy call with deopt operand bundle, we want to say that it can read any memory, but only write argument memory. This would allow them to be treated like any other calls. However, we currently can't express this and have to say that it can read or write any memory. (cc @ebrevnov)
• D127383 would ideally be modelled as a separate threadid location, where threadid Refs outside pre-split coroutines can be ignored (like other accesses to constant memory). The current representation does not allow modelling this precisely. (cc @ChuanqiXu)

The patch as implemented is intended to be NFC, but there are some obvious opportunities for improvements and simplification. To fully capitalize on this we would also want to change the way we represent memory attributes on functions, but that's a larger change, and I think it makes sense to separate out the FunctionModRefBehavior refactoring.

[nikic]

Rebase & ping

[nikic]

Ping!

[ebrevnov]

If nobody do it before I'll do my best to take a look this week.

[ebrevnov]

Hi @nikic

Thanks for moving this forward! In general, the direction looks good to me. Before commenting on specific things I would like to discuss one high level thing. I found new FMRB interface a bit overloaded. It's was hard to quickly understand which API creates new FMRB instance and which makes in place update. My proposal would be:

1. Make FMRB non-mutable (that would also allow to use static instances for common cases like none, unknown, etc...)
2. Move location specific API from FMRB to Location. That would separate things out and allow to reduce total number of public API. For example, argMemOnly(ModRefInfo MR) would be not needed as one can simply instantiate FMRB through public constructor.
3. Don't introduce withModRef & withoutLoc. Instead model operations through 'operator &' and 'operator |'

What do you think?

[nikic]

In D130896#3763481, @ebrevnov wrote:

Hi @nikic

Thanks for moving this forward! In general, the direction looks good to me. Before commenting on specific things I would like to discuss one high level thing. I found new FMRB interface a bit overloaded. It's was hard to quickly understand which API creates new FMRB instance and which makes in place update. My proposal would be:

1. Make FMRB non-mutable (that would also allow to use static instances for common cases like none, unknown, etc...)

I think this makes sense, and would mostly be a matter of making setModRef private. withModRef (which returns a new instance) is intended as the public API.

2. Move location specific API from FMRB to Location. That would separate things out and allow to reduce total number of public API. For example, argMemOnly(ModRefInfo MR) would be not needed as one can simply instantiate FMRB through public constructor.

I'm not sure I understand the suggested API here. Do you mean that instead of FunctionModRefBehavior::argMemOnly(MR) we should write FunctionModRefBehavior(FunctionModRefBehavior::ArgMem, MR), or something else?

3. Don't introduce withModRef & withoutLoc. Instead model operations through 'operator &' and 'operator |'

I think this would be a bit inconvenient in that manipulating FMRB usually involves first unsetting the old MR for the location and then setting the new one. So FMRB.withModRef(Loc, NewMR) would have to become something like FMRB & ~FunctionModRefInfo(Loc, ModRefInfo::ModRef) | FunctionModRefInfo(Loc, NewMR), which is a bit of a mouthful.

[ebrevnov]

In D130896#3763527, @nikic wrote:

In D130896#3763481, @ebrevnov wrote:

Hi @nikic

Thanks for moving this forward! In general, the direction looks good to me. Before commenting on specific things I would like to discuss one high level thing. I found new FMRB interface a bit overloaded. It's was hard to quickly understand which API creates new FMRB instance and which makes in place update. My proposal would be:

1. Make FMRB non-mutable (that would also allow to use static instances for common cases like none, unknown, etc...)

I think this makes sense, and would mostly be a matter of making setModRef private. withModRef (which returns a new instance) is intended as the public API.

Cool.

2. Move location specific API from FMRB to Location. That would separate things out and allow to reduce total number of public API. For example, argMemOnly(ModRefInfo MR) would be not needed as one can simply instantiate FMRB through public constructor.

I'm not sure I understand the suggested API here. Do you mean that instead of FunctionModRefBehavior::argMemOnly(MR) we should write FunctionModRefBehavior(FunctionModRefBehavior::ArgMem, MR), or something else?

Yep, something like that, except, I was thinking about keeping FunctionModRefLocation top level and calling its member FunctionModRefLocation::argMemOnly() to get location.

3. Don't introduce withModRef & withoutLoc. Instead model operations through 'operator &' and 'operator |'

I think this would be a bit inconvenient in that manipulating FMRB usually involves first unsetting the old MR for the location and then setting the new one. So FMRB.withModRef(Loc, NewMR) would have to become something like FMRB & ~FunctionModRefInfo(Loc, ModRefInfo::ModRef) | FunctionModRefInfo(Loc, NewMR), which is a bit of a mouthful.

Agree. Maybe we can find a bit better name(s). In particular 'withoutLoc' looks confusing.

[nikic]

Rebase, remove setModRef from public API, include methods from D130980.

[nikic]

Upload the correct patch...

[asbirlea]

This *is* a much cleaner way to handle ModRefBehavior.
I left some comments inline, some are nits that's up to you if you think they make sense.

I'm more curious if this change impacts compile-time, since it's being pretty general with the iteration over the number of locations possible and I'm not sure how much of that will be inlined.

llvm/include/llvm/Analysis/AliasAnalysis.h

301

Naming option: getWithModRef?

308

similar getWithoutLoc?

309

nit: I'd find this easier to read if it didn't defer to the withModRef API, even if it's 2 LoC longer.

FunctionModRefBehavior FMRB = *this;
FMRB.setModRef(Loc, ModRefInfo::NoModRef);
return FMRB;

352

Is this return isNoModRef(getModRef(Other)); ?

llvm/lib/Analysis/BasicAliasAnalysis.cpp

770

Not sure how much it's worth avoiding the setting anyLoc when it gets overwritten right after.
Suggestion would be to do:
:759 FunctionModRefBehavior Min;

:765

else
  Min = FunctionModRefBehavior::anyLoc(MR);

polly/lib/Analysis/ScopBuilder.cpp

1643

Shouldn't the check for does not access memory be kept here?
It's included in the onlyReadsMemory below, but it shouldn't add to GlobalReads.

if (FMRB.doesNotAccessMemory())
  return true;

[nikic]

Address comments

[nikic]

In D130896#3764753, @asbirlea wrote:

I'm more curious if this change impacts compile-time, since it's being pretty general with the iteration over the number of locations possible and I'm not sure how much of that will be inlined.

Yeah, I was concerned about compile-time impact as well, but the change doesn't not seem to have any measurable impact.

llvm/lib/Analysis/BasicAliasAnalysis.cpp

770

That would be nice, but C++ doesn't let us :( This would require a default constructor for FunctionModRefBehavior, and effectively initialize to FunctionModRefBehavior::none(). I don't think there is a good way to express this in C++ apart from either using some deeply nested ternaries or putting this in a separate function.

[nikic]

Ping

[reames]

Generally, this makes sense to me. However, reading through, I spot a couple things which don't look NFC.

Can we find a way to stage this change? Here's one idea, but I'm open to others as well.

1. Leave the AliasAnalysis accessors for the moment, canonicalize code to use them rather than direct comparison of FRM. (This just shrinks the patch.)
2. Wrap the existing enum in a class of the same name. Add the accessor functions, and use them where obvious.
3. Move the non-obvious ones into their own reviews.
4. Change the representation of the class.

The things I spotted are minor, so I can be convinced to approve without splitting, but I would split if it were my patch, if only to convince myself I'd gotten it right.

llvm/lib/Analysis/BasicAliasAnalysis.cpp

789–790

This bit of code is repeated from the diff above. Seems like a candidate for a helper function. (In a follow up change please!)

llvm/lib/Analysis/GlobalsModRef.cpp

241–242

This change doesn't look nfc. Previously, the FunctionInfo could only improve AA results on the function. Now, you can get less precise results if you have a FunctionInfo.

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

419

Same problem as above. Imagine the call was readnone.

[nikic]

llvm/lib/Analysis/BasicAliasAnalysis.cpp

789–790

These two pieces of code work on different types (Function and CallBase) -- but it's probably possible to reuse them with a templated function...

llvm/lib/Analysis/GlobalsModRef.cpp

241–242

The relevant detail here is that AAResultBase::getModRefBehavior(F) actually always returns FunctionModRefBehavior::unknown(), so there is no point in intersecting with it.

The reason why the code was written the way it was is probably a historical leftover: I believe that at some point in the past, this was how AA providers were chained. However, nowadays a different layer is responsible for performing the intersection (AAResults). Individual AA providers only return the best result they can produce based on their own information. It will then get intersected with the results from other AA providers by AAResults.

The AAResultBase methods are only default implementations returning the conservative result for the case where an AA provider does not wish to override a specific method.

I can land the removal of the intersection separately to make it more obvious that this patch doesn't change any behavior.

[reames]

LGTM given @nikic's explanation of why my two concerns are actually addressed.

llvm/lib/Analysis/GlobalsModRef.cpp

241–242

If you could, I'd appreciate it.

[asbirlea]

LGTM.

llvm/lib/Analysis/BasicAliasAnalysis.cpp

770

Yes, I meant initializing to FunctionModRefBehavior::none(), to avoid one codepath of iterating the locations for argmem and/or inaccessible. But if for the whole patch compile-time is not affected, taking this out shouldn't make much of a difference.

[ebrevnov]

I've left some NITs which are not blockers and can be addressed later. LGTM.

llvm/include/llvm/Analysis/AliasAnalysis.h

257

Naming suggestion: readWrite or canReadWrite or doReadWrite.

262

Naming suggestion: noReadWrite() or dontReadWrite.

263

Default constructor makes unnecessary dependence on internals of ModRefInfo. In particular, it relays on NoModRef being 0. My suggestion is to explicitly use anyLoc(ModRefInfo::NoModRef) here (default constructor can be removed then since this looks to be the only use)

308

Do we really need this API? Looks like it is simply a wrapper and equivalent to getWithModRef(Loc, ModRefInfo::NoModRef) call, which I find more readable. WDYT?

352

I believe "(in-place)" should be removed since it returns new instance.

363

I believe "(in-place)" should be removed since it returns new instance.

[nikic]

llvm/include/llvm/Analysis/AliasAnalysis.h

263

Removing the default constructor was a bit tricky because we still do need to initialize Data at some point. What I ended up doing is to drop anyLoc() and instead have a proper FunctionModRefBehavior constructor that only takes a ModRefInfo that applies to all locations.

For now, I have made this constructor explicit, so you have to write FunctionModRefBehavior(MR) or similar to use it. An option (regarding your two comments above) would be to make it non-explicit, so that for example ModRefInfo::Ref could be implicitly converted to FunctionModRefBehavior(ModRefInfo::Ref). I think if I did this, then there would be no need for methods like FunctionModRefBehavior::readOnly(), which has the benefit that there is no need to pick a name for them... It would blur the line between MR and FMRB at bit though. What do you think?

308

I feel like this API does add value -- the typical usage would be as in D130980 to get FMRB without inaccessiblemem or argmem.

Would it be clearer if this wasn't a generic method, but rather something specific to those, like FMRB.getWithoutInaccessibleMem()?

352

Right, the "in-place" comments were on the wrong operators...

[ebrevnov]

llvm/include/llvm/Analysis/AliasAnalysis.h

263

I'm a bit more in favor for the "explicit" version. I think current version is just good enough. Thanks!

308

I feel like this API does add value -- the typical usage would be as in D130980 to get FMRB without inaccessiblemem or argmem.

I personally think this API just makes things harder to understand.
We should either find better name or just use existing API (getWithModRef)

Let's look at the description of getWithoutLoc:

/// Get new FunctionModRefBehavior with NoModRef on the given Loc

This is stated in terms of setting/resetting mod/ref bits for some Loc. I'm having troubles to match this intent with "getWithoutLoc" name. Possible names could be:

resetModRef() or setNoModRef(), etc.

Or just use existing API and pass NoModRef explicitly:

FMRB.setModRef(Loc, ModRefInfo::NoModRef);

Currently we have:
getWithoutLoc(FunctionModRefBehavior::InaccessibleMem);

Would it be clearer if this wasn't a generic method, but rather something specific to those, like FMRB.getWithoutInaccessibleMem()?

I don't think it worths it.

llvm/include/llvm/Analysis/AliasAnalysis.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_ALIASANALYSIS_H
 #define LLVM_ANALYSIS_ALIASANALYSIS_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/MemoryLocation.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <vector>

 unionModRef(const ModRefInfo MRI1, const ModRefInfo MRI2) {
   return MRI1 | MRI2;
 }
 [[deprecated("Use operator & instead")]] [[nodiscard]] inline ModRefInfo
 intersectModRef(const ModRefInfo MRI1, const ModRefInfo 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 {
-  /// Base case is no access to memory.
-  FMRL_Nowhere = 0,
-  /// Access to memory via argument pointers.
-  FMRL_ArgumentPointees = 8,
-  /// Memory that is inaccessible via LLVM IR.
-  FMRL_InaccessibleMem = 16,
-  /// Access to any memory.
-  FMRL_Anywhere = 32 | FMRL_InaccessibleMem | FMRL_ArgumentPointees
-};
+/// Debug print ModRefInfo.
+raw_ostream &operator<<(raw_ostream &OS, ModRefInfo MR);
 
 /// Summary of how a function affects memory in the program.
 ///
 /// Loads from constant globals are not considered memory accesses for this
 /// interface. Also, functions may freely modify stack space local to their
 /// invocation without having to report it through these interfaces.
-enum FunctionModRefBehavior {
-  /// This function does not perform any non-local loads or stores to memory.
-  ///
-  /// This property corresponds to the GCC 'const' attribute.
-  /// This property corresponds to the LLVM IR 'readnone' attribute.
-  /// This property corresponds to the IntrNoMem LLVM intrinsic flag.
-  FMRB_DoesNotAccessMemory =
-      FMRL_Nowhere | static_cast<int>(ModRefInfo::NoModRef),
-
-  /// The only memory references in this function (if it has any) are
-  /// non-volatile loads from objects pointed to by its pointer-typed
-  /// arguments, with arbitrary offsets.
-  ///
-  /// This property corresponds to the combination of the IntrReadMem
-  /// and IntrArgMemOnly LLVM intrinsic flags.
-  FMRB_OnlyReadsArgumentPointees =
-      FMRL_ArgumentPointees | static_cast<int>(ModRefInfo::Ref),
-
-  /// The only memory references in this function (if it has any) are
-  /// non-volatile stores from objects pointed to by its pointer-typed
-  /// arguments, with arbitrary offsets.
-  ///
-  /// This property corresponds to the combination of the IntrWriteMem
-  /// and IntrArgMemOnly LLVM intrinsic flags.
-  FMRB_OnlyWritesArgumentPointees =
-      FMRL_ArgumentPointees | static_cast<int>(ModRefInfo::Mod),
-
-  /// The only memory references in this function (if it has any) are
-  /// non-volatile loads and stores from objects pointed to by its
-  /// pointer-typed arguments, with arbitrary offsets.
-  ///
-  /// This property corresponds to the IntrArgMemOnly LLVM intrinsic flag.
-  FMRB_OnlyAccessesArgumentPointees =
-      FMRL_ArgumentPointees | static_cast<int>(ModRefInfo::ModRef),
-
-  /// The only memory references in this function (if it has any) are
-  /// reads of memory that is otherwise inaccessible via LLVM IR.
-  ///
-  /// This property corresponds to the LLVM IR inaccessiblememonly attribute.
-  FMRB_OnlyReadsInaccessibleMem =
-      FMRL_InaccessibleMem | static_cast<int>(ModRefInfo::Ref),
-
-  /// The only memory references in this function (if it has any) are
-  /// writes to memory that is otherwise inaccessible via LLVM IR.
-  ///
-  /// This property corresponds to the LLVM IR inaccessiblememonly attribute.
-  FMRB_OnlyWritesInaccessibleMem =
-      FMRL_InaccessibleMem | static_cast<int>(ModRefInfo::Mod),
-
-  /// The only memory references in this function (if it has any) are
-  /// references of memory that is otherwise inaccessible via LLVM IR.
-  ///
-  /// This property corresponds to the LLVM IR inaccessiblememonly attribute.
-  FMRB_OnlyAccessesInaccessibleMem =
-      FMRL_InaccessibleMem | static_cast<int>(ModRefInfo::ModRef),
-
-  /// The function may perform non-volatile loads from objects pointed
-  /// to by its pointer-typed arguments, with arbitrary offsets, and
-  /// it may also perform loads of memory that is otherwise
-  /// inaccessible via LLVM IR.
-  ///
-  /// This property corresponds to the LLVM IR
-  /// inaccessiblemem_or_argmemonly attribute.
-  FMRB_OnlyReadsInaccessibleOrArgMem = FMRL_InaccessibleMem |
-                                       FMRL_ArgumentPointees |
-                                       static_cast<int>(ModRefInfo::Ref),
-
-  /// The function may perform non-volatile stores to objects pointed
-  /// to by its pointer-typed arguments, with arbitrary offsets, and
-  /// it may also perform stores of memory that is otherwise
-  /// inaccessible via LLVM IR.
-  ///
-  /// This property corresponds to the LLVM IR
-  /// inaccessiblemem_or_argmemonly attribute.
-  FMRB_OnlyWritesInaccessibleOrArgMem = FMRL_InaccessibleMem |
-                                        FMRL_ArgumentPointees |
-                                        static_cast<int>(ModRefInfo::Mod),
-
-  /// The function may perform non-volatile loads and stores of objects
-  /// pointed to by its pointer-typed arguments, with arbitrary offsets, and
-  /// it may also perform loads and stores of memory that is otherwise
-  /// inaccessible via LLVM IR.
-  ///
-  /// This property corresponds to the LLVM IR
-  /// inaccessiblemem_or_argmemonly attribute.
-  FMRB_OnlyAccessesInaccessibleOrArgMem = FMRL_InaccessibleMem |
-                                          FMRL_ArgumentPointees |
-                                          static_cast<int>(ModRefInfo::ModRef),
+class FunctionModRefBehavior {
+public:
+  /// The locations at which a function might access memory.
+  enum Location {
+    /// Access to memory via argument pointers.
+    ArgMem = 0,
+    /// Memory that is inaccessible via LLVM IR.
+    InaccessibleMem = 1,
+    /// Any other memory.
+    Other = 2,
+  };
 
-  /// This function does not perform any non-local stores or volatile loads,
-  /// but may read from any memory location.
-  ///
-  /// This property corresponds to the GCC 'pure' attribute.
-  /// This property corresponds to the LLVM IR 'readonly' attribute.
-  /// This property corresponds to the IntrReadMem LLVM intrinsic flag.
-  FMRB_OnlyReadsMemory = FMRL_Anywhere | static_cast<int>(ModRefInfo::Ref),
+private:
+  uint32_t Data = 0;
 
-  // This function does not read from memory anywhere, but may write to any
-  // memory location.
-  //
-  // This property corresponds to the LLVM IR 'writeonly' attribute.
-  // This property corresponds to the IntrWriteMem LLVM intrinsic flag.
-  FMRB_OnlyWritesMemory = FMRL_Anywhere | static_cast<int>(ModRefInfo::Mod),
-
-  /// This indicates that the function could not be classified into one of the
-  /// behaviors above.
-  FMRB_UnknownModRefBehavior =
-      FMRL_Anywhere | static_cast<int>(ModRefInfo::ModRef)
-};
-
-// 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.
-[[nodiscard]] inline ModRefInfo
-createModRefInfo(const FunctionModRefBehavior FMRB) {
-  return ModRefInfo(FMRB & static_cast<int>(ModRefInfo::ModRef));
+  static constexpr uint32_t BitsPerLoc = 2;
+  static constexpr uint32_t LocMask = (1 << BitsPerLoc) - 1;
+
+  static uint32_t getLocationPos(Location Loc) {
+    return (uint32_t)Loc * BitsPerLoc;
+  }
+
+  static auto locations() {
+    return enum_seq_inclusive(Location::ArgMem, Location::Other,
+                              force_iteration_on_noniterable_enum);
+  }
+
+  FunctionModRefBehavior(uint32_t Data) : Data(Data) {}
+
+  void setModRef(Location Loc, ModRefInfo MR) {
+    Data &= ~(LocMask << getLocationPos(Loc));
+    Data |= static_cast<uint32_t>(MR) << getLocationPos(Loc);
+  }
+
+  friend raw_ostream &operator<<(raw_ostream &OS, FunctionModRefBehavior RMRB);
+
+public:
+  /// Create FunctionModRefBehavior that can access only the given location
+  /// with the given ModRefInfo.
+  FunctionModRefBehavior(Location Loc, ModRefInfo MR) { setModRef(Loc, MR); }
+
+  /// Create FunctionModRefBehavior that can access any location with the
+  /// given ModRefInfo.
+  explicit FunctionModRefBehavior(ModRefInfo MR) {
+    for (Location Loc : locations())
+      setModRef(Loc, MR);
+  }
+
+  /// Create FunctionModRefBehavior that can read and write any memory.
+  static FunctionModRefBehavior unknown() {
+    return FunctionModRefBehavior(ModRefInfo::ModRef);
+  }
+
+  /// Create FunctionModRefBehavior that cannot read or write any memory.
+  static FunctionModRefBehavior none() {
+    return FunctionModRefBehavior(ModRefInfo::NoModRef);
+  }
+
+  /// Create FunctionModRefBehavior that can read any memory.
+  static FunctionModRefBehavior readOnly() {
+    return FunctionModRefBehavior(ModRefInfo::Ref);
+  }
+
+  /// Create FunctionModRefBehavior that can write any memory.
+  static FunctionModRefBehavior writeOnly() {
+    return FunctionModRefBehavior(ModRefInfo::Mod);
+  }
+
+  /// Create FunctionModRefBehavior that can only access argument memory.
+  static FunctionModRefBehavior argMemOnly(ModRefInfo MR) {
+    return FunctionModRefBehavior(ArgMem, MR);
+  }
+
+  /// Create FunctionModRefBehavior that can only access inaccessible memory.
+  static FunctionModRefBehavior inaccessibleMemOnly(ModRefInfo MR) {
+    return FunctionModRefBehavior(InaccessibleMem, MR);
+  }
+
+  /// Create FunctionModRefBehavior that can only access inaccessible or
+  /// argument memory.
+  static FunctionModRefBehavior inaccessibleOrArgMemOnly(ModRefInfo MR) {
+    FunctionModRefBehavior FRMB = none();
+    FRMB.setModRef(ArgMem, MR);
+    FRMB.setModRef(InaccessibleMem, MR);
+    return FRMB;
+  }
+
+  /// Get ModRefInfo for the given Location.
+  ModRefInfo getModRef(Location Loc) const {
+    return ModRefInfo((Data >> getLocationPos(Loc)) & LocMask);
+  }
+
+  /// Get new FunctionModRefBehavior with modified ModRefInfo for Loc.
+  FunctionModRefBehavior getWithModRef(Location Loc, ModRefInfo MR) const {
+    FunctionModRefBehavior FMRB = *this;
+    FMRB.setModRef(Loc, MR);
+    return FMRB;
   }
 
+  /// Get new FunctionModRefBehavior with NoModRef on the given Loc.
+  FunctionModRefBehavior getWithoutLoc(Location Loc) const {
+    FunctionModRefBehavior FMRB = *this;
+    FMRB.setModRef(Loc, ModRefInfo::NoModRef);
+    return FMRB;
+  }
+
+  /// Get ModRefInfo for any location.
+  ModRefInfo getModRef() const {
+    ModRefInfo MR = ModRefInfo::NoModRef;
+    for (Location Loc : locations())
+      MR |= getModRef(Loc);
+    return MR;
+  }
+
+  /// Whether this function accesses no memory.
+  bool doesNotAccessMemory() const { return Data == 0; }
+
+  /// Whether this function only (at most) reads memory.
+  bool onlyReadsMemory() const { return !isModSet(getModRef()); }
+
+  /// Whether this function only (at most) writes memory.
+  bool onlyWritesMemory() const { return !isRefSet(getModRef()); }
+
+  /// Whether this function only (at most) accesses argument memory.
+  bool onlyAccessesArgPointees() const {
+    return getWithoutLoc(ArgMem).doesNotAccessMemory();
+  }
+
+  /// Whether this function may access argument memory.
+  bool doesAccessArgPointees() const {
+    return isModOrRefSet(getModRef(ArgMem));
+  }
+
+  /// Whether this function only (at most) accesses inaccessible memory.
+  bool onlyAccessesInaccessibleMem() const {
+    return getWithoutLoc(InaccessibleMem).doesNotAccessMemory();
+  }
+
+  /// Whether this function only (at most) accesses argument and inaccessible
+  /// memory.
+  bool onlyAccessesInaccessibleOrArgMem() const {
+    return isNoModRef(getModRef(Other));
+  }
+
+  /// Intersect with another FunctionModRefBehavior.
+  FunctionModRefBehavior operator&(FunctionModRefBehavior Other) const {
+    return FunctionModRefBehavior(Data & Other.Data);
+  }
+
+  /// Intersect (in-place) with another FunctionModRefBehavior.
+  FunctionModRefBehavior &operator&=(FunctionModRefBehavior Other) {
+    Data &= Other.Data;
+    return *this;
+  }
+
+  /// Union with another FunctionModRefBehavior.
+  FunctionModRefBehavior operator|(FunctionModRefBehavior Other) const {
+    return FunctionModRefBehavior(Data | Other.Data);
+  }
+
+  /// Union (in-place) with another FunctionModRefBehavior.
+  FunctionModRefBehavior &operator|=(FunctionModRefBehavior Other) {
+    Data |= Other.Data;
+    return *this;
+  }
+
+  /// Check whether this is the same as another FunctionModRefBehavior.
+  bool operator==(FunctionModRefBehavior Other) const {
+    return Data == Other.Data;
+  }
+
+  /// Check whether this is different from another FunctionModRefBehavior.
+  bool operator!=(FunctionModRefBehavior Other) const {
+    return !operator==(Other);
+  }
+};
+
+/// Debug print FunctionModRefBehavior.
+raw_ostream &operator<<(raw_ostream &OS, FunctionModRefBehavior RMRB);
+
 /// Virtual base class for providers of capture information.
 struct CaptureInfo {
   virtual ~CaptureInfo() = 0;
   virtual bool isNotCapturedBeforeOrAt(const Value *Object,
                                        const Instruction *I) = 0;
 };
 
 /// Context-free CaptureInfo provider, which computes and caches whether an
public:
   /// this predicate.
   ///
   /// Many optimizations (such as CSE and LICM) can be performed on such calls
   /// without worrying about aliasing properties, and many calls have this
   /// property (e.g. calls to 'sin' and 'cos').
   ///
   /// This property corresponds to the GCC 'const' attribute.
   bool doesNotAccessMemory(const CallBase *Call) {
-    return getModRefBehavior(Call) == FMRB_DoesNotAccessMemory;
+    return getModRefBehavior(Call).doesNotAccessMemory();
   }
 
   /// Checks if the specified function is known to never read or write memory.
   ///
   /// Note that if the function only reads from known-constant memory, it is
   /// also legal to return true. Also, function that unwind the stack are legal
   /// for this predicate.
   ///
   /// Many optimizations (such as CSE and LICM) can be performed on such calls
   /// to such functions without worrying about aliasing properties, and many
   /// functions have this property (e.g. 'sin' and 'cos').
   ///
   /// This property corresponds to the GCC 'const' attribute.
   bool doesNotAccessMemory(const Function *F) {
-    return getModRefBehavior(F) == FMRB_DoesNotAccessMemory;
+    return getModRefBehavior(F).doesNotAccessMemory();
   }
 
   /// Checks if the specified call is known to only read from non-volatile
   /// memory (or not access memory at all).
   ///
   /// Calls that unwind the stack are legal for this predicate.
   ///
   /// This property allows many common optimizations to be performed in the
   /// absence of interfering store instructions, such as CSE of strlen calls.
   ///
   /// This property corresponds to the GCC 'pure' attribute.
   bool onlyReadsMemory(const CallBase *Call) {
-    return onlyReadsMemory(getModRefBehavior(Call));
+    return getModRefBehavior(Call).onlyReadsMemory();
   }
 
   /// Checks if the specified function is known to only read from non-volatile
   /// memory (or not access memory at all).
   ///
   /// Functions that unwind the stack are legal for this predicate.
   ///
   /// This property allows many common optimizations to be performed in the
   /// absence of interfering store instructions, such as CSE of strlen calls.
   ///
   /// This property corresponds to the GCC 'pure' attribute.
   bool onlyReadsMemory(const Function *F) {
-    return onlyReadsMemory(getModRefBehavior(F));
-  }
-
-  /// Checks if functions with the specified behavior are known to only read
-  /// from non-volatile memory (or not access memory at all).
-  static bool onlyReadsMemory(FunctionModRefBehavior MRB) {
-    return !isModSet(createModRefInfo(MRB));
-  }
-
-  /// Checks if functions with the specified behavior are known to only write
-  /// memory (or not access memory at all).
-  static bool onlyWritesMemory(FunctionModRefBehavior MRB) {
-    return !isRefSet(createModRefInfo(MRB));
-  }
-
-  /// Checks if functions with the specified behavior are known to read and
-  /// write at most from objects pointed to by their pointer-typed arguments
-  /// (with arbitrary offsets).
-  static bool onlyAccessesArgPointees(FunctionModRefBehavior MRB) {
-    return !((unsigned)MRB & FMRL_Anywhere & ~FMRL_ArgumentPointees);
-  }
-
-  /// Checks if functions with the specified behavior are known to potentially
-  /// read or write from objects pointed to be their pointer-typed arguments
-  /// (with arbitrary offsets).
-  static bool doesAccessArgPointees(FunctionModRefBehavior MRB) {
-    return isModOrRefSet(createModRefInfo(MRB)) &&
-           ((unsigned)MRB & FMRL_ArgumentPointees);
-  }
-
-  /// Checks if functions with the specified behavior are known to read and
-  /// write at most from memory that is inaccessible from LLVM IR.
-  static bool onlyAccessesInaccessibleMem(FunctionModRefBehavior MRB) {
-    return !((unsigned)MRB & FMRL_Anywhere & ~FMRL_InaccessibleMem);
-  }
-
-  /// Checks if functions with the specified behavior are known to potentially
-  /// read or write from memory that is inaccessible from LLVM IR.
-  static bool doesAccessInaccessibleMem(FunctionModRefBehavior MRB) {
-    return isModOrRefSet(createModRefInfo(MRB)) &&
-             ((unsigned)MRB & FMRL_InaccessibleMem);
-  }
-
-  /// Checks if functions with the specified behavior are known to read and
-  /// write at most from memory that is inaccessible from LLVM IR or objects
-  /// pointed to by their pointer-typed arguments (with arbitrary offsets).
-  static bool onlyAccessesInaccessibleOrArgMem(FunctionModRefBehavior MRB) {
-    return !((unsigned)MRB & FMRL_Anywhere &
-             ~(FMRL_InaccessibleMem | FMRL_ArgumentPointees));
+    return getModRefBehavior(F).onlyReadsMemory();
   }
 
   /// getModRefInfo (for call sites) - Return information about whether
   /// a particular call site modifies or reads the specified memory location.
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc);
 
   /// getModRefInfo (for call sites) - A convenience wrapper.
   ModRefInfo getModRefInfo(const CallBase *Call, const Value *P,
bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI,
     return false;
   }
 
   ModRefInfo getArgModRefInfo(const CallBase *Call, unsigned ArgIdx) {
     return ModRefInfo::ModRef;
   }
 
   FunctionModRefBehavior getModRefBehavior(const CallBase *Call) {
-    return FMRB_UnknownModRefBehavior;
+    return FunctionModRefBehavior::unknown();
   }
 
   FunctionModRefBehavior getModRefBehavior(const Function *F) {
-    return FMRB_UnknownModRefBehavior;
+    return FunctionModRefBehavior::unknown();
   }
 
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI) {
     return ModRefInfo::ModRef;
   }
 
   ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2,

llvm/lib/Analysis/AliasAnalysis.cpp

for (const auto &AA : AAs) {
     // 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))
+  if (MRB.onlyAccessesInaccessibleMem())
     return ModRefInfo::NoModRef;
 
-  if (onlyReadsMemory(MRB))
-    Result &= ModRefInfo::Ref;
-  else if (onlyWritesMemory(MRB))
-    Result &= ModRefInfo::Mod;
+  // TODO: Exclude inaccessible memory location here.
+  Result &= MRB.getModRef();
 
-  if (onlyAccessesArgPointees(MRB) || onlyAccessesInaccessibleOrArgMem(MRB)) {
+  if (MRB.onlyAccessesArgPointees() || MRB.onlyAccessesInaccessibleOrArgMem()) {
     ModRefInfo AllArgsMask = ModRefInfo::NoModRef;
-    if (doesAccessArgPointees(MRB)) {
+    if (MRB.doesAccessArgPointees()) {
       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 (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.
 
   // If Call1 or Call2 are readnone, they don't interact.
   auto Call1B = getModRefBehavior(Call1);
-  if (Call1B == FMRB_DoesNotAccessMemory)
+  if (Call1B.doesNotAccessMemory())
     return ModRefInfo::NoModRef;
 
   auto Call2B = getModRefBehavior(Call2);
-  if (Call2B == FMRB_DoesNotAccessMemory)
+  if (Call2B.doesNotAccessMemory())
     return ModRefInfo::NoModRef;
 
   // If they both only read from memory, there is no dependence.
-  if (onlyReadsMemory(Call1B) && onlyReadsMemory(Call2B))
+  if (Call1B.onlyReadsMemory() && Call2B.onlyReadsMemory())
     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))
+  if (Call1B.onlyReadsMemory())
     Result &= ModRefInfo::Ref;
-  else if (onlyWritesMemory(Call1B))
+  else if (Call1B.onlyWritesMemory())
     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))
+  if (Call2B.onlyAccessesArgPointees()) {
+    if (!Call2B.doesAccessArgPointees())
       return ModRefInfo::NoModRef;
     ModRefInfo R = ModRefInfo::NoModRef;
     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 =
for (auto I = Call2->arg_begin(), E = Call2->arg_end(); I != E; ++I) {
         break;
     }
 
     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))
+  if (Call1B.onlyAccessesArgPointees()) {
+    if (!Call1B.doesAccessArgPointees())
       return ModRefInfo::NoModRef;
     ModRefInfo R = ModRefInfo::NoModRef;
     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 =
if (Call1B.onlyAccessesArgPointees()) {
 
     return R;
   }
 
   return Result;
 }
 
 FunctionModRefBehavior AAResults::getModRefBehavior(const CallBase *Call) {
-  FunctionModRefBehavior Result = FMRB_UnknownModRefBehavior;
+  FunctionModRefBehavior Result = FunctionModRefBehavior::unknown();
 
   for (const auto &AA : AAs) {
-    Result = FunctionModRefBehavior(Result & AA->getModRefBehavior(Call));
+    Result &= AA->getModRefBehavior(Call);
 
     // Early-exit the moment we reach the bottom of the lattice.
-    if (Result == FMRB_DoesNotAccessMemory)
+    if (Result.doesNotAccessMemory())
       return Result;
   }
 
   return Result;
 }
 
 FunctionModRefBehavior AAResults::getModRefBehavior(const Function *F) {
-  FunctionModRefBehavior Result = FMRB_UnknownModRefBehavior;
+  FunctionModRefBehavior Result = FunctionModRefBehavior::unknown();
 
   for (const auto &AA : AAs) {
-    Result = FunctionModRefBehavior(Result & AA->getModRefBehavior(F));
+    Result &= AA->getModRefBehavior(F);
 
     // Early-exit the moment we reach the bottom of the lattice.
-    if (Result == FMRB_DoesNotAccessMemory)
+    if (Result.doesNotAccessMemory())
       return Result;
   }
 
   return Result;
 }
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, AliasResult AR) {
   switch (AR) {
case AliasResult::PartialAlias:
     OS << "PartialAlias";
     if (AR.hasOffset())
       OS << " (off " << AR.getOffset() << ")";
     break;
   }
   return OS;
 }
 
+raw_ostream &llvm::operator<<(raw_ostream &OS, ModRefInfo MR) {
+  switch (MR) {
+  case ModRefInfo::NoModRef:
+    OS << "NoModRef";
+    break;
+  case ModRefInfo::Ref:
+    OS << "Ref";
+    break;
+  case ModRefInfo::Mod:
+    OS << "Mod";
+    break;
+  case ModRefInfo::ModRef:
+    OS << "ModRef";
+    break;
+  }
+  return OS;
+}
+
+raw_ostream &llvm::operator<<(raw_ostream &OS, FunctionModRefBehavior FMRB) {
+  for (FunctionModRefBehavior::Location Loc :
+       FunctionModRefBehavior::locations()) {
+    switch (Loc) {
+    case FunctionModRefBehavior::ArgMem:
+      OS << "ArgMem: ";
+      break;
+    case FunctionModRefBehavior::InaccessibleMem:
+      OS << "InaccessibleMem: ";
+      break;
+    case FunctionModRefBehavior::Other:
+      OS << "Other: ";
+      break;
+    }
+    OS << FMRB.getModRef(Loc) << ", ";
+  }
+  return OS;
+}
+
 //===----------------------------------------------------------------------===//
 // Helper method implementation
 //===----------------------------------------------------------------------===//
 
 ModRefInfo AAResults::getModRefInfo(const LoadInst *L,
                                     const MemoryLocation &Loc) {
   SimpleAAQueryInfo AAQIP;
   return getModRefInfo(L, Loc, AAQIP);
ModRefInfo AAResults::getModRefInfo(const AtomicRMWInst *RMW,
 
   return ModRefInfo::ModRef;
 }
 
 ModRefInfo AAResults::getModRefInfo(const Instruction *I,
                                     const Optional<MemoryLocation> &OptLoc,
                                     AAQueryInfo &AAQIP) {
   if (OptLoc == None) {
-    if (const auto *Call = dyn_cast<CallBase>(I)) {
-      return createModRefInfo(getModRefBehavior(Call));
-    }
+    if (const auto *Call = dyn_cast<CallBase>(I))
+      return getModRefBehavior(Call).getModRef();
   }
 
   const MemoryLocation &Loc = OptLoc.value_or(MemoryLocation());
 
   switch (I->getOpcode()) {
   case Instruction::VAArg:
     return getModRefInfo((const VAArgInst *)I, Loc, AAQIP);
   case Instruction::Load:

llvm/lib/Analysis/AliasSetTracker.cpp

if (Call->onlyAccessesArgMemory()) {
         else if (isModSet(MRI))
           return AliasSet::ModAccess;
         else if (isRefSet(MRI))
           return AliasSet::RefAccess;
         else
           return AliasSet::NoAccess;
       };
 
-      ModRefInfo CallMask = createModRefInfo(AA.getModRefBehavior(Call));
+      ModRefInfo CallMask = AA.getModRefBehavior(Call).getModRef();
 
       // 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 &= ModRefInfo::Ref;

llvm/lib/Analysis/BasicAliasAnalysis.cpp

static bool isIntrinsicCall(const CallBase *Call, Intrinsic::ID IID) {
   const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Call);
   return II && II->getIntrinsicID() == IID;
 }
 
 /// Returns the behavior when calling the given call site.
 FunctionModRefBehavior BasicAAResult::getModRefBehavior(const CallBase *Call) {
   if (Call->doesNotAccessMemory())
     // Can't do better than this.
-    return FMRB_DoesNotAccessMemory;
-
-  FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior;
+    return FunctionModRefBehavior::none();
 
   // If the callsite knows it only reads memory, don't return worse
   // than that.
+  ModRefInfo MR = ModRefInfo::ModRef;
   if (Call->onlyReadsMemory())
-    Min = FMRB_OnlyReadsMemory;
+    MR = ModRefInfo::Ref;
   else if (Call->onlyWritesMemory())
-    Min = FMRB_OnlyWritesMemory;
+    MR = ModRefInfo::Mod;
 
+  FunctionModRefBehavior Min(MR);
   if (Call->onlyAccessesArgMemory())
-    Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesArgumentPointees);
+    Min = FunctionModRefBehavior::argMemOnly(MR);
   else if (Call->onlyAccessesInaccessibleMemory())
-    Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleMem);
+    Min = FunctionModRefBehavior::inaccessibleMemOnly(MR);
   else if (Call->onlyAccessesInaccessibleMemOrArgMem())
-    Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleOrArgMem);
+    Min = FunctionModRefBehavior::inaccessibleOrArgMemOnly(MR);
 
   // If the call has operand bundles then aliasing attributes from the function
   // it calls do not directly apply to the call.  This can be made more precise
   // in the future.
   if (!Call->hasOperandBundles())
     if (const Function *F = Call->getCalledFunction())
-      Min =
-          FunctionModRefBehavior(Min & getBestAAResults().getModRefBehavior(F));
+      Min &= getBestAAResults().getModRefBehavior(F);
 
   return Min;
 }
 
 /// Returns the behavior when calling the given function. For use when the call
 /// site is not known.
 FunctionModRefBehavior BasicAAResult::getModRefBehavior(const Function *F) {
   // If the function declares it doesn't access memory, we can't do better.
   if (F->doesNotAccessMemory())
-    return FMRB_DoesNotAccessMemory;
-
-  FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior;
+    return FunctionModRefBehavior::none();
 
   // If the function declares it only reads memory, go with that.
+  ModRefInfo MR = ModRefInfo::ModRef;
   if (F->onlyReadsMemory())
-    Min = FMRB_OnlyReadsMemory;
+    MR = ModRefInfo::Ref;
   else if (F->onlyWritesMemory())
-    Min = FMRB_OnlyWritesMemory;
+    MR = ModRefInfo::Mod;
 
   if (F->onlyAccessesArgMemory())
-    Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesArgumentPointees);
-  else if (F->onlyAccessesInaccessibleMemory())
-    Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleMem);
-  else if (F->onlyAccessesInaccessibleMemOrArgMem())
-    Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleOrArgMem);
-
-  return Min;
+    return FunctionModRefBehavior::argMemOnly(MR);
+  if (F->onlyAccessesInaccessibleMemory())
+    return FunctionModRefBehavior::inaccessibleMemOnly(MR);
+  if (F->onlyAccessesInaccessibleMemOrArgMem())
+    return FunctionModRefBehavior::inaccessibleOrArgMemOnly(MR);
+  return FunctionModRefBehavior(MR);
 }
 
 /// Returns true if this is a writeonly (i.e Mod only) parameter.
 static bool isWriteOnlyParam(const CallBase *Call, unsigned ArgIdx,
                              const TargetLibraryInfo &TLI) {
   if (Call->paramHasAttr(ArgIdx, Attribute::WriteOnly))
     return true;
 
ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call1,
   // *Unlike* assumes, guard intrinsics are modeled as reading memory since the
   // heap state at the point the guard is issued needs to be consistent in case
   // the guard invokes the "deopt" continuation.
 
   // NB! This function is *not* commutative, so we special case two
   // possibilities for guard intrinsics.
 
   if (isIntrinsicCall(Call1, Intrinsic::experimental_guard))
-    return isModSet(createModRefInfo(getModRefBehavior(Call2)))
+    return isModSet(getModRefBehavior(Call2).getModRef())
                ? ModRefInfo::Ref
                : ModRefInfo::NoModRef;
 
   if (isIntrinsicCall(Call2, Intrinsic::experimental_guard))
-    return isModSet(createModRefInfo(getModRefBehavior(Call1)))
+    return isModSet(getModRefBehavior(Call1).getModRef())
                ? ModRefInfo::Mod
                : ModRefInfo::NoModRef;
 
   // The AAResultBase base class has some smarts, lets use them.
   return AAResultBase::getModRefInfo(Call1, Call2, AAQI);
 }
 
 /// Return true if we know V to the base address of the corresponding memory

llvm/lib/Analysis/GlobalsModRef.cpp

void GlobalsAAResult::DeletionCallbackHandle::deleted() {
   GAR->AllocsForIndirectGlobals.erase(V);
 
   // And clear out the handle.
   setValPtr(nullptr);
   GAR->Handles.erase(I);
   // This object is now destroyed!
 }
 
 FunctionModRefBehavior GlobalsAAResult::getModRefBehavior(const Function *F) {
-  if (FunctionInfo *FI = getFunctionInfo(F)) {
-    if (!isModOrRefSet(FI->getModRefInfo()))
-      return FMRB_DoesNotAccessMemory;
-    else if (!isModSet(FI->getModRefInfo()))
-      return FMRB_OnlyReadsMemory;
-  }
+  if (FunctionInfo *FI = getFunctionInfo(F))
+    return FunctionModRefBehavior(FI->getModRefInfo());
 
   return AAResultBase::getModRefBehavior(F);
 }
 
 /// Returns the function info for the function, or null if we don't have
 /// anything useful to say about it.
 GlobalsAAResult::FunctionInfo *
 GlobalsAAResult::getFunctionInfo(const Function *F) {
for (auto *Node : SCC) {
             // The callgraph doesn't include intrinsic calls.
             if (Callee->isIntrinsic()) {
               if (isa<DbgInfoIntrinsic>(Call))
                 // Don't let dbg intrinsics affect alias info.
                 continue;
 
               FunctionModRefBehavior Behaviour =
                   AAResultBase::getModRefBehavior(Callee);
-              FI.addModRefInfo(createModRefInfo(Behaviour));
+              FI.addModRefInfo(Behaviour.getModRef());
             }
           }
           continue;
         }
 
         // All non-call instructions we use the primary predicates for whether
         // they read or write memory.
         if (I.mayReadFromMemory())

llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp

 }
 
 FunctionModRefBehavior ObjCARCAAResult::getModRefBehavior(const Function *F) {
   if (!EnableARCOpts)
     return AAResultBase::getModRefBehavior(F);
 
   switch (GetFunctionClass(F)) {
   case ARCInstKind::NoopCast:
-    return FMRB_DoesNotAccessMemory;
+    return FunctionModRefBehavior::none();
   default:
     break;
   }
 
   return AAResultBase::getModRefBehavior(F);
 }
 
 ModRefInfo ObjCARCAAResult::getModRefInfo(const CallBase *Call,

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

TypeBasedAAResult::getModRefBehavior(const CallBase *Call) {
   if (!EnableTBAA)
     return AAResultBase::getModRefBehavior(Call);
 
   // If this is an "immutable" type, we can assume the call doesn't write
   // to memory.
   if (const MDNode *M = Call->getMetadata(LLVMContext::MD_tbaa))
     if ((!isStructPathTBAA(M) && TBAANode(M).isTypeImmutable()) ||
         (isStructPathTBAA(M) && TBAAStructTagNode(M).isTypeImmutable()))
-      return FMRB_OnlyReadsMemory;
+      return FunctionModRefBehavior::readOnly();
 
   return AAResultBase::getModRefBehavior(Call);
 }
 
 FunctionModRefBehavior TypeBasedAAResult::getModRefBehavior(const Function *F) {
   // Functions don't have metadata. Just chain to the next implementation.
   return AAResultBase::getModRefBehavior(F);
 }
 
 ModRefInfo TypeBasedAAResult::getModRefInfo(const CallBase *Call,

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

 /// return a result pertaining to this copy of the function. If it is false, the
 /// result will be based only on AA results for the function declaration; it
 /// will be assumed that some other (perhaps less optimized) version of the
 /// function may be selected at link time.
 static FunctionModRefBehavior
 checkFunctionMemoryAccess(Function &F, bool ThisBody, AAResults &AAR,
                           const SCCNodeSet &SCCNodes) {
   FunctionModRefBehavior MRB = AAR.getModRefBehavior(&F);
-  if (MRB == FMRB_DoesNotAccessMemory)
+  if (MRB.doesNotAccessMemory())
     // Already perfect!
     return MRB;
 
   if (!ThisBody)
     return MRB;
 
+  // TODO: We should directly populate a FunctionModRefBehavior here.
   // Scan the function body for instructions that may read or write memory.
-  bool ReadsMemory = false;
-  bool WritesMemory = false;
+  ModRefInfo MR = ModRefInfo::NoModRef;
   // Track if the function accesses memory not based on pointer arguments or
   // allocas.
   bool AccessesNonArgsOrAlloca = false;
   // Returns true if Ptr is not based on a function argument.
   auto IsArgumentOrAlloca = [](const Value *Ptr) {
     const Value *UO = getUnderlyingObject(Ptr);
     return isa<Argument>(UO) || isa<AllocaInst>(UO);
   };
   for (Instruction &I : instructions(F)) {
     // Some instructions can be ignored even if they read or write memory.
     // Detect these now, skipping to the next instruction if one is found.
     if (auto *Call = dyn_cast<CallBase>(&I)) {
       // Ignore calls to functions in the same SCC, as long as the call sites
       // don't have operand bundles.  Calls with operand bundles are allowed to
       // have memory effects not described by the memory effects of the call
       // target.
       if (!Call->hasOperandBundles() && Call->getCalledFunction() &&
           SCCNodes.count(Call->getCalledFunction()))
         continue;
       FunctionModRefBehavior MRB = AAR.getModRefBehavior(Call);
-      ModRefInfo MRI = createModRefInfo(MRB);
+      ModRefInfo MRI = MRB.getModRef();
 
       // If the call doesn't access memory, we're done.
       if (isNoModRef(MRI))
         continue;
 
       // A pseudo probe call shouldn't change any function attribute since it
       // doesn't translate to a real instruction. It comes with a memory access
       // tag to prevent itself being removed by optimizations and not block
       // other instructions being optimized.
       if (isa<PseudoProbeInst>(I))
         continue;
 
-      if (!AliasAnalysis::onlyAccessesArgPointees(MRB)) {
-        // The call could access any memory. If that includes writes, note it.
-        if (isModSet(MRI))
-          WritesMemory = true;
-        // If it reads, note it.
-        if (isRefSet(MRI))
-          ReadsMemory = true;
+      if (!MRB.onlyAccessesArgPointees()) {
+        // The call could access any memory.
+        MR |= MRI;
         AccessesNonArgsOrAlloca = true;
         continue;
       }
 
       // Check whether all pointer arguments point to local memory, and
       // ignore calls that only access local memory.
       for (const Use &U : Call->args()) {
         const Value *Arg = U;
         if (!Arg->getType()->isPtrOrPtrVectorTy())
           continue;
 
         MemoryLocation Loc =
             MemoryLocation::getBeforeOrAfter(Arg, I.getAAMetadata());
         // Skip accesses to local or constant memory as they don't impact the
         // externally visible mod/ref behavior.
         if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
           continue;
 
         AccessesNonArgsOrAlloca |= !IsArgumentOrAlloca(Loc.Ptr);
-
-        if (isModSet(MRI))
-          // Writes non-local memory.
-          WritesMemory = true;
-        if (isRefSet(MRI))
-          // Ok, it reads non-local memory.
-          ReadsMemory = true;
+        MR |= MRI;
       }
       continue;
     } else if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
       MemoryLocation Loc = MemoryLocation::get(LI);
       // Ignore non-volatile loads from local memory. (Atomic is okay here.)
       if (!LI->isVolatile() &&
           AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
         continue;
if (auto *Call = dyn_cast<CallBase>(&I)) {
       // conservatively.
       AccessesNonArgsOrAlloca |= I.mayReadOrWriteMemory();
     }
 
     // Any remaining instructions need to be taken seriously!  Check if they
     // read or write memory.
     //
     // Writes memory, remember that.
-    WritesMemory |= I.mayWriteToMemory();
+    if (I.mayWriteToMemory())
+      MR |= ModRefInfo::Mod;
 
     // If this instruction may read memory, remember that.
-    ReadsMemory |= I.mayReadFromMemory();
+    if (I.mayReadFromMemory())
+      MR |= ModRefInfo::Ref;
   }
 
-  if (!WritesMemory && !ReadsMemory)
-    return FMRB_DoesNotAccessMemory;
-
-  FunctionModRefBehavior Result = FunctionModRefBehavior(FMRL_Anywhere);
   if (!AccessesNonArgsOrAlloca)
-    Result = FunctionModRefBehavior(FMRL_ArgumentPointees);
-  if (WritesMemory)
-    Result = FunctionModRefBehavior(Result | static_cast<int>(ModRefInfo::Mod));
-  if (ReadsMemory)
-    Result = FunctionModRefBehavior(Result | static_cast<int>(ModRefInfo::Ref));
-  return Result;
+    return FunctionModRefBehavior::argMemOnly(MR);
+  return FunctionModRefBehavior(MR);
 }
 
 FunctionModRefBehavior llvm::computeFunctionBodyMemoryAccess(Function &F,
                                                              AAResults &AAR) {
   return checkFunctionMemoryAccess(F, /*ThisBody=*/true, AAR, {});
 }
 
 /// Deduce readonly/readnone/writeonly attributes for the SCC.
static void addMemoryAttrs(const SCCNodeSet &SCCNodes, AARGetterT &&AARGetter,
   for (Function *F : SCCNodes) {
     // Call the callable parameter to look up AA results for this function.
     AAResults &AAR = AARGetter(*F);
     // Non-exact function definitions may not be selected at link time, and an
     // alternative version that writes to memory may be selected.  See the
     // comment on GlobalValue::isDefinitionExact for more details.
     FunctionModRefBehavior FMRB =
         checkFunctionMemoryAccess(*F, F->hasExactDefinition(), AAR, SCCNodes);
-    if (FMRB == FMRB_DoesNotAccessMemory)
+    if (FMRB.doesNotAccessMemory())
       continue;
-    ModRefInfo MR = createModRefInfo(FMRB);
+    ModRefInfo MR = FMRB.getModRef();
     ReadsMemory |= isRefSet(MR);
     WritesMemory |= isModSet(MR);
-    ArgMemOnly &= AliasAnalysis::onlyAccessesArgPointees(FMRB);
+    ArgMemOnly &= FMRB.onlyAccessesArgPointees();
     // Reached neither readnone, readonly, writeonly nor argmemonly can be
     // inferred. Exit.
     if (ReadsMemory && WritesMemory && !ArgMemOnly)
       return;
   }
 
   assert((!ReadsMemory || !WritesMemory || ArgMemOnly) &&
          "no memory attributes can be added for this SCC, should have exited "

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

if (HasTypeMetadata(&GV)) {
             !F->arg_begin()->use_empty())
           return;
         for (auto &Arg : drop_begin(F->args())) {
           auto *ArgT = dyn_cast<IntegerType>(Arg.getType());
           if (!ArgT || ArgT->getBitWidth() > 64)
             return;
         }
         if (!F->isDeclaration() &&
-            computeFunctionBodyMemoryAccess(*F, AARGetter(*F)) ==
-                FMRB_DoesNotAccessMemory)
+            computeFunctionBodyMemoryAccess(*F, AARGetter(*F))
+                .doesNotAccessMemory())
           EligibleVirtualFns.insert(F);
       });
     }
 
   ValueToValueMapTy VMap;
   std::unique_ptr<Module> MergedM(
       CloneModule(M, VMap, [&](const GlobalValue *GV) -> bool {
         if (const auto *C = GV->getComdat())

llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp

bool DevirtModule::tryVirtualConstProp(
   // Note that we test whether this copy of the function is readnone, rather
   // than testing function attributes, which must hold for any copy of the
   // function, even a less optimized version substituted at link time. This is
   // sound because the virtual constant propagation optimizations effectively
   // inline all implementations of the virtual function into each call site,
   // rather than using function attributes to perform local optimization.
   for (VirtualCallTarget &Target : TargetsForSlot) {
     if (Target.Fn->isDeclaration() ||
-        computeFunctionBodyMemoryAccess(*Target.Fn, AARGetter(*Target.Fn)) !=
-            FMRB_DoesNotAccessMemory ||
+        !computeFunctionBodyMemoryAccess(*Target.Fn, AARGetter(*Target.Fn))
+             .doesNotAccessMemory() ||
         Target.Fn->arg_empty() || !Target.Fn->arg_begin()->use_empty() ||
         Target.Fn->getReturnType() != RetType)
       return false;
   }
 
   for (auto &&CSByConstantArg : SlotInfo.ConstCSInfo) {
     if (!tryEvaluateFunctionsWithArgs(TargetsForSlot, CSByConstantArg.first))
       continue;

llvm/lib/Transforms/ObjCARC/DependencyAnalysis.cpp

case ARCInstKind::User:
     return false;
   default: break;
   }
 
   const auto *Call = cast<CallBase>(Inst);
 
   // See if AliasAnalysis can help us with the call.
   FunctionModRefBehavior MRB = PA.getAA()->getModRefBehavior(Call);
-  if (AliasAnalysis::onlyReadsMemory(MRB))
+  if (MRB.onlyReadsMemory())
     return false;
-  if (AliasAnalysis::onlyAccessesArgPointees(MRB)) {
+  if (MRB.onlyAccessesArgPointees()) {
     for (const Value *Op : Call->args()) {
       if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Ptr, Op))
         return true;
     }
     return false;
   }
 
   // Assume the worst.

llvm/lib/Transforms/Scalar/LICM.cpp

if (match(CI, m_Intrinsic<Intrinsic::assume>()))
       return true;
 
     if (match(CI, m_Intrinsic<Intrinsic::experimental_widenable_condition>()))
       // Widenable conditions don't actually alias anything or throw
       return true;
 
     // Handle simple cases by querying alias analysis.
     FunctionModRefBehavior Behavior = AA->getModRefBehavior(CI);
-    if (Behavior == FMRB_DoesNotAccessMemory)
+    if (Behavior.doesNotAccessMemory())
       return true;
-    if (AAResults::onlyReadsMemory(Behavior)) {
+    if (Behavior.onlyReadsMemory()) {
       // A readonly argmemonly function only reads from memory pointed to by
       // it's arguments with arbitrary offsets.  If we can prove there are no
       // writes to this memory in the loop, we can hoist or sink.
-      if (AAResults::onlyAccessesArgPointees(Behavior)) {
+      if (Behavior.onlyAccessesArgPointees()) {
         // TODO: expand to writeable arguments
         for (Value *Op : CI->args())
           if (Op->getType()->isPointerTy() &&
               pointerInvalidatedByLoop(
                   MSSA, cast<MemoryUse>(MSSA->getMemoryAccess(CI)), CurLoop, I,
                   Flags))
             return false;
         return true;

llvm/lib/Transforms/Utils/InlineFunction.cpp

if (const Instruction *I = dyn_cast<Instruction>(VMI->first)) {
         if (Call->doesNotAccessMemory())
           continue;
 
         IsFuncCall = true;
         if (CalleeAAR) {
           FunctionModRefBehavior MRB = CalleeAAR->getModRefBehavior(Call);
 
           // We'll retain this knowledge without additional metadata.
-          if (AAResults::onlyAccessesInaccessibleMem(MRB))
+          if (MRB.onlyAccessesInaccessibleMem())
             continue;
 
-          if (AAResults::onlyAccessesArgPointees(MRB))
+          if (MRB.onlyAccessesArgPointees())
             IsArgMemOnlyCall = true;
         }
 
         for (Value *Arg : Call->args()) {
           // Only care about pointer arguments. If a noalias argument is
           // accessed through a non-pointer argument, it must be captured
           // first (e.g. via ptrtoint), and we protect against captures below.
           if (!Arg->getType()->isPointerTy())

llvm/unittests/Analysis/GlobalsModRefTest.cpp

TEST(GlobalsModRef, OptNone) {
   Triple Trip(M->getTargetTriple());
   TargetLibraryInfoImpl TLII(Trip);
   TargetLibraryInfo TLI(TLII);
   auto GetTLI = [&TLI](Function &F) -> TargetLibraryInfo & { return TLI; };
   llvm::CallGraph CG(*M);
 
   auto AAR = GlobalsAAResult::analyzeModule(*M, GetTLI, CG);
 
-  EXPECT_EQ(FMRB_UnknownModRefBehavior, AAR.getModRefBehavior(&F1));
-  EXPECT_EQ(FMRB_DoesNotAccessMemory, AAR.getModRefBehavior(&F2));
-  EXPECT_EQ(FMRB_OnlyReadsMemory, AAR.getModRefBehavior(&F3));
+  EXPECT_EQ(FunctionModRefBehavior::unknown(), AAR.getModRefBehavior(&F1));
+  EXPECT_EQ(FunctionModRefBehavior::none(), AAR.getModRefBehavior(&F2));
+  EXPECT_EQ(FunctionModRefBehavior::readOnly(), AAR.getModRefBehavior(&F3));
 }

polly/lib/Analysis/ScopBuilder.cpp

bool ScopBuilder::buildAccessCallInst(MemAccInst Inst, ScopStmt *Stmt) {
   auto *CI = dyn_cast_or_null<CallInst>(Inst);
 
   if (CI == nullptr)
     return false;
 
   if (CI->doesNotAccessMemory() || isIgnoredIntrinsic(CI) || isDebugCall(CI))
     return true;
 
-  bool ReadOnly = false;
   auto *AF = SE.getConstant(IntegerType::getInt64Ty(CI->getContext()), 0);
   auto *CalledFunction = CI->getCalledFunction();
-  switch (AA.getModRefBehavior(CalledFunction)) {
-  case FMRB_UnknownModRefBehavior:
-    llvm_unreachable("Unknown mod ref behaviour cannot be represented.");
-  case FMRB_DoesNotAccessMemory:
-    return true;
-  case FMRB_OnlyWritesMemory:
-  case FMRB_OnlyWritesInaccessibleMem:
-  case FMRB_OnlyWritesInaccessibleOrArgMem:
-  case FMRB_OnlyAccessesInaccessibleMem:
-  case FMRB_OnlyAccessesInaccessibleOrArgMem:
-    return false;
-  case FMRB_OnlyReadsMemory:
-  case FMRB_OnlyReadsInaccessibleMem:
-  case FMRB_OnlyReadsInaccessibleOrArgMem:
-    GlobalReads.emplace_back(Stmt, CI);
+  FunctionModRefBehavior FMRB = AA.getModRefBehavior(CalledFunction);
+  if (FMRB.doesNotAccessMemory())
     return true;
-  case FMRB_OnlyReadsArgumentPointees:
-    ReadOnly = true;
-    [[fallthrough]];
-  case FMRB_OnlyWritesArgumentPointees:
-  case FMRB_OnlyAccessesArgumentPointees: {
-    auto AccType = ReadOnly ? MemoryAccess::READ : MemoryAccess::MAY_WRITE;
+
+  if (FMRB.onlyAccessesArgPointees()) {
+    ModRefInfo ArgMR = FMRB.getModRef(FunctionModRefBehavior::ArgMem);
+    auto AccType =
+        !isModSet(ArgMR) ? MemoryAccess::READ : MemoryAccess::MAY_WRITE;
     Loop *L = LI.getLoopFor(Inst->getParent());
     for (const auto &Arg : CI->args()) {
       if (!Arg->getType()->isPointerTy())
         continue;
 
       auto *ArgSCEV = SE.getSCEVAtScope(Arg, L);
       if (ArgSCEV->isZero())
         continue;
 
       if (auto *U = dyn_cast<SCEVUnknown>(ArgSCEV)) {
         if (isa<ConstantPointerNull>(U->getValue()))
           return true;
       }
 
       auto *ArgBasePtr = cast<SCEVUnknown>(SE.getPointerBase(ArgSCEV));
       addArrayAccess(Stmt, Inst, AccType, ArgBasePtr->getValue(),
                      ArgBasePtr->getType(), false, {AF}, {nullptr}, CI);
     }
     return true;
   }
-  }
 
+  if (FMRB.onlyReadsMemory()) {
+    GlobalReads.emplace_back(Stmt, CI);
     return true;
   }
+  return false;
+}
 
 void ScopBuilder::buildAccessSingleDim(MemAccInst Inst, ScopStmt *Stmt) {
   Value *Address = Inst.getPointerOperand();
   Value *Val = Inst.getValueOperand();
   Type *ElementType = Val->getType();
   enum MemoryAccess::AccessType AccType =
       isa<LoadInst>(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
 

polly/lib/Analysis/ScopDetection.cpp

bool ScopDetection::isValidCallInst(CallInst &CI,
 
   if (isDebugCall(&CI)) {
     LLVM_DEBUG(dbgs() << "Allow call to debug function: "
                       << CalledFunction->getName() << '\n');
     return true;
   }
 
   if (AllowModrefCall) {
-    switch (AA.getModRefBehavior(CalledFunction)) {
-    case FMRB_UnknownModRefBehavior:
-      return false;
-    case FMRB_DoesNotAccessMemory:
-    case FMRB_OnlyReadsMemory:
-    case FMRB_OnlyReadsInaccessibleMem:
-    case FMRB_OnlyReadsInaccessibleOrArgMem:
-      // Implicitly disable delinearization since we have an unknown
-      // accesses with an unknown access function.
-      Context.HasUnknownAccess = true;
-      // Explicitly use addUnknown so we don't put a loop-variant
-      // pointer into the alias set.
-      Context.AST.addUnknown(&CI);
-      return true;
-    case FMRB_OnlyReadsArgumentPointees:
-    case FMRB_OnlyAccessesArgumentPointees:
-    case FMRB_OnlyWritesArgumentPointees:
+    FunctionModRefBehavior FMRB = AA.getModRefBehavior(CalledFunction);
+    if (FMRB.onlyAccessesArgPointees()) {
       for (const auto &Arg : CI.args()) {
         if (!Arg->getType()->isPointerTy())
           continue;
 
         // Bail if a pointer argument has a base address not known to
         // ScalarEvolution. Note that a zero pointer is acceptable.
         auto *ArgSCEV = SE.getSCEVAtScope(Arg, LI.getLoopFor(CI.getParent()));
         if (ArgSCEV->isZero())
           continue;
 
         auto *BP = dyn_cast<SCEVUnknown>(SE.getPointerBase(ArgSCEV));
         if (!BP)
           return false;
 
         // Implicitly disable delinearization since we have an unknown
         // accesses with an unknown access function.
         Context.HasUnknownAccess = true;
       }
 
       // Explicitly use addUnknown so we don't put a loop-variant
       // pointer into the alias set.
       Context.AST.addUnknown(&CI);
       return true;
-    case FMRB_OnlyWritesMemory:
-    case FMRB_OnlyWritesInaccessibleMem:
-    case FMRB_OnlyWritesInaccessibleOrArgMem:
-    case FMRB_OnlyAccessesInaccessibleMem:
-    case FMRB_OnlyAccessesInaccessibleOrArgMem:
-      return false;
     }
+
+    if (FMRB.onlyReadsMemory()) {
+      // Implicitly disable delinearization since we have an unknown
+      // accesses with an unknown access function.
+      Context.HasUnknownAccess = true;
+      // Explicitly use addUnknown so we don't put a loop-variant
+      // pointer into the alias set.
+      Context.AST.addUnknown(&CI);
+      return true;
+    }
+    return false;
   }
 
   return false;
 }
 
 bool ScopDetection::isValidIntrinsicInst(IntrinsicInst &II,
                                          DetectionContext &Context) const {
   if (isIgnoredIntrinsic(&II))