[AA] Rename FunctionModRefBehavior (NFC)

[nikic]

Summary

As part of https://discourse.llvm.org/t/rfc-unify-memory-effect-attributes/65579, the FunctionModRefBehavior class sees a good bit of additional use, and I've found the name to be something of a mouthful. I'd like to rename it to something more concise. I have two suggestions:

• FunctionModRefBehavior -> ModRefBehavior. I don't think the Function prefix is adding anything here, and I think we will actually want to use this class to model memory effects of non-call instructions as well. While most non-call instructions are argmemonly ("arg" in the sense of "instruction operand" here), this is not true for volatile operations and other special instructions like fences, and having central modelling for this would prevent mistakes like D135863.
• FunctionModRefBehavior -> MemoryEffects (what this patch currently does). This would be in line with the terminology of the aforementioned RFC. I think this term is more obvious to people who are not familiar with our AA lingo.

Happy to bikeshed other variants though :)

This patch currently just updates the class definition. If we do the rename, I would of course also update other references. For the second option, I'd also rename getModRefBehavior() methods to getMemoryEffects().

[jdoerfert]

I am in favor of this version. I was already not happy with the new uses of the long "FunctionModRefBehavior" for the memory attribute, this makes it shorter and less confusing (IMHO).

[fhahn]

MemoryEffects sounds good to me.

[nikic]

As there seems to be support for the MemoryEffects name, I plan to land this tomorrow, if there are no further objections.

[nhaehnle]

+1

[asbirlea]

SGTM.

[fhahn]

LGTM, thanks!

llvm/include/llvm/IR/ModRef.h

 //===--- ModRef.h - Memory effect modelling ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// Definitions of ModRefInfo and FunctionModRefBehavior, which are used to
+// Definitions of ModRefInfo and MemoryEffects, which are used to
 // describe the memory effects of instructions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_MODREF_H
 #define LLVM_IR_MODREF_H
 
 #include "llvm/ADT/BitmaskEnum.h"

 /// 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.
