[MLIR] Rename MemRefBoundCheck.cpp -> TestMemRefBoundCheck.cpp

[stephenneuendorffer]

Summary

This makes it consistent with other test passes.

[merge_guards_bot]

Unit tests: pass. 62508 tests passed, 0 failed and 844 were skipped.

clang-tidy: pass.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[rriddle]

Can you remove my name from the title when submitting?

mlir/include/mlir/Analysis/Passes.h

26

This file can be deleted.

mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp

1

This needs to be updated. The original comment here also looks incorrect.

[stephenneuendorffer]

mlir/include/mlir/Analysis/Passes.h

26

I was wondering about that. It doesn't seem that these methods are used in tree. I'll create a separate patch to remove the methods entirely.

mlir/include/mlir/Analysis/Passes.h

 #include <memory>
 
 namespace mlir {
 
 class FuncOp;
 template <typename T> class OpPassBase;
 
 /// Creates a pass to check memref accesses in a Function.
-std::unique_ptr<OpPassBase<FuncOp>> createMemRefBoundCheckPass();
+std::unique_ptr<OpPassBase<FuncOp>> createTestMemRefBoundCheckPass();
 
 /// Creates a pass to check memref access dependences in a Function.
 std::unique_ptr<OpPassBase<FuncOp>> createTestMemRefDependenceCheckPass();
 
 /// Creates a pass to test parallelism detection; emits note for parallel loops.
 std::unique_ptr<OpPassBase<FuncOp>> createParallelismDetectionTestPass();
 
 } // end namespace mlir
 
 #endif // MLIR_ANALYSIS_PASSES_H

mlir/test/Transforms/memref-bound-check.mlir

-// RUN: mlir-opt %s -memref-bound-check -split-input-file -verify-diagnostics | FileCheck %s
+// RUN: mlir-opt %s -test-memref-bound-check -split-input-file -verify-diagnostics | FileCheck %s
 
 // -----
 
 // CHECK-LABEL: func @test() {
 func @test() {
   %zero = constant 0 : index
   %minusone = constant -1 : index
   %sym = constant 111 : index

mlir/test/lib/Transforms/CMakeLists.txt

 add_llvm_library(MLIRTestTransforms
   TestAllReduceLowering.cpp
   TestCallGraph.cpp
   TestConstantFold.cpp
   TestLoopFusion.cpp
   TestGpuMemoryPromotion.cpp
   TestInlining.cpp
   TestLinalgTransforms.cpp
   TestLiveness.cpp
   TestLoopMapping.cpp
   TestLoopParametricTiling.cpp
   TestOpaqueLoc.cpp
-  MemRefBoundCheck.cpp
+  TestMemRefBoundCheck.cpp
   TestMemRefDependenceCheck.cpp
   TestMemRefStrideCalculation.cpp
   TestParallelismDetection.cpp
   TestVectorToLoopsConversion.cpp
   TestVectorTransforms.cpp
   TestVectorizationUtils.cpp
 
   ADDITIONAL_HEADER_DIRS

mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp

-//===- MemRefBoundCheck.cpp - MLIR Affine Structures Class ----------------===//
+//===- TestMemRefBoundCheck.cpp - Test out of bound access checks ---------===//
 //
 // 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 implements a pass to check memref accesses for out of bound

 
 #define DEBUG_TYPE "memref-bound-check"
 
 using namespace mlir;
 
 namespace {
 
 /// Checks for out of bound memef access subscripts..
-struct MemRefBoundCheck : public FunctionPass<MemRefBoundCheck> {
+struct TestMemRefBoundCheck : public FunctionPass<TestMemRefBoundCheck> {
   void runOnFunction() override;
 };
 
 } // end anonymous namespace
 
-std::unique_ptr<OpPassBase<FuncOp>> mlir::createMemRefBoundCheckPass() {
-  return std::make_unique<MemRefBoundCheck>();
+std::unique_ptr<OpPassBase<FuncOp>> mlir::createTestMemRefBoundCheckPass() {
+  return std::make_unique<TestMemRefBoundCheck>();
 }
 
-void MemRefBoundCheck::runOnFunction() {
+void TestMemRefBoundCheck::runOnFunction() {
   getFunction().walk([](Operation *opInst) {
     TypeSwitch<Operation *>(opInst).Case<AffineLoadOp, AffineStoreOp>(
         [](auto op) { boundCheckLoadOrStoreOp(op); });
 
     // TODO(bondhugula): do this for DMA ops as well.
   });
 }
 
-static PassRegistration<MemRefBoundCheck>
-    memRefBoundCheck("memref-bound-check",
+static PassRegistration<TestMemRefBoundCheck>
+    memRefBoundCheck("test-memref-bound-check",
                      "Check memref access bounds in a Function");