[MemoryEffects][NFCI] Make the MemoryEffects class reusable

[jdoerfert]

Summary

In a follow up we will reuse the logic in MemoryEffectsBase to merge
moryLocation and AAMemoryBehavior without duplicating all the bit
ling code already available in MemoryEffectsBase.

This is part of an effort to match FunctionAttr performance with a lightweight Attributor pass, and this should also speed it up as we need less AAs.

[jdoerfert]

I can upload this again w/ context. This needs to wait for the AA commit to be cleaned up anyway.

[nikic]

Looks reasonable. A bit unfortunate to lose the ability to forward declare.

llvm/include/llvm/Support/ModRef.h

58

Why the enum wrapped in a class here?

224

This function assumes that there are only three locations. You need to make it getWithoutLoc(Location::InaccessibleMem).getWithoutLoc(Location::ArgMem).doesNotAccessMemory() to gracefully handle extra locations.

[jdoerfert]

llvm/include/llvm/Support/ModRef.h

58

Just to keep the sth::Location syntax around. A namespace would work, or I just rename the location into IRLocation and remove the class. No good reason not to do that.

224

good catch

[jdoerfert]

Fix oversight, rename location

[nikic]

Looks fine to me, apart from the question about reinterpret_cast.

llvm/include/llvm/Support/ModRef.h

73–74

Broken indentation?

231

Why does this need a reinterpret_cast?

[jdoerfert]

Fixed both comments, can't upload, phab error.

[nikic]

LGTM

[yrouban]

llvm/include/llvm/Support/ModRef.h

65

These unscoped enumerators expose very generic identifiers Other, First, Last in the namespace llvm.
So all sources using llvm namespace may get a compilation error if they use these identifiers for their own purposes.

[yrouban]

llvm/include/llvm/Support/ModRef.h

65

These unscoped enumerators expose very generic identifiers Other, First, Last in the namespace llvm.
So all sources using llvm namespace may get a compilation error if they use these identifiers for their own purposes.

65

I suggest that we use a scoped enumerators:

enum class IRMemLocation { ... }

[nikic]

@yrouban That was an oversights, fixed in https://github.com/llvm/llvm-project/commit/8f6e7b28712ae197f5674a1341f6c976746eaa69.

llvm/include/llvm/AsmParser/LLParser.h

 
 #include "LLLexer.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/FMF.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
