Remove static registration for dialects, and the "alwayslink" hack for passes

[mehdi_amini]

Summary

In the previous state, we were relying on forcing the linker to include
all libraries in the final binary and the global initializer to self-register
every piece of the system. This change help moving away from this model, and
allow users to compose pieces more freely. The current change is only "fixing"
the dialect registration and avoiding relying on "whole link" for the passes.
The translation is still relying on the global registry, and some refactoring
is needed to make this all more convenient.

[mehdi_amini]

mlir/tools/mlir-opt/CMakeLists.txt

99

^^ This was the goal for this milestone

[jpienaar]

Yay, thanks good step in the right direction.

mlir/include/mlir/InitAllPasses.h

40

s/must be called/may be called/

s/force registering the/register all/ ?

46

command-line testing tools ?

49

Sentence fragment ? (, at end)

53

But you've now documented it inside the compiler, what if the compiler reads its own comments?!?

71

Do you want to add somewhere a comment as to the values/should these have flags associated and should those flags be in this file ... (can also be follow up if so :))

mlir/include/mlir/Transforms/Passes.h

113–114

list of ops ?

mlir/lib/Dialect/CMakeLists.txt

31

I don't know what this does?

[rriddle]

mlir/include/mlir/InitAllPasses.h

40

Use /// for comments.

48

nit: Drop the newline here.

81

I thought this was removed?

mlir/lib/Quantizer/Transforms/InferQuantizedTypesPass.cpp

287

What are you moving pass registration to?

mlir/test/Dialect/SPIRV/TestAvailability.cpp

217

Can you not do void mlir::registerConvertToTargetEnvPass?

[mehdi_amini]

Address comments

[mehdi_amini]

Add back FULL_LIBS to mlir-translate, inadvertently removed between the two diffs

mlir/include/mlir/InitAllPasses.h

71

You noticed that this call will never be executed right?

mlir/lib/Dialect/CMakeLists.txt

31

Added a comment: Empty libraries aren't possible with CMake, create a dummy file.

mlir/lib/Quantizer/Transforms/InferQuantizedTypesPass.cpp

287

At the moment we just removed the "force link" invocation in favor of pulling it objects by referencing their symbols. Ultimately I'd like this to replace the static below though.

I couldn't use a "createXXXXPass" method here because the pass needs a complex data structure in its initializer.

mlir/test/Dialect/SPIRV/TestAvailability.cpp

217

I would need a header declaration for this, but we don't have public headers for the test directory

[stephenneuendorffer]

I think getting rid of whole_archive_link is a good thing, but I'm concerned that this actually makes it somewhat more complicated to get new Passes and Dialects into the system in a not error-prone way.

mlir/examples/toy/Ch7/toyc.cpp

23

Why "Init" vs. "register"? A little bikeshedding, but when it's this close, it's really annoying that it's not exactly the same..

mlir/include/mlir/InitAllPasses.h

19–31

Most passes are associated with a Dialect, or the presence of two related Dialects. Perhaps this could be used to simplify this registration?

57

It seems like there should be some hierarchy here. I don't think it scales to list all the passes here. At least the ones from a dialect should be 'registered' as part of the dialect registration?
Ultimately, getting rid of whole-program-link is good, but is it really better to convert it to a list of passes here?

mlir/test/EDSC/builder-api-test.cpp

40

maybe registerDialects could be a variadic template class, avoiding the need for the functor?

[mehdi_amini]

to get new Passes and Dialects into the system in a not error-prone way

What kind of error that wouldn’t be trivially found during ninja check do you foresee?

In general I agree with all you other comments in this revision, you can see this as an incremental step. I had to land this because I couldn’t get more done and it was important to fix the nasty issue with incremental builds of mlir-opt being broken.

I’d like indeed to look into more unified way of registering passes with their dialect for example.

For the long list of passes, have you seen how LLVM works?
https://github.com/llvm/llvm-project/blob/master/llvm/include/llvm/LinkAllPasses.h
I did it shamelessly here only because LLVM was as pragmatic... I don’t find it particularly nice.

[stephenneuendorffer]

mlir/lib/Dialect/CMakeLists.txt

36–52

Do you actually want this library to exist, or just to have an easy way to structure CMakeFiles?
This doesn't help the latter for BUILD_SHARED_LIBS=on because you still need to specify all libraries you have a dependence against.
My preference would be to have add_mlir_dialect generate a list of dialects which can be used to solve the second problem.

[mehdi_amini]

mlir/lib/Dialect/CMakeLists.txt

36–52

Do you mean add_mlir_dialect would build a CMake macro like "ALL_MLIR_DIALECTS" and this macro would be used to link them all in place where we use MLIRAllDialects right now? That works for me!

mlir/examples/toy/Ch5/CMakeLists.txt

 add_dependencies(toyc-ch5 ToyCh5OpsIncGen)
 add_dependencies(toyc-ch5 ToyCh5CombineIncGen)
 add_dependencies(toyc-ch5 MLIRCallOpInterfacesIncGen)
 include_directories(include/)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 target_link_libraries(toyc-ch5
   PRIVATE
-    MLIRAffineOps
+    MLIRAllDialects
     MLIRAnalysis
     MLIRIR
     MLIRParser
     MLIRPass
-    MLIRStandardOps
     MLIRTransforms)
 
-whole_archive_link(toyc-ch5
-  MLIRAffineOps
-  MLIRStandardOps
-  )

mlir/examples/toy/Ch5/toyc.cpp

 #include "toy/Dialect.h"
 #include "toy/MLIRGen.h"
 #include "toy/Parser.h"
 #include "toy/Passes.h"
 
 #include "mlir/Analysis/Verifier.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
+#include "mlir/InitAllDialects.h"
 #include "mlir/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/Passes.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorOr.h"
int dumpAST() {
   if (!moduleAST)
     return 1;
 
   dump(*moduleAST);
   return 0;
 }
 
 int main(int argc, char **argv) {
+  mlir::registerAllDialects();
   mlir::registerPassManagerCLOptions();
   cl::ParseCommandLineOptions(argc, argv, "toy compiler\n");
 
   switch (emitAction) {
   case Action::DumpAST:
     return dumpAST();
   case Action::DumpMLIR:
   case Action::DumpMLIRAffine:
     return dumpMLIR();
   default:
     llvm::errs() << "No action specified (parsing only?), use -emit=<action>\n";
   }
 
   return 0;
 }

mlir/examples/toy/Ch6/CMakeLists.txt

 add_dependencies(toyc-ch6 ToyCh6OpsIncGen)
 add_dependencies(toyc-ch6 ToyCh6CombineIncGen)
 add_dependencies(toyc-ch6 MLIRCallOpInterfacesIncGen)
 include_directories(include/)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 target_link_libraries(toyc-ch6
   PRIVATE
-    MLIRAffineOps
+    MLIRAllDialects
     MLIRAffineToStandard
     MLIRAnalysis
     MLIRExecutionEngine
     MLIRIR
     MLIRLLVMIR
     MLIRLoopToStandard
     MLIRParser
     MLIRPass
-    MLIRStandardOps
     MLIRStandardToLLVM
     MLIRTargetLLVMIR
     MLIRTransforms
     )
 
-whole_archive_link(toyc-ch6
-  MLIRAffineToStandard
-  MLIRAffineOps
-  MLIRLLVMIR
-  MLIRStandardOps
-  )

mlir/examples/toy/Ch6/toyc.cpp

 #include "toy/Parser.h"
 #include "toy/Passes.h"
 
 #include "mlir/Analysis/Verifier.h"
 #include "mlir/ExecutionEngine/ExecutionEngine.h"
 #include "mlir/ExecutionEngine/OptUtils.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
+#include "mlir/InitAllDialects.h"
 #include "mlir/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Target/LLVMIR.h"
 #include "mlir/Transforms/Passes.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Module.h"
