[mlir] Rename conversions involving ex-Loop dialect to mention SCF

[ftynse]

Summary

The following Conversions are affected: LoopToStandard -> SCFToStandard,
LoopsToGPU -> SCFToGPU, VectorToLoops -> VectorToSCF. Full file paths are
affected. Additionally, drop the 'Convert' prefix from filenames living under
lib/Conversion where applicable.

API names and CLI options for pass testing are also renamed when applicable. In
particular, LoopsToGPU contains several passes that apply to different kinds of
loops (for or parallel), for which the original names are preserved.

[rriddle]

mlir/include/mlir/Conversion/SCFToGPU/SCFToGPUPass.h

8

Looks like this was missed.

mlir/lib/Conversion/SCFToGPU/SCFToGPUPass.cpp

22

Should this be renamed/removed?

[ftynse]

eb8edd852601270eff090dc7d42acde7cd7a2573

mlir/include/mlir/Conversion/SCFToGPU/SCFToGPUPass.h

8

Good catch, thanks!

mlir/lib/Conversion/SCFToGPU/SCFToGPUPass.cpp

22

Looks unused, so let's remove.

flang/tools/tco/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 set(LIBS
   FIRDialect
   FIRSupport
   ${dialect_libs}
   MLIRIR
   MLIRLLVMIR
   MLIRPass
   MLIRStandardToLLVM
   MLIRTransforms
   MLIRAffineToStandard
   MLIRAnalysis
-  MLIRLoopToStandard
+  MLIRSCFToStandard
   MLIREDSC
   MLIRParser
   MLIRStandardToLLVM
   MLIRSupport
   MLIRVectorToLLVM
 )
 
 add_flang_tool(tco tco.cpp)
 target_link_libraries(tco PRIVATE ${LIBS})

mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp

 // have been inlined, and all shapes have been resolved.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 #include "toy/Passes.h"
 
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
-#include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
+#include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"

mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp

 // have been inlined, and all shapes have been resolved.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 #include "toy/Passes.h"
 
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
-#include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
+#include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"

mlir/include/mlir/Conversion/Passes.td

 //===----------------------------------------------------------------------===//
 
 def ConvertLinalgToSPIRV : Pass<"convert-linalg-to-spirv", "ModuleOp"> {
   let summary = "Convert Linalg ops to SPIR-V ops";
   let constructor = "mlir::createLinalgToSPIRVPass()";
 }
 
 //===----------------------------------------------------------------------===//
-// LoopToStandard
+// SCFToStandard
 //===----------------------------------------------------------------------===//
 
