Infrastructure for alias analysis in flang

[Renaud-K]

Summary

These changes provide a development framework for the development of aliasing analysis in flang which will depend on the FIR dialect.
See https://github.com/llvm/llvm-project/blob/main/flang/docs/AliasingAnalysisFIR.md and https://discourse.llvm.org/t/alias-analysis-in-llvm-flang/62639/16

There is an emphasis on reusing/leveraging the mlir::AliasAnalysis and the MLIR testing passes for alias analysis.
There are no substantial changes in MLIR other than sharing code between test passes through a base class the passes can inherit from.
There might need to be more changes in MLIR in the future but I did not want these to be lost in this noise.

With these changes we will explore the possibility of stacking up several alias analysis with mlir::AliasAnalysis::addAnalysisImplementation

Changes include:

1. Adding an Analysis/AliasAnalysis directory in flang which right now is doing a mock alias analysis
2. Adding a lib directory under flang/test to allow for test passes to be built.
3. Registering the test passes with fir-opt. Mimicking what is done with mlir-opt
4. Moved the MLIR testing code into a common based class that can be reused among passes

[Renaud-K]

Needed to run clang-format on a couple of files.

[jeanPerier]

The Flang changes look good to me (a small nit). The MLIR changes make some sense to me, but I will leave @riddle or someone from MLIR comment about sharing that MLIR testing infrastructure.

flang/lib/Lower/IntrinsicCall.cpp

5007

Did you intend for the parenthesis to wrap sizeof() / sizeof() instead of just the second sizeof ?

flang/test/lib/Analysis/AliasAnalysis/CMakeLists.txt

29

Does this work in flang out of tree builds ?

[clementval]

flang/test/lib/Analysis/AliasAnalysis/alias-analysis-1.fir

18–19

Is there a reason to split the input file here since you do not add any check lines after? Same for the split below.

[Renaud-K]

flang/lib/Lower/IntrinsicCall.cpp

5007