if (invocationResult) {
     llvm::errs() << "JIT invocation failed\n";
     return -1;
   }
 
   return 0;
 }
 
 int main(int argc, char **argv) {
+  mlir::registerAllDialects();
   mlir::registerPassManagerCLOptions();
   cl::ParseCommandLineOptions(argc, argv, "toy compiler\n");
 
   if (emitAction == Action::DumpAST)
     return dumpAST();
 
   // If we aren't dumping the AST, then we are compiling with/to MLIR.
 

mlir/examples/toy/Ch7/CMakeLists.txt

 add_dependencies(toyc-ch7 ToyCh7OpsIncGen)
 add_dependencies(toyc-ch7 ToyCh7CombineIncGen)
 add_dependencies(toyc-ch7 MLIRCallOpInterfacesIncGen)
 include_directories(include/)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 target_link_libraries(toyc-ch7
   PRIVATE
-    MLIRAffineOps
+    MLIRAllDialects
     MLIRAffineToStandard
     MLIRAnalysis
     MLIRExecutionEngine
     MLIRIR
-    MLIRLLVMIR
     MLIRLoopToStandard
     MLIRParser
     MLIRPass
-    MLIRStandardOps
     MLIRStandardToLLVM
     MLIRTargetLLVMIR
     MLIRTransforms
     )
-
-whole_archive_link(toyc-ch7
-  MLIRAffineToStandard
-  MLIRAffineOps
-  MLIRLLVMIR
-  MLIRStandardOps
-  )

mlir/examples/toy/Ch7/toyc.cpp

 #include "toy/Parser.h"
 #include "toy/Passes.h"
 
 #include "mlir/Analysis/Verifier.h"
 #include "mlir/ExecutionEngine/ExecutionEngine.h"
 #include "mlir/ExecutionEngine/OptUtils.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
+#include "mlir/InitAllDialects.h"
 #include "mlir/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Target/LLVMIR.h"
 #include "mlir/Transforms/Passes.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Module.h"
if (invocationResult) {
     llvm::errs() << "JIT invocation failed\n";
     return -1;
   }
 
   return 0;
 }
 
 int main(int argc, char **argv) {
+  mlir::registerAllDialects();
   mlir::registerPassManagerCLOptions();
   cl::ParseCommandLineOptions(argc, argv, "toy compiler\n");
 
   if (emitAction == Action::DumpAST)
     return dumpAST();
 
   // If we aren't dumping the AST, then we are compiling with/to MLIR.
 

mlir/include/mlir/Analysis/Passes.h

 template <typename T> class OpPassBase;
 
 /// Creates a pass to check memref accesses in a Function.
 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/include/mlir/InitAllDialects.h

+//===- InitAllDialects.h - MLIR Dialects Registration -----------*- 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 defines a helper to trigger the registration of all dialects and
+// passes to the system.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_INITALLDIALECTS_H_
+#define MLIR_INITALLDIALECTS_H_
+
+#include "mlir/Dialect/AffineOps/AffineOps.h"
+#include "mlir/Dialect/FxpMathOps/FxpMathOps.h"
+#include "mlir/Dialect/GPU/GPUDialect.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/LLVMIR/NVVMDialect.h"
+#include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
+#include "mlir/Dialect/Linalg/IR/LinalgOps.h"
+#include "mlir/Dialect/LoopOps/LoopOps.h"
+#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
+#include "mlir/Dialect/QuantOps/QuantOps.h"
+#include "mlir/Dialect/SDBM/SDBMDialect.h"
+#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/VectorOps/VectorOps.h"
+#include "mlir/IR/Dialect.h"
+
+namespace mlir {
+
+// This function should be called before creating any MLIRContext if one expect
+// all the possible dialects to be made available to the context automatically.
+inline void registerAllDialects() {
+  static bool init_once = []() {
+    registerDialect<AffineOpsDialect>();
+    registerDialect<fxpmath::FxpMathOpsDialect>();
+    registerDialect<gpu::GPUDialect>();
+    registerDialect<LLVM::LLVMDialect>();
+    registerDialect<linalg::LinalgDialect>();
+    registerDialect<loop::LoopOpsDialect>();
+    registerDialect<omp::OpenMPDialect>();
+    registerDialect<quant::QuantizationDialect>();
+    registerDialect<spirv::SPIRVDialect>();
+    registerDialect<StandardOpsDialect>();
+    registerDialect<vector::VectorOpsDialect>();
+    registerDialect<NVVM::NVVMDialect>();
+    registerDialect<ROCDL::ROCDLDialect>();
+    registerDialect<SDBMDialect>();
+    return true;
+  }();
+  (void)init_once;
+}
+} // namespace mlir
+
+#endif // MLIR_INITALLDIALECTS_H_

mlir/include/mlir/InitAllPasses.h

+//===- LinkAllPassesAndDialects.h - MLIR Registration -----------*- 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 defines a helper to trigger the registration of all dialects and
+// passes to the system.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_INITALLPASSES_H_
+#define MLIR_INITALLPASSES_H_
+
+#include "mlir/Analysis/Passes.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/LinalgToLLVM/LinalgToLLVM.h"
+#include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
+#include "mlir/Conversion/LoopsToGPU/LoopsToGPUPass.h"
+#include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h"
+#include "mlir/Dialect/FxpMathOps/Passes.h"
+#include "mlir/Dialect/GPU/Passes.h"
+#include "mlir/Dialect/Linalg/Passes.h"
+#include "mlir/Dialect/QuantOps/Passes.h"
+#include "mlir/Dialect/SPIRV/Passes.h"
+#include "mlir/Quantizer/Transforms/Passes.h"
+#include "mlir/Transforms/LocationSnapshot.h"
+#include "mlir/Transforms/Passes.h"
+
+#include <cstdlib>
+
+namespace mlir {
+
+// This function may be called to register the MLIR passes with the
+// global registry.
+// If you're building a compiler, you likely don't need this: you would build a
+// pipeline programmatically without the need to register with the global
+// registry, since it would already be calling the creation routine of the
+// individual passes.
+// The global registry is interesting to interact with the command-line tools.
+inline void registerAllPasses() {
+  // At the moment we still rely on global initializers for registering passes,
+  // but we may not do it in the future.
+  // We must reference the passes in such a way that compilers will not
+  // delete it all as dead code, even with whole program optimization,
+  // yet is effectively a NO-OP. As the compiler isn't smart enough
+  // to know that getenv() never returns -1, this will do the job.
+  if (std::getenv("bar") != (char *)-1)
+    return;
+
+  // Init general passes
+  createCanonicalizerPass();
+  createCSEPass();
+  createVectorizePass({});
+  createLoopUnrollPass();
+  createLoopUnrollAndJamPass();
+  createSimplifyAffineStructuresPass();
+  createLoopFusionPass();
+  createLoopInvariantCodeMotionPass();
+  createAffineLoopInvariantCodeMotionPass();
+  createPipelineDataTransferPass();
+  createLowerAffinePass();
+  createLoopTilingPass(0);
+  createLoopCoalescingPass();
+  createAffineDataCopyGenerationPass(0, 0);
+  createMemRefDataFlowOptPass();
+  createStripDebugInfoPass();
+  createPrintOpStatsPass();
+  createInlinerPass();
+  createSymbolDCEPass();
+  createLocationSnapshotPass({});
+
+  // GPUtoRODCLPass
+  createLowerGpuOpsToROCDLOpsPass();
+
+  // FxpOpsDialect passes
+  fxpmath::createLowerUniformRealMathPass();
+  fxpmath::createLowerUniformCastsPass();
+
+  // GPU
+  createGpuKernelOutliningPass();
+  createSimpleLoopsToGPUPass(0, 0);
+  createLoopToGPUPass({}, {});
+
+  // CUDA
+  createConvertGpuLaunchFuncToCudaCallsPass();
+  createConvertGPUKernelToCubinPass(
+      [](const std::string &, Location, StringRef) { return nullptr; });
+  createLowerGpuOpsToNVVMOpsPass();
+
+  // Linalg
+  createLinalgFusionPass();
+  createLinalgTilingPass();
+  createLinalgTilingToParallelLoopsPass();
+  createLinalgPromotionPass(0);
+  createConvertLinalgToLoopsPass();
+  createConvertLinalgToParallelLoopsPass();
+  createConvertLinalgToAffineLoopsPass();
+  createConvertLinalgToLLVMPass();
+
+  // QuantOps
+  quant::createConvertSimulatedQuantPass();
+  quant::createConvertConstPass();
+  quantizer::createAddDefaultStatsPass();
+  quantizer::createRemoveInstrumentationPass();
+  quantizer::registerInferQuantizedTypesPass();
+
+  // SPIR-V
+  spirv::createDecorateSPIRVCompositeTypeLayoutPass();
+  spirv::createLowerABIAttributesPass();
+  createConvertGPUToSPIRVPass();
+  createConvertStandardToSPIRVPass();
+  createLegalizeStdOpsForSPIRVLoweringPass();
+  createLinalgToSPIRVPass();
+}
+
+} // namespace mlir
+
+#endif // MLIR_INITALLPASSES_H_

mlir/include/mlir/Quantizer/Transforms/Passes.h

 class TargetConfiguration;
 
 /// Creates a pass that infers quantized types based on metadata discovered
 /// in the computation.
 std::unique_ptr<OpPassBase<ModuleOp>>
 createInferQuantizedTypesPass(SolverContext &solverContext,
                               const TargetConfiguration &config);
 
+/// Registers the InferQuantizedTypes pass with the global registry.
+void registerInferQuantizedTypesPass();
+
 /// Creates a pass which removes any instrumentation and hint ops which have
 /// no effect on final runtime.
 std::unique_ptr<OpPassBase<FuncOp>> createRemoveInstrumentationPass();
 
 /// Adds default (dummy) statistics to ops that can benefit from runtime stats.
 /// Meant for testing.
 std::unique_ptr<OpPassBase<FuncOp>> createAddDefaultStatsPass();
 
 } // namespace quantizer
 } // namespace mlir
 
 #endif // MLIR_QUANTIZER_TRANSFORMS_PASSES_H