+#include "llvm/Support/ModRef.h"
 #include <map>
 #include <optional>
 
 namespace llvm {
   class Module;
   class ConstantRange;
   class FunctionType;
   class GlobalObject;
   class SMDiagnostic;
   class SMLoc;
   class SourceMgr;
   class Type;
   struct MaybeAlign;
   class Function;
   class Value;
   class BasicBlock;
   class Instruction;
   class Constant;
   class GlobalValue;
   class Comdat;
   class MDString;
   class MDNode;
-  class MemoryEffects;
   struct SlotMapping;
 
   /// ValID - Represents a reference of a definition of some sort with no type.
   /// There are several cases where we have to parse the value but where the
   /// type can depend on later context.  This may either be a numeric reference
   /// or a symbolic (%var) reference.  This is just a discriminated union.
   struct ValID {
     enum {

llvm/include/llvm/IR/Attributes.h

 
 #include "llvm-c/Types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/CodeGen.h"
+#include "llvm/Support/ModRef.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <cassert>
 #include <cstdint>
 #include <optional>
 #include <string>
 #include <utility>
 
 namespace llvm {
 
 class AttrBuilder;
 class AttributeMask;
 class AttributeImpl;
 class AttributeListImpl;
 class AttributeSetNode;
 class FoldingSetNodeID;
 class Function;
 class LLVMContext;
-class MemoryEffects;
 class Type;
 class raw_ostream;
 enum FPClassTest : unsigned;
 
 enum class AllocFnKind : uint64_t {
   Unknown = 0,
   Alloc = 1 << 0,         // Allocator function returns a new allocation
   Realloc = 1 << 1,       // Allocator function resizes the `allocptr` argument

llvm/include/llvm/Support/ModRef.h

 }
 [[nodiscard]] inline bool isRefSet(const ModRefInfo MRI) {
   return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Ref);
 }
 
 /// 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 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.
-    Other = 2,
-  };
+enum IRMemLocation {
+
+  /// Helpers to iterate all locations in the MemoryEffectsBase class.
+  First = ArgMem,
+  Last = Other,
 
+template <typename LocationEnum> class MemoryEffectsBase {
+public:
+  using Location = LocationEnum;
+
 private:
   uint32_t Data = 0;
 
   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;
   }
 
-  MemoryEffects(uint32_t Data) : Data(Data) {}
+  MemoryEffectsBase(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, MemoryEffects RMRB);
-
 public:
   /// Returns iterator over all supported location kinds.
   static auto locations() {
-    return enum_seq_inclusive(Location::ArgMem, Location::Other,
+    return enum_seq_inclusive(Location::First, Location::Last,
                               force_iteration_on_noniterable_enum);
   }
 
-  /// Create MemoryEffects that can access only the given location with the
+  /// Create MemoryEffectsBase that can access only the given location with the
   /// given ModRefInfo.
-  MemoryEffects(Location Loc, ModRefInfo MR) { setModRef(Loc, MR); }
+  MemoryEffectsBase(Location Loc, ModRefInfo MR) { setModRef(Loc, MR); }
 
-  /// Create MemoryEffects that can access any location with the given
+  /// Create MemoryEffectsBase that can access any location with the given
   /// ModRefInfo.
-  explicit MemoryEffects(ModRefInfo MR) {
+  explicit MemoryEffectsBase(ModRefInfo MR) {
     for (Location Loc : locations())
       setModRef(Loc, MR);
   }
 
-  /// Create MemoryEffects that can read and write any memory.
-  static MemoryEffects unknown() {
-    return MemoryEffects(ModRefInfo::ModRef);
+  /// Create MemoryEffectsBase that can read and write any memory.
+  static MemoryEffectsBase unknown() {
+    return MemoryEffectsBase(ModRefInfo::ModRef);
   }
 
-  /// Create MemoryEffects that cannot read or write any memory.
-  static MemoryEffects none() {
-    return MemoryEffects(ModRefInfo::NoModRef);
+  /// Create MemoryEffectsBase that cannot read or write any memory.
+  static MemoryEffectsBase none() {
+    return MemoryEffectsBase(ModRefInfo::NoModRef);
   }
 
-  /// Create MemoryEffects that can read any memory.
-  static MemoryEffects readOnly() {
-    return MemoryEffects(ModRefInfo::Ref);
+  /// Create MemoryEffectsBase that can read any memory.
+  static MemoryEffectsBase readOnly() {
+    return MemoryEffectsBase(ModRefInfo::Ref);
   }
 
-  /// Create MemoryEffects that can write any memory.
-  static MemoryEffects writeOnly() {
-    return MemoryEffects(ModRefInfo::Mod);
+  /// Create MemoryEffectsBase that can write any memory.
+  static MemoryEffectsBase writeOnly() {
+    return MemoryEffectsBase(ModRefInfo::Mod);
   }
 
-  /// Create MemoryEffects that can only access argument memory.
-  static MemoryEffects argMemOnly(ModRefInfo MR = ModRefInfo::ModRef) {
-    return MemoryEffects(ArgMem, MR);
+  /// Create MemoryEffectsBase that can only access argument memory.
+  static MemoryEffectsBase argMemOnly(ModRefInfo MR = ModRefInfo::ModRef) {
+    return MemoryEffectsBase(Location::ArgMem, MR);
   }
 
-  /// Create MemoryEffects that can only access inaccessible memory.
-  static MemoryEffects inaccessibleMemOnly(ModRefInfo MR = ModRefInfo::ModRef) {
-    return MemoryEffects(InaccessibleMem, MR);
+  /// Create MemoryEffectsBase that can only access inaccessible memory.
+  static MemoryEffectsBase
+  inaccessibleMemOnly(ModRefInfo MR = ModRefInfo::ModRef) {
+    return MemoryEffectsBase(Location::InaccessibleMem, MR);
   }
 
-  /// Create MemoryEffects that can only access inaccessible or argument memory.
-  static MemoryEffects
+  /// Create MemoryEffectsBase that can only access inaccessible or argument
+  /// memory.
+  static MemoryEffectsBase
   inaccessibleOrArgMemOnly(ModRefInfo MR = ModRefInfo::ModRef) {
-    MemoryEffects FRMB = none();
-    FRMB.setModRef(ArgMem, MR);
-    FRMB.setModRef(InaccessibleMem, MR);
+    MemoryEffectsBase FRMB = none();
+    FRMB.setModRef(Location::ArgMem, MR);
+    FRMB.setModRef(Location::InaccessibleMem, MR);
     return FRMB;
   }
 
-  /// Create MemoryEffects from an encoded integer value (used by memory
+  /// Create MemoryEffectsBase from an encoded integer value (used by memory
   /// attribute).
-  static MemoryEffects createFromIntValue(uint32_t Data) {
-    return MemoryEffects(Data);
+  static MemoryEffectsBase createFromIntValue(uint32_t Data) {
+    return MemoryEffectsBase(Data);
   }
 
-  /// Convert MemoryEffects into an encoded integer value (used by memory
+  /// Convert MemoryEffectsBase into an encoded integer value (used by memory
   /// attribute).
   uint32_t toIntValue() const {
     return Data;
   }
 
   /// Get ModRefInfo for the given Location.
   ModRefInfo getModRef(Location Loc) const {
     return ModRefInfo((Data >> getLocationPos(Loc)) & LocMask);
   }
 
-  /// Get new MemoryEffects with modified ModRefInfo for Loc.
-  MemoryEffects getWithModRef(Location Loc, ModRefInfo MR) const {
-    MemoryEffects ME = *this;
+  /// Get new MemoryEffectsBase with modified ModRefInfo for Loc.
+  MemoryEffectsBase getWithModRef(Location Loc, ModRefInfo MR) const {
+    MemoryEffectsBase ME = *this;
     ME.setModRef(Loc, MR);
     return ME;
   }
 
-  /// Get new MemoryEffects with NoModRef on the given Loc.
-  MemoryEffects getWithoutLoc(Location Loc) const {
-    MemoryEffects ME = *this;
+  /// Get new MemoryEffectsBase with NoModRef on the given Loc.
+  MemoryEffectsBase getWithoutLoc(Location Loc) const {
+    MemoryEffectsBase 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;
   }
 
   /// 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();
+    return getWithoutLoc(Location::ArgMem).doesNotAccessMemory();
   }
 
   /// Whether this function may access argument memory.
   bool doesAccessArgPointees() const {
-    return isModOrRefSet(getModRef(ArgMem));
+    return isModOrRefSet(getModRef(Location::ArgMem));
   }
 
   /// Whether this function only (at most) accesses inaccessible memory.
   bool onlyAccessesInaccessibleMem() const {
-    return getWithoutLoc(InaccessibleMem).doesNotAccessMemory();
+    return getWithoutLoc(Location::InaccessibleMem).doesNotAccessMemory();
   }
 
   /// Whether this function only (at most) accesses argument and inaccessible
   /// memory.
   bool onlyAccessesInaccessibleOrArgMem() const {
-    return isNoModRef(getModRef(Other));
+    return getWithoutLoc(Location::InaccessibleMem)
+        .getWithoutLoc(Location::ArgMem)
+        .doesNotAccessMemory();
   }
 
-  /// Intersect with other MemoryEffects.
-  MemoryEffects operator&(MemoryEffects Other) const {
-    return MemoryEffects(Data & Other.Data);
+  /// Intersect with other MemoryEffectsBase.
+  MemoryEffectsBase operator&(MemoryEffectsBase Other) const {
+    return MemoryEffectsBase(Data & Other.Data);
   }
 
-  /// Intersect (in-place) with other MemoryEffects.
-  MemoryEffects &operator&=(MemoryEffects Other) {
+  /// Intersect (in-place) with other MemoryEffectsBase.
+  MemoryEffectsBase &operator&=(MemoryEffectsBase Other) {
     Data &= Other.Data;
     return *this;
   }
 
-  /// Union with other MemoryEffects.
-  MemoryEffects operator|(MemoryEffects Other) const {
-    return MemoryEffects(Data | Other.Data);
+  /// Union with other MemoryEffectsBase.
+  MemoryEffectsBase operator|(MemoryEffectsBase Other) const {
+    return MemoryEffectsBase(Data | Other.Data);
   }
 
-  /// Union (in-place) with other MemoryEffects.
-  MemoryEffects &operator|=(MemoryEffects Other) {
+  /// Union (in-place) with other MemoryEffectsBase.
+  MemoryEffectsBase &operator|=(MemoryEffectsBase Other) {
     Data |= Other.Data;
     return *this;
   }
 
-  /// Check whether this is the same as other MemoryEffects.
-  bool operator==(MemoryEffects Other) const {
-    return Data == Other.Data;
+  /// Subtract other MemoryEffectsBase.
+  MemoryEffectsBase operator-(MemoryEffectsBase Other) const {
+    return MemoryEffectsBase(Data & ~Other.Data);
   }
 
-  /// Check whether this is different from other MemoryEffects.
-  bool operator!=(MemoryEffects Other) const {
-    return !operator==(Other);
+  /// Subtract (in-place) with other MemoryEffectsBase.
+  MemoryEffectsBase &operator-=(MemoryEffectsBase Other) {
+    Data &= ~Other.Data;
+    return *this;
   }
+
+  /// Check whether this is the same as other MemoryEffectsBase.
+  bool operator==(MemoryEffectsBase Other) const { return Data == Other.Data; }
+
+  /// Check whether this is different from other MemoryEffectsBase.
+  bool operator!=(MemoryEffectsBase Other) const { return !operator==(Other); }
 };
 
+/// 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.
+using MemoryEffects = MemoryEffectsBase<IRMemLocation>;
+
 /// Debug print MemoryEffects.
 raw_ostream &operator<<(raw_ostream &OS, MemoryEffects RMRB);
 
 // Legacy alias.
 using FunctionModRefBehavior = MemoryEffects;
 
 } // namespace llvm
 
 #endif

llvm/lib/Analysis/AliasAnalysis.cpp

ModRefInfo AAResults::getModRefInfo(const CallBase *Call,
   }
 
   // Try to refine the mod-ref info further using other API entry points to the
   // aggregate set of AA results.
 
   // We can completely ignore inaccessible memory here, because MemoryLocations
   // can only reference accessible memory.
   auto ME = getMemoryEffects(Call, AAQI)
-                .getWithoutLoc(MemoryEffects::InaccessibleMem);
+                .getWithoutLoc(IRMemLocation::InaccessibleMem);
   if (ME.doesNotAccessMemory())
     return ModRefInfo::NoModRef;
 
-  ModRefInfo ArgMR = ME.getModRef(MemoryEffects::ArgMem);
-  ModRefInfo OtherMR = ME.getWithoutLoc(MemoryEffects::ArgMem).getModRef();
+  ModRefInfo ArgMR = ME.getModRef(IRMemLocation::ArgMem);
+  ModRefInfo OtherMR = ME.getWithoutLoc(IRMemLocation::ArgMem).getModRef();
   if ((ArgMR | OtherMR) != OtherMR) {
     // Refine the modref info for argument memory. We only bother to do this
     // if ArgMR is not a subset of OtherMR, otherwise this won't have an impact
     // on the final result.
     ModRefInfo AllArgsMask = ModRefInfo::NoModRef;
     for (const auto &I : llvm::enumerate(Call->args())) {
       const Value *Arg = I.value();
       if (!Arg->getType()->isPointerTy())
raw_ostream &llvm::operator<<(raw_ostream &OS, ModRefInfo MR) {
   case ModRefInfo::ModRef:
     OS << "ModRef";
     break;
   }
   return OS;
 }
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, MemoryEffects ME) {
-  for (MemoryEffects::Location Loc : MemoryEffects::locations()) {
+  for (IRMemLocation Loc : MemoryEffects::locations()) {
     switch (Loc) {
-    case MemoryEffects::ArgMem:
+    case IRMemLocation::ArgMem:
       OS << "ArgMem: ";
       break;
-    case MemoryEffects::InaccessibleMem:
+    case IRMemLocation::InaccessibleMem:
       OS << "InaccessibleMem: ";
       break;
-    case MemoryEffects::Other:
+    case IRMemLocation::Other:
       OS << "Other: ";
       break;
     }
     OS << ME.getModRef(Loc) << ", ";
   }
   return OS;
 }
 

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::parseAllocKind(AllocFnKind &Kind) {
   if (Kind == AllocFnKind::Unknown)
     return error(KindLoc, "expected allockind value");
   return false;
 }
 
 static std::optional<MemoryEffects::Location> keywordToLoc(lltok::Kind Tok) {
   switch (Tok) {
   case lltok::kw_argmem:
-    return MemoryEffects::ArgMem;
+    return IRMemLocation::ArgMem;
   case lltok::kw_inaccessiblemem:
-    return MemoryEffects::InaccessibleMem;
+    return IRMemLocation::InaccessibleMem;
   default:
     return std::nullopt;
   }
 }
 
 static std::optional<ModRefInfo> keywordToModRef(lltok::Kind Tok) {
   switch (Tok) {
   case lltok::kw_none:
std::optional<MemoryEffects> LLParser::parseMemoryAttr() {
   Lex.Lex();
   if (!EatIfPresent(lltok::lparen)) {
     tokError("expected '('");
     return std::nullopt;
   }
 
   bool SeenLoc = false;
   do {
-    std::optional<MemoryEffects::Location> Loc = keywordToLoc(Lex.getKind());
+    std::optional<IRMemLocation> Loc = keywordToLoc(Lex.getKind());
     if (Loc) {
       Lex.Lex();
       if (!EatIfPresent(lltok::colon)) {
         tokError("expected ':' after location");
         return std::nullopt;
       }
     }
 

llvm/lib/IR/Attributes.cpp

if (hasAttribute(Attribute::Memory)) {
     raw_string_ostream OS(Result);
     bool First = true;
     OS << "memory(";
 
     MemoryEffects ME = getMemoryEffects();
 
     // Print access kind for "other" as the default access kind. This way it
     // will apply to any new location kinds that get split out of "other".
-    ModRefInfo OtherMR = ME.getModRef(MemoryEffects::Other);
+    ModRefInfo OtherMR = ME.getModRef(IRMemLocation::Other);
     if (OtherMR != ModRefInfo::NoModRef || ME.getModRef() == OtherMR) {
       First = false;
       OS << getModRefStr(OtherMR);
     }
 
     for (auto Loc : MemoryEffects::locations()) {
       ModRefInfo MR = ME.getModRef(Loc);
       if (MR == OtherMR)
         continue;
 
       if (!First)
         OS << ", ";
       First = false;
 
       switch (Loc) {
-      case MemoryEffects::ArgMem:
+      case IRMemLocation::ArgMem:
         OS << "argmem: ";
         break;
-      case MemoryEffects::InaccessibleMem:
+      case IRMemLocation::InaccessibleMem:
         OS << "inaccessiblemem: ";
         break;
-      case MemoryEffects::Other:
+      case IRMemLocation::Other:
         llvm_unreachable("This is represented as the default access kind");
       }
       OS << getModRefStr(MR);
     }
     OS << ")";
     OS.flush();
     return Result;
   }

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

auto AddLocAccess = [&](const MemoryLocation &Loc, ModRefInfo MR) {
     if (isa<Argument>(UO)) {
       ME |= MemoryEffects::argMemOnly(MR);
       return;
     }
 
     // If it's not an identified object, it might be an argument.
     if (!isIdentifiedObject(UO))
       ME |= MemoryEffects::argMemOnly(MR);
-    ME |= MemoryEffects(MemoryEffects::Other, MR);
+    ME |= MemoryEffects(IRMemLocation::Other, MR);
   };
   // Scan the function body for instructions that may read or write memory.
   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
if (auto *Call = dyn_cast<CallBase>(&I)) {
 
       // 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;
 
-      ME |= CallME.getWithoutLoc(MemoryEffects::ArgMem);
+      ME |= CallME.getWithoutLoc(IRMemLocation::ArgMem);
 
       // If the call accesses captured memory (currently part of "other") and
       // an argument is captured (currently not tracked), then it may also
       // access argument memory.
-      ModRefInfo OtherMR = CallME.getModRef(MemoryEffects::Other);
+      ModRefInfo OtherMR = CallME.getModRef(IRMemLocation::Other);
       ME |= MemoryEffects::argMemOnly(OtherMR);
 
       // Check whether all pointer arguments point to local memory, and
       // ignore calls that only access local memory.
-      ModRefInfo ArgMR = CallME.getModRef(MemoryEffects::ArgMem);
+      ModRefInfo ArgMR = CallME.getModRef(IRMemLocation::ArgMem);
       if (ArgMR != ModRefInfo::NoModRef) {
         for (const Use &U : Call->args()) {
           const Value *Arg = U;
           if (!Arg->getType()->isPtrOrPtrVectorTy())
             continue;
 
           AddLocAccess(MemoryLocation::getBeforeOrAfter(Arg, I.getAAMetadata()), ArgMR);
         }

llvm/lib/Transforms/IPO/SCCP.cpp

if (Solver.isBlockExecutable(&F.front())) {
       // If we replaced an argument, we may now also access a global (currently
       // classified as "other" memory). Update memory attribute to reflect this.
       if (ReplacedPointerArg) {
         auto UpdateAttrs = [&](AttributeList AL) {
           MemoryEffects ME = AL.getMemoryEffects();
           if (ME == MemoryEffects::unknown())
             return AL;
 
-          ME |= MemoryEffects(MemoryEffects::Other,
-                              ME.getModRef(MemoryEffects::ArgMem));
+          ME |= MemoryEffects(IRMemLocation::Other,
+                              ME.getModRef(IRMemLocation::ArgMem));
           return AL.addFnAttribute(
               F.getContext(),
               Attribute::getWithMemoryEffects(F.getContext(), ME));
         };
 
         F.setAttributes(UpdateAttrs(F.getAttributes()));
         for (User *U : F.users()) {
           auto *CB = dyn_cast<CallBase>(U);