[mlir] Add support for querying the ModRef behavior from the AliasAnalysis class

[rriddle]

Summary

This allows for checking if a given operation may modify/reference/or both a given value. Right now this API is limited to Value based memory locations, but we should expand this to include attribute based values at some point. This is left for future work because the rest of the AliasAnalysis API also has this restriction.

[silvas]

mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp

346

This looks like it could get very expensive for multiple nested scf.if ops. It even looks like it could go quadratic for certain kinds of query patterns (e.g. calling getModRef on each operation in a function)

[bondhugula]

mlir/include/mlir/Analysis/AliasAnalysis.h

94

The class doc comment refers to memory access and memory alone, while an aliasing relation is being referred to here. I think a line or two is missing on the connection in the class doc comment.

150–155

Comment copied.

mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp

198

?

[tschuett]

Could you document the differences to:
https://github.com/llvm/llvm-project/blob/cc58e8918b70d5698ec06c0b6e4c6e4c27971870/llvm/include/llvm/Analysis/AliasAnalysis.h#L148
for future reference?

[tschuett]

Similar to ModRefInfo, you used an unscoped enum to facilitate the logical operations. Is a design based on a type-safe scoped enum too verbose?

[rriddle]

update

[rriddle]

In D101673#2731435, @tschuett wrote:

Similar to ModRefInfo, you used an unscoped enum to facilitate the logical operations. Is a design based on a type-safe scoped enum too verbose?

IMO yeah. Just switched to using static creation methods, given that access to the kind isn't really necessary anyways. I'll switch AliasResult to do the same in a followup.

mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp

198

It's marking what the section corresponds to, given that I use the same LocalAliasAnalysis below.

346

Yeah, I agree. For now just added a TODO, will handle as necessary in a followup.

mlir/include/mlir/Analysis/AliasAnalysis.h

public:
   bool isMay() const { return kind == MayAlias; }
 
   /// Returns if this result is a must alias.
   bool isMust() const { return kind == MustAlias; }
 
   /// Returns if this result is a partial alias.
   bool isPartial() const { return kind == PartialAlias; }
 
-  /// Return the internal kind of this alias result.
-  Kind getKind() const { return kind; }
+  /// Print this alias result to the provided output stream.
+  void print(raw_ostream &os) const;
 
 private:
   /// The internal kind of the result.
   Kind kind;
 };
 