mlir/include/mlir/Transforms/Passes.h

 /// Creates a pass to perform common sub expression elimination.
 std::unique_ptr<Pass> createCSEPass();
 
 /// Creates a pass to vectorize loops, operations and data types using a
 /// target-independent, n-D super-vector abstraction.
 std::unique_ptr<OpPassBase<FuncOp>>
 createVectorizePass(ArrayRef<int64_t> virtualVectorSize);
 
-/// Creates a pass to allow independent testing of vectorizer functionality with
-/// FileCheck.
-std::unique_ptr<OpPassBase<FuncOp>> createVectorizerTestPass();
-
 /// Creates a loop unrolling pass with the provided parameters.
 /// 'getUnrollFactor' is a function callback for clients to supply a function
 /// that computes an unroll factor - the callback takes precedence over unroll
 /// factors supplied through other means. If -1 is passed as the unrollFactor
 /// and no callback is provided, anything passed from the command-line (if at
 /// all) or the default unroll factor is used (LoopUnroll:kDefaultUnrollFactor).
 std::unique_ptr<OpPassBase<FuncOp>> createLoopUnrollPass(
     int unrollFactor = -1, int unrollFull = -1,

 /// to equivalent lower-level constructs (flow of basic blocks and arithmetic
 /// primitives).
 std::unique_ptr<OpPassBase<FuncOp>> createLowerAffinePass();
 
 /// Creates a pass to perform tiling on loop nests.
 std::unique_ptr<OpPassBase<FuncOp>>
 createLoopTilingPass(uint64_t cacheSizeBytes);
 
-/// Creates a pass that performs parametric tiling so that the outermost loops
-/// have the given fixed number of iterations.  Assumes outermost loop nests
-/// are permutable.
-std::unique_ptr<OpPassBase<FuncOp>>
-createSimpleParametricTilingPass(ArrayRef<int64_t> outerLoopSizes);
-
 /// Creates a pass that transforms perfectly nested loops with independent
 /// bounds into a single loop.
 std::unique_ptr<OpPassBase<FuncOp>> createLoopCoalescingPass();
 
 /// Performs packing (or explicit copying) of accessed memref regions into
 /// buffers in the specified faster memory space through either pointwise copies
 /// or DMA operations.
 std::unique_ptr<OpPassBase<FuncOp>> createAffineDataCopyGenerationPass(
     unsigned slowMemorySpace, unsigned fastMemorySpace,
     unsigned tagMemorySpace = 0, int minDmaTransferSize = 1024,
     uint64_t fastMemCapacityBytes = std::numeric_limits<uint64_t>::max());
 
 /// Creates a pass to perform optimizations relying on memref dataflow such as
 /// store to load forwarding, elimination of dead stores, and dead allocs.
 std::unique_ptr<OpPassBase<FuncOp>> createMemRefDataFlowOptPass();
 
 /// Creates a pass to strip debug information from a function.
 std::unique_ptr<Pass> createStripDebugInfoPass();
 
-/// Creates a pass which tests loop fusion utilities.
-std::unique_ptr<OpPassBase<FuncOp>> createTestLoopFusionPass();
+/// Creates a pass which prints the list of ops and the number of occurences in
+/// the module.
+std::unique_ptr<OpPassBase<ModuleOp>> createPrintOpStatsPass();
 
-/// Creates a pass which inlines calls and callable operations as defined by the
-/// CallGraph.
+/// Creates a pass which inlines calls and callable operations as defined by
+/// the CallGraph.
 std::unique_ptr<Pass> createInlinerPass();
 
 /// Creates a pass which delete symbol operations that are unreachable. This
 /// pass may *only* be scheduled on an operation that defines a SymbolTable.
 std::unique_ptr<Pass> createSymbolDCEPass();
 } // end namespace mlir
 
 #endif // MLIR_TRANSFORMS_PASSES_H

mlir/lib/Dialect/AffineOps/CMakeLists.txt

 add_llvm_library(MLIRAffineOps
   AffineOps.cpp
   AffineValueMap.cpp
-  DialectRegistration.cpp
   EDSC/Builders.cpp
-  
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/AffineOps
   )
 add_dependencies(MLIRAffineOps
 
   MLIRAffineOpsIncGen
   MLIREDSC
   MLIRIR

mlir/lib/Dialect/AffineOps/DialectRegistration.cpp

-//===- DialectRegistration.cpp - Register Affine Op 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/Dialect/AffineOps/AffineOps.h"
-using namespace mlir;
-
-// Static initialization for Affine op dialect registration.
-static DialectRegistration<AffineOpsDialect> StandardOps;

mlir/lib/Dialect/CMakeLists.txt

 add_subdirectory(AffineOps)
 add_subdirectory(FxpMathOps)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(LoopOps)
 add_subdirectory(OpenMP)
 add_subdirectory(QuantOps)
 add_subdirectory(SDBM)
 add_subdirectory(Shape)
 add_subdirectory(SPIRV)
 add_subdirectory(StandardOps)
 add_subdirectory(VectorOps)
 
+
+set(LLVM_OPTIONAL_SOURCES
+  Traits.cpp
+)
+
 add_llvm_library(MLIRDialect
   Traits.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect
   )
 target_link_libraries(MLIRDialect MLIRIR)
+
+# Create a dummy MLIRAllDialects library for the purpose
+# of having an easy tracking of all dialects when linking
+# them in tools.
+# Empty libraries aren't possible with CMake, create a dummy file.
+file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/all_dialects.c "typedef int make_iso_compilers_happy;\n")
+add_llvm_library(MLIRAllDialects
+  ${CMAKE_CURRENT_BINARY_DIR}/all_dialects.c
+)
+target_link_libraries(MLIRAllDialects
+  MLIRAffineOps
+  MLIRFxpMathOps
+  MLIRGPU
+  MLIRLLVMIR
+  MLIRNVVMIR
+  MLIRROCDLIR
+  MLIRLinalgOps
+  MLIRLoopOps
+  MLIROpenMP
+  MLIRQuantOps
+  MLIRSDBM
+  MLIRShape
+  MLIRSPIRV
+  MLIRStandardOps
+  MLIRVectorOps
+)

