[mlir] Add initial support for an alias analysis framework in MLIR

[rriddle]

Summary

This revision adds a new AliasAnalysis class that represents the main alias analysis interface in MLIR. The purpose of this class is not to hold the aliasing logic itself, but to provide an interface into various different alias analysis implementations. As it evolves this should allow for users to plug in specialized alias analysis implementations for their own needs, and have them immediately usable by other analyses and transformations.

This revision also adds an initial simple generic alias, LocalAliasAnalysis, that provides support for performing stateless local alias queries between values. This class is similar in scope to LLVM's BasicAA.

[mehdi_amini]

Do we have a Discourse thread for this already?

[ftynse]

Thanks, River, this looks useful! I have a couple of comments.

mlir/include/mlir/Analysis/AliasAnalysis.h

38

Does this also guarantee that there exists some non-overlapping portion? Or can this be used as "could not prove precise aliasing, but there is definitely some aliasing"?

132

it should also be move-constructible

mlir/lib/Analysis/AliasAnalysis.cpp

36

Do we expect other analyses to register themselves here, or do we rather expect the user of AliasAnalysis to add what they want?

42

If PartialAlias cases are a subset of MustAlias cases (see above), we may be returning too early here: an insufficiently precise analyses that happens to be first in the list returns PartialAlias but some other analysis further down in the list could return MustAlias.

44

Do we want a check, under NDEBUG that analyses don't contradict each other (e.g. we don't have NoAlias and MustAlias simultaneously)

mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp

1

Nit: //=== -> //===-

27

Nit: mention that the behavior if region is null follows the convention of RegionBranchOpInterface, i.e. the successor is assumed to be the parent op.

36

Nit: this deserves a doc

38

Can we just sink the definition into the lambda? This does not seem used anywhere else.

82

Shouldn't this also rely on RegionBranchOpInterface? There may be terminator that are not exactly return like, but for which we have the same sort of information

183

Nit: could we have a named constexpr for this and put it at the top of the file?

214

Nit: automatically

239–240

Should we then conservatively say constants may alias without further checking the values?

[ftynse]

mlir/lib/Analysis/AliasAnalysis.cpp

1

This file may require CMakeLists update

[silvas]

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

22

drive-by: not obvious to me why a freshly allocated value MayAlias the function argument. Surely even LocalAliasAnalysis can mark this NoAlias, especially since it already does so for the alloca case.

[rriddle]

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

22

This requires doing a proper escape analysis, which is a TODO in the code as an improvement. Will add a note here as well.

[nicolasvasilache]

Very cool, thanks River!
I have a bunch of use cases for this :)

[rriddle]

Resolve comments and rebase

[rriddle]

mlir/include/mlir/Analysis/AliasAnalysis.h

38

It does not guarantee that there is a non-overlapping portion, it simply guarantees that there is an overlap of some kind. It's not as strong as Must which is I know for a fact they completely alias, but is stronger than MayAlias which is effectively I don't know. When chaining together alias analysis results it is useful because MayAlias is not a strong result when it comes to merging, it will take whatever the other result is. PartialAlias establishes a precedent that there is some overlapping aliasing there, but it couldn't prove any more than that.

mlir/lib/Analysis/AliasAnalysis.cpp

1

I forget about that more often than I'd like to admit.

36

This is something that needs a bit more fleshing out(and some work in a couple of other areas), but the way that I see it now there are two scenarios that additional analysis implementations would be added:

• DialectInterface

Allow dialects to provide alias analyses that are specific to their types/related types. Given that we span many different domains, having dialects be able to plug in their own analysis implementations seems useful.

• External users via the PassPipeline(similar to how LLVM AAManager works)

Kind of along the same lines as above, but it is also useful to allow for external users that are building a pipeline to plugin in their own analyses that they are writing. This is a useful invariant IMO as it provides another mechanism to provide this information that may be toolchain specific, as well as simplifying the ability to test new implementations without changing upstream MLIR.

The API for each of these needs fleshed out, but I've attempted to write this initial skeleton in such a way that it will be easy to build these use cases in the future. For now, we can hardcode the specific default implementations here but in the future I imagine what we have here to simply be a default configuration.

44

The nature of alias analyses is that they may conflict. An easy example is type based alias analysis(TBAA). TBAA puts types into different alias classes, which determines what things that can alias with. For C++, float* and int* would have different classes. If we end up in a situation like:

int foo(int *ptr) {
  *ptr = 8;
  float *fptr = reinterpret_cast<float *>(ptr);
  *fptr = 100;
  return *ptr;
}

fptr and ptr must alias as per the local alias analysis here, but TBAA would say that they don't alias each other. So we can end up with NoAlias and MustAlias. In practice that's technically UB in C++, but for the sake of this analysis we just pick the first resolved result and move on. It gives determinism and allow for us to order the analyses in a way that the most conservative ones get picked up first.

https://godbolt.org/z/jq9xEq

mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp

82

For the situations where we don't have a proper trait, most likely yeah. RegionBranchOpInterface doesn't support that at the moment, and we don't have any use cases yet AFAIK. So I'd leave that to a separate change given that it would be usable by most other users of RegionBranchOpInterface.

239–240