-class FunctionModRefBehavior {
+class MemoryEffects {
 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.
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) {}
+  MemoryEffects(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);
+  friend raw_ostream &operator<<(raw_ostream &OS, MemoryEffects 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
+  /// Create MemoryEffects that can access only the given location with the
   /// given ModRefInfo.
-  explicit FunctionModRefBehavior(ModRefInfo MR) {
+  MemoryEffects(Location Loc, ModRefInfo MR) { setModRef(Loc, MR); }
+
+  /// Create MemoryEffects that can access any location with the given
+  /// ModRefInfo.
+  explicit MemoryEffects(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 MemoryEffects that can read and write any memory.
+  static MemoryEffects unknown() {
+    return MemoryEffects(ModRefInfo::ModRef);
   }
 
-  /// Create FunctionModRefBehavior that cannot read or write any memory.
-  static FunctionModRefBehavior none() {
-    return FunctionModRefBehavior(ModRefInfo::NoModRef);
+  /// Create MemoryEffects that cannot read or write any memory.
+  static MemoryEffects none() {
+    return MemoryEffects(ModRefInfo::NoModRef);
   }
 
-  /// Create FunctionModRefBehavior that can read any memory.
-  static FunctionModRefBehavior readOnly() {
-    return FunctionModRefBehavior(ModRefInfo::Ref);
+  /// Create MemoryEffects that can read any memory.
+  static MemoryEffects readOnly() {
+    return MemoryEffects(ModRefInfo::Ref);
   }
 
-  /// Create FunctionModRefBehavior that can write any memory.
-  static FunctionModRefBehavior writeOnly() {
-    return FunctionModRefBehavior(ModRefInfo::Mod);
+  /// Create MemoryEffects that can write any memory.
+  static MemoryEffects writeOnly() {
+    return MemoryEffects(ModRefInfo::Mod);
   }
 
-  /// Create FunctionModRefBehavior that can only access argument memory.
-  static FunctionModRefBehavior argMemOnly(ModRefInfo MR) {
-    return FunctionModRefBehavior(ArgMem, MR);
+  /// Create MemoryEffects that can only access argument memory.
+  static MemoryEffects argMemOnly(ModRefInfo MR) {
+    return MemoryEffects(ArgMem, MR);
   }
 
-  /// Create FunctionModRefBehavior that can only access inaccessible memory.
-  static FunctionModRefBehavior inaccessibleMemOnly(ModRefInfo MR) {
-    return FunctionModRefBehavior(InaccessibleMem, MR);
+  /// Create MemoryEffects that can only access inaccessible memory.
+  static MemoryEffects inaccessibleMemOnly(ModRefInfo MR) {
+    return MemoryEffects(InaccessibleMem, MR);
   }
 
-  /// Create FunctionModRefBehavior that can only access inaccessible or
-  /// argument memory.
-  static FunctionModRefBehavior inaccessibleOrArgMemOnly(ModRefInfo MR) {
-    FunctionModRefBehavior FRMB = none();
+  /// Create MemoryEffects that can only access inaccessible or argument memory.
+  static MemoryEffects inaccessibleOrArgMemOnly(ModRefInfo MR) {
+    MemoryEffects 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 MemoryEffects with modified ModRefInfo for Loc.
+  MemoryEffects getWithModRef(Location Loc, ModRefInfo MR) const {
+    MemoryEffects ME = *this;
+    ME.setModRef(Loc, MR);
+    return ME;
   }
 
-  /// 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 new MemoryEffects with NoModRef on the given Loc.
+  MemoryEffects getWithoutLoc(Location Loc) const {
+    MemoryEffects ME = *this;
+    ME.setModRef(Loc, ModRefInfo::NoModRef);
+    return ME;
   }
 
   /// Get ModRefInfo for any location.
   ModRefInfo getModRef() const {
     ModRefInfo MR = ModRefInfo::NoModRef;
     for (Location Loc : locations())
       MR |= getModRef(Loc);
     return MR;
public:
   }
 
   /// 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 with other MemoryEffects.
+  MemoryEffects operator&(MemoryEffects Other) const {
+    return MemoryEffects(Data & Other.Data);
   }
 
-  /// Intersect (in-place) with another FunctionModRefBehavior.
-  FunctionModRefBehavior &operator&=(FunctionModRefBehavior Other) {
+  /// Intersect (in-place) with other MemoryEffects.
+  MemoryEffects &operator&=(MemoryEffects Other) {
     Data &= Other.Data;
     return *this;
   }
 
-  /// Union with another FunctionModRefBehavior.
-  FunctionModRefBehavior operator|(FunctionModRefBehavior Other) const {
-    return FunctionModRefBehavior(Data | Other.Data);
+  /// Union with other MemoryEffects.
+  MemoryEffects operator|(MemoryEffects Other) const {
+    return MemoryEffects(Data | Other.Data);
   }
 
-  /// Union (in-place) with another FunctionModRefBehavior.
-  FunctionModRefBehavior &operator|=(FunctionModRefBehavior Other) {
+  /// Union (in-place) with other MemoryEffects.
+  MemoryEffects &operator|=(MemoryEffects Other) {
     Data |= Other.Data;
     return *this;
   }
 
-  /// Check whether this is the same as another FunctionModRefBehavior.
-  bool operator==(FunctionModRefBehavior Other) const {
+  /// Check whether this is the same as other MemoryEffects.
+  bool operator==(MemoryEffects Other) const {
     return Data == Other.Data;
   }
 
-  /// Check whether this is different from another FunctionModRefBehavior.
-  bool operator!=(FunctionModRefBehavior Other) const {
+  /// Check whether this is different from other MemoryEffects.
+  bool operator!=(MemoryEffects Other) const {
     return !operator==(Other);
   }
 };
 
-/// Debug print FunctionModRefBehavior.
-raw_ostream &operator<<(raw_ostream &OS, FunctionModRefBehavior RMRB);
+/// Debug print MemoryEffects.
+raw_ostream &operator<<(raw_ostream &OS, MemoryEffects RMRB);
+
+// Legacy alias.
+using FunctionModRefBehavior = MemoryEffects;
 
 } // namespace llvm
 
 #endif