mlir/lib/Dialect/FxpMathOps/CMakeLists.txt

 add_llvm_library(MLIRFxpMathOps
   IR/FxpMathOps.cpp
-  IR/DialectRegistration.cpp
   Transforms/LowerUniformRealMath.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/FxpMathOps
   )
 
 target_link_libraries(MLIRFxpMathOps
   MLIRQuantOps

mlir/lib/Dialect/FxpMathOps/IR/DialectRegistration.cpp

-//===- DialectRegistration.cpp - Register FxpMathOps 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/Dialect/FxpMathOps/FxpMathOps.h"
-
-using namespace mlir;
-using namespace mlir::fxpmath;
-
-// Static initialization for the fxpmath ops dialect registration.
-static mlir::DialectRegistration<FxpMathOpsDialect> FxpMathOps;

mlir/lib/Dialect/GPU/CMakeLists.txt

 add_llvm_library(MLIRGPU
   IR/GPUDialect.cpp
-  IR/DialectRegistration.cpp
   Transforms/AllReduceLowering.cpp
   Transforms/KernelOutlining.cpp
   Transforms/MemoryPromotion.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/GPU
 )
 add_dependencies(MLIRGPU

mlir/lib/Dialect/GPU/IR/DialectRegistration.cpp

-//===- DialectRegistration.cpp - MLIR GPU dialect registration ------------===//
-//
-// 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/Dialect/GPU/GPUDialect.h"
-
-// Static initialization for GPU dialect registration.
-static mlir::DialectRegistration<mlir::gpu::GPUDialect> kernelDialect;

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

LogicalResult LLVMDialect::verifyRegionArgAttribute(Operation *op,
                                                     NamedAttribute argAttr) {
   // Check that llvm.noalias is a boolean attribute.
   if (argAttr.first == "llvm.noalias" && !argAttr.second.isa<BoolAttr>())
     return op->emitError()
            << "llvm.noalias argument attribute of non boolean type";
   return success();
 }
 
-static DialectRegistration<LLVMDialect> llvmDialect;
-
 //===----------------------------------------------------------------------===//
 // LLVMType.
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace LLVM {
 namespace detail {
 struct LLVMTypeStorage : public ::mlir::TypeStorage {

mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp

 
 namespace mlir {
 namespace NVVM {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/NVVMOps.cpp.inc"
 } // namespace NVVM
 } // namespace mlir
 
-static DialectRegistration<NVVMDialect> nvvmDialect;

mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp

 
 namespace mlir {
 namespace ROCDL {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/ROCDLOps.cpp.inc"
 } // namespace ROCDL
 } // namespace mlir
 
-static DialectRegistration<ROCDLDialect> rocdlDialect;

mlir/lib/Dialect/Linalg/IR/CMakeLists.txt

 set(LIBS
 
   MLIRIR
   MLIRStandardOps
   )
 
 add_llvm_library(MLIRLinalgOps
   LinalgOps.cpp
   LinalgTypes.cpp
-  LinalgRegistration.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Linalg
   DEPENDS
   intrinsics_gen
   )
 
 add_dependencies(MLIRLinalgOps
 
   ${LIBS}
   MLIRLinalgOpsIncGen
   MLIRLinalgStructuredOpsIncGen
   )
 target_link_libraries(MLIRLinalgOps ${LIBS})

mlir/lib/Dialect/Linalg/IR/LinalgRegistration.cpp

-//===- LinalgRegistration.cpp - Register the linalg dialect statically ----===//
-//
-// 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/Dialect/Linalg/IR/LinalgOps.h"
-#include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
-
-using namespace mlir;
-using namespace mlir::linalg;
-
-// Static initialization for LinalgOps dialect registration.
-static DialectRegistration<LinalgDialect> LinalgOps;

mlir/lib/Dialect/LoopOps/DialectRegistration.cpp

-//===- DialectRegistration.cpp - Register loop 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/Dialect/LoopOps/LoopOps.h"
-using namespace mlir;
-
-// Static initialization for loop dialect registration.
-static DialectRegistration<loop::LoopOpsDialect> LoopOps;

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

 }
 
 namespace mlir {
 namespace omp {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/OpenMP/OpenMPOps.cpp.inc"
 } // namespace omp
 } // namespace mlir
-
-static DialectRegistration<OpenMPDialect> ompDialect;

mlir/lib/Dialect/QuantOps/CMakeLists.txt

 add_llvm_library(MLIRQuantOps
-  IR/DialectRegistration.cpp
   IR/QuantOps.cpp
   IR/QuantTypes.cpp
   IR/TypeDetail.h
   IR/TypeParser.cpp
   Transforms/ConvertConst.cpp
   Transforms/ConvertSimQuant.cpp
   Utils/QuantizeUtils.cpp
   Utils/UniformSupport.cpp

mlir/lib/Dialect/QuantOps/IR/DialectRegistration.cpp

-//===- DialectRegistration.cpp - Register Quantization 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/Dialect/QuantOps/QuantOps.h"
-
-using namespace mlir;
-using namespace mlir::quant;
-
-// Static initialization for Quantization dialect registration.
-static mlir::DialectRegistration<QuantizationDialect> QuantizationOps;

mlir/lib/Dialect/SDBM/CMakeLists.txt

 add_llvm_library(MLIRSDBM
   SDBM.cpp
   SDBMExpr.cpp
-  SDBMDialect.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SDBM
 )
 add_dependencies(MLIRSDBM MLIRIR)
 target_link_libraries(MLIRSDBM MLIRIR)

mlir/lib/Dialect/SDBM/SDBMDialect.cpp

-//===- SDBMDialect.cpp - Dialect for striped difference-bound matrices ----===//
-//
-// 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/Dialect/SDBM/SDBMDialect.h"
-
-static mlir::DialectRegistration<mlir::SDBMDialect> SDBMDialect;

mlir/lib/Dialect/SPIRV/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS SPIRVCanonicalization.td)
 mlir_tablegen(SPIRVCanonicalization.inc -gen-rewriters)
 add_public_tablegen_target(MLIRSPIRVCanonicalizationIncGen)
 
 add_llvm_library(MLIRSPIRV
-  DialectRegistration.cpp
   LayoutUtils.cpp
   SPIRVDialect.cpp
   SPIRVOps.cpp
   SPIRVLowering.cpp
   SPIRVTypes.cpp
   TargetAndABI.cpp
 
   ADDITIONAL_HEADER_DIRS

mlir/lib/Dialect/SPIRV/DialectRegistration.cpp

-//===- DialectRegistration.cpp - MLIR SPIR-V dialect registration ---------===//
-//
-// 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/Dialect/SPIRV/SPIRVDialect.h"
-
-// Static initialization for SPIR-V dialect registration.
-static mlir::DialectRegistration<mlir::spirv::SPIRVDialect> spirvDialect;

mlir/lib/Dialect/StandardOps/DialectRegistration.cpp

-//===- DialectRegistration.cpp - Register standard Op 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/Dialect/StandardOps/Ops.h"
-using namespace mlir;
-
-// Static initialization for standard op dialect registration.
-static DialectRegistration<StandardOpsDialect> StandardOps;

mlir/lib/Dialect/VectorOps/CMakeLists.txt

 add_llvm_library(MLIRVectorOps
-  DialectRegistration.cpp
   VectorOps.cpp
   VectorTransforms.cpp
   VectorUtils.cpp
   EDSC/Builders.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/VectorOps
   )
 
 add_dependencies(MLIRVectorOps MLIRVectorOpsIncGen)
 add_dependencies(MLIRVectorOps MLIRVectorTransformPatternsIncGen)
 
 target_link_libraries(MLIRVectorOps MLIRIR MLIRStandardOps MLIRAffineOps MLIRLoopOps MLIRLoopAnalysis)

mlir/lib/Dialect/VectorOps/DialectRegistration.cpp

-//===- DialectRegistration.cpp - Register super vectorization 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/Dialect/VectorOps/VectorOps.h"
-using namespace mlir;
-
-// Static initialization for VectorOps dialect registration.
-static DialectRegistration<vector::VectorOpsDialect> VectorOps;

mlir/lib/Quantizer/Transforms/InferQuantizedTypesPass.cpp

void InferQuantizedTypesPass::transformResultType(CAGResultAnchor *anchor,
   }
 }
 
 std::unique_ptr<OpPassBase<ModuleOp>>
 mlir::quantizer::createInferQuantizedTypesPass(
     SolverContext &solverContext, const TargetConfiguration &config) {
   return std::make_unique<InferQuantizedTypesPass>(solverContext, config);
 }
+void mlir::quantizer::registerInferQuantizedTypesPass() {
+  // Do nothing, this will be enough to force link this file and the static
+  // registration will kick-in. This is temporary while we're refactoring pass
+  // registration to move away from static constructors.
+}
 
 static PassRegistration<InferQuantizedTypesPass>
     pass("quantizer-infer-quantized-types",
          "Infers quantized types for a module");

mlir/lib/Support/JitRunner.cpp

 #include "mlir/Support/JitRunner.h"
 
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/ExecutionEngine/ExecutionEngine.h"
 #include "mlir/ExecutionEngine/OptUtils.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
+#include "mlir/InitAllDialects.h"
 #include "mlir/Parser.h"
 #include "mlir/Support/FileUtilities.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassNameParser.h"

 
 // Entry point for all CPU runners. Expects the common argc/argv arguments for
 // standard C++ main functions and an mlirTransformer.
 // The latter is applied after parsing the input into MLIR IR and before passing
 // the MLIR module to the ExecutionEngine.
 int mlir::JitRunnerMain(
     int argc, char **argv,
     function_ref<LogicalResult(mlir::ModuleOp)> mlirTransformer) {
+  registerAllDialects();
   llvm::InitLLVM y(argc, argv);
 
   initializeLLVM();
   mlir::initializeLLVMPasses();
 
   llvm::cl::ParseCommandLineOptions(argc, argv, "MLIR CPU execution driver\n");
 
   Optional<unsigned> optLevel = getCommandLineOptLevel();

mlir/lib/Transforms/OpStats.cpp

 //===- OpStats.cpp - Prints stats of operations in module -----------------===//
 //
 // 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/IR/Module.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/OperationSupport.h"
 #include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 
 namespace {
 struct PrintOpStatsPass : public ModulePass<PrintOpStatsPass> {
else
       os << llvm::right_justify(dialectName, maxLenDialect + 2) << '.';
 
     // Left justify the operation name.
     os << llvm::left_justify(opName, maxLenOpName) << " , " << opCount[key]
        << '\n';
   }
 }
 
+std::unique_ptr<OpPassBase<ModuleOp>> mlir::createPrintOpStatsPass() {
+  return std::make_unique<PrintOpStatsPass>();
+}
+
 static PassRegistration<PrintOpStatsPass>
     pass("print-op-stats", "Print statistics of operations");

mlir/test/Dialect/SPIRV/TestAvailability.cpp

ConvertToSubgroupBallot::matchAndRewrite(Operation *op,
                                          PatternRewriter &rewriter) const {
   Value predicate = op->getOperand(0);
 
   rewriter.replaceOpWithNewOp<spirv::SubgroupBallotKHROp>(
       op, op->getResult(0).getType(), predicate);
   return matchSuccess();
 }
 
-static PassRegistration<ConvertToTargetEnv>
-    convertToTargetEnvPass("test-spirv-target-env",
-                           "Test SPIR-V target environment");
+namespace mlir {
+void registerConvertToTargetEnvPass() {
+  PassRegistration<ConvertToTargetEnv> convertToTargetEnvPass(
+      "test-spirv-target-env", "Test SPIR-V target environment");
+}
+} // namespace mlir

mlir/test/EDSC/builder-api-test.cpp

 //===- builder-api-test.cpp - Tests for Declarative Builder APIs ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-// RUN: mlir-edsc-builder-api-test | FileCheck %s
+// RUN: mlir-edsc-builder-api-test | FileCheck %s -dump-input-on-failure
 
 #include "mlir/Dialect/AffineOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
 #include "mlir/Dialect/LoopOps/EDSC/Builders.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/VectorOps/EDSC/Intrinsics.h"
 #include "mlir/EDSC/Builders.h"
 #include "mlir/EDSC/Intrinsics.h"

 
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 
 static MLIRContext &globalContext() {
+  static bool init_once = []() {
+    registerDialect<AffineOpsDialect>();
+    registerDialect<linalg::LinalgDialect>();
+    registerDialect<loop::LoopOpsDialect>();
+    registerDialect<StandardOpsDialect>();
+    registerDialect<vector::VectorOpsDialect>();
+    return true;
+  }();
+  (void)init_once;
   static thread_local MLIRContext context;
   return context;
 }
 
 static FuncOp makeFunction(StringRef name, ArrayRef<Type> results = {},
                            ArrayRef<Type> args = {}) {
   auto &ctx = globalContext();
   auto function = FuncOp::create(UnknownLoc::get(&ctx), name,

mlir/test/SDBM/sdbm-api-test.cpp

 #include "mlir/IR/MLIRContext.h"
 
 #include "llvm/Support/raw_ostream.h"
 
 #include "APITest.h"
 
 using namespace mlir;
 
+// Load the SDBM dialect
+static DialectRegistration<SDBMDialect> SDBMRegistration;
+
 static MLIRContext *ctx() {
   static thread_local MLIRContext context;
   return &context;
 }
 
 static SDBMDialect *dialect() {
   static thread_local SDBMDialect *d = nullptr;
   if (!d) {

mlir/test/lib/IR/TestFunc.cpp

for (FuncOp func : module.getOps<FuncOp>()) {
       if (!sym)
         continue;
       func.setType(symbolTable.lookup<FuncOp>(sym.getValue()).getType());
     }
   }
 };
 } // end anonymous namespace
 
-static PassRegistration<TestFuncEraseArg> pass("test-func-erase-arg",
-                                               "Test erasing func args.");
+namespace mlir {
+void registerTestFunc() {
+  PassRegistration<TestFuncEraseArg> pass("test-func-erase-arg",
 
-static PassRegistration<TestFuncSetType> pass2("test-func-set-type",
-                                               "Test FuncOp::setType.");
+  PassRegistration<TestFuncSetType> pass2("test-func-set-type",
+}
+} // namespace mlir

mlir/test/lib/IR/TestMatchers.cpp

void TestMatchers::runOnFunction() {
   auto f = getFunction();
   llvm::outs() << f.getName() << "\n";
   if (f.getName() == "test1")
     test1(f);
   if (f.getName() == "test2")
     test2(f);
 }
 
-static PassRegistration<TestMatchers> pass("test-matchers",
-                                           "Test C++ pattern matchers.");
+namespace mlir {
+void registerTestMatchers() {
+  PassRegistration<TestMatchers>("test-matchers", "Test C++ pattern matchers.");
+}
+} // namespace mlir

mlir/test/lib/IR/TestSymbolUses.cpp

module.getBodyRegion().walk([&](Operation *nestedOp) {
       if (succeeded(SymbolTable::replaceAllSymbolUses(
               nestedOp, newName.getValue(), &module.getBodyRegion())))
         SymbolTable::setSymbolName(nestedOp, newName.getValue());
     });
   }
 };
 } // end anonymous namespace
 
-static PassRegistration<SymbolUsesPass> pass("test-symbol-uses",
-                                             "Test detection of symbol uses");
+namespace mlir {
+void registerSymbolTestPasses() {
+  PassRegistration<SymbolUsesPass>("test-symbol-uses",
 
-static PassRegistration<SymbolReplacementPass>
-    rauwPass("test-symbol-rauw", "Test replacement of symbol uses");
+  PassRegistration<SymbolReplacementPass>("test-symbol-rauw",
+                                          "Test replacement of symbol uses");
+}
+} // namespace mlir

mlir/test/lib/Pass/TestPassManager.cpp

static void testNestedPipeline(OpPassManager &pm) {
   auto &functionPM = pm.nest<FuncOp>();
   functionPM.addPass(std::make_unique<TestFunctionPass>());
 }
 
 static void testNestedPipelineTextual(OpPassManager &pm) {
   (void)parsePassPipeline("test-pm-nested-pipeline", pm);
 }
 
-static PassRegistration<TestOptionsPass>
-    reg("test-options-pass", "Test options parsing capabilities");
+namespace mlir {
+void registerPassManagerTestPass() {
+  PassRegistration<TestOptionsPass>("test-options-pass",
+                                    "Test options parsing capabilities");
 
-static PassRegistration<TestModulePass>
-    unusedMP("test-module-pass", "Test a module pass in the pass manager");
-static PassRegistration<TestFunctionPass>
-    unusedFP("test-function-pass", "Test a function pass in the pass manager");
-
-static PassRegistration<TestCrashRecoveryPass>
-    unusedCrashP("test-pass-crash",
-                 "Test a pass in the pass manager that always crashes");
+  PassRegistration<TestModulePass>("test-module-pass",
+                                   "Test a module pass in the pass manager");
 
-static PassRegistration<TestStatisticPass> unusedStatP("test-stats-pass",
-                                                       "Test pass statistics");
+  PassRegistration<TestFunctionPass>(
+      "test-function-pass", "Test a function pass in the pass manager");
+
+  PassRegistration<TestCrashRecoveryPass>(
+      "test-pass-crash", "Test a pass in the pass manager that always crashes");
+
+  PassRegistration<TestStatisticPass> unusedStatP("test-stats-pass",
 
-static PassPipelineRegistration<>
-    unused("test-pm-nested-pipeline",
-           "Test a nested pipeline in the pass manager", testNestedPipeline);
-static PassPipelineRegistration<>
-    unusedTextual("test-textual-pm-nested-pipeline",
+  PassPipelineRegistration<>("test-pm-nested-pipeline",
+                             "Test a nested pipeline in the pass manager",
+                             testNestedPipeline);
+  PassPipelineRegistration<>("test-textual-pm-nested-pipeline",
                              "Test a nested pipeline in the pass manager",
                              testNestedPipelineTextual);
-static PassPipelineRegistration<>
-    unusedDump("test-dump-pipeline",
-               "Dumps the pipeline build so far for debugging purposes",
-               [](OpPassManager &pm) {
-                 pm.printAsTextualPipeline(llvm::errs());
-                 llvm::errs() << "\n";
-               });
+  PassPipelineRegistration<>(
+      "test-dump-pipeline",
 
-static PassPipelineRegistration<TestOptionsPass::Options>
+  PassPipelineRegistration<TestOptionsPass::Options>
       registerOptionsPassPipeline(
           "test-options-pass-pipeline",
           "Parses options using pass pipeline registration",
           [](OpPassManager &pm, const TestOptionsPass::Options &options) {
             pm.addPass(std::make_unique<TestOptionsPass>(options));
           });
+}
+} // namespace mlir

mlir/test/lib/TestDialect/TestPatterns.cpp

void runOnFunction() override {
     // Verify named pattern is generated with expected name.
     patterns.insert<TestNamedPatternRule>(&getContext());
 
     applyPatternsGreedily(getFunction(), patterns);
   }
 };
 } // end anonymous namespace
 
-static mlir::PassRegistration<TestPatternDriver>
-    pass("test-patterns", "Run test dialect patterns");
-
 //===----------------------------------------------------------------------===//
 // ReturnType Driver.
 //===----------------------------------------------------------------------===//
 
 namespace {
 // Generate ops for each instance where the type can be successfully infered.
 template <typename OpTy>
 static void invokeCreateWithInferedReturnType(Operation *op) {
if (getFunction().getName() == "testCreateFunctions") {
             op);
       };
       return;
     }
   }
 };
 } // end anonymous namespace
 
-static mlir::PassRegistration<TestReturnTypeDriver>
-    rt_pass("test-return-type", "Run return type functions");
-
 //===----------------------------------------------------------------------===//
 // Legalization Driver.
 //===----------------------------------------------------------------------===//
 
 namespace {
 //===----------------------------------------------------------------------===//
 // Region-Block Rewrite Testing
 
legalizerConversionMode(
         llvm::cl::values(
             clEnumValN(TestLegalizePatternDriver::ConversionMode::Analysis,
                        "analysis", "Perform an analysis conversion"),
             clEnumValN(TestLegalizePatternDriver::ConversionMode::Full, "full",
                        "Perform a full conversion"),
             clEnumValN(TestLegalizePatternDriver::ConversionMode::Partial,
                        "partial", "Perform a partial conversion")));
 
-static mlir::PassRegistration<TestLegalizePatternDriver>
-    legalizer_pass("test-legalize-patterns",
-                   "Run test dialect legalization patterns", [] {
-                     return std::make_unique<TestLegalizePatternDriver>(
-                         legalizerConversionMode);
-                   });
-
 //===----------------------------------------------------------------------===//
 // ConversionPatternRewriter::getRemappedValue testing. This method is used
 // to get the remapped value of a original value that was replaced using
 // ConversionPatternRewriter.
 namespace {
 /// Converter that replaces a one-result one-operand OneVResOneVOperandOp1 with
 /// a one-operand two-result OneVResOneVOperandOp1 by replicating its original
 /// operand twice.
void runOnFunction() override {
 
     if (failed(mlir::applyFullConversion(getFunction(), target, patterns))) {
       signalPassFailure();
     }
   }
 };
 } // end anonymous namespace
 
-static PassRegistration<TestRemappedValue> remapped_value_pass(
+namespace mlir {
+void registerPatternsTestPass() {
+  mlir::PassRegistration<TestReturnTypeDriver>("test-return-type",
+                                               "Run return type functions");
+
+  mlir::PassRegistration<TestPatternDriver>("test-patterns",
+                                            "Run test dialect patterns");
+
+  mlir::PassRegistration<TestLegalizePatternDriver>(
+      "test-legalize-patterns", "Run test dialect legalization patterns", [] {
+        return std::make_unique<TestLegalizePatternDriver>(
+            legalizerConversionMode);
+      });
+
+  PassRegistration<TestRemappedValue>(
       "test-remapped-value",
       "Test public remapped value mechanism in ConversionPatternRewriter");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestAllReduceLowering.cpp

struct TestAllReduceLoweringPass
   void runOnModule() override {
     OwningRewritePatternList patterns;
     populateGpuRewritePatterns(&getContext(), patterns);
     applyPatternsGreedily(getModule(), patterns);
   }
 };
 } // namespace
 
-static PassRegistration<TestAllReduceLoweringPass>
-    pass("test-all-reduce-lowering",
-         "Lowers gpu.all-reduce ops within the GPU dialect.");
+namespace mlir {
+void registerTestAllReduceLoweringPass() {
+  PassRegistration<TestAllReduceLoweringPass> pass(
+      "test-all-reduce-lowering",
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestCallGraph.cpp

 struct TestCallGraphPass : public ModulePass<TestCallGraphPass> {
   void runOnModule() {
     llvm::errs() << "Testing : " << getModule().getAttr("test.name") << "\n";
     getAnalysis<CallGraph>().print(llvm::errs());
   }
 };
 } // end anonymous namespace
 
-static PassRegistration<TestCallGraphPass>
-    pass("test-print-callgraph",
-         "Print the contents of a constructed callgraph.");
+namespace mlir {
+void registerTestCallGraphPass() {
+  PassRegistration<TestCallGraphPass> pass(
+      "test-print-callgraph", "Print the contents of a constructed callgraph.");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestConstantFold.cpp

void TestConstantFold::runOnFunction() {
   // By the time we are done, we may have simplified a bunch of code, leaving
   // around dead constants.  Check for them now and remove them.
   for (auto *cst : existingConstants) {
     if (cst->use_empty())
       cst->erase();
   }
 }
 
-static PassRegistration<TestConstantFold>
-    pass("test-constant-fold", "Test operation constant folding");
+namespace mlir {
+void registerTestConstantFold() {
+  PassRegistration<TestConstantFold>("test-constant-fold",
+                                     "Test operation constant folding");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestGpuMemoryPromotion.cpp

void runOnOperation() override {
     for (unsigned i = 0, e = op.getNumArguments(); i < e; ++i) {
       if (op.getArgAttrOfType<UnitAttr>(i, "gpu.test_promote_workgroup"))
         promoteToWorkgroupMemory(op, i);
     }
   }
 };
 } // end namespace
 
-static PassRegistration<TestGpuMemoryPromotionPass> registration(
+namespace mlir {
+void registerTestGpuMemoryPromotionPass() {
+  PassRegistration<TestGpuMemoryPromotionPass>(
       "test-gpu-memory-promotion",
       "Promotes the annotated arguments of gpu.func to workgroup memory.");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestInlining.cpp

for (auto caller : callers) {
       caller.erase();
       if (callee.use_empty())
         callee.erase();
     }
   }
 };
 } // end anonymous namespace
 
-static PassRegistration<Inliner> pass("test-inline",
-                                      "Test inlining region calls");
+namespace mlir {
+void registerInliner() {
+  PassRegistration<Inliner>("test-inline", "Test inlining region calls");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestLinalgTransforms.cpp

void TestLinalgTransforms::runOnFunction() {
   applyPatternsGreedily(funcOp, patterns);
 
   // Drop the marker.
   funcOp.walk([](LinalgOp op) {
     op.removeAttr(LinalgTransforms::kLinalgTransformMarker);
   });
 }
 
-static PassRegistration<TestLinalgTransforms>
-    pass("test-linalg-transform-patterns",
-         "Test Linalg transformation patterns by applying them greedily.");
+namespace mlir {
+void registerTestLinalgTransforms() {
+  PassRegistration<TestLinalgTransforms>(
+      "test-linalg-transform-patterns",
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestLiveness.cpp

struct TestLivenessPass : public FunctionPass<TestLivenessPass> {
   void runOnFunction() override {
     llvm::errs() << "Testing : " << getFunction().getName() << "\n";
     getAnalysis<Liveness>().print(llvm::errs());
   }
 };
 
 } // end anonymous namespace
 
-static PassRegistration<TestLivenessPass>
-    pass("test-print-liveness",
-         "Print the contents of a constructed liveness information.");
+namespace mlir {
+void registerTestLivenessPass() {
+  PassRegistration<TestLivenessPass>(
+      "test-print-liveness",
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestLoopFusion.cpp

 namespace {
 
 struct TestLoopFusion : public FunctionPass<TestLoopFusion> {
   void runOnFunction() override;
 };
 
 } // end anonymous namespace
 
-std::unique_ptr<OpPassBase<FuncOp>> mlir::createTestLoopFusionPass() {
-  return std::make_unique<TestLoopFusion>();
-}
-
 // Gathers all AffineForOps in 'block' at 'currLoopDepth' in 'depthToLoops'.
 static void
 gatherLoops(Block *block, unsigned currLoopDepth,
             DenseMap<unsigned, SmallVector<AffineForOp, 2>> &depthToLoops) {
   auto &loopsAtDepth = depthToLoops[currLoopDepth];
   for (auto &op : *block) {
     if (auto forOp = dyn_cast<AffineForOp>(op)) {
       loopsAtDepth.push_back(forOp);
void TestLoopFusion::runOnFunction() {
 
   // Run tests on all combinations of src/dst loop nests in 'depthToLoops'.
   if (clTestDependenceCheck)
     iterateLoops(depthToLoops, testDependenceCheck);
   if (clTestSliceComputation)
     iterateLoops(depthToLoops, testSliceComputation);
 }
 
-static PassRegistration<TestLoopFusion>
-    pass("test-loop-fusion", "Tests loop fusion utility functions.");
+namespace mlir {
+void registerTestLoopFusion() {
+  PassRegistration<TestLoopFusion>("test-loop-fusion",
+                                   "Tests loop fusion utility functions.");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestLoopMapping.cpp

func.walk([&processorIds, &numProcessors](loop::ForOp op) {
       if (op.getParentRegion()->getParentOfType<loop::ForOp>())
         return;
       mapLoopToProcessorIds(op, processorIds, numProcessors);
     });
   }
 };
 } // end namespace
 
-static PassRegistration<TestLoopMappingPass>
-    reg("test-mapping-to-processing-elements",
-        "test mapping a single loop on a virtual processor grid",
-        [] { return std::make_unique<TestLoopMappingPass>(); });
+namespace mlir {
+void registerTestLoopMappingPass() {
+  PassRegistration<TestLoopMappingPass>(
+      "test-mapping-to-processing-elements",
+      "test mapping a single loop on a virtual processor grid");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestLoopParametricTiling.cpp

public:
 
   ListOption<int64_t> sizes{
       *this, "test-outer-loop-sizes", llvm::cl::MiscFlags::CommaSeparated,
       llvm::cl::desc(
           "fixed number of iterations that the outer loops should have")};
 };
 } // end namespace
 
-std::unique_ptr<OpPassBase<FuncOp>>
-mlir::createSimpleParametricTilingPass(ArrayRef<int64_t> outerLoopSizes) {
-  return std::make_unique<SimpleParametricLoopTilingPass>(outerLoopSizes);
-}
-
-static PassRegistration<SimpleParametricLoopTilingPass>
-    reg("test-extract-fixed-outer-loops",
-        "test application of parametric tiling to the outer loops so that the "
-        "ranges of outer loops become static");
+namespace mlir {
+void registerSimpleParametricTilingPass() {
+  PassRegistration<SimpleParametricLoopTilingPass>(
+      "test-extract-fixed-outer-loops",
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp

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<TestMemRefBoundCheck>
-    memRefBoundCheck("test-memref-bound-check",
-                     "Check memref access bounds in a Function");
+namespace mlir {
+void registerMemRefBoundCheck() {
+  PassRegistration<TestMemRefBoundCheck>(
+      "test-memref-bound-check", "Check memref access bounds in a Function");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestMemRefDependenceCheck.cpp

void TestMemRefDependenceCheck::runOnFunction() {
   getFunction().walk([&](Operation *op) {
     if (isa<AffineLoadOp>(op) || isa<AffineStoreOp>(op))
       loadsAndStores.push_back(op);
   });
 
   checkDependences(loadsAndStores);
 }
 
-static PassRegistration<TestMemRefDependenceCheck>
-    pass("test-memref-dependence-check",
-         "Checks dependences between all pairs of memref accesses.");
+namespace mlir {
+void registerTestMemRefDependenceCheck() {
+  PassRegistration<TestMemRefDependenceCheck> pass(
+      "test-memref-dependence-check",
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestMemRefStrideCalculation.cpp

interleaveComma(strides, llvm::outs(), [&](int64_t v) {
       else
         llvm::outs() << v;
     });
     llvm::outs() << "\n";
   });
   llvm::outs().flush();
 }
 
-static PassRegistration<TestMemRefStrideCalculation>
-    pass("test-memref-stride-calculation", "Test operation constant folding");
+namespace mlir {
+void registerTestMemRefStrideCalculation() {
+  PassRegistration<TestMemRefStrideCalculation> pass(
+      "test-memref-stride-calculation", "Test operation constant folding");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestOpaqueLoc.cpp

void runOnModule() override {
     });
 
     getModule().walk([&](Operation *op) { op->emitOpError(); });
   }
 };
 
 } // end anonymous namespace
 
-static PassRegistration<TestOpaqueLoc>
-    pass("test-opaque-loc", "Changes all leaf locations to opaque locations");
+namespace mlir {
+void registerTestOpaqueLoc() {
+  PassRegistration<TestOpaqueLoc> pass(
+      "test-opaque-loc", "Changes all leaf locations to opaque locations");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestParallelismDetection.cpp

 
 struct TestParallelismDetection
     : public FunctionPass<TestParallelismDetection> {
   void runOnFunction() override;
 };
 
 } // end anonymous namespace
 
-std::unique_ptr<OpPassBase<FuncOp>> mlir::createParallelismDetectionTestPass() {
-  return std::make_unique<TestParallelismDetection>();
-}
 
 // Walks the function and emits a note for all 'affine.for' ops detected as
 // parallel.
 void TestParallelismDetection::runOnFunction() {
   FuncOp f = getFunction();
   OpBuilder b(f.getBody());
   f.walk([&](AffineForOp forOp) {
     if (isLoopParallel(forOp))
       forOp.emitRemark("parallel loop");
     else
       forOp.emitRemark("sequential loop");
   });
 }
 
-static PassRegistration<TestParallelismDetection>
-    pass("test-detect-parallel", "Test parallelism detection ");
+namespace mlir {
+void registerTestParallelismDetection() {
+  PassRegistration<TestParallelismDetection> pass(
+      "test-detect-parallel", "Test parallelism detection ");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestVectorToLoopsConversion.cpp

void runOnFunction() override {
     auto *context = &getContext();
     populateVectorToAffineLoopsConversionPatterns(context, patterns);
     applyPatternsGreedily(getFunction(), patterns);
   }
 };
 
 } // end anonymous namespace
 
-static PassRegistration<TestVectorToLoopsPass>
-    pass("test-convert-vector-to-loops",
-         "Converts vector transfer ops to loops over scalars and vector casts");
+namespace mlir {
+void registerTestVectorToLoopsPass() {
+  PassRegistration<TestVectorToLoopsPass> pass(
+      "test-convert-vector-to-loops",
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestVectorTransforms.cpp

void runOnFunction() override {
     OwningRewritePatternList patterns;
     populateVectorSlicesLoweringPatterns(patterns, &getContext());
     applyPatternsGreedily(getFunction(), patterns);
   }
 };
 
 } // end anonymous namespace
 
-static PassRegistration<TestVectorToVectorConversion>
-    pass("test-vector-to-vector-conversion",
-         "Test conversion patterns between ops in the vector dialect");
+namespace mlir {
+void registerTestVectorConversions() {
+  PassRegistration<TestVectorToVectorConversion> pass(
+      "test-vector-to-vector-conversion",
 
-static PassRegistration<TestVectorSlicesConversion> slices_pass(
+  PassRegistration<TestVectorSlicesConversion> slices_pass(
       "test-vector-slices-conversion",
       "Test conversion patterns that lower slices ops in the vector dialect");
+}
+} // namespace mlir

mlir/test/lib/Transforms/TestVectorizationUtils.cpp

void VectorizerTestPass::runOnFunction() {
   if (clTestNormalizeMaps)
     testNormalizeMaps();
 
   if (!outs.str().empty()) {
     emitRemark(UnknownLoc::get(&getContext()), outs.str());
   }
 }
 
-std::unique_ptr<OpPassBase<FuncOp>> mlir::createVectorizerTestPass() {
-  return std::make_unique<VectorizerTestPass>();
+namespace mlir {
+void registerVectorizerTestPass() {
+  PassRegistration<VectorizerTestPass> pass(
+      "affine-vectorizer-test", "Tests vectorizer standalone functionality.");
 }
-
-static PassRegistration<VectorizerTestPass>
-    pass("affine-vectorizer-test",
-         "Tests vectorizer standalone functionality.");
-
-#undef DEBUG_TYPE
+} // namespace mlir

mlir/tools/mlir-cpu-runner/CMakeLists.txt

 add_llvm_tool(mlir-cpu-runner
   mlir-cpu-runner.cpp
 )
 llvm_update_compile_flags(mlir-cpu-runner)
-whole_archive_link(mlir-cpu-runner
-  MLIRAffineOps
-  MLIRLLVMIR
-  MLIRTargetLLVMIR
-  MLIRTranslation
-)
 target_link_libraries(mlir-cpu-runner PRIVATE
+  MLIRAllDialects
   MLIRAnalysis
   MLIREDSC
   MLIRExecutionEngine
   MLIRIR
   MLIRJitRunner
   MLIRLLVMIR
   MLIRParser
   MLIRTargetLLVMIR
   MLIRSupport
   LLVMCore
   LLVMSupport
 )

mlir/tools/mlir-opt/CMakeLists.txt

 )
 add_llvm_library(MLIRMlirOptMain
   mlir-opt.cpp
 )
 target_link_libraries(MLIRMlirOptMain
   ${LIB_LIBS}
 )
 
-set(FULL_LINK_LIBS
+set(LIBS
   MLIRLoopAnalysis
   MLIRAnalysis
   MLIRAffineOps
   MLIRAffineToStandard
   MLIRDialect
   MLIRLoopsToGPU
   MLIRLinalgToLLVM
 
set(LIBS
   MLIRTestDialect
   MLIRTestIR
   MLIRTestPass
   MLIRTestTransforms
   MLIRSupport
   MLIRVectorOps
   MLIRVectorToLLVM
   MLIRVectorToLoops
-)
-set(LIBS
   MLIRIR
   MLIROptLib
   LLVMSupport
   LLVMCore
   LLVMAsmParser
 )
 
 if(MLIR_CUDA_CONVERSIONS_ENABLED)
   list(APPEND LIBS
     LLVMNVPTXCodeGen
     LLVMNVPTXDesc
     LLVMNVPTXInfo
-    MLIRTargetNVVMIR
-  )
-  # Order matters here, so insert at front.
-  list(INSERT FULL_LINK_LIBS 0
     MLIRGPUtoCUDATransforms
+    MLIRTargetNVVMIR
   )
 endif()
 add_llvm_tool(mlir-opt
  mlir-opt.cpp
 )
 llvm_update_compile_flags(mlir-opt)
-# It is necessary to use whole_archive_link to ensure that all static
-# initializers are called. However, whole_archive_link libraries cannot
-# also be target_link_libraries.
-whole_archive_link(mlir-opt ${FULL_LINK_LIBS})
 target_link_libraries(mlir-opt PRIVATE ${LIBS})

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

 //===- mlir-opt.cpp - MLIR Optimizer Driver -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Main entry function for mlir-opt for when built as standalone binary.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Passes.h"
+#include "mlir/InitAllDialects.h"
+#include "mlir/InitAllPasses.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Support/FileUtilities.h"
 #include "mlir/Support/MlirOptMain.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 using namespace llvm;
 using namespace mlir;
 
+namespace mlir {
+// Defined in the test directory, no public header.
+void registerConvertToTargetEnvPass();
+void registerInliner();
+void registerMemRefBoundCheck();
+void registerPassManagerTestPass();
+void registerPatternsTestPass();
+void registerSimpleParametricTilingPass();
+void registerSymbolTestPasses();
+void registerTestAllReduceLoweringPass();
+void registerTestCallGraphPass();
+void registerTestConstantFold();
+void registerTestFunc();
+void registerTestGpuMemoryPromotionPass();
+void registerTestLinalgTransforms();
+void registerTestLivenessPass();
+void registerTestLoopFusion();
+void registerTestLoopMappingPass();
+void registerTestMatchers();
+void registerTestMemRefDependenceCheck();
+void registerTestMemRefStrideCalculation();
+void registerTestOpaqueLoc();
+void registerTestParallelismDetection();
+void registerTestVectorConversions();
+void registerTestVectorToLoopsPass();
+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"),
                                            cl::init("-"));
 
 static cl::opt<bool>
     splitInputFile("split-input-file",
                    cl::desc("Split the input file into pieces and process each "
                             "chunk independently"),
                    cl::init(false));
 
 static cl::opt<bool>
     verifyDiagnostics("verify-diagnostics",
                       cl::desc("Check that emitted diagnostics match "
                                "expected-* lines on the corresponding line"),
                       cl::init(false));
 
 static cl::opt<bool>
     verifyPasses("verify-each",
                  cl::desc("Run the verifier after each transformation pass"),
                  cl::init(true));
 
+void registerTestPasses() {
+  registerConvertToTargetEnvPass();
+  registerInliner();
+  registerMemRefBoundCheck();
+  registerPassManagerTestPass();
+  registerPatternsTestPass();
+  registerSimpleParametricTilingPass();
+  registerSymbolTestPasses();
+  registerTestAllReduceLoweringPass();
+  registerTestCallGraphPass();
+  registerTestConstantFold();
+  registerTestFunc();
+  registerTestGpuMemoryPromotionPass();
+  registerTestLinalgTransforms();
+  registerTestLivenessPass();
+  registerTestLoopFusion();
+  registerTestLoopMappingPass();
+  registerTestMatchers();
+  registerTestMemRefDependenceCheck();
+  registerTestMemRefStrideCalculation();
+  registerTestOpaqueLoc();
+  registerTestParallelismDetection();
+  registerTestVectorConversions();
+  registerTestVectorToLoopsPass();
+  registerVectorizerTestPass();
+
+  // The following passes are using global initializers, just link them in.
+  if (std::getenv("bar") != (char *)-1)
+    return;
+
+  // TODO: move these to the test folder.
+  createTestMemRefBoundCheckPass();
+  createTestMemRefDependenceCheckPass();
+}
+
 int main(int argc, char **argv) {
+  registerAllDialects();
+  registerAllPasses();
+  registerTestPasses();
   InitLLVM y(argc, argv);
 
   // Register any pass manager command line options.
   registerPassManagerCLOptions();
   PassPipelineCLParser passPipeline("", "Compiler passes to run");
 
   // Parse pass names in main to ensure static initialization completed.
   cl::ParseCommandLineOptions(argc, argv, "MLIR modular optimizer driver\n");

mlir/tools/mlir-translate/CMakeLists.txt

 set(LIBS
+  MLIRAllDialects
   MLIRParser
   MLIRPass
   MLIRSPIRV
   MLIRSPIRVSerialization
   MLIRTargetLLVMIR
   MLIRTargetNVVMIR
   MLIRTargetROCDLIR
   MLIRTranslation
   MLIRSupport
 )
+set(FULL_LIBS
+  MLIRSPIRVSerialization
+  MLIRTargetLLVMIR
+  MLIRTargetNVVMIR
+  MLIRTargetROCDLIR
+)
 add_llvm_tool(mlir-translate
   mlir-translate.cpp
 )
 llvm_update_compile_flags(mlir-translate)
-whole_archive_link(mlir-translate ${LIBS})
+whole_archive_link(mlir-translate ${FULL_LIBS})
 target_link_libraries(mlir-translate PRIVATE MLIRIR MLIRTranslateClParser ${LIBS} LLVMSupport)

mlir/tools/mlir-translate/mlir-translate.cpp

 //===- mlir-translate.cpp - MLIR Translate Driver -------------------------===//
 //
 // 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 is a command line utility that translates a file from/to MLIR using one
 // of the registered translations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/MLIRContext.h"
+#include "mlir/InitAllDialects.h"
 #include "mlir/Support/FileUtilities.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Support/ToolUtilities.h"
 #include "mlir/Support/TranslateClParser.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"

 
 static llvm::cl::opt<bool> verifyDiagnostics(
     "verify-diagnostics",
     llvm::cl::desc("Check that emitted diagnostics match "
                    "expected-* lines on the corresponding line"),
     llvm::cl::init(false));
 
 int main(int argc, char **argv) {
+  registerAllDialects();
   llvm::InitLLVM y(argc, argv);
 
   // Add flags for all the registered translations.
   llvm::cl::opt<const TranslateFunction *, false, TranslationParser>
       translationRequested("", llvm::cl::desc("Translation to perform"),
                            llvm::cl::Required);
 
   llvm::cl::ParseCommandLineOptions(argc, argv, "MLIR translation driver\n");

mlir/unittests/Dialect/QuantOps/QuantizationUtilsTest.cpp

 //===- QuantizationUtilsTest.cpp - unit tests for quantization utils ------===//
 //
 // 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/Dialect/QuantOps/QuantOps.h"
 #include "mlir/Dialect/QuantOps/QuantizeUtils.h"
 #include "mlir/Dialect/QuantOps/UniformSupport.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/StandardTypes.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace mlir;
 using namespace mlir::quant;
 
+// Load the quant dialect
+static DialectRegistration<QuantizationDialect> QuantOpsRegistration;
+
 namespace {
 
 // Test UniformQuantizedValueConverter converts all APFloat to a magic number 5.
 class TestUniformQuantizedValueConverter
     : public UniformQuantizedValueConverter {
 public:
   TestUniformQuantizedValueConverter(UniformQuantizedType type)
       : UniformQuantizedValueConverter(type), qtype(type) {}

mlir/unittests/Dialect/SPIRV/DeserializationTest.cpp

 //===- DeserializationTest.cpp - SPIR-V Deserialization Tests -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // The purpose of this file is to provide negative deserialization tests.
 // For positive deserialization tests, please use serialization and
 // deserialization for roundtripping.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/SPIRV/SPIRVBinaryUtils.h"
+#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/Serialization.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/MLIRContext.h"
 #include "gmock/gmock.h"
 
 #include <memory>
 
 using namespace mlir;
 
+// Load the SPIRV dialect
+static DialectRegistration<spirv::SPIRVDialect> SPIRVRegistration;
+
 using ::testing::StrEq;
 
 //===----------------------------------------------------------------------===//
 // Test Fixture
 //===----------------------------------------------------------------------===//
 
 /// A deserialization test fixture providing minimal SPIR-V building and
 /// diagnostic checking utilities.

mlir/unittests/SDBM/SDBMTest.cpp

 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/MLIRContext.h"
 #include "gtest/gtest.h"
 
 #include "llvm/ADT/DenseSet.h"
 
 using namespace mlir;
 
+// Load the SDBM dialect
+static DialectRegistration<SDBMDialect> SDBMRegistration;
+
 static MLIRContext *ctx() {
   static thread_local MLIRContext context;
   return &context;
 }
 
 static SDBMDialect *dialect() {
   static thread_local SDBMDialect *d = nullptr;
   if (!d) {