Yeah, switched to may alias for now. We'll need to refine this for things like globals(via SymbolRefAttr) though, so also rephrased the TODO.

mlir/include/mlir/Analysis/AliasAnalysis.h

+//===- AliasAnalysis.h - Alias Analysis in MLIR -----------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This header file defines utilities and analyses for performing alias queries
+// and related memory queries in MLIR.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_ANALYSIS_ALIASANALYSIS_H_
+#define MLIR_ANALYSIS_ALIASANALYSIS_H_
+
+#include "mlir/IR/Operation.h"
+
+namespace mlir {
+
+//===----------------------------------------------------------------------===//
+// AliasResult
+//===----------------------------------------------------------------------===//
+
+/// The possible results of an alias query.
+class AliasResult {
+public:
+  enum Kind {
+    /// The two locations do not alias at all.
+    ///
+    /// This value is arranged to convert to false, while all other values
+    /// convert to true. This allows a boolean context to convert the result to
+    /// a binary flag indicating whether there is the possibility of aliasing.
+    NoAlias = 0,
+    /// The two locations may or may not alias. This is the least precise
+    /// result.
+    MayAlias,
+    /// The two locations alias, but only due to a partial overlap.
+    PartialAlias,
+    /// The two locations precisely alias each other.
+    MustAlias,
+  };
+
+  AliasResult(Kind kind) : kind(kind) {}
+  bool operator==(const AliasResult &other) const { return kind == other.kind; }
+  bool operator!=(const AliasResult &other) const { return !(*this == other); }
+
+  /// Allow conversion to bool to signal if there is an aliasing or not.
+  explicit operator bool() const { return kind != NoAlias; }
+
+  /// Merge this alias result with `other` and return a new result that
+  /// represents the conservative merge of both results.
+  AliasResult merge(AliasResult other) const;
+
+  /// Return the internal kind of this alias result.
+  Kind getKind() const { return kind; }
+
+private:
+  /// The internal kind of the result.
+  Kind kind;
+};
+
+//===----------------------------------------------------------------------===//
+// 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;
+  };
+
+  /// 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);
+    }
+
+  private:
+    ImplT impl;
+  };
+};
+} // end namespace detail
+
+//===----------------------------------------------------------------------===//
+// AliasAnalysis
+//===----------------------------------------------------------------------===//
+
+/// This class represents the main alias analysis interface in MLIR. It
+/// functions as an aggregate of various different alias analysis
+/// implementations. This aggregation allows for utilizing the strengths of
+/// different alias analysis implementations that either target or have access
+/// to different aliasing information. This is especially important for MLIR
+/// given the scope of different types of memory models and aliasing behaviors.
+/// For users of this analysis that want to perform aliasing queries, see the
+/// `Alias Queries` section below for the available methods. For users of this
+/// analysis that want to add a new alias analysis implementation to the
+/// aggregate, see the `Alias Implementations` section below.
+class AliasAnalysis {
+  using Concept = detail::AliasAnalysisTraits::Concept;
+  template <typename ImplT>
+  using Model = detail::AliasAnalysisTraits::Model<ImplT>;
+
+public:
+  AliasAnalysis(Operation *op);
+
+  //===--------------------------------------------------------------------===//
+  // Alias Implementations
+  //===--------------------------------------------------------------------===//
+
+  /// 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:
+  ///   * AliasResult alias(Value lhs, Value rhs)
+  ///     - This method returns an `AliasResult` that corresponds to the
+  ///       aliasing behavior between `lhs` and `rhs`.
+  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);
+
+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

+//===- LocalAliasAnalysis.h - Local Stateless Alias Analysis ----*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the implementation of a local stateless alias analysis.
+// This analysis walks from the values being compared to determine their
+// potential for aliasing.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_ANALYSIS_ALIASANALYSIS_LOCALALIASANALYSIS_H_
+#define MLIR_ANALYSIS_ALIASANALYSIS_LOCALALIASANALYSIS_H_
+
+#include "mlir/Analysis/AliasAnalysis.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);
+};
+} // end namespace mlir
+
+#endif // MLIR_ANALYSIS_ALIASANALYSIS_LOCALALIASANALYSIS_H_