+inline raw_ostream &operator<<(raw_ostream &os, const AliasResult &result) {
+  result.print(os);
+  return os;
+}
+
+//===----------------------------------------------------------------------===//
+// ModRefResult
+//===----------------------------------------------------------------------===//
+
+/// The possible results of whether a memory access modifies or references
+/// a memory location. The possible results are: no access at all, a
+/// modification, a reference, or both a modification and a reference.
+class LLVM_NODISCARD ModRefResult {
+  /// Note: This is a simplified version of the ModRefResult in
+  /// `llvm/Analysis/AliasAnalysis.h`, and namely removes the `Must` concept. If
+  /// this becomes useful/necessary we should add it here.
+  enum class Kind {
+    /// The access neither references nor modifies the value stored in memory.
+    NoModRef = 0,
+    /// The access may reference the value stored in memory.
+    Ref = 1,
+    /// The access may modify the value stored in memory.
+    Mod = 2,
+    /// The access may reference and may modify the value stored in memory.
+    ModRef = Ref | Mod,
+  };
+
+public:
+  bool operator==(const ModRefResult &rhs) const { return kind == rhs.kind; }
+  bool operator!=(const ModRefResult &rhs) const { return !(*this == rhs); }
+
+  /// Return a new result that indicates that the memory access neither
+  /// references nor modifies the value stored in memory.
+  static ModRefResult getNoModRef() { return Kind::NoModRef; }
+
+  /// Return a new result that indicates that the memory access may reference
+  /// the value stored in memory.
+  static ModRefResult getRef() { return Kind::Ref; }
+
+  /// Return a new result that indicates that the memory access may modify the
+  /// value stored in memory.
+  static ModRefResult getMod() { return Kind::Mod; }
+
+  /// Return a new result that indicates that the memory access may reference
+  /// and may modify the value stored in memory.
+  static ModRefResult getModAndRef() { return Kind::ModRef; }
+
+  /// Returns if this result does not modify or reference memory.
+  LLVM_NODISCARD bool isNoModRef() const { return kind == Kind::NoModRef; }
+
+  /// Returns if this result modifies memory.
+  LLVM_NODISCARD bool isMod() const {
+    return static_cast<int>(kind) & static_cast<int>(Kind::Mod);
+  }
+
+  /// Returns if this result references memory.
+  LLVM_NODISCARD bool isRef() const {
+    return static_cast<int>(kind) & static_cast<int>(Kind::Ref);
+  }
+
+  /// Returns if this result modifies *or* references memory.
+  LLVM_NODISCARD bool isModOrRef() const { return kind != Kind::NoModRef; }
+
+  /// Returns if this result modifies *and* references memory.
+  LLVM_NODISCARD bool isModAndRef() const { return kind == Kind::ModRef; }
+
+  /// Merge this ModRef result with `other` and return the result.
+  ModRefResult merge(const ModRefResult &other) {
+    return ModRefResult(static_cast<Kind>(static_cast<int>(kind) |
+                                          static_cast<int>(other.kind)));
+  }
+  /// Intersect this ModRef result with `other` and return the result.
+  ModRefResult intersect(const ModRefResult &other) {
+    return ModRefResult(static_cast<Kind>(static_cast<int>(kind) &
+                                          static_cast<int>(other.kind)));
+  }
+
+  /// Print this ModRef result to the provided output stream.
+  void print(raw_ostream &os) const;
+
+private:
+  ModRefResult(Kind kind) : kind(kind) {}
+
+  /// The internal kind of the result.
+  Kind kind;
+};
+
+inline raw_ostream &operator<<(raw_ostream &os, const ModRefResult &result) {
+  result.print(os);
+  return os;
+}
+
 //===----------------------------------------------------------------------===//
 // AliasAnalysisTraits
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 /// This class contains various internal trait classes used by the main
 /// AliasAnalysis class below.
 struct AliasAnalysisTraits {
   /// This class represents the `Concept` of an alias analysis implementation.
   /// It is the abstract base class used by the AliasAnalysis class for
   /// querying into derived analysis implementations.
   class Concept {
   public:
     virtual ~Concept() {}
 
     /// Given two values, return their aliasing behavior.
     virtual AliasResult alias(Value lhs, Value rhs) = 0;
+
+    /// Return the modify-reference behavior of `op` on `location`.
+    virtual ModRefResult getModRef(Operation *op, Value location) = 0;
   };
 
   /// This class represents the `Model` of an alias analysis implementation
   /// `ImplT`. A model is instantiated for each alias analysis implementation
   /// to implement the `Concept` without the need for the derived
   /// implementation to inherit from the `Concept` class.
   template <typename ImplT> class Model final : public Concept {
   public:
     explicit Model(ImplT &&impl) : impl(std::forward<ImplT>(impl)) {}
     ~Model() override = default;
 
     /// Given two values, return their aliasing behavior.
     AliasResult alias(Value lhs, Value rhs) final {
       return impl.alias(lhs, rhs);
     }
 
+    /// Return the modify-reference behavior of `op` on `location`.
+    ModRefResult getModRef(Operation *op, Value location) final {
+      return impl.getModRef(op, location);
+    }
+
   private:
     ImplT impl;
   };
 };
 } // end namespace detail
 
 //===----------------------------------------------------------------------===//
 // AliasAnalysis
public:
 
   /// Add a new alias analysis implementation `AnalysisT` to this analysis
   /// aggregate. This allows for users to access this implementation when
   /// performing alias queries. Implementations added here must provide the
   /// following:
   ///   * AnalysisT(AnalysisT &&)
   ///   * AliasResult alias(Value lhs, Value rhs)
   ///     - This method returns an `AliasResult` that corresponds to the
-  ///       aliasing behavior between `lhs` and `rhs`.
+  ///       aliasing behavior between `lhs` and `rhs`. The conservative "I don't
+  ///       know" result of this method should be MayAlias.
+  ///   * ModRefResult getModRef(Operation *op, Value location)
+  ///     - This method returns a `ModRefResult` that corresponds to the
+  ///       modify-reference behavior of `op` on the given `location`. The
+  ///       conservative "I don't know" result of this method should be ModRef.
   template <typename AnalysisT>
   void addAnalysisImplementation(AnalysisT &&analysis) {
     aliasImpls.push_back(
         std::make_unique<Model<AnalysisT>>(std::forward<AnalysisT>(analysis)));
   }
 
   //===--------------------------------------------------------------------===//
   // Alias Queries
   //===--------------------------------------------------------------------===//
 
   /// Given two values, return their aliasing behavior.
   AliasResult alias(Value lhs, Value rhs);
 
