[TableGen] Use MemoryEffects to represent intrinsic memory effects (NFCI)

[nikic]

Summary

The TableGen implementation was using a homegrown implementation of FunctionModRefInfo. This switches it to use MemoryEffects instead. This makes the code simpler, and will allow exposing the full representational power of MemoryEffects in the future. Among other things, this will allow us to map IntrHasSideEffects to an inaccessiblemem readwrite, rather than just ignoring it entirely in most cases.

A caveat here is that this includes a header from IR in TableGen. I think this should be unproblematic as long as IR/ModRef.h doesn't itself depend on any TableGen-generated headers. Alternatively, it could be moved into Support, but that feels somewhat out of place.

[aeubanks]

the layering seems problematic, I think we should move ModRef.h into Support
there are already headers in there that don't seem like they quite belong due to layering, e.g. all the target-specific headers, CodeGen.h

[nikic]

Move ModRef.h to Support to avoid layering problems.

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/ModRef.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/ModRef.h"
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <vector>
 
 namespace llvm {
 
 class AnalysisUsage;

llvm/lib/AsmParser/LLParser.cpp

 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalIFunc.h"
 #include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
-#include "llvm/IR/ModRef.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/ModRef.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstring>
 #include <vector>
 
 using namespace llvm;

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/IntrinsicsAArch64.h"
 #include "llvm/IR/IntrinsicsARM.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
-#include "llvm/IR/ModRef.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/ModRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <deque>
 #include <map>
 #include <memory>

llvm/lib/CodeGen/MachineVerifier.cpp

 #include "llvm/CodeGen/TargetOpcodes.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instructions.h"
-#include "llvm/IR/ModRef.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/MC/LaneBitmask.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LowLevelTypeImpl.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/ModRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <string>

llvm/lib/IR/Attributes.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
-#include "llvm/IR/ModRef.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ModRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <limits>
 #include <string>
 #include <tuple>

llvm/lib/IR/Function.cpp

 #include "llvm/IR/IntrinsicsS390.h"
 #include "llvm/IR/IntrinsicsVE.h"
 #include "llvm/IR/IntrinsicsWebAssembly.h"
 #include "llvm/IR/IntrinsicsX86.h"
 #include "llvm/IR/IntrinsicsXCore.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Metadata.h"
-#include "llvm/IR/ModRef.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/SymbolTableListTraits.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Use.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ModRef.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <string>
 
 using namespace llvm;
 using ProfileCount = Function::ProfileCount;

llvm/lib/IR/Instructions.cpp

 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Metadata.h"
-#include "llvm/IR/ModRef.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/ModRef.h"
 #include "llvm/Support/TypeSize.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <vector>
 
 using namespace llvm;
 

llvm/lib/Target/AMDGPU/AMDGPULibFunc.cpp

 
 #include "AMDGPULibFunc.h"
 #include "AMDGPU.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
-#include "llvm/IR/ModRef.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ModRef.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 static cl::opt<bool> EnableOCLManglingMismatchWA(
     "amdgpu-enable-ocl-mangling-mismatch-workaround", cl::init(true),
     cl::ReallyHidden,
     cl::desc("Enable the workaround for OCL name mangling mismatch."));

llvm/lib/Target/AMDGPU/SIISelLowering.cpp

 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineLoopInfo.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/IntrinsicsAMDGPU.h"
 #include "llvm/IR/IntrinsicsR600.h"
-#include "llvm/IR/ModRef.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ModRef.h"
 #include "llvm/Support/KnownBits.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "si-lower"
 
 STATISTIC(NumTailCalls, "Number of tail calls");
 

llvm/lib/Target/Mips/Mips16HardFloat.cpp

 //===- Mips16HardFloat.cpp for Mips16 Hard Float --------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a pass needed for Mips16 Hard Float
 //
 //===----------------------------------------------------------------------===//
 
 #include "MipsTargetMachine.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
-#include "llvm/IR/ModRef.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/ModRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <string>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "mips16-hard-float"
 

llvm/utils/TableGen/CodeGenDAGPatterns.cpp