mlir/include/mlir/IR/OpDefinition.h

 /// back from the operation's region. Any operations performing such allocations
 /// (for eg. std.alloca) will have their allocations automatically freed at
 /// their closest enclosing operation with this trait.
 template <typename ConcreteType>
 class AutomaticAllocationScope
     : public TraitBase<ConcreteType, AutomaticAllocationScope> {
 public:
   static LogicalResult verifyTrait(Operation *op) {
-    if (op->hasTrait<ZeroRegion>())
-      return op->emitOpError("is expected to have regions");
+    static_assert(!ConcreteType::template hasTrait<ZeroRegion>(),
+                  "expected operation to have one or more regions");
     return success();
   }
 };
 
 /// This class provides a verifier for ops that are expecting their parent
 /// to be one of the given parent ops
 template <typename... ParentOpTypes>
 struct HasParent {

mlir/include/mlir/Interfaces/SideEffectInterfaceBase.td

let extraClassDeclaration = [{
     /// and place them in 'effects'.
     void getEffectsOnValue(::mlir::Value value,
               llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
               }] # baseEffect # [{>> & effects) {
       getEffects(effects);
       llvm::erase_if(effects, [&](auto &it) { return it.getValue() != value; });
     }
 
+    /// Return the effect of the given type `Effect` that is applied to the
+    /// given value, or None if no effect exists.
+    template <typename Effect>
+    ::llvm::Optional<::mlir::SideEffects::EffectInstance<}] # baseEffect # [{>>
+    getEffectOnValue(::mlir::Value value) {
+      llvm::SmallVector<::mlir::SideEffects::EffectInstance<
+              }] # baseEffect # [{>, 4> effects;
+      getEffects(effects);
+      auto it = llvm::find_if(effects, [&](auto &it) {
+        return isa<Effect>(it.getEffect()) && it.getValue() == value;
+      });
+      if (it == effects.end())
+        return llvm::None;
+      return *it;
+    }
+
     /// Collect all of the effect instances that operate on the provided symbol
     /// reference and place them in 'effects'.
     void getEffectsOnSymbol(::mlir::SymbolRefAttr value,
               llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
               }] # baseEffect # [{>> & effects) {
       getEffects(effects);
       llvm::erase_if(effects, [&](auto &it) {
         return it.getSymbolRef() != value;

mlir/lib/Analysis/AliasAnalysis.cpp

+//===- AliasAnalysis.cpp - Alias Analysis for MLIR ------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Analysis/AliasAnalysis.h"
+#include "mlir/Analysis/AliasAnalysis/LocalAliasAnalysis.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// AliasResult
+//===----------------------------------------------------------------------===//
+
+/// Merge this alias result with `other` and return a new result that
+/// represents the conservative merge of both results.
+AliasResult AliasResult::merge(AliasResult other) const {
+  if (kind == other.kind)
+    return *this;
+  // A mix of PartialAlias and MustAlias is PartialAlias.
+  if ((kind == PartialAlias && other.kind == MustAlias) ||
+      (other.kind == PartialAlias && kind == MustAlias))
+    return PartialAlias;
+  // Otherwise, don't assume anything.
+  return MayAlias;
+}
+
+//===----------------------------------------------------------------------===//
+// 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 != AliasResult::MayAlias)
+      return result;
+  }
+  return AliasResult::MayAlias;
+}

mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp

+//===LocalAliasAnalysis.cpp - Local stateless alias Analysis for MLIR -----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Analysis/AliasAnalysis/LocalAliasAnalysis.h"
+
+#include "mlir/IR/Matchers.h"
+#include "mlir/Interfaces/ControlFlowInterfaces.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
+#include "mlir/Interfaces/ViewLikeInterface.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// Underlying Address Computation
+//===----------------------------------------------------------------------===//
+
+/// Given a value, collect all of the underlying values being addressed.
+static void collectUnderlyingAddressValues(Value value, unsigned maxDepth,
+                                           DenseSet<Value> &visited,
+                                           SmallVectorImpl<Value> &output);
+
+/// Given a successor (`region`) of a RegionBranchOpInterface, collect all of
+/// the underlying values being addressed by one of the successor inputs.
+static void collectUnderlyingAddressValues(RegionBranchOpInterface branch,
+                                           Region *region, Value inputValue,
+                                           unsigned inputIndex,
+                                           unsigned maxDepth,
+                                           DenseSet<Value> &visited,
+                                           SmallVectorImpl<Value> &output) {
+  SmallVector<RegionSuccessor, 2> successors;
+  auto getOperandIndexIfPred =
+      [&](Optional<unsigned> predIndex) -> Optional<unsigned> {
+    successors.clear();
+    branch.getSuccessorRegions(predIndex, successors);
+    for (RegionSuccessor &successor : successors) {
+      if (successor.getSuccessor() != region)
+        continue;
+      // Check that the successor inputs map to the given input value.
+      ValueRange inputs = successor.getSuccessorInputs();
+      if (inputs.empty()) {
+        output.push_back(inputValue);
+        break;
+      }
+      unsigned firstInputIndex, lastInputIndex;
+      if (region) {
+        firstInputIndex = inputs[0].cast<BlockArgument>().getArgNumber();
+        lastInputIndex = inputs.back().cast<BlockArgument>().getArgNumber();
+      } else {
+        firstInputIndex = inputs[0].cast<OpResult>().getResultNumber();
+        lastInputIndex = inputs.back().cast<OpResult>().getResultNumber();
+      }
+      if (firstInputIndex > inputIndex || lastInputIndex < inputIndex) {
+        output.push_back(inputValue);
+        break;
+      }
+      return inputIndex - firstInputIndex;
+    }
+    return llvm::None;
+  };
+
+  // Check branches from the parent operation.
+  if (region) {
+    if (Optional<unsigned> operandIndex =
+            getOperandIndexIfPred(/*predIndex=*/llvm::None)) {
+      collectUnderlyingAddressValues(
+          branch.getSuccessorEntryOperands(
+              region->getRegionNumber())[*operandIndex],
+          maxDepth, visited, output);
+    }
+  }
+  // Check branches from each child region.
+  Operation *op = branch.getOperation();
+  for (int i = 0, e = op->getNumRegions(); i != e; ++i) {
+    if (Optional<unsigned> operandIndex = getOperandIndexIfPred(i)) {
+      for (Block &block : op->getRegion(i)) {
+        Operation *term = block.getTerminator();
+        if (term->hasTrait<OpTrait::ReturnLike>()) {
+          collectUnderlyingAddressValues(term->getOperand(*operandIndex),
+                                         maxDepth, visited, output);
+        } else if (term->getNumSuccessors()) {
+          // Otherwise, if this terminator may exit the region we can't make
+          // any assumptions about which values get passed.
+          output.push_back(inputValue);
+          return;
+        }
+      }
+    }
+  }
+}
+
+/// Given a result, collect all of the underlying values being addressed.
+static void collectUnderlyingAddressValues(OpResult result, unsigned maxDepth,
+                                           DenseSet<Value> &visited,
+                                           SmallVectorImpl<Value> &output) {
+  Operation *op = result.getOwner();
+
+  // If this is a view, unwrap to the source.
+  if (ViewLikeOpInterface view = dyn_cast<ViewLikeOpInterface>(op))
+    return collectUnderlyingAddressValues(view.getViewSource(), maxDepth,
+                                          visited, output);
+  // Check to see if we can reason about the control flow of this op.
+  if (auto branch = dyn_cast<RegionBranchOpInterface>(op)) {
+    return collectUnderlyingAddressValues(branch, /*region=*/nullptr, result,
+                                          result.getResultNumber(), maxDepth,
+                                          visited, output);
+  }
+
+  output.push_back(result);
+}
+
+/// Given a block argument, collect all of the underlying values being
+/// addressed.
+static void collectUnderlyingAddressValues(BlockArgument arg, unsigned maxDepth,
+                                           DenseSet<Value> &visited,
+                                           SmallVectorImpl<Value> &output) {
+  Block *block = arg.getOwner();
+  unsigned argNumber = arg.getArgNumber();
+
+  // Handle the case of a non-entry block.
+  if (!block->isEntryBlock()) {
+    for (auto it = block->pred_begin(), e = block->pred_end(); it != e; ++it) {
+      auto branch = dyn_cast<BranchOpInterface>((*it)->getTerminator());
+      if (!branch) {
+        // We can't analyze the control flow, so bail out early.
+        output.push_back(arg);
+        return;
+      }
+
+      // Try to get the operand passed for this argument.
+      unsigned index = it.getSuccessorIndex();
+      Optional<OperandRange> operands = branch.getSuccessorOperands(index);
+      if (!operands) {
+        // We can't analyze the control flow, so bail out early.
+        output.push_back(arg);
+        return;
+      }
+      collectUnderlyingAddressValues((*operands)[argNumber], maxDepth, visited,
+                                     output);
+    }
+    return;
+  }
+
+  // Otherwise, check to see if we can reason about the control flow of this op.
+  Region *region = block->getParent();
+  Operation *op = region->getParentOp();
+  if (auto branch = dyn_cast<RegionBranchOpInterface>(op)) {
+    return collectUnderlyingAddressValues(branch, region, arg, argNumber,
+                                          maxDepth, visited, output);
+  }
+
+  // We can't reason about the underlying address of this argument.
+  output.push_back(arg);
+}
+
+/// Given a value, collect all of the underlying values being addressed.
+static void collectUnderlyingAddressValues(Value value, unsigned maxDepth,
+                                           DenseSet<Value> &visited,
+                                           SmallVectorImpl<Value> &output) {
+  // Check that we don't infinitely recurse.
+  if (!visited.insert(value).second)
+    return;
+  if (maxDepth == 0) {
+    output.push_back(value);
+    return;
+  }
+  --maxDepth;
+
+  if (BlockArgument arg = value.dyn_cast<BlockArgument>())
+    return collectUnderlyingAddressValues(arg, maxDepth, visited, output);
+  collectUnderlyingAddressValues(value.cast<OpResult>(), maxDepth, visited,
+                                 output);
+}
+
+/// Given a value, collect all of the underlying values being addressed.
+static void collectUnderlyingAddressValues(Value value,
+                                           SmallVectorImpl<Value> &output) {
+  DenseSet<Value> visited;
+  collectUnderlyingAddressValues(value, /*maxDepth=*/10, visited, output);
+}
+
+//===----------------------------------------------------------------------===//
+// LocalAliasAnalysis
+//===----------------------------------------------------------------------===//
+
+/// 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.
+static LogicalResult
+getAllocEffectFor(Value value, Optional<MemoryEffects::EffectInstance> &effect,
+                  Operation *&allocScopeOp) {
+  // Try to get a memory effect interface for the parent operation.
+  Operation *op;
+  if (BlockArgument arg = value.dyn_cast<BlockArgument>())
+    op = arg.getOwner()->getParentOp();
+  else
+    op = value.cast<OpResult>().getOwner();
+  MemoryEffectOpInterface interface = dyn_cast<MemoryEffectOpInterface>(op);
+  if (!interface)
+    return failure();
+
+  // Try to find an allocation effect on the resource.
+  if (!(effect = interface.getEffectOnValue<MemoryEffects::Allocate>(value)))
+    return failure();
+
+  // If we found an allocation effect, try to find a scope for the allocation.
+  // If the resource of this allocation is autonatically scoped, find the parent
+  // operation that bounds the allocation scope.
+  if (llvm::isa<SideEffects::AutomaticAllocationScopeResource>(
+          effect->getResource())) {
+    allocScopeOp = op->getParentWithTrait<OpTrait::AutomaticAllocationScope>();
+    return success();
+  }
+
+  // TODO: Here we could look at the users to see if the resource is either
+  // freed on all paths within the region, or is just not captured by anything.
+  allocScopeOp = nullptr;
+  return success();
+}
+
+/// Given the two values, return their aliasing behavior.
+static AliasResult aliasImpl(Value lhs, Value rhs) {
+  if (lhs == rhs)
+    return AliasResult::MustAlias;
+  Operation *lhsAllocScope = nullptr, *rhsAllocScope = nullptr;
+  Optional<MemoryEffects::EffectInstance> lhsAlloc, rhsAlloc;
+
+  // Handle the case where lhs is a constant.
+  Attribute lhsAttr, rhsAttr;
+  if (matchPattern(lhs, m_Constant(&lhsAttr))) {
+    // If rhs is also a constant, they either must alias or don't alias at all.
+    // TODO: There could be constants representing the same address but with a
+    //       different attribute value.
+    if (matchPattern(rhs, m_Constant(&rhsAttr)))
+      return lhsAttr == rhsAttr ? AliasResult::MayAlias : AliasResult::NoAlias;
+
+    // Try to find an alloc effect on rhs. If an effect was found we can't
+    // alias, otherwise we might.
+    return succeeded(getAllocEffectFor(rhs, rhsAlloc, rhsAllocScope))
+               ? AliasResult::NoAlias
+               : AliasResult::MayAlias;
+  }
+  // Handle the case where rhs is a constant.
+  if (matchPattern(rhs, m_Constant(&rhsAttr))) {
+    // Try to find an alloc effect on lhs. If an effect was found we can't
+    // alias, otherwise we might.
+    return succeeded(getAllocEffectFor(lhs, lhsAlloc, lhsAllocScope))
+               ? AliasResult::NoAlias
+               : AliasResult::MayAlias;
+  }
+
+  // Otherwise, neither of the values are constant so check to see if either has
+  // an allocation effect.
+  bool lhsHasAlloc = succeeded(getAllocEffectFor(lhs, lhsAlloc, lhsAllocScope));
+  bool rhsHasAlloc = succeeded(getAllocEffectFor(rhs, rhsAlloc, rhsAllocScope));
+  if (lhsHasAlloc == rhsHasAlloc) {
+    // If both values have an allocation effect we know they don't alias, and if
+    // neither have an effect we can't make an assumptions.
+    return lhsHasAlloc ? AliasResult::NoAlias : AliasResult::MayAlias;
+  }
+
+  // When we reach this point we have one value with a known allocation effect,
+  // and one without. Move the one with the effect to the lhs to make the next
+  // checks simpler.
+  if (rhsHasAlloc) {
+    std::swap(lhs, rhs);
+    lhsAlloc = rhsAlloc;
+    lhsAllocScope = rhsAllocScope;
+  }
+
+  // If the effect has a scoped allocation region, check to see if the
+  // non-effect value is defined above that scope.
+  if (lhsAllocScope) {
+    // If the parent operation of rhs is an ancestor of the allocation scope, or
+    // if rhs is an entry block argument of the allocation scope we know the two
+    // values can't alias.
+    Operation *rhsParentOp = rhs.getParentRegion()->getParentOp();
+    if (rhsParentOp->isProperAncestor(lhsAllocScope))
+      return AliasResult::NoAlias;
+    if (rhsParentOp == lhsAllocScope) {
+      BlockArgument rhsArg = rhs.dyn_cast<BlockArgument>();
+      if (rhsArg && rhs.getParentBlock()->isEntryBlock())
+        return AliasResult::NoAlias;
+    }
+  }
+
+  // If we couldn't reason about the relationship between the two values,
+  // conservatively assume they might alias.
+  return AliasResult::MayAlias;
+}
+
+/// Given the two values, return their aliasing behavior.
+AliasResult LocalAliasAnalysis::alias(Value lhs, Value rhs) {
+  if (lhs == rhs)
+    return AliasResult::MustAlias;
+
+  // Get the underlying values being addressed.
+  SmallVector<Value, 8> lhsValues, rhsValues;
+  collectUnderlyingAddressValues(lhs, lhsValues);
+  collectUnderlyingAddressValues(rhs, rhsValues);
+
+  // If we failed to collect for either of the values somehow, conservatively
+  // assume they may alias.
+  if (lhsValues.empty() || rhsValues.empty())
+    return AliasResult::MayAlias;
+
+  // Check the alias results against each of the underlying values.
+  Optional<AliasResult> result;
+  for (Value lhsVal : lhsValues) {
+    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;
+}

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

+// RUN: mlir-opt %s -pass-pipeline='func(test-alias-analysis)' -split-input-file -allow-unregistered-dialect 2>&1 | FileCheck %s
+
+// CHECK-LABEL: Testing : "simple"
+// CHECK-DAG: func.region0#0 <-> func.region0#1: MayAlias
+
+// CHECK-DAG: alloca_1#0 <-> alloca_2#0: NoAlias
+// CHECK-DAG: alloca_1#0 <-> alloc_1#0: NoAlias
+// CHECK-DAG: alloca_1#0 <-> alloc_2#0: NoAlias
+// CHECK-DAG: alloca_1#0 <-> func.region0#0: NoAlias
+// CHECK-DAG: alloca_1#0 <-> func.region0#1: NoAlias
+
+// CHECK-DAG: alloca_2#0 <-> alloc_1#0: NoAlias
+// CHECK-DAG: alloca_2#0 <-> alloc_2#0: NoAlias
+// CHECK-DAG: alloca_2#0 <-> func.region0#0: NoAlias
+// CHECK-DAG: alloca_2#0 <-> func.region0#1: NoAlias
+
+// CHECK-DAG: alloc_1#0 <-> alloc_2#0: NoAlias
+// CHECK-DAG: alloc_1#0 <-> func.region0#0: MayAlias
+// CHECK-DAG: alloc_1#0 <-> func.region0#1: MayAlias
+
+// CHECK-DAG: alloc_2#0 <-> func.region0#0: MayAlias
+// CHECK-DAG: alloc_2#0 <-> func.region0#1: MayAlias
+func @simple(%arg: memref<2xf32>, %arg1: memref<2xf32>) attributes {test.ptr = "func"} {
+  %0 = alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
+  %1 = alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
+  %2 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+  %3 = alloc() {test.ptr = "alloc_2"} : memref<8x64xf32>
+  return
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "control_flow"
+// CHECK-DAG: alloca_1#0 <-> func.region0.block1#0: MustAlias
+// CHECK-DAG: alloca_1#0 <-> func.region0.block2#0: MustAlias
+
+// CHECK-DAG: alloca_2#0 <-> func.region0.block1#0: NoAlias
+// CHECK-DAG: alloca_2#0 <-> func.region0.block2#0: NoAlias
+
+// CHECK-DAG: alloc_1#0 <-> func.region0.block1#0: NoAlias
+// CHECK-DAG: alloc_1#0 <-> func.region0.block2#0: NoAlias
+
+// CHECK-DAG: func.region0#0 <-> func.region0.block1#0: NoAlias
+// CHECK-DAG: func.region0#0 <-> func.region0.block2#0: NoAlias
+
+// CHECK-DAG: func.region0#1 <-> func.region0.block1#0: NoAlias
+// CHECK-DAG: func.region0#1 <-> func.region0.block2#0: NoAlias
+
+// CHECK-DAG: func.region0.block1#0 <-> func.region0.block2#0: MustAlias
+func @control_flow(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} {
+  %0 = alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
+  %1 = alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
+  %2 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+
+  cond_br %cond, ^bb1(%0 : memref<8x64xf32>), ^bb2(%0 : memref<8x64xf32>)
+
+^bb1(%arg1: memref<8x64xf32>):
+  br ^bb2(%arg1 : memref<8x64xf32>)
+
+^bb2(%arg2: memref<8x64xf32>):
+  return
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "control_flow_merge"
+// CHECK-DAG: alloca_1#0 <-> func.region0.block1#0: MustAlias
+// CHECK-DAG: alloca_1#0 <-> func.region0.block2#0: MayAlias
+
+// CHECK-DAG: alloca_2#0 <-> func.region0.block1#0: NoAlias
+// CHECK-DAG: alloca_2#0 <-> func.region0.block2#0: NoAlias
+
+// CHECK-DAG: alloc_1#0 <-> func.region0.block1#0: NoAlias
+// CHECK-DAG: alloc_1#0 <-> func.region0.block2#0: MayAlias
+
+// CHECK-DAG: func.region0#0 <-> func.region0.block1#0: NoAlias
+// CHECK-DAG: func.region0#0 <-> func.region0.block2#0: MayAlias
+
+// CHECK-DAG: func.region0#1 <-> func.region0.block1#0: NoAlias
+// CHECK-DAG: func.region0#1 <-> func.region0.block2#0: MayAlias
+
+// CHECK-DAG: func.region0.block1#0 <-> func.region0.block2#0: MayAlias
+func @control_flow_merge(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} {
+  %0 = alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
+  %1 = alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
+  %2 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+
+  cond_br %cond, ^bb1(%0 : memref<8x64xf32>), ^bb2(%2 : memref<8x64xf32>)
+
+^bb1(%arg1: memref<8x64xf32>):
+  br ^bb2(%arg1 : memref<8x64xf32>)
+
+^bb2(%arg2: memref<8x64xf32>):
+  return
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "region_control_flow"
+// CHECK-DAG: alloca_1#0 <-> if_alloca#0: MustAlias
+// CHECK-DAG: alloca_1#0 <-> if_alloca_merge#0: MayAlias
+// CHECK-DAG: alloca_1#0 <-> if_alloc#0: NoAlias
+
+// CHECK-DAG: alloca_2#0 <-> if_alloca#0: NoAlias
+// CHECK-DAG: alloca_2#0 <-> if_alloca_merge#0: MayAlias
+// CHECK-DAG: alloca_2#0 <-> if_alloc#0: NoAlias
+
+// CHECK-DAG: alloc_1#0 <-> if_alloca#0: NoAlias
+// CHECK-DAG: alloc_1#0 <-> if_alloca_merge#0: NoAlias
+// CHECK-DAG: alloc_1#0 <-> if_alloc#0: MustAlias
+
+// CHECK-DAG: if_alloca#0 <-> if_alloca_merge#0: MayAlias
+// CHECK-DAG: if_alloca#0 <-> if_alloc#0: NoAlias
+// CHECK-DAG: if_alloca#0 <-> func.region0#0: NoAlias
+// CHECK-DAG: if_alloca#0 <-> func.region0#1: NoAlias
+
+// CHECK-DAG: if_alloca_merge#0 <-> if_alloc#0: NoAlias
+// CHECK-DAG: if_alloca_merge#0 <-> func.region0#0: NoAlias
+// CHECK-DAG: if_alloca_merge#0 <-> func.region0#1: NoAlias
+
+// CHECK-DAG: if_alloc#0 <-> func.region0#0: MayAlias
+// CHECK-DAG: if_alloc#0 <-> func.region0#1: MayAlias
+func @region_control_flow(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} {
+  %0 = alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
+  %1 = alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
+  %2 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+
+  %3 = scf.if %cond -> (memref<8x64xf32>) {
+    scf.yield %0 : memref<8x64xf32>
+  } else {
+    scf.yield %0 : memref<8x64xf32>
+  } {test.ptr = "if_alloca"}
+
+  %4 = scf.if %cond -> (memref<8x64xf32>) {
+    scf.yield %0 : memref<8x64xf32>
+  } else {
+    scf.yield %1 : memref<8x64xf32>
+  } {test.ptr = "if_alloca_merge"}
+
+  %5 = scf.if %cond -> (memref<8x64xf32>) {
+    scf.yield %2 : memref<8x64xf32>
+  } else {
+    scf.yield %2 : memref<8x64xf32>
+  } {test.ptr = "if_alloc"}
+  return
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "region_loop_control_flow"
+// CHECK-DAG: alloca_1#0 <-> for_alloca#0: MustAlias
+// CHECK-DAG: alloca_1#0 <-> for_alloca.region0#0: MayAlias
+// CHECK-DAG: alloca_1#0 <-> for_alloca.region0#1: MustAlias
+
+// CHECK-DAG: alloca_2#0 <-> for_alloca#0: NoAlias
+// CHECK-DAG: alloca_2#0 <-> for_alloca.region0#0: MayAlias
+// CHECK-DAG: alloca_2#0 <-> for_alloca.region0#1: NoAlias
+
+// CHECK-DAG: alloc_1#0 <-> for_alloca#0: NoAlias
+// CHECK-DAG: alloc_1#0 <-> for_alloca.region0#0: MayAlias
+// CHECK-DAG: alloc_1#0 <-> for_alloca.region0#1: NoAlias
+
+// CHECK-DAG: for_alloca#0 <-> for_alloca.region0#0: MayAlias
+// CHECK-DAG: for_alloca#0 <-> for_alloca.region0#1: MustAlias
+// CHECK-DAG: for_alloca#0 <-> func.region0#0: NoAlias
+// CHECK-DAG: for_alloca#0 <-> func.region0#1: NoAlias
+// CHECK-DAG: for_alloca#0 <-> func.region0#2: NoAlias
+// CHECK-DAG: for_alloca#0 <-> func.region0#3: NoAlias
+
+// CHECK-DAG: for_alloca.region0#0 <-> for_alloca.region0#1: MayAlias
+// CHECK-DAG: for_alloca.region0#0 <-> func.region0#0: MayAlias
+// CHECK-DAG: for_alloca.region0#0 <-> func.region0#1: MayAlias
+// CHECK-DAG: for_alloca.region0#0 <-> func.region0#2: MayAlias
+// CHECK-DAG: for_alloca.region0#0 <-> func.region0#3: MayAlias
+
+// CHECK-DAG: for_alloca.region0#1 <-> func.region0#0: NoAlias
+// CHECK-DAG: for_alloca.region0#1 <-> func.region0#1: NoAlias
+// CHECK-DAG: for_alloca.region0#1 <-> func.region0#2: NoAlias
+// CHECK-DAG: for_alloca.region0#1 <-> func.region0#3: NoAlias
+func @region_loop_control_flow(%arg: memref<2xf32>, %loopI0 : index,
+                               %loopI1 : index, %loopI2 : index) attributes {test.ptr = "func"} {
+  %0 = alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
+  %1 = alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
+  %2 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+
+  %result = scf.for %i0 = %loopI0 to %loopI1 step %loopI2 iter_args(%si = %0) -> (memref<8x64xf32>) {
+    scf.yield %si : memref<8x64xf32>
+  } {test.ptr = "for_alloca"}
+  return
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "view_like"
+// CHECK-DAG: alloc_1#0 <-> view#0: NoAlias
+
+// CHECK-DAG: alloca_1#0 <-> view#0: MustAlias
+
+// CHECK-DAG: view#0 <-> func.region0#0: NoAlias
+// CHECK-DAG: view#0 <-> func.region0#1: NoAlias
+func @view_like(%arg: memref<2xf32>, %size: index) attributes {test.ptr = "func"} {
+  %1 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+
+  %c0 = constant 0 : index
+  %2 = alloca (%size) {test.ptr = "alloca_1"} : memref<?xi8>
+  %3 = view %2[%c0][] {test.ptr = "view"} : memref<?xi8> to memref<8x64xf32>
+  return
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "constants"
+// CHECK-DAG: alloc_1#0 <-> constant_1#0: NoAlias
+// CHECK-DAG: alloc_1#0 <-> constant_2#0: NoAlias
+// CHECK-DAG: alloc_1#0 <-> constant_3#0: NoAlias
+
+// CHECK-DAG: constant_1#0 <-> constant_2#0: MayAlias
+// CHECK-DAG: constant_1#0 <-> constant_3#0: NoAlias
+// CHECK-DAG: constant_1#0 <-> func.region0#0: MayAlias
+
+// CHECK-DAG: constant_2#0 <-> constant_3#0: NoAlias
+// CHECK-DAG: constant_2#0 <-> func.region0#0: MayAlias
+
+// CHECK-DAG: constant_3#0 <-> func.region0#0: MayAlias
+func @constants(%arg: memref<2xf32>) attributes {test.ptr = "func"} {
+  %1 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+
+  %c0 = constant {test.ptr = "constant_1"} 0 : index
+  %c0_2 = constant {test.ptr = "constant_2"} 0 : index
+  %c1 = constant {test.ptr = "constant_3"} 1 : index
+
+  return
+}

mlir/test/lib/Analysis/CMakeLists.txt

+# Exclude tests from libMLIR.so
+add_mlir_library(MLIRTestAnalysis
+  TestAliasAnalysis.cpp
+
+  EXCLUDE_FROM_LIBMLIR
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Transforms
+
+  DEPENDS
+  MLIRStandardOpsIncGen
+
+  LINK_LIBS PUBLIC
+  MLIRAnalysis
+  MLIRPass
+  MLIRTestDialect
+  )
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../Dialect/Test)
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/../Dialect/Test)

mlir/test/lib/Analysis/TestAliasAnalysis.cpp

+//===- TestAliasAnalysis.cpp - Test alias analysis results ----------------===//
+//
+// 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 contains test passes for constructing and testing alias analysis
+// results.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Analysis/AliasAnalysis.h"
+#include "mlir/Pass/Pass.h"
+
+using namespace mlir;
+
+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";
+
+    // 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();
+      return;
+    }
+    OpResult result = value.cast<OpResult>();
+    llvm::errs()
+        << result.getOwner()->getAttrOfType<StringAttr>("test.ptr").getValue()
+        << "#" << result.getResultNumber();
+  }
+};
+} // end anonymous namespace
+
+namespace mlir {
+namespace test {
+void registerTestAliasAnalysisPass() {
+  PassRegistration<TestAliasAnalysisPass> pass("test-alias-analysis",
+                                               "Test alias analysis results.");
+}
+} // namespace test
+} // namespace mlir

mlir/test/lib/CMakeLists.txt

+add_subdirectory(Analysis)
 add_subdirectory(Dialect)
 add_subdirectory(IR)
 add_subdirectory(Pass)
 add_subdirectory(Reducer)
 add_subdirectory(Transforms)

mlir/tools/mlir-opt/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   AsmParser
   )
 
 if(MLIR_INCLUDE_TESTS)
   set(test_libs
     MLIRAffineTransformsTestPasses
     MLIRShapeTestPasses
     MLIRSPIRVTestPasses
+    MLIRTestAnalysis
     MLIRTestDialect
     MLIRTestIR
     MLIRTestPass
     MLIRTestReducer
     MLIRTestTransforms
     )
 endif()
 