+  //===--------------------------------------------------------------------===//
+  // ModRef Queries
+  //===--------------------------------------------------------------------===//
+
+  /// Return the modify-reference behavior of `op` on `location`.
+  ModRefResult getModRef(Operation *op, Value location);
+
 private:
   /// A set of internal alias analysis implementations.
   SmallVector<std::unique_ptr<Concept>, 4> aliasImpls;
 };
 
 } // end namespace mlir
 
 #endif // MLIR_ANALYSIS_ALIASANALYSIS_H_

mlir/include/mlir/Analysis/AliasAnalysis/LocalAliasAnalysis.h

 namespace mlir {
 /// This class implements a location form of aliasing that tries to identify the
 /// underlying values addressed by each value and performs a few basic checks to
 /// see if they alias.
 class LocalAliasAnalysis {
 public:
   /// Given two values, return their aliasing behavior.
   AliasResult alias(Value lhs, Value rhs);
+
+  /// Return the modify-reference behavior of `op` on `location`.
+  ModRefResult getModRef(Operation *op, Value location);
 };
 } // end namespace mlir
 
 #endif // MLIR_ANALYSIS_ALIASANALYSIS_LOCALALIASANALYSIS_H_

mlir/lib/Analysis/AliasAnalysis.cpp

if (kind == other.kind)
     return *this;
   // A mix of PartialAlias and MustAlias is PartialAlias.
   if ((isPartial() && other.isMust()) || (other.isPartial() && isMust()))
     return PartialAlias;
   // Otherwise, don't assume anything.
   return MayAlias;
 }
 