TreePatternNodePtr TreePattern::ParseTreePattern(Init *TheInit,
   if (Operator->isSubClassOf("Intrinsic")) {
     const CodeGenIntrinsic &Int = getDAGPatterns().getIntrinsic(Operator);
     unsigned IID = getDAGPatterns().getIntrinsicID(Operator)+1;
 
     // If this intrinsic returns void, it must have side-effects and thus a
     // chain.
     if (Int.IS.RetVTs.empty())
       Operator = getDAGPatterns().get_intrinsic_void_sdnode();
-    else if (Int.ModRef != CodeGenIntrinsic::NoMem || Int.hasSideEffects)
+    else if (!Int.ME.doesNotAccessMemory() || Int.hasSideEffects)
       // Has side-effects, requires chain.
       Operator = getDAGPatterns().get_intrinsic_w_chain_sdnode();
     else // Otherwise, no chain.
       Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode();
 
     Children.insert(Children.begin(), std::make_shared<TreePatternNode>(
                                           IntInit::get(RK, IID), 1));
   }
void AnalyzeNode(const TreePatternNode *N) {
     // Notice properties of the node.
     if (N->NodeHasProperty(SDNPMayStore, CDP)) mayStore = true;
     if (N->NodeHasProperty(SDNPMayLoad, CDP)) mayLoad = true;
     if (N->NodeHasProperty(SDNPSideEffect, CDP)) hasSideEffects = true;
     if (N->NodeHasProperty(SDNPVariadic, CDP)) isVariadic = true;
     if (N->NodeHasProperty(SDNPHasChain, CDP)) hasChain = true;
 
     if (const CodeGenIntrinsic *IntInfo = N->getIntrinsicInfo(CDP)) {
+      ModRefInfo MR = IntInfo->ME.getModRef();
       // If this is an intrinsic, analyze it.
-      if (IntInfo->ModRef & CodeGenIntrinsic::MR_Ref)
-        mayLoad = true;// These may load memory.
+      if (isRefSet(MR))
+        mayLoad = true; // These may load memory.
 
-      if (IntInfo->ModRef & CodeGenIntrinsic::MR_Mod)
-        mayStore = true;// Intrinsics that can write to memory are 'mayStore'.
+      if (isModSet(MR))
+        mayStore = true; // Intrinsics that can write to memory are 'mayStore'.
 
-      if (IntInfo->ModRef >= CodeGenIntrinsic::ReadWriteMem ||
-          IntInfo->hasSideEffects)
-        // ReadWriteMem intrinsics can have other strange effects.
+      // Consider intrinsics that don't specify any restrictions on memory
+      // effects as having a side-effect.
+      if (IntInfo->ME == MemoryEffects::unknown() || IntInfo->hasSideEffects)
         hasSideEffects = true;
     }
   }
 
 };
 
 static bool InferFromPattern(CodeGenInstruction &InstInfo,
                              const InstAnalyzer &PatInfo,

llvm/utils/TableGen/CodeGenIntrinsics.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_UTILS_TABLEGEN_CODEGENINTRINSICS_H
 #define LLVM_UTILS_TABLEGEN_CODEGENINTRINSICS_H
 
 #include "SDNodeProperties.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/MachineValueType.h"
+#include "llvm/Support/ModRef.h"
 #include <string>
 #include <vector>
 
 namespace llvm {
 class Record;
 class RecordKeeper;
 
 struct CodeGenIntrinsic {
struct IntrinsicSignature {
     std::vector<MVT::SimpleValueType> ParamVTs;
 
     /// The records for each parameter type.
     std::vector<Record *> ParamTypeDefs;
   };
 
   IntrinsicSignature IS;
 
-  /// Bit flags describing the type (ref/mod) and location of memory
-  /// accesses that may be performed by the intrinsics. Analogous to
-  /// \c FunctionModRefBehaviour.
-  enum ModRefBits {
-    /// The intrinsic may access memory that is otherwise inaccessible via
-    /// LLVM IR.
-    MR_InaccessibleMem = 1,
-
-    /// The intrinsic may access memory through pointer arguments.
-    /// LLVM IR.
-    MR_ArgMem = 2,
-
-    /// The intrinsic may access memory anywhere, i.e. it is not restricted
-    /// to access through pointer arguments.
-    MR_Anywhere = 4 | MR_ArgMem | MR_InaccessibleMem,
-
-    /// The intrinsic may read memory.
-    MR_Ref = 8,
-
-    /// The intrinsic may write memory.
-    MR_Mod = 16,
-
-    /// The intrinsic may both read and write memory.
-    MR_ModRef = MR_Ref | MR_Mod,
-  };
-
-  /// Memory mod/ref behavior of this intrinsic, corresponding to intrinsic
-  /// properties (IntrReadMem, IntrArgMemOnly, etc.).
-  enum ModRefBehavior {
-    NoMem = 0,
-    ReadArgMem = MR_Ref | MR_ArgMem,
-    ReadInaccessibleMem = MR_Ref | MR_InaccessibleMem,
-    ReadInaccessibleMemOrArgMem = MR_Ref | MR_ArgMem | MR_InaccessibleMem,
-    ReadMem = MR_Ref | MR_Anywhere,
-    WriteArgMem = MR_Mod | MR_ArgMem,
-    WriteInaccessibleMem = MR_Mod | MR_InaccessibleMem,
-    WriteInaccessibleMemOrArgMem = MR_Mod | MR_ArgMem | MR_InaccessibleMem,
-    WriteMem = MR_Mod | MR_Anywhere,
-    ReadWriteArgMem = MR_ModRef | MR_ArgMem,
-    ReadWriteInaccessibleMem = MR_ModRef | MR_InaccessibleMem,
-    ReadWriteInaccessibleMemOrArgMem = MR_ModRef | MR_ArgMem |
-                                       MR_InaccessibleMem,
-    ReadWriteMem = MR_ModRef | MR_Anywhere,
-  };
-  ModRefBehavior ModRef;
+  /// Memory effects of the intrinsic.
+  MemoryEffects ME = MemoryEffects::unknown();
 
   /// SDPatternOperator Properties applied to the intrinsic.
   unsigned Properties;
 
   /// This is set to true if the intrinsic is overloaded by its argument
   /// types.
   bool isOverloaded;
 

llvm/utils/TableGen/CodeGenTarget.cpp

CodeGenIntrinsicTable::CodeGenIntrinsicTable(const RecordKeeper &RC) {
   Targets.back().Count = Intrinsics.size() - Targets.back().Offset;
 }
 
 CodeGenIntrinsic::CodeGenIntrinsic(Record *R,
                                    std::vector<Record *> DefaultProperties) {
   TheDef = R;
   std::string DefName = std::string(R->getName());
   ArrayRef<SMLoc> DefLoc = R->getLoc();
-  ModRef = ReadWriteMem;
   Properties = 0;
   isOverloaded = false;
   isCommutative = false;
   canThrow = false;
   isNoReturn = false;
   isNoCallback = false;
   isNoSync = false;
   isNoFree = false;
if (R->getValueAsBit("DisableDefaultAttributes"))
     return;
 
   for (Record *Rec : DefaultProperties)
     setProperty(Rec);
 }
 
 void CodeGenIntrinsic::setProperty(Record *R) {
   if (R->getName() == "IntrNoMem")
-    ModRef = NoMem;
+    ME = MemoryEffects::none();
   else if (R->getName() == "IntrReadMem") {
-    if (!(ModRef & MR_Ref))
+    if (ME.onlyWritesMemory())
       PrintFatalError(TheDef->getLoc(),
                       Twine("IntrReadMem cannot be used after IntrNoMem or "
                             "IntrWriteMem. Default is ReadWrite"));
-    ModRef = ModRefBehavior(ModRef & ~MR_Mod);
+    ME &= MemoryEffects::readOnly();
   } else if (R->getName() == "IntrWriteMem") {
-    if (!(ModRef & MR_Mod))
+    if (ME.onlyReadsMemory())
       PrintFatalError(TheDef->getLoc(),
                       Twine("IntrWriteMem cannot be used after IntrNoMem or "
                             "IntrReadMem. Default is ReadWrite"));
-    ModRef = ModRefBehavior(ModRef & ~MR_Ref);
+    ME &= MemoryEffects::writeOnly();
   } else if (R->getName() == "IntrArgMemOnly")
-    ModRef = ModRefBehavior((ModRef & ~MR_Anywhere) | MR_ArgMem);
+    ME &= MemoryEffects::argMemOnly();
   else if (R->getName() == "IntrInaccessibleMemOnly")
-    ModRef = ModRefBehavior((ModRef & ~MR_Anywhere) | MR_InaccessibleMem);
+    ME &= MemoryEffects::inaccessibleMemOnly();
   else if (R->getName() == "IntrInaccessibleMemOrArgMemOnly")
-    ModRef = ModRefBehavior((ModRef & ~MR_Anywhere) | MR_ArgMem |
-                            MR_InaccessibleMem);
+    ME &= MemoryEffects::inaccessibleOrArgMemOnly();
   else if (R->getName() == "Commutative")
     isCommutative = true;
   else if (R->getName() == "Throws")
     canThrow = true;
   else if (R->getName() == "IntrNoDuplicate")
     isNoDuplicate = true;
   else if (R->getName() == "IntrNoMerge")
     isNoMerge = true;

llvm/utils/TableGen/IntrinsicEmitter.cpp

Optional<bool> compareFnAttributes(const CodeGenIntrinsic *L,
 
   if (L->isSpeculatable != R->isSpeculatable)
     return R->isSpeculatable;
 
   if (L->hasSideEffects != R->hasSideEffects)
     return R->hasSideEffects;
 
   // Try to order by readonly/readnone attribute.
-  CodeGenIntrinsic::ModRefBehavior LK = L->ModRef;
-  CodeGenIntrinsic::ModRefBehavior RK = R->ModRef;
+  uint32_t LK = L->ME.toIntValue();
+  uint32_t RK = R->ME.toIntValue();
   if (LK != RK) return (LK > RK);
 
   return None;
 }
 
 struct FnAttributeComparator {
   bool operator()(const CodeGenIntrinsic *L, const CodeGenIntrinsic *R) const {
     return compareFnAttributes(L, R).value_or(false);
if (Intrinsic.isNoDuplicate)
       OS << "      Attribute::get(C, Attribute::NoDuplicate),\n";
     if (Intrinsic.isNoMerge)
       OS << "      Attribute::get(C, Attribute::NoMerge),\n";
     if (Intrinsic.isConvergent)
       OS << "      Attribute::get(C, Attribute::Convergent),\n";
     if (Intrinsic.isSpeculatable)
       OS << "      Attribute::get(C, Attribute::Speculatable),\n";
 
-    switch (Intrinsic.ModRef) {
-    case CodeGenIntrinsic::NoMem:
-      if (Intrinsic.hasSideEffects)
-        break;
-      OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::none()),\n";
-      break;
-    case CodeGenIntrinsic::ReadArgMem:
-      OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::argMemOnly(ModRefInfo::Ref)),\n";
-      break;
-    case CodeGenIntrinsic::ReadMem:
-      OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::readOnly()),\n";
-      break;
-    case CodeGenIntrinsic::ReadInaccessibleMem:
-      OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::inaccessibleMemOnly(ModRefInfo::Ref)),\n";
-      break;
-    case CodeGenIntrinsic::ReadInaccessibleMemOrArgMem:
-      OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::inaccessibleOrArgMemOnly(ModRefInfo::Ref)),\n";
-      break;
-      break;
-    case CodeGenIntrinsic::WriteArgMem:
-      OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::argMemOnly(ModRefInfo::Mod)),\n";
-      break;
-    case CodeGenIntrinsic::WriteMem:
-      OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::writeOnly()),\n";
-      break;
-    case CodeGenIntrinsic::WriteInaccessibleMem:
-      OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::inaccessibleMemOnly(ModRefInfo::Mod)),\n";
-      break;
-    case CodeGenIntrinsic::WriteInaccessibleMemOrArgMem:
-      OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::inaccessibleOrArgMemOnly(ModRefInfo::Mod)),\n";
-      break;
-    case CodeGenIntrinsic::ReadWriteArgMem:
+    MemoryEffects ME = Intrinsic.ME;
+    // TODO: IntrHasSideEffects should affect not only readnone intrinsics.
+    if (ME.doesNotAccessMemory() && Intrinsic.hasSideEffects)
+      ME = MemoryEffects::unknown();
+    if (ME != MemoryEffects::unknown()) {
       OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::argMemOnly(ModRefInfo::ModRef)),\n";