-def ConvertLoopToStandard : Pass<"convert-loop-to-std"> {
+def SCFToStandard : Pass<"convert-scf-to-std"> {
   let summary = "Convert SCF dialect to Standard dialect, replacing structured"
                 " control flow with a CFG";
   let constructor = "mlir::createLowerToCFGPass()";
 }
 
 //===----------------------------------------------------------------------===//
-// LoopsToGPU
+// SCFToGPU
 //===----------------------------------------------------------------------===//
 
-def ConvertSimpleLoopsToGPU : FunctionPass<"convert-loops-to-gpu"> {
+def ConvertSimpleSCFToGPU : FunctionPass<"convert-scf-to-gpu"> {
   let summary = "Convert top-level loops to GPU kernels";
-  let constructor = "mlir::createSimpleLoopsToGPUPass()";
+  let constructor = "mlir::createSimpleSCFToGPUPass()";
   let options = [
     Option<"numBlockDims", "gpu-block-dims", "unsigned", /*default=*/"1u",
            "Number of GPU block dimensions for mapping">,
     Option<"numThreadDims", "gpu-thread-dims", "unsigned", /*default=*/"1u",
            "Number of GPU thread dimensions for mapping">
   ];
 }
 
-def ConvertLoopsToGPU : FunctionPass<"convert-loop-op-to-gpu"> {
+def ConvertSCFToGPU : FunctionPass<"convert-loop-op-to-gpu"> {
   let summary = "Convert top-level scf::ForOp to GPU kernels";
   let constructor = "mlir::createLoopToGPUPass()";
   let options = [
     ListOption<"numWorkGroups", "gpu-num-workgroups", "int64_t",
                "Num workgroups in the GPU launch",
                "llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated">,
     ListOption<"workGroupSize", "gpu-workgroup-size", "int64_t",
                "Workgroup Size in the GPU launch",

mlir/include/mlir/Conversion/SCFToGPU/SCFToGPU.h

-//===- LoopsToGPU.h - Convert loop nests to GPU kernels ---------*- C++ -*-===//
+//===- SCFToGPU.h - Convert loop nests to GPU kernels -----------*- 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 MLIR_CONVERSION_LOOPSTOGPU_LOOPSTOGPU_H_
-#define MLIR_CONVERSION_LOOPSTOGPU_LOOPSTOGPU_H_
+#ifndef MLIR_CONVERSION_SCFTOGPU_SCFTOGPU_H_
+#define MLIR_CONVERSION_SCFTOGPU_SCFTOGPU_H_
 
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
 class AffineForOp;
 class MLIRContext;
 class OwningRewritePatternList;
 struct LogicalResult;

 
 /// Adds the conversion pattern from `scf.parallel` to `gpu.launch` to the
 /// provided pattern list.
 void populateParallelLoopToGPUPatterns(OwningRewritePatternList &patterns,
                                        MLIRContext *ctx);
 
 } // namespace mlir
 
-#endif // MLIR_CONVERSION_LOOPSTOGPU_LOOPSTOGPU_H_
+#endif // MLIR_CONVERSION_SCFTOGPU_SCFTOGPU_H_

mlir/include/mlir/Conversion/SCFToGPU/SCFToGPUPass.h

-//===- LoopsToGPUPass.h - Pass converting loops to GPU kernels --*- C++ -*-===//
+//===- SCFToGPUPass.h - Pass converting loops to GPU kernels ----*- 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 MLIR_CONVERSION_LOOPSTOGPU_LOOPSTOGPUPASS_H_
 #define MLIR_CONVERSION_LOOPSTOGPU_LOOPSTOGPUPASS_H_
 
 #include "mlir/Support/LLVM.h"
 
 #include <memory>
 
 namespace mlir {
 class FuncOp;
-template <typename T> class OperationPass;
+template <typename T>
+class OperationPass;
 class Pass;
 
 /// Create a pass that converts loop nests into GPU kernels.  It considers
 /// top-level affine.for and linalg.for operations as roots of loop nests and
 /// converts them to the gpu.launch operations if possible.
 ///
 /// No check on the size of the block or grid, or on the validity of
 /// parallelization is performed, it is under the responsibility of the caller
 /// to strip-mine the loops and to perform the dependence analysis before
 /// calling the conversion.
 std::unique_ptr<OperationPass<FuncOp>>
-createSimpleLoopsToGPUPass(unsigned numBlockDims, unsigned numThreadDims);
-std::unique_ptr<OperationPass<FuncOp>> createSimpleLoopsToGPUPass();
+createSimpleSCFToGPUPass(unsigned numBlockDims, unsigned numThreadDims);
+std::unique_ptr<OperationPass<FuncOp>> createSimpleSCFToGPUPass();
 
 /// Create a pass that converts every loop operation within the body of the
 /// FuncOp into a GPU launch. The number of workgroups and workgroup size for
 /// the implementation is controlled by SSA values passed into conversion
 /// method. For testing, the values are set as constants obtained from a command
 /// line flag. See convertLoopToGPULaunch for a description of the required
 /// semantics of the converted loop operation.
 std::unique_ptr<OperationPass<FuncOp>>

mlir/include/mlir/Conversion/SCFToStandard/SCFToStandard.h

-//===- ConvertLoopToStandard.h - Pass entrypoint ----------------*- C++ -*-===//
+//===- ConvertSCFToStandard.h - Pass entrypoint -----------------*- 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 MLIR_CONVERSION_LOOPTOSTANDARD_CONVERTLOOPTOSTANDARD_H_
-#define MLIR_CONVERSION_LOOPTOSTANDARD_CONVERTLOOPTOSTANDARD_H_
+#ifndef MLIR_CONVERSION_SCFTOSTANDARD_SCFTOSTANDARD_H_
+#define MLIR_CONVERSION_SCFTOSTANDARD_SCFTOSTANDARD_H_
 
 #include <memory>
 #include <vector>
 
 namespace mlir {
 struct LogicalResult;
 class MLIRContext;
 class Pass;
 class RewritePattern;
 
 // Owning list of rewriting patterns.
 class OwningRewritePatternList;
 
 /// Collect a set of patterns to lower from scf.for, scf.if, and
 /// loop.terminator to CFG operations within the Standard dialect, in particular
 /// convert structured control flow into CFG branch-based control flow.
 void populateLoopToStdConversionPatterns(OwningRewritePatternList &patterns,
                                          MLIRContext *ctx);
 
 /// Creates a pass to convert scf.for, scf.if and loop.terminator ops to CFG.
 std::unique_ptr<Pass> createLowerToCFGPass();
 
 } // namespace mlir
 
-#endif // MLIR_CONVERSION_LOOPTOSTANDARD_CONVERTLOOPTOSTANDARD_H_
+#endif // MLIR_CONVERSION_SCFTOSTANDARD_SCFTOSTANDARD_H_

mlir/include/mlir/Conversion/VectorToSCF/VectorToSCF.h

-//===- ConvertVectorToLoops.h - Utils to convert from the vector dialect --===//
+//===- VectorToSCF.h - Utils to convert from the vector dialect -*- 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 MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLOOPS_H_
-#define MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLOOPS_H_
+#ifndef MLIR_CONVERSION_VECTORTOSCF_VECTORTOSCF_H_
+#define MLIR_CONVERSION_VECTORTOSCF_VECTORTOSCF_H_
 
 namespace mlir {
 class MLIRContext;
 class OwningRewritePatternList;
 
 /// Collect a set of patterns to convert from the Vector dialect to loops + std.
-void populateVectorToLoopsConversionPatterns(OwningRewritePatternList &patterns,
-                                             MLIRContext *context);
+void populateVectorToSCFConversionPatterns(OwningRewritePatternList &patterns,
 
 } // namespace mlir
 
-#endif // MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLOOPS_H_
+#endif // MLIR_CONVERSION_VECTORTOSCF_VECTORTOSCF_H_

mlir/include/mlir/Dialect/GPU/ParallelLoopMapper.h

LogicalResult setMappingAttr(scf::ParallelOp ploopOp,
                              ArrayRef<ParallelLoopDimMapping> mapping);
 } // end namespace gpu
 
 /// Maps the parallel loops found in the given function to workgroups. The first
 /// loop encountered will be mapped to the global workgroup and the second loop
 /// encountered to the local workgroup. Within each mapping, the first three
 /// dimensions are mapped to x/y/z hardware ids and all following dimensions are
 /// mapped to sequential loops.
-void greedilyMapParallelLoopsToGPU(Region &region);
+void greedilyMapParallelSCFToGPU(Region &region);
 
 } // end namespace mlir
 #endif // MLIR_DIALECT_GPU_PARALLELLOOPMAPPER_H

mlir/include/mlir/Dialect/Vector/VectorTransforms.h

 
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 class MLIRContext;
 class OwningRewritePatternList;
 
 /// Collect a set of patterns to convert from the Vector dialect to itself.
-/// Should be merged with populateVectorToLoopsLoweringPattern.
+/// Should be merged with populateVectorToSCFLoweringPattern.
 void populateVectorToVectorConversionPatterns(
     MLIRContext *context, OwningRewritePatternList &patterns,
     ArrayRef<int64_t> coarseVectorShape = {},
     ArrayRef<int64_t> fineVectorShape = {});
 
 ////////////////////////////////////////////////////////////////////////////////
 // The following Declarative Rewrite Rule (DRR) helpers are used in rewrite
 // patterns. As such, they must not call into `rewriter.erase/replace` APIs and

mlir/include/mlir/InitAllPasses.h

 #include "mlir/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.h"
 #include "mlir/Conversion/GPUToCUDA/GPUToCUDAPass.h"
 #include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h"
 #include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h"
 #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h"
 #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
 #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
 #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
-#include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
-#include "mlir/Conversion/LoopsToGPU/LoopsToGPUPass.h"
+#include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h"
+#include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h"
 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/GPU/Passes.h"
 #include "mlir/Dialect/LLVMIR/Transforms/LegalizeForExport.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Quant/Passes.h"

mlir/lib/Conversion/CMakeLists.txt

 add_subdirectory(AffineToStandard)
 add_subdirectory(AVX512ToLLVM)
 add_subdirectory(GPUToCUDA)
 add_subdirectory(GPUToNVVM)
 add_subdirectory(GPUToROCDL)
 add_subdirectory(GPUToSPIRV)
 add_subdirectory(GPUToVulkan)
 add_subdirectory(LinalgToLLVM)
 add_subdirectory(LinalgToSPIRV)
-add_subdirectory(LoopsToGPU)
-add_subdirectory(LoopToStandard)
+add_subdirectory(SCFToGPU)
+add_subdirectory(SCFToStandard)
 add_subdirectory(StandardToLLVM)
 add_subdirectory(StandardToSPIRV)
 add_subdirectory(VectorToLLVM)
-add_subdirectory(VectorToLoops)
+add_subdirectory(VectorToSCF)

mlir/lib/Conversion/LinalgToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIRLinalgToLLVM
   Core
 
   LINK_LIBS PUBLIC
   MLIRAffineToStandard
   MLIREDSC
   MLIRIR
   MLIRLinalgOps
   MLIRLLVMIR
-  MLIRLoopToStandard
+  MLIRSCFToStandard
   MLIRStandardToLLVM
-  MLIRVectorToLLVM
-  MLIRVectorToLoops
   MLIRTransforms
+  MLIRVectorToLLVM
+  MLIRVectorToSCF
   )

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

 //===- LinalgToLLVM.cpp - conversion from Linalg to LLVM dialect ----------===//
 //
 // 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/Conversion/LinalgToLLVM/LinalgToLLVM.h"
 
 #include "../PassDetail.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
-#include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
+#include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
-#include "mlir/Conversion/VectorToLoops/ConvertVectorToLoops.h"
+#include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
void ConvertLinalgToLLVMPass::runOnOperation() {
   auto module = getOperation();
 
   // Convert to the LLVM IR dialect using the converter defined above.
   OwningRewritePatternList patterns;
   LLVMTypeConverter converter(&getContext());
   populateAffineToStdConversionPatterns(patterns, &getContext());
   populateLoopToStdConversionPatterns(patterns, &getContext());
   populateStdToLLVMConversionPatterns(converter, patterns);
-  populateVectorToLoopsConversionPatterns(patterns, &getContext());
+  populateVectorToSCFConversionPatterns(patterns, &getContext());
   populateVectorToLLVMMatrixConversionPatterns(converter, patterns);
   populateVectorToLLVMConversionPatterns(converter, patterns);
   populateLinalgToStandardConversionPatterns(patterns, &getContext());
   populateLinalgToLLVMConversionPatterns(converter, patterns, &getContext());
 
   LLVMConversionTarget target(getContext());
   target.addDynamicallyLegalOp<FuncOp>(
       [&](FuncOp op) { return converter.isSignatureLegal(op.getType()); });
   target.addLegalOp<ModuleOp, ModuleTerminatorOp>();
   if (failed(applyFullConversion(module, target, patterns, &converter)))
     signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertLinalgToLLVMPass() {
   return std::make_unique<ConvertLinalgToLLVMPass>();
 }

mlir/lib/Conversion/SCFToGPU/CMakeLists.txt

-add_mlir_conversion_library(MLIRLoopsToGPU
-  LoopsToGPU.cpp
-  LoopsToGPUPass.cpp
+add_mlir_conversion_library(MLIRSCFToGPU
+  SCFToGPU.cpp
+  SCFToGPUPass.cpp
 
   ADDITIONAL_HEADER_DIRS
-  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/LoopsToGPU
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToGPU
 
   DEPENDS
   MLIRConversionPassIncGen
 
   LINK_LIBS PUBLIC
   MLIRAffineOps
   MLIRAffineToStandard
   MLIRGPU
   MLIRIR
   MLIRLinalgOps
   MLIRPass
   MLIRStandardOps
   MLIRSupport
   MLIRTransforms
   )

mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp

-//===- LoopsToGPU.cpp - Convert an affine loop nest to a GPU kernel -------===//
+//===- SCFToGPU.cpp - Convert an affine loop nest to a GPU kernel -------===//
 //
 // 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 implements a straightforward conversion of an loop nest into a GPU
 // kernel.  The caller is expected to guarantee that the conversion is correct
 // or to further transform the kernel to ensure correctness.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Conversion/LoopsToGPU/LoopsToGPU.h"
+#include "mlir/Conversion/SCFToGPU/SCFToGPU.h"
 
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/GPU/ParallelLoopMapper.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/AffineExpr.h"

mlir/lib/Conversion/SCFToGPU/SCFToGPUPass.cpp

-//===- LoopsToGPUPass.cpp - Convert a loop nest to a GPU kernel -----------===//
+//===- SCFToGPUPass.cpp - Convert a loop nest to a GPU kernel -----------===//
 //
 // 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/Conversion/LoopsToGPU/LoopsToGPUPass.h"
+#include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h"
 #include "../PassDetail.h"
-#include "mlir/Conversion/LoopsToGPU/LoopsToGPU.h"
+#include "mlir/Conversion/SCFToGPU/SCFToGPU.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/CommandLine.h"
 
-#define PASS_NAME "convert-loops-to-gpu"
+#define PASS_NAME "convert-scf-to-gpu"
 #define LOOPOP_TO_GPU_PASS_NAME "convert-loop-op-to-gpu"
 
 using namespace mlir;
 using namespace mlir::scf;
 
 namespace {
 // A pass that traverses top-level loops in the function and converts them to
 // GPU launch operations.  Nested launches are not allowed, so this does not
 // walk the function recursively to avoid considering nested loops.
-struct ForLoopMapper : public ConvertSimpleLoopsToGPUBase<ForLoopMapper> {
+struct ForLoopMapper : public ConvertSimpleSCFToGPUBase<ForLoopMapper> {
   ForLoopMapper() = default;
   ForLoopMapper(unsigned numBlockDims, unsigned numThreadDims) {
     this->numBlockDims = numBlockDims;
     this->numThreadDims = numThreadDims;
   }
 
   void runOnFunction() override {
     for (Operation &op : llvm::make_early_inc_range(getFunction().getOps())) {

 };
 
 // A pass that traverses top-level loops in the function and convertes them to
 // GPU launch operations. The top-level loops itself does not have to be
 // perfectly nested. The only requirement is that there be as many perfectly
 // nested loops as the size of `numWorkGroups`. Within these any loop nest has
 // to be perfectly nested upto depth equal to size of `workGroupSize`.
 struct ImperfectlyNestedForLoopMapper
-    : public ConvertLoopsToGPUBase<ImperfectlyNestedForLoopMapper> {
+    : public ConvertSCFToGPUBase<ImperfectlyNestedForLoopMapper> {
   ImperfectlyNestedForLoopMapper() = default;
   ImperfectlyNestedForLoopMapper(ArrayRef<int64_t> numWorkGroups,
                                  ArrayRef<int64_t> workGroupSize) {
     this->numWorkGroups = numWorkGroups;
     this->workGroupSize = workGroupSize;
   }
 
   void runOnFunction() override {
void runOnOperation() override {
     if (failed(applyPartialConversion(getOperation(), target, patterns)))
       signalPassFailure();
   }
 };
 
 } // namespace
 
 std::unique_ptr<OperationPass<FuncOp>>
-mlir::createSimpleLoopsToGPUPass(unsigned numBlockDims,
-                                 unsigned numThreadDims) {
+mlir::createSimpleSCFToGPUPass(unsigned numBlockDims, unsigned numThreadDims) {
   return std::make_unique<ForLoopMapper>(numBlockDims, numThreadDims);
 }
-std::unique_ptr<OperationPass<FuncOp>> mlir::createSimpleLoopsToGPUPass() {
+std::unique_ptr<OperationPass<FuncOp>> mlir::createSimpleSCFToGPUPass() {
   return std::make_unique<ForLoopMapper>();
 }
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createLoopToGPUPass(ArrayRef<int64_t> numWorkGroups,
                           ArrayRef<int64_t> workGroupSize) {
   return std::make_unique<ImperfectlyNestedForLoopMapper>(numWorkGroups,
                                                           workGroupSize);
 }
 std::unique_ptr<OperationPass<FuncOp>> mlir::createLoopToGPUPass() {
   return std::make_unique<ImperfectlyNestedForLoopMapper>();
 }
 
 std::unique_ptr<Pass> mlir::createParallelLoopToGpuPass() {
   return std::make_unique<ParallelLoopToGpuPass>();
 }

mlir/lib/Conversion/SCFToStandard/CMakeLists.txt

-add_mlir_conversion_library(MLIRLoopToStandard
-  LoopToStandard.cpp
+add_mlir_conversion_library(MLIRSCFToStandard
+  SCFToStandard.cpp
 
   ADDITIONAL_HEADER_DIRS
-  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/LoopToStandard
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToStandard
 
   DEPENDS
   MLIRConversionPassIncGen
 
   LINK_COMPONENTS
   Core
 
   LINK_LIBS PUBLIC
   MLIRSCF
   MLIRTransforms
   )

mlir/lib/Conversion/SCFToStandard/SCFToStandard.cpp

-//===- LoopToStandard.cpp - ControlFlow to CFG conversion -----------------===//
+//===- SCFToStandard.cpp - ControlFlow to CFG conversion ------------------===//
 //
 // 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 convert scf.for, scf.if and loop.terminator
 // ops into standard CFG ops.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
 #include "../PassDetail.h"
-#include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/Utils.h"
 
 using namespace mlir;
 using namespace mlir::scf;
 
 namespace {
 
-struct LoopToStandardPass
-    : public ConvertLoopToStandardBase<LoopToStandardPass> {
+struct SCFToStandardPass : public SCFToStandardBase<SCFToStandardPass> {
   void runOnOperation() override;
 };
 
 // Create a CFG subgraph for the loop around its body blocks (if the body
 // contained other loops, they have been already lowered to a flow of blocks).
 // Maintain the invariants that a CFG subgraph created for any loop has a single
 // entry and a single exit, and that the entry/exit blocks are respectively
 // first/last blocks in the parent region.  The original loop operation is
ParallelLowering::matchAndRewrite(ParallelOp parallelOp,
   return success();
 }
 
 void mlir::populateLoopToStdConversionPatterns(
     OwningRewritePatternList &patterns, MLIRContext *ctx) {
   patterns.insert<ForLowering, IfLowering, ParallelLowering>(ctx);
 }
 
-void LoopToStandardPass::runOnOperation() {
+void SCFToStandardPass::runOnOperation() {
   OwningRewritePatternList patterns;
   populateLoopToStdConversionPatterns(patterns, &getContext());
   ConversionTarget target(getContext());
   target.addLegalDialect<StandardOpsDialect>();
   if (failed(applyPartialConversion(getOperation(), target, patterns)))
     signalPassFailure();
 }
 
 std::unique_ptr<Pass> mlir::createLowerToCFGPass() {
-  return std::make_unique<LoopToStandardPass>();
+  return std::make_unique<SCFToStandardPass>();
 }

mlir/lib/Conversion/VectorToSCF/CMakeLists.txt

-add_mlir_conversion_library(MLIRVectorToLoops
-  ConvertVectorToLoops.cpp
+add_mlir_conversion_library(MLIRVectorToSCF
+  VectorToSCF.cpp
 
   ADDITIONAL_HEADER_DIRS
-  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToLoops
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToSCF
 
   LINK_COMPONENTS
   Core
 
   LINK_LIBS PUBLIC
   MLIREDSC
   MLIRAffineEDSC
   MLIRLLVMIR
   MLIRTransforms
   )

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

-//===- VectorToLoops.cpp - Conversion from Vector to mix of Loops and Std -===//
+//===- VectorToSCF.cpp - Conversion from Vector to mix of SCF and Std -----===//
 //
 // 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 target-dependent lowering of vector transfer operations.
 //
 //===----------------------------------------------------------------------===//
 
 #include <type_traits>
 
-#include "mlir/Conversion/VectorToLoops/ConvertVectorToLoops.h"
+#include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
 #include "mlir/Dialect/Affine/EDSC/Intrinsics.h"
 #include "mlir/Dialect/SCF/EDSC/Builders.h"
 #include "mlir/Dialect/SCF/EDSC/Intrinsics.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Vector/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
LogicalResult VectorTransferRewriter<TransferWriteOp>::matchAndRewrite(
   (std_dealloc(tmp)); // vexing parse...
 
   rewriter.eraseOp(op);
   return success();
 }
 
 } // namespace
 
-void mlir::populateVectorToLoopsConversionPatterns(
+void mlir::populateVectorToSCFConversionPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {
   patterns.insert<VectorTransferRewriter<vector::TransferReadOp>,
                   VectorTransferRewriter<vector::TransferWriteOp>>(context);
 }

mlir/lib/Dialect/GPU/Transforms/ParallelLoopMapper.cpp

static void mapParallelOp(ParallelOp parallelOp,
   // Parallel loop operations are immediately nested, so do not use
   // walk but just iterate over the operations.
   for (Operation &op : *parallelOp.getBody()) {
     if (ParallelOp nested = dyn_cast<ParallelOp>(op))
       mapParallelOp(nested, mappingLevel);
   }
 }
 
-void mlir::greedilyMapParallelLoopsToGPU(Region &region) {
+void mlir::greedilyMapParallelSCFToGPU(Region &region) {
   region.walk([](ParallelOp parallelOp) { mapParallelOp(parallelOp); });
 }

mlir/lib/Dialect/Vector/VectorTransforms.cpp

-//===- VectorToLoops.cpp - Conversion within the Vector dialect -----------===//
+//===- VectorTransforms.cpp - Conversion within the Vector dialect --------===//
 //
 // 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 target-independent rewrites as 1->N patterns.

mlir/test/Conversion/LoopsToGPU/linalg_to_gpu.mlir

-// RUN: mlir-opt -convert-loops-to-gpu %s | FileCheck %s
+// RUN: mlir-opt -convert-scf-to-gpu %s | FileCheck %s
 
 // CHECK-LABEL: @foo
 func @foo(%arg0: memref<?xf32>, %arg1 : index) {
   %c0 = constant 0 : index
   %c42 = constant 42 : index
   %c3 = constant 3 : index
   // CHECK:      subi %{{.*}}, %{{.*}} : index
   // CHECK-NEXT: %[[range_i:.*]] = divi_signed {{.*}}, %{{.*}} : index

mlir/test/Conversion/LoopsToGPU/no_blocks_no_threads.mlir

-// RUN: mlir-opt -convert-loops-to-gpu="gpu-block-dims=0 gpu-thread-dims=1" %s | FileCheck --check-prefix=CHECK-THREADS %s --dump-input-on-failure
-// RUN: mlir-opt -convert-loops-to-gpu="gpu-block-dims=1 gpu-thread-dims=0" %s | FileCheck --check-prefix=CHECK-BLOCKS %s --dump-input-on-failure
+// RUN: mlir-opt -convert-scf-to-gpu="gpu-block-dims=0 gpu-thread-dims=1" %s | FileCheck --check-prefix=CHECK-THREADS %s --dump-input-on-failure
+// RUN: mlir-opt -convert-scf-to-gpu="gpu-block-dims=1 gpu-thread-dims=0" %s | FileCheck --check-prefix=CHECK-BLOCKS %s --dump-input-on-failure
 
 // CHECK-THREADS-LABEL: @one_d_loop
 // CHECK-BLOCKS-LABEL: @one_d_loop
 func @one_d_loop(%A : memref<?xf32>, %B : memref<?xf32>) {
   // Bounds of the loop, its range and step.
   // CHECK-THREADS-NEXT: %{{.*}} = constant 0 : index
   // CHECK-THREADS-NEXT: %{{.*}} = constant 42 : index
   // CHECK-THREADS-NEXT: %[[BOUND:.*]] = subi %{{.*}}, %{{.*}} : index

mlir/test/Conversion/LoopsToGPU/step_one.mlir

-// RUN: mlir-opt -convert-loops-to-gpu="gpu-block-dims=1 gpu-thread-dims=1" %s | FileCheck --check-prefix=CHECK-11 %s
-// RUN: mlir-opt -convert-loops-to-gpu="gpu-block-dims=2 gpu-thread-dims=2" %s | FileCheck --check-prefix=CHECK-22 %s
+// RUN: mlir-opt -convert-scf-to-gpu="gpu-block-dims=1 gpu-thread-dims=1" %s | FileCheck --check-prefix=CHECK-11 %s
+// RUN: mlir-opt -convert-scf-to-gpu="gpu-block-dims=2 gpu-thread-dims=2" %s | FileCheck --check-prefix=CHECK-22 %s
 
 // CHECK-11-LABEL: @step_1
 // CHECK-22-LABEL: @step_1
 func @step_1(%A : memref<?x?x?x?xf32>, %B : memref<?x?x?x?xf32>) {
   // Bounds of the loop, its range and step.
   // CHECK-11-NEXT: %{{.*}} = constant 0 : index
   // CHECK-11-NEXT: %{{.*}} = constant 42 : index
   // CHECK-11-NEXT: %{{.*}} = subi %{{.*}}, %{{.*}} : index

mlir/test/Conversion/LoopsToGPU/step_positive.mlir

-// RUN: mlir-opt -convert-loops-to-gpu="gpu-block-dims=1 gpu-thread-dims=1" %s | FileCheck %s
+// RUN: mlir-opt -convert-scf-to-gpu="gpu-block-dims=1 gpu-thread-dims=1" %s | FileCheck %s
 
 // CHECK-LABEL: @step_var
 func @step_var(%A : memref<?x?xf32>, %B : memref<?x?xf32>) {
   // Check that we divide by step.
   // CHECK:  %[[range_i:.*]] = divi_signed {{.*}}, %{{.*}}
   // CHECK:  %[[range_j:.*]] = divi_signed {{.*}}, %{{.*}}
 
   // CHECK: gpu.launch

mlir/test/Conversion/VectorToLoops/vector-to-loops.mlir

-// RUN: mlir-opt %s -test-convert-vector-to-loops -split-input-file | FileCheck %s
+// RUN: mlir-opt %s -test-convert-vector-to-scf -split-input-file | FileCheck %s
 
 // CHECK-LABEL: func @materialize_read_1d() {
 func @materialize_read_1d() {
   %f0 = constant 0.0: f32
   %A = alloc () : memref<7x42xf32>
   affine.for %i0 = 0 to 7 step 4 {
     affine.for %i1 = 0 to 42 step 4 {
       %f1 = vector.transfer_read %A[%i0, %i1], %f0 {permutation_map = affine_map<(d0, d1) -> (d0)>} : memref<7x42xf32>, vector<4xf32>

mlir/test/Conversion/convert-to-cfg.mlir

-// RUN: mlir-opt -convert-loop-to-std %s | FileCheck %s
+// RUN: mlir-opt -convert-scf-to-std %s | FileCheck %s
 
 // CHECK-LABEL: func @simple_std_for_loop(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 //  CHECK-NEXT:  br ^bb1(%{{.*}} : index)
 //  CHECK-NEXT:  ^bb1(%{{.*}}: index):    // 2 preds: ^bb0, ^bb2
 //  CHECK-NEXT:    %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
 //  CHECK-NEXT:    cond_br %{{.*}}, ^bb2, ^bb3
 //  CHECK-NEXT:  ^bb2:   // pred: ^bb1
 //  CHECK-NEXT:    %{{.*}} = constant 1 : index

mlir/test/lib/Transforms/CMakeLists.txt

add_mlir_library(MLIRTestTransforms
   TestLiveness.cpp
   TestLoopMapping.cpp
   TestLoopParametricTiling.cpp
   TestLoopUnrolling.cpp
   TestOpaqueLoc.cpp
   TestMemRefBoundCheck.cpp
   TestMemRefDependenceCheck.cpp
   TestMemRefStrideCalculation.cpp
-  TestVectorToLoopsConversion.cpp
+  TestVectorToSCFConversion.cpp
   TestVectorTransforms.cpp
 
   EXCLUDE_FROM_LIBMLIR
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Transforms
 
   DEPENDS
add_mlir_library(MLIRTestTransforms
   MLIRLinalgOps
   MLIRLinalgTransforms
   MLIRSCF
   MLIRGPU
   MLIRPass
   MLIRStandardOpsTransforms
   MLIRTestDialect
   MLIRTransformUtils
-  MLIRVectorToLoops
+  MLIRVectorToSCF
   MLIRVector
   )
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../Dialect/Test)
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/../Dialect/Test)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../DeclarativeTransforms)
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/../DeclarativeTransforms)

mlir/test/lib/Transforms/TestGpuParallelLoopMapping.cpp

 /// Simple pass for testing the mapping of parallel loops to hardware ids using
 /// a greedy mapping strategy.
 class TestGpuGreedyParallelLoopMappingPass
     : public PassWrapper<TestGpuGreedyParallelLoopMappingPass,
                          OperationPass<FuncOp>> {
   void runOnOperation() override {
     Operation *op = getOperation();
     for (Region &region : op->getRegions())
-      greedilyMapParallelLoopsToGPU(region);
+      greedilyMapParallelSCFToGPU(region);
   }
 };
 } // end namespace
 
 namespace mlir {
 void registerTestGpuParallelLoopMappingPass() {
   PassRegistration<TestGpuGreedyParallelLoopMappingPass> registration(
       "test-gpu-greedy-parallel-loop-mapping",
       "Greedily maps all parallel loops to gpu hardware ids.");
 }
 } // namespace mlir

mlir/test/lib/Transforms/TestVectorToSCFConversion.cpp

-//===- TestVectorToLoopsConversion.cpp - Test VectorTransfers lowering ----===//
+//===- TestVectorToSCFConversion.cpp - Test VectorTransfers lowering ------===//
 //
 // 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 <type_traits>
 
-#include "mlir/Conversion/VectorToLoops/ConvertVectorToLoops.h"
+#include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
 namespace {
 
-struct TestVectorToLoopsPass
-    : public PassWrapper<TestVectorToLoopsPass, FunctionPass> {
+struct TestVectorToSCFPass
+    : public PassWrapper<TestVectorToSCFPass, FunctionPass> {
   void runOnFunction() override {
     OwningRewritePatternList patterns;
     auto *context = &getContext();
-    populateVectorToLoopsConversionPatterns(patterns, context);
+    populateVectorToSCFConversionPatterns(patterns, context);
     applyPatternsAndFoldGreedily(getFunction(), patterns);
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
-void registerTestVectorToLoopsPass() {
-  PassRegistration<TestVectorToLoopsPass> pass(
-      "test-convert-vector-to-loops",
+void registerTestVectorToSCFPass() {
+  PassRegistration<TestVectorToSCFPass> pass(
+      "test-convert-vector-to-scf",
       "Converts vector transfer ops to loops over scalars and vector casts");
 }
 } // namespace mlir

mlir/test/mlir-cpu-runner/bare_ptr_call_conv.mlir

-// RUN: mlir-opt %s -convert-loop-to-std -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' | mlir-cpu-runner -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s
+// RUN: mlir-opt %s -convert-scf-to-std -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' | mlir-cpu-runner -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s
 
 // Verify bare pointer memref calling convention. `simple_add1_add2_test`
 // gets two 2xf32 memrefs, adds 1.0f to the first one and 2.0f to the second
 // one. 'main' calls 'simple_add1_add2_test' with {1, 1} and {2, 2} so {2, 2}
 // and {4, 4} are the expected outputs.
 
 func @simple_add1_add2_test(%arg0: memref<2xf32>, %arg1: memref<2xf32>) {
   %c2 = constant 2 : index

mlir/test/mlir-cpu-runner/sgemm_naive_codegen.mlir

-// RUN: mlir-opt -convert-linalg-to-loops -lower-affine -convert-loop-to-std -convert-std-to-llvm %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext | FileCheck %s
+// RUN: mlir-opt -convert-linalg-to-loops -lower-affine -convert-scf-to-std -convert-std-to-llvm %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext | FileCheck %s
 
 func @main() {
   %A = alloc() : memref<64x64xf32>
   %B = alloc() : memref<64x64xf32>
   %C = alloc() : memref<64x64xf32>
 
   %cf1 = constant 1.00000e+00 : f32
 

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

 void registerTestLoopUnrollingPass();
 void registerTestMatchers();
 void registerTestMemRefDependenceCheck();
 void registerTestMemRefStrideCalculation();
 void registerTestOpaqueLoc();
 void registerTestParallelismDetection();
 void registerTestGpuParallelLoopMappingPass();
 void registerTestVectorConversions();
-void registerTestVectorToLoopsPass();
+void registerTestVectorToSCFPass();
 void registerVectorizerTestPass();
 } // namespace mlir
 
 static cl::opt<std::string>
     inputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
 
 static cl::opt<std::string> outputFilename("o", cl::desc("Output filename"),
                                            cl::value_desc("filename"),
#endif
   registerTestLoopUnrollingPass();
   registerTestMatchers();
   registerTestMemRefDependenceCheck();
   registerTestMemRefStrideCalculation();
   registerTestOpaqueLoc();
   registerTestParallelismDetection();
   registerTestGpuParallelLoopMappingPass();
   registerTestVectorConversions();
-  registerTestVectorToLoopsPass();
+  registerTestVectorToSCFPass();
   registerVectorizerTestPass();
 }
 
 static cl::opt<bool>
     showDialects("show-dialects",
                  cl::desc("Print the list of registered dialects"),
                  cl::init(false));