+void AliasResult::print(raw_ostream &os) const {
+  switch (kind) {
+  case Kind::NoAlias:
+    os << "NoAlias";
+    break;
+  case Kind::MayAlias:
+    os << "MayAlias";
+    break;
+  case Kind::PartialAlias:
+    os << "PartialAlias";
+    break;
+  case Kind::MustAlias:
+    os << "MustAlias";
+    break;
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// ModRefResult
+//===----------------------------------------------------------------------===//
+
+void ModRefResult::print(raw_ostream &os) const {
+  switch (kind) {
+  case Kind::NoModRef:
+    os << "NoModRef";
+    break;
+  case Kind::Ref:
+    os << "Ref";
+    break;
+  case Kind::Mod:
+    os << "Mod";
+    break;
+  case Kind::ModRef:
+    os << "ModRef";
+    break;
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // AliasAnalysis
 //===----------------------------------------------------------------------===//
 
 AliasAnalysis::AliasAnalysis(Operation *op) {
   addAnalysisImplementation(LocalAliasAnalysis());
 }
 
-/// Given the two values, return their aliasing behavior.
 AliasResult AliasAnalysis::alias(Value lhs, Value rhs) {
   // Check each of the alias analysis implemenations for an alias result.
   for (const std::unique_ptr<Concept> &aliasImpl : aliasImpls) {
     AliasResult result = aliasImpl->alias(lhs, rhs);
     if (!result.isMay())
       return result;
   }
   return AliasResult::MayAlias;
 }
+
+ModRefResult AliasAnalysis::getModRef(Operation *op, Value location) {
+  // Compute the mod-ref behavior by refining a top `ModRef` result with each of
+  // the alias analysis implementations. We early exit at the point where we
+  // refine down to a `NoModRef`.
+  ModRefResult result = ModRefResult::getModAndRef();
+  for (const std::unique_ptr<Concept> &aliasImpl : aliasImpls) {
+    result = result.intersect(aliasImpl->getModRef(op, location));
+    if (result.isNoModRef())
+      return result;
+  }
+  return result;
+}

mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp

 static void collectUnderlyingAddressValues(Value value,
                                            SmallVectorImpl<Value> &output) {
   DenseSet<Value> visited;
   collectUnderlyingAddressValues(value, maxUnderlyingValueSearchDepth, visited,
                                  output);
 }
 
 //===----------------------------------------------------------------------===//
-// LocalAliasAnalysis
+// LocalAliasAnalysis: alias
 //===----------------------------------------------------------------------===//
 
 /// Given a value, try to get an allocation effect attached to it. If
 /// successful, `allocEffect` is populated with the effect. If an effect was
 /// found, `allocScopeOp` is also specified if a parent operation of `value`
 /// could be identified that bounds the scope of the allocated value; i.e. if
 /// non-null it specifies the parent operation that the allocation does not
 /// escape. If no scope is found, `allocScopeOp` is set to nullptr.
for (Value rhsVal : rhsValues) {
       AliasResult nextResult = aliasImpl(lhsVal, rhsVal);
       result = result ? result->merge(nextResult) : nextResult;
     }
   }
 
   // We should always have a valid result here.
   return *result;
 }
+
+//===----------------------------------------------------------------------===//
+// LocalAliasAnalysis: getModRef
+//===----------------------------------------------------------------------===//
+
+ModRefResult LocalAliasAnalysis::getModRef(Operation *op, Value location) {
+  // Check to see if this operation relies on nested side effects.
+  if (op->hasTrait<OpTrait::HasRecursiveSideEffects>()) {
+    // TODO: To check recursive operations we need to check all of the nested
+    // operations, which can result in a quadratic number of queries. We should
+    // introduce some caching of some kind to help alleviate this, especially as
+    // this caching could be used in other areas of the codebase (e.g. when
+    // checking `wouldOpBeTriviallyDead`).
+    return ModRefResult::getModAndRef();
+  }
+
+  // Otherwise, check to see if this operation has a memory effect interface.
+  MemoryEffectOpInterface interface = dyn_cast<MemoryEffectOpInterface>(op);
+  if (!interface)
+    return ModRefResult::getModAndRef();
+
+  // Build a ModRefResult by merging the behavior of the effects of this
+  // operation.
+  SmallVector<MemoryEffects::EffectInstance> effects;
+  interface.getEffects(effects);
+
+  ModRefResult result = ModRefResult::getNoModRef();
+  for (const MemoryEffects::EffectInstance &effect : effects) {
+    if (isa<MemoryEffects::Allocate, MemoryEffects::Free>(effect.getEffect()))
+      continue;
+
+    // Check for an alias between the effect and our memory location.
+    // TODO: Add support for checking an alias with a symbol reference.
+    AliasResult aliasResult = AliasResult::MayAlias;
+    if (Value effectValue = effect.getValue())
+      aliasResult = alias(effectValue, location);
+
+    // If we don't alias, ignore this effect.
+    if (aliasResult.isNo())
+      continue;
+
+    // Merge in the corresponding mod or ref for this effect.
+    if (isa<MemoryEffects::Read>(effect.getEffect())) {
+      result = result.merge(ModRefResult::getRef());
+    } else {
+      assert(isa<MemoryEffects::Write>(effect.getEffect()));
+      result = result.merge(ModRefResult::getMod());
+    }
+    if (result.isModAndRef())
+      break;
+  }
+  return result;
+}

mlir/test/Analysis/test-alias-analysis-modref.mlir

+// RUN: mlir-opt %s -pass-pipeline='func(test-alias-analysis-modref)' -split-input-file -allow-unregistered-dialect 2>&1 | FileCheck %s
+
+// CHECK-LABEL: Testing : "no_side_effects"
+// CHECK: alloc -> func.region0#0: NoModRef
+// CHECK: dealloc -> func.region0#0: NoModRef
+// CHECK: return -> func.region0#0: NoModRef
+func @no_side_effects(%arg: memref<2xf32>) attributes {test.ptr = "func"} {
+  %1 = memref.alloc() {test.ptr = "alloc"} : memref<8x64xf32>
+  memref.dealloc %1 {test.ptr = "dealloc"} : memref<8x64xf32>
+  return {test.ptr = "return"}
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "simple"
+// CHECK-DAG: store -> alloc#0: Mod
+// CHECK-DAG: load -> alloc#0: Ref
+
+// CHECK-DAG: store -> func.region0#0: NoModRef
+// CHECK-DAG: load -> func.region0#0: NoModRef
+func @simple(%arg: memref<i32>, %value: i32) attributes {test.ptr = "func"} {
+  %1 = memref.alloca() {test.ptr = "alloc"} : memref<i32>
+  memref.store %value, %1[] {test.ptr = "store"} : memref<i32>
+  %2 = memref.load %1[] {test.ptr = "load"} : memref<i32>
+  return {test.ptr = "return"}
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "mayalias"
+// CHECK-DAG: store -> func.region0#0: Mod
+// CHECK-DAG: load -> func.region0#0: Ref
+
+// CHECK-DAG: store -> func.region0#1: Mod
+// CHECK-DAG: load -> func.region0#1: Ref
+func @mayalias(%arg0: memref<i32>, %arg1: memref<i32>, %value: i32) attributes {test.ptr = "func"} {
+  memref.store %value, %arg1[] {test.ptr = "store"} : memref<i32>
+  %1 = memref.load %arg1[] {test.ptr = "load"} : memref<i32>
+  return {test.ptr = "return"}
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "recursive"
+// CHECK-DAG: if -> func.region0#0: ModRef
+// CHECK-DAG: if -> func.region0#1: ModRef
+
+// TODO: This is provably NoModRef, but requires handling recursive side
+// effects.
+// CHECK-DAG: if -> alloc#0: ModRef
+func @recursive(%arg0: memref<i32>, %arg1: memref<i32>, %cond: i1, %value: i32) attributes {test.ptr = "func"} {
+  %0 = memref.alloca() {test.ptr = "alloc"} : memref<i32>
+  scf.if %cond {
+    memref.store %value, %arg0[] : memref<i32>
+    %1 = memref.load %arg0[] : memref<i32>
+  } {test.ptr = "if"}
+  return {test.ptr = "return"}
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "unknown"
+// CHECK-DAG: unknown -> func.region0#0: ModRef
+func @unknown(%arg0: memref<i32>) attributes {test.ptr = "func"} {
+  "foo.op"() {test.ptr = "unknown"} : () -> ()
+  return
+}

mlir/test/lib/Analysis/TestAliasAnalysis.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/AliasAnalysis.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
+/// Print a value that is used as an operand of an alias query.
+static void printAliasOperand(Operation *op) {
+  llvm::errs() << op->getAttrOfType<StringAttr>("test.ptr").getValue();
+}
+static void printAliasOperand(Value value) {
+  if (BlockArgument arg = value.dyn_cast<BlockArgument>()) {
+    Region *region = arg.getParentRegion();
+    unsigned parentBlockNumber =
+        std::distance(region->begin(), arg.getOwner()->getIterator());
+    llvm::errs() << region->getParentOp()
+                        ->getAttrOfType<StringAttr>("test.ptr")
+                        .getValue()
+                 << ".region" << region->getRegionNumber();
+    if (parentBlockNumber != 0)
+      llvm::errs() << ".block" << parentBlockNumber;
+    llvm::errs() << "#" << arg.getArgNumber();
+    return;
+  }
+  OpResult result = value.cast<OpResult>();
+  printAliasOperand(result.getOwner());
+  llvm::errs() << "#" << result.getResultNumber();
+}
+
+//===----------------------------------------------------------------------===//
+// Testing AliasResult
+//===----------------------------------------------------------------------===//
+
 namespace {
 struct TestAliasAnalysisPass
     : public PassWrapper<TestAliasAnalysisPass, OperationPass<>> {
   void runOnOperation() override {
-    llvm::errs() << "Testing : ";
-    if (Attribute testName = getOperation()->getAttr("test.name"))
-      llvm::errs() << testName << "\n";
-    else
-      llvm::errs() << getOperation()->getAttr("sym_name") << "\n";
+    llvm::errs() << "Testing : " << getOperation()->getAttr("sym_name") << "\n";
 
     // Collect all of the values to check for aliasing behavior.
     AliasAnalysis &aliasAnalysis = getAnalysis<AliasAnalysis>();
     SmallVector<Value, 32> valsToCheck;
     getOperation()->walk([&](Operation *op) {
       if (!op->getAttr("test.ptr"))
         return;
       valsToCheck.append(op->result_begin(), op->result_end());
       for (Region &region : op->getRegions())
         for (Block &block : region)
           valsToCheck.append(block.args_begin(), block.args_end());
     });
 
     // Check for aliasing behavior between each of the values.
     for (auto it = valsToCheck.begin(), e = valsToCheck.end(); it != e; ++it)
       for (auto innerIt = valsToCheck.begin(); innerIt != it; ++innerIt)
         printAliasResult(aliasAnalysis.alias(*innerIt, *it), *innerIt, *it);
   }
 
   /// Print the result of an alias query.
   void printAliasResult(AliasResult result, Value lhs, Value rhs) {
     printAliasOperand(lhs);
     llvm::errs() << " <-> ";
     printAliasOperand(rhs);
-    llvm::errs() << ": ";
-
-    switch (result.getKind()) {
-    case AliasResult::NoAlias:
-      llvm::errs() << "NoAlias";
-      break;
-    case AliasResult::MayAlias:
-      llvm::errs() << "MayAlias";
-      break;
-    case AliasResult::PartialAlias:
-      llvm::errs() << "PartialAlias";
-      break;
-    case AliasResult::MustAlias:
-      llvm::errs() << "MustAlias";
-      break;
-    }
-    llvm::errs() << "\n";
-  }
-  /// Print a value that is used as an operand of an alias query.
-  void printAliasOperand(Value value) {
-    if (BlockArgument arg = value.dyn_cast<BlockArgument>()) {
-      Region *region = arg.getParentRegion();
-      unsigned parentBlockNumber =
-          std::distance(region->begin(), arg.getOwner()->getIterator());
-      llvm::errs() << region->getParentOp()
-                          ->getAttrOfType<StringAttr>("test.ptr")
-                          .getValue()
-                   << ".region" << region->getRegionNumber();
-      if (parentBlockNumber != 0)
-        llvm::errs() << ".block" << parentBlockNumber;
-      llvm::errs() << "#" << arg.getArgNumber();
+    llvm::errs() << ": " << result << "\n";
+};
+} // end anonymous namespace
+
+//===----------------------------------------------------------------------===//
+// Testing ModRefResult
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct TestAliasAnalysisModRefPass
+    : public PassWrapper<TestAliasAnalysisModRefPass, OperationPass<>> {
+  void runOnOperation() override {
+    llvm::errs() << "Testing : " << getOperation()->getAttr("sym_name") << "\n";
+
+    // Collect all of the values to check for aliasing behavior.
+    AliasAnalysis &aliasAnalysis = getAnalysis<AliasAnalysis>();
+    SmallVector<Value, 32> valsToCheck;
+    getOperation()->walk([&](Operation *op) {
+      if (!op->getAttr("test.ptr"))
         return;
+      valsToCheck.append(op->result_begin(), op->result_end());
+      for (Region &region : op->getRegions())
+        for (Block &block : region)
+          valsToCheck.append(block.args_begin(), block.args_end());
+    });
+
+    // Check for aliasing behavior between each of the values.
+    for (auto it = valsToCheck.begin(), e = valsToCheck.end(); it != e; ++it) {
+      getOperation()->walk([&](Operation *op) {
+        if (!op->getAttr("test.ptr"))
+          return;
+        printModRefResult(aliasAnalysis.getModRef(op, *it), op, *it);
+      });
     }
-    OpResult result = value.cast<OpResult>();
-    llvm::errs()
-        << result.getOwner()->getAttrOfType<StringAttr>("test.ptr").getValue()
-        << "#" << result.getResultNumber();
+  }
+
+  /// Print the result of an alias query.
+  void printModRefResult(ModRefResult result, Operation *op, Value location) {
+    printAliasOperand(op);
+    llvm::errs() << " -> ";
+    printAliasOperand(location);
+    llvm::errs() << ": " << result << "\n";
   }
 };
 } // end anonymous namespace
 
+//===----------------------------------------------------------------------===//
+// Pass Registration
+//===----------------------------------------------------------------------===//
+
 namespace mlir {
 namespace test {
 void registerTestAliasAnalysisPass() {
-  PassRegistration<TestAliasAnalysisPass> pass("test-alias-analysis",
-                                               "Test alias analysis results.");
+  PassRegistration<TestAliasAnalysisPass> aliasPass(
+      "test-alias-analysis", "Test alias analysis results.");
+  PassRegistration<TestAliasAnalysisModRefPass> modRefPass(
+      "test-alias-analysis-modref", "Test alias analysis ModRef results.");
 }
 } // namespace test
 } // namespace mlir