Just the second sizeof. This helps with a strange clang compilation error. I have the issue with clang 11 and up.

 expression does not compute the number of elements in this array; element type is 'const IntrinsicDummyArgument', not 'decltype(*rules.args)' (aka 'const IntrinsicDummyArgument &') [-Werror,-Wsizeof-array-div]
  assert(position < sizeof(rules.args) / sizeof(decltype(*rules.args)) &&
                           ~~~~~~~~~~  ^
/usr/include/assert.h:90:27: note: expanded from macro 'assert'
     (static_cast <bool> (expr)                                         \
                          ^~~~
/local/home/rkauffmann/clients/llvm-project-mirror/flang/lib/Lower/IntrinsicCall.cpp:5007:40: note: place parentheses around the 'sizeof(decltype(*rules.args))' expression to silence this warning
1 error generated.

place parentheses around the 'sizeof(decltype(*rules.args))' expression to silence this warning

flang/test/lib/Analysis/AliasAnalysis/alias-analysis-1.fir

18–19

There will be a message issued for the empty functions that will be interspersed with the other functions. -split-input-file helps with that. Though I was not a fan of it either. The output looks good on the terminal where stdout and stderr are properly interleaved but as soon as the terminal output is redirected through a pipe or a file the two are separated and it is hard to see which stdout corresponds to which stderr.

The pass itself is a generic op pass, it does not expect a function or check for empty functions which would have been my preference. Let me know if you know a better way.

[PeteSteinfeld]

Aside from my one nit comment, all builds and tests correctly and looks good.

flang/lib/Optimizer/Analysis/AliasAnalysis.cpp

32

"notable" rather than "notables"

[vzakhari]

flang/test/lib/Analysis/AliasAnalysis/TestAliasAnalysis.cpp

73

Please add a new line.

mlir/test/lib/Analysis/TestAliasAnalysis.h

38

Please add new line.

[Renaud-K]

flang/test/lib/Analysis/AliasAnalysis/CMakeLists.txt

29

It works because there is no such thing as a flang only repo. Based on these instructions https://github.com/llvm/llvm-project/blob/main/flang/README.md, it is still expected to do a clone of the entire llvm-project for the stand-alone build. The MLIR sources are always going to be available.

[Renaud-K]

Added lines at end of files.
Corrected typo

[vzakhari]

flang/test/lib/Analysis/AliasAnalysis/CMakeLists.txt

29

I guess a more elegant way to get the right path is to use get_target_property(INC_PATH MLIRTestAnalysis SOURCE_DIR) OR set ${CMAKE_CURRENT_SOURCE_DIR} as INTERFACE in target_include_directories inside mlir/test/lib/Analysis/CMakeLists.txt for MLIRTestAnalysis target and add a dependency on this target here.

[Renaud-K]

flang/test/lib/Analysis/AliasAnalysis/CMakeLists.txt

29

I am not sure it is better because you can no longer do

#include "mlir/test/lib/Analysis/TestAliasAnalysis.h"

but have to do

#include "TestAliasAnalysis.h"

instead which is misleading

Is there a variable pointing to the root ?

[Renaud-K]

flang/test/lib/Analysis/AliasAnalysis/CMakeLists.txt

29

I could use ${CMAKE_SOURCE_DIR}/..

[vzakhari]

flang/test/lib/Analysis/AliasAnalysis/CMakeLists.txt

29

I see what you mean.

I believe ${MLIR_MAIN_SRC_DIR} is pointing to mlir source directory in both in-tree (defined in mlir/CMakeLists.txt) and standalone build (defined in ${MLIR_INSTALL_PREFIX}/lib/cmake/mlir/MLIRConfig.cmake), so if you use it you may include test/lib/Analysis/TestAliasAnalysis.h

[Renaud-K]

flang/test/lib/Analysis/AliasAnalysis/CMakeLists.txt

29

All our MLIR includes start with "mlir/...."
So I like ${CMAKE_SOURCE_DIR}/.. better

[Renaud-K]

flang/test/lib/Analysis/AliasAnalysis/CMakeLists.txt

29

I could go with ${MLIR_MAIN_SRC_DIR}/.. but there seems to be a bug in our to CMakeLists.txt file:

set(MLIR_MAIN_SRC_DIR ${LLVM_MAIN_SRC_DIR}/../mlir/include ) # --src-root
set(MLIR_INCLUDE_DIR ${LLVM_MAIN_SRC_DIR}/../mlir/include ) # --includedir

We have set MLIR_MAIN_SRC_DIR and MLIR_INCLUDE_DIR to the same path

While in MLIR they are set as:

set(MLIR_MAIN_SRC_DIR     ${CMAKE_CURRENT_SOURCE_DIR}  )
set(MLIR_MAIN_INCLUDE_DIR ${MLIR_MAIN_SRC_DIR}/include )

[Renaud-K]

Using MLIR_MAIN_SRC_DIR instead of CMAKE_SOURCE_DIR because

1. It's definition is now fixed
2. It works for both in and out-of-tree builds

[Renaud-K]

Needed to fix test because of change https://reviews.llvm.org/D134900

[rriddle]

The changes here LGTM!

[rriddle]

flang/lib/Optimizer/Analysis/AliasAnalysis.cpp

33

Can you add me to the data flow analysis review when you have that? I'd be interested in seeing what is necessary there/if we could promote stuff to just live in MLIR.

[Renaud-K]

flang/lib/Optimizer/Analysis/AliasAnalysis.cpp

33

Will do.

[nikic]

flang/test/lib/Analysis/AliasAnalysis/CMakeLists.txt

29

Independently of how the include is performed, this is still a layering violation: Flang is using a private header (part of lib/ rather than include/) and linking against a private library (MLIRTestXYZ) here.

This header should be publicly exported if other (sub)projects want to make use of it.

flang/CMakeLists.txt

if (APPLE)
   else()
     message(FATAL_ERROR "${CMAKE_LINKER} failed with status ${HAD_ERROR}")
   endif()
 endif()
 
 include(CMakeParseArguments)
 include(AddFlang)
 
+if (FLANG_INCLUDE_TESTS)
+  add_compile_definitions(FLANG_INCLUDE_TESTS=1)
+endif()
 
 add_subdirectory(include)
 add_subdirectory(lib)
 add_subdirectory(cmake/modules)
 
 option(FLANG_BUILD_TOOLS
   "Build the Flang tools. If OFF, just generate build targets." ON)
 if (FLANG_BUILD_TOOLS)

flang/include/flang/Optimizer/Analysis/AliasAnalysis.h

+//===- AliasAnalysis.h - Alias Analysis in FIR -----------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FIR_ANALYSIS_ALIASANALYSIS_H_
+#define FIR_ANALYSIS_ALIASANALYSIS_H_
+
+#include "mlir/Analysis/AliasAnalysis.h"
+
+namespace fir {
+
+//===----------------------------------------------------------------------===//
+// AliasAnalysis
+//===----------------------------------------------------------------------===//
+class AliasAnalysis {
+public:
+  /// Given two values, return their aliasing behavior.
+  mlir::AliasResult alias(mlir::Value lhs, mlir::Value rhs);
+
+  /// Return the modify-reference behavior of `op` on `location`.
+  mlir::ModRefResult getModRef(mlir::Operation *op, mlir::Value location);
+};
+} // namespace fir
+
+#endif // FIR_ANALYSIS_ALIASANALYSIS_H_

flang/lib/Lower/IntrinsicCall.cpp

if (!handler->argLoweringRules.hasDefaultRules())
       return &handler->argLoweringRules;
   return nullptr;
 }
 
 /// Return how argument \p argName should be lowered given the rules for the
 /// intrinsic function.
 Fortran::lower::ArgLoweringRule Fortran::lower::lowerIntrinsicArgumentAs(
     const IntrinsicArgumentLoweringRules &rules, unsigned position) {
-  assert(position < sizeof(rules.args) / sizeof(decltype(*rules.args)) &&
+  assert(position < sizeof(rules.args) / (sizeof(decltype(*rules.args))) &&
          "invalid argument");
   return {rules.args[position].lowerAs,
           rules.args[position].handleDynamicOptional};
 }
 
 //===----------------------------------------------------------------------===//
 // Public intrinsic call helpers
 //===----------------------------------------------------------------------===//

flang/lib/Optimizer/Analysis/AliasAnalysis.cpp

+//===- AliasAnalysis.cpp - Alias Analysis for FIR  ------------------------===//
+//
+// 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 "flang/Optimizer/Analysis/AliasAnalysis.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// AliasAnalysis: alias
+//===----------------------------------------------------------------------===//
+
+namespace fir {
+AliasResult AliasAnalysis::alias(Value lhs, Value rhs) {
+  // This is for now a mock analysis
+  if (lhs == rhs) {
+    return AliasResult::MustAlias;
+  }
+  return AliasResult::MayAlias;
+}
+
+//===----------------------------------------------------------------------===//
+// AliasAnalysis: getModRef
+//===----------------------------------------------------------------------===//
+
+/// This is mostly inspired by MLIR::LocalAliasAnalysis with 2 notable
+/// differences 1) Regions are not handled here but will be handled by a data
+/// flow analysis to come 2) Allocate and Free effects are considered modifying
+ModRefResult AliasAnalysis::getModRef(Operation *op, Value location) {
+  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) {
+
+    // Check for an alias between the effect and our memory location.
+    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 {
+      result = result.merge(ModRefResult::getMod());
+    }
+    if (result.isModAndRef())
+      break;
+  }
+  return result;
+}
+} // namespace fir

flang/lib/Optimizer/Analysis/CMakeLists.txt

+add_flang_library(FIRAnalysis
+  AliasAnalysis.cpp
+
+  DEPENDS
+  FIRBuilder
+  FIRDialect
+  FIRSupport
+
+  LINK_LIBS
+  FIRBuilder
+  FIRDialect
+  MLIRFuncDialect
+  MLIRLLVMDialect
+  MLIRMathTransforms
+  FIRSupport
+)

flang/lib/Optimizer/CMakeLists.txt

 add_subdirectory(Builder)
 add_subdirectory(CodeGen)
 add_subdirectory(Dialect)
 add_subdirectory(HLFIR)
 add_subdirectory(Support)
 add_subdirectory(Transforms)
+add_subdirectory(Analysis)

flang/test/CMakeLists.txt

 # Test runner infrastructure for Flang. This configures the Flang test trees
 # for use by Lit, and delegates to LLVM's lit test handlers.
+add_subdirectory(lib)
 
 llvm_canonicalize_cmake_booleans(
   FLANG_BUILD_EXAMPLES
   FLANG_STANDALONE_BUILD
   LLVM_ENABLE_PLUGINS
 )
 
 set(FLANG_TOOLS_DIR ${FLANG_BINARY_DIR}/bin)

flang/test/lib/Analysis/AliasAnalysis/CMakeLists.txt

+# Exclude tests from libMLIR.so
+add_flang_library(FIRTestAnalysis
+  TestAliasAnalysis.cpp
+
+  DEPENDS
+  FIRDialect
+  FIRBuilder
+  FIRSupport
+  FIRTransforms
+  FIRAnalysis
+  ${dialect_libs}
+
+  LINK_LIBS
+  FIRDialect
+  FIRBuilder
+  FIRSupport
+  FIRTransforms
+  FIRAnalysis
+  ${dialect_libs}
+  MLIRFuncDialect
+  MLIRLLVMDialect
+  MLIRAnalysis
+  MLIRTestAnalysis
+  )
+
+target_include_directories(FIRTestAnalysis
+  PRIVATE
+  ${MLIR_MAIN_SRC_DIR}/..
+  )
 No newline at end of file

flang/test/lib/Analysis/AliasAnalysis/TestAliasAnalysis.cpp

+//===- TestAliasAnalysis.cpp - Test FIR lias analysis     -----------------===//
+//
+// 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/test/lib/Analysis/TestAliasAnalysis.h"
+#include "mlir/Analysis/AliasAnalysis.h"
+#include "mlir/Pass/Pass.h"
+#include "flang/Optimizer/Analysis/AliasAnalysis.h"
+
+using namespace mlir;
+
+namespace {
+
+//===----------------------------------------------------------------------===//
+// Testing AliasResult
+//===----------------------------------------------------------------------===//
+
+struct TestFIRAliasAnalysisPass
+    : public test::TestAliasAnalysisBase,
+      PassWrapper<TestFIRAliasAnalysisPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestFIRAliasAnalysisPass)
+
+  StringRef getArgument() const final { return "test-fir-alias-analysis"; }
+  StringRef getDescription() const final {
+    return "Test alias analysis results.";
+  }
+  void runOnOperation() override {
+    mlir::AliasAnalysis aliasAnalysis(getOperation());
+    aliasAnalysis.addAnalysisImplementation(fir::AliasAnalysis());
+    runAliasAnalysisOnOperation(getOperation(), aliasAnalysis);
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// Testing ModRefResult
+//===----------------------------------------------------------------------===//
+
+struct TestFIRAliasAnalysisModRefPass
+    : public test::TestAliasAnalysisModRefBase,
+      PassWrapper<TestFIRAliasAnalysisModRefPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestFIRAliasAnalysisModRefPass)
+
+  StringRef getArgument() const final {
+    return "test-fir-alias-analysis-modref";
+  }
+  StringRef getDescription() const final {
+    return "Test alias analysis ModRef results.";
+  }
+  void runOnOperation() override {
+    mlir::AliasAnalysis aliasAnalysis(getOperation());
+    aliasAnalysis.addAnalysisImplementation(fir::AliasAnalysis());
+    runAliasAnalysisOnOperation(getOperation(), aliasAnalysis);
+  }
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// Pass Registration
+//===----------------------------------------------------------------------===//
+
+namespace fir {
+namespace test {
+void registerTestFIRAliasAnalysisPass() {
+  PassRegistration<TestFIRAliasAnalysisPass>();
+  PassRegistration<TestFIRAliasAnalysisModRefPass>();
+}
+} // namespace test
+} // namespace fir
 No newline at end of file

flang/test/lib/Analysis/AliasAnalysis/alias-analysis-1.fir

+// RUN: fir-opt %s -pass-pipeline='builtin.module(func.func(test-fir-alias-analysis))' -split-input-file 2>&1 | FileCheck %s
+
+// CHECK-LABEL: Testing : "_QPtest"
+// CHECK-DAG: alloca_1#0 <-> address_of#0: MayAlias
+func.func @_QPtest(%arg1: !fir.ref<i32>) {
+  %c1_i32 = arith.constant 1 : i32
+  %0 = fir.alloca () -> () {test.ptr = "alloca_1"}
+  %1 = fir.address_of(@_QPf) {test.ptr = "address_of"} : () -> i32 
+  %2 = fir.convert %1 : (() -> i32) -> (() -> ())
+  %4 = fir.convert %0 : (!fir.ref<() -> ()>) -> !fir.llvm_ptr<() -> ()>
+  fir.store %2 to %4 : !fir.llvm_ptr<() -> ()>
+  %6 = fir.load %0 : !fir.ref<() -> ()>
+  fir.call @_QPs(%6) : (() -> ()) -> ()
+  return
+}
+
+// -----
+func.func private @_QPs(%arg0: () -> ()) 
+
+// -----
+func.func private @_QPf() -> i32

flang/test/lib/Analysis/CMakeLists.txt

+add_subdirectory(AliasAnalysis)

flang/test/lib/CMakeLists.txt

+add_subdirectory(Analysis)

flang/test/lib/lit.local.cfg

+
+# Excluding .cpp file from the extensions since from this level down they are used for the development 
+config.suffixes = ['.c', '.f', '.F', '.ff', '.FOR', '.for', '.f77', '.f90', '.F90',
+                   '.ff90', '.f95', '.F95', '.ff95', '.fpp', '.FPP', '.cuf'
+                   '.CUF', '.f18', '.F18', '.f03', '.F03', '.f08', '.F08',
+                   '.ll', '.fir', '.mlir']
+

flang/tools/fir-opt/CMakeLists.txt

 add_flang_tool(fir-opt fir-opt.cpp)
 llvm_update_compile_flags(fir-opt)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
+if(FLANG_INCLUDE_TESTS)
+  set(test_libs
+    FIRTestAnalysis
+    )
+endif()
+
 target_link_libraries(fir-opt PRIVATE
   FIRDialect
   FIRSupport
   FIRTransforms
   FIRCodeGen
   HLFIRDialect
+  FIRAnalysis
+  ${test_libs}
   ${dialect_libs}
 
   # TODO: these should be transitive dependencies from a target providing
   # "registerFIRPasses()"
   MLIRIR
   MLIRLLVMDialect
   MLIRPass
   MLIRFuncToLLVM

flang/tools/fir-opt/fir-opt.cpp

 //===----------------------------------------------------------------------===//
 
 #include "mlir/Tools/mlir-opt/MlirOptMain.h"
 #include "flang/Optimizer/CodeGen/CodeGen.h"
 #include "flang/Optimizer/Support/InitFIR.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 
 using namespace mlir;
+namespace fir {
+namespace test {
+void registerTestFIRAliasAnalysisPass();
+} // namespace test
+} // namespace fir
 
 int main(int argc, char **argv) {
   fir::support::registerMLIRPassesForFortranTools();
   fir::registerOptCodeGenPasses();
   fir::registerOptTransformPasses();
+#ifdef FLANG_INCLUDE_TESTS
+  fir::test::registerTestFIRAliasAnalysisPass();
+#endif
   DialectRegistry registry;
   fir::support::registerDialects(registry);
   return failed(MlirOptMain(argc, argv, "FIR modular optimizer driver\n",
       registry, /*preloadDialectsInContext=*/false));
 }

mlir/test/lib/Analysis/TestAliasAnalysis.h

+//===- TestAliasAnalysis.h - MLIR Test Utility ------------------*- 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 provides a common facility that can be reused for the
+// testing of various aliasing analyses
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TEST_LIB_ANALYSIS_ALIASANALYSIS_H
+#define MLIR_TEST_LIB_ANALYSIS_ALIASANALYSIS_H
+
+#include "mlir/Analysis/AliasAnalysis.h"
+
+namespace mlir {
+namespace test {
+
+/// Print the result of an alias query.
+void printAliasResult(AliasResult result, Value lhs, Value rhs);
+void printModRefResult(ModRefResult result, Operation *op, Value location);
+
+struct TestAliasAnalysisBase {
+  void runAliasAnalysisOnOperation(Operation *op, AliasAnalysis &aliasAnalysis);
+};
+
+struct TestAliasAnalysisModRefBase {
+  void runAliasAnalysisOnOperation(Operation *op, AliasAnalysis &aliasAnalysis);
+};
+
+} // namespace test
+} // namespace mlir
+
+#endif // MLIR_TEST_LIB_ANALYSIS_ALIASANALYSIS_H

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 "TestAliasAnalysis.h"
 #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();
if (BlockArgument arg = value.dyn_cast<BlockArgument>()) {
     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<>> {
-  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAliasAnalysisPass)
+namespace mlir {
+namespace test {
+void printAliasResult(AliasResult result, Value lhs, Value rhs) {
+  printAliasOperand(lhs);
+  llvm::errs() << " <-> ";
+  printAliasOperand(rhs);
+  llvm::errs() << ": " << result << "\n";
+}
 
-  StringRef getArgument() const final { return "test-alias-analysis"; }
-  StringRef getDescription() const final {
-    return "Test alias analysis results.";
-  }
-  void runOnOperation() override {
-    llvm::errs() << "Testing : " << getOperation()->getAttr("sym_name") << "\n";
+/// 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";
+
+void TestAliasAnalysisBase::runAliasAnalysisOnOperation(
+    Operation *op, AliasAnalysis &aliasAnalysis) {
+  llvm::errs() << "Testing : " << op->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());
-    });
+  op->walk([&](Operation *op) {
 
-    // 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() << ": " << result << "\n";
-  }
-};
-} // namespace
-
-//===----------------------------------------------------------------------===//
-// Testing ModRefResult
-//===----------------------------------------------------------------------===//
-
-namespace {
-struct TestAliasAnalysisModRefPass
-    : public PassWrapper<TestAliasAnalysisModRefPass, OperationPass<>> {
-  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAliasAnalysisModRefPass)
-
-  StringRef getArgument() const final { return "test-alias-analysis-modref"; }
-  StringRef getDescription() const final {
-    return "Test alias analysis ModRef results.";
-  }
-  void runOnOperation() override {
-    llvm::errs() << "Testing : " << getOperation()->getAttr("sym_name") << "\n";
+void TestAliasAnalysisModRefBase::runAliasAnalysisOnOperation(
+    Operation *op, AliasAnalysis &aliasAnalysis) {
+  llvm::errs() << "Testing : " << op->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());
-    });
+  op->walk([&](Operation *op) {
 
-    // Check for aliasing behavior between each of the values.
-    for (auto &it : valsToCheck) {
-      getOperation()->walk([&](Operation *op) {
-        if (!op->getAttr("test.ptr"))
-          return;
-        printModRefResult(aliasAnalysis.getModRef(op, it), op, it);
-      });
-    }
-  }
+    op->walk([&](Operation *op) {
 
-  /// 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";
+} // namespace test
+} // namespace mlir
+
+//===----------------------------------------------------------------------===//
+// Testing AliasResult
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct TestAliasAnalysisPass
+    : public test::TestAliasAnalysisBase,
+      PassWrapper<TestAliasAnalysisPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAliasAnalysisPass)
+
+  StringRef getArgument() const final { return "test-alias-analysis"; }
+  StringRef getDescription() const final {
+    return "Test alias analysis results.";
+  }
+  void runOnOperation() override {
+    AliasAnalysis &aliasAnalysis = getAnalysis<AliasAnalysis>();
+    runAliasAnalysisOnOperation(getOperation(), aliasAnalysis);
+  }
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// Testing ModRefResult
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct TestAliasAnalysisModRefPass
+    : public test::TestAliasAnalysisModRefBase,
+      PassWrapper<TestAliasAnalysisModRefPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAliasAnalysisModRefPass)
+
+  StringRef getArgument() const final { return "test-alias-analysis-modref"; }
+  StringRef getDescription() const final {
+    return "Test alias analysis ModRef results.";
+  }
+  void runOnOperation() override {
+    AliasAnalysis &aliasAnalysis = getAnalysis<AliasAnalysis>();
+    runAliasAnalysisOnOperation(getOperation(), aliasAnalysis);
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Pass Registration
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace test {
 void registerTestAliasAnalysisPass() {
   PassRegistration<TestAliasAnalysisPass>();
   PassRegistration<TestAliasAnalysisModRefPass>();
 }
 } // namespace test
 } // namespace mlir