-      break;
-    case CodeGenIntrinsic::ReadWriteInaccessibleMem:
-      OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::inaccessibleMemOnly(ModRefInfo::ModRef)),\n";
-      break;
-    case CodeGenIntrinsic::ReadWriteInaccessibleMemOrArgMem:
-      OS << "      Attribute::getWithMemoryEffects(C, "
-         << "MemoryEffects::inaccessibleOrArgMemOnly(ModRefInfo::ModRef)),\n";
-      break;
-    case CodeGenIntrinsic::ReadWriteMem:
-      break;
+         << "MemoryEffects::createFromIntValue(" << ME.toIntValue() << ")),\n";
     }
     OS << "    });\n";
   }
   OS << "  }\n";
   OS << "}\n\n";
   OS << "AttributeList Intrinsic::getAttributes(LLVMContext &C, ID id) {\n";
 
   // Compute the maximum number of attribute arguments and the map
for (const auto &[AttrIdx, Attrs] :
         continue;
 
       unsigned ID = UniqArgAttributes.find(Attrs)->second;
       OS << "      AS[" << numAttrs++ << "] = {" << AttrIdx
          << ", getIntrinsicArgAttributeSet(C, " << ID << ")};\n";
     }
 
     if (!Intrinsic.canThrow ||
-        (Intrinsic.ModRef != CodeGenIntrinsic::ReadWriteMem &&
+        (Intrinsic.ME != MemoryEffects::unknown() &&
          !Intrinsic.hasSideEffects) ||
         Intrinsic.isNoReturn || Intrinsic.isNoCallback || Intrinsic.isNoSync ||
         Intrinsic.isNoFree || Intrinsic.isWillReturn || Intrinsic.isCold ||
         Intrinsic.isNoDuplicate || Intrinsic.isNoMerge ||
         Intrinsic.isConvergent || Intrinsic.isSpeculatable) {
       unsigned ID = UniqFnAttributes.find(&Intrinsic)->second;
       OS << "      AS[" << numAttrs++ << "] = {AttributeList::FunctionIndex, "
          << "getIntrinsicFnAttributeSet(C, " << ID << ")};\n";