mlir/tools/mlir-opt/mlir-opt.cpp

 
 namespace test {
 void registerConvertCallOpPass();
 void registerInliner();
 void registerMemRefBoundCheck();
 void registerPatternsTestPass();
 void registerSimpleParametricTilingPass();
 void registerTestAffineLoopParametricTilingPass();
+void registerTestAliasAnalysisPass();
 void registerTestCallGraphPass();
 void registerTestConstantFold();
 void registerTestConvVectorization();
 void registerTestConvertGPUKernelToCubinPass();
 void registerTestConvertGPUKernelToHsacoPass();
 void registerTestDecomposeCallGraphTypes();
 void registerTestDialect(DialectRegistry &);
 void registerTestDominancePass();
void registerTestPasses() {
   registerTosaTestQuantUtilAPIPass();
 
   test::registerConvertCallOpPass();
   test::registerInliner();
   test::registerMemRefBoundCheck();
   test::registerPatternsTestPass();
   test::registerSimpleParametricTilingPass();
   test::registerTestAffineLoopParametricTilingPass();
+  test::registerTestAliasAnalysisPass();
   test::registerTestCallGraphPass();
   test::registerTestConstantFold();
 #if MLIR_CUDA_CONVERSIONS_ENABLED
   test::registerTestConvertGPUKernelToCubinPass();
 #endif
 #if MLIR_ROCM_CONVERSIONS_ENABLED
   test::registerTestConvertGPUKernelToHsacoPass();
 #endif