[mlir] Add an out-of-tree dialect example

[Kayjukh]

Summary

This adds a minimal out-of-tree dialect template which can be used to start work on a standalone dialect implementation without having to integrate it in the main LLVM tree.

It mostly sets up the directory structure and provides CMakeLists.txt files to build a dialect library, an opt-like tool to operate on that dialect as well as tests. It could be expanded in the future to add examples of more user-defined operations, types, attributes, generated enums, transforms, etc. and linked to a tutorial.

[stephenneuendorffer]

Thanks for taking the lead on this!

mlir/examples/standalone/README.md

6

This needs some documentation before it goes in.

mlir/examples/standalone/include/Standalone/StandaloneOps.td

14

I think this actually needs to define an OP and use it.

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

58–97

I'm a little concerned about the amount of copy-pasta here: it would be nice if more of this could be pushed into MlirOptMain., but it's unclear what the most useful line is to draw around the 'shared' bits vs. the boilerplate that just has to get copied. I don't think this necessarily has to get changed before it goes in.

[vchuravy]

This is fantastic, thanks.

1. Would it be possible to use libMLIR.so and a plugin library?
2. LLVM opt has a -load option that allows one to load new passes. So I can do opt -load=libjulia.so and load all the Julia passes and then run them as part of opt.

[Kayjukh]

This update adds build instructions to the README file as well as an example of a user-defined operation.

The custom operation does not use the declarative TableGen assembly form even though it could really benefit from it. I think it illustrates the more general case, but I am open to further discussing this point.

[rriddle]

Looks great.

mlir/examples/standalone/include/Standalone/StandaloneDialect.h

18

Please use the dialect declaration generator instead. i.e. -gen-dialect-decls

mlir/examples/standalone/include/Standalone/StandaloneOps.td

19

This looks like it needs to be wrapped at 80 characters.

mlir/examples/standalone/lib/Standalone/StandaloneOps.cpp

16

nit: Please use /// for top-level comments

23

Should you be using the declarative assembly format instead?

https://mlir.llvm.org/docs/OpDefinitions/#declarative-assembly-format

[Kayjukh]

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

58–97

I think the current split makes most sense because it separates user input processing and tool-specific customization points (such as which dialects to enable in the final executable) from the core MlirOptMain.

There is a lot of copy-pasting in this case because I wanted to stick to the current mlir-opt behavior.

[Kayjukh]

In D77133#1953259, @vchuravy wrote:

This is fantastic, thanks.

1. Would it be possible to use libMLIR.so and a plugin library?
2. LLVM opt has a -load option that allows one to load new passes. So I can do opt -load=libjulia.so and load all the Julia passes and then run them as part of opt.

I'm not sure I understand. Do you mean adding a dynamic plugin-loading infrastructure to the standalone-opt example tool?

[Kayjukh]

The main dialect include file now includes the tablegen'd declaration of the dialect instead of providing it manually.

[Kayjukh]

mlir/examples/standalone/lib/Standalone/StandaloneOps.cpp

23

I considered using the declarative syntax at first, but I think using a custom parser and printer illustrates a more general (albeit rare) case where you might want to do more during parsing than what is done by the generated parser.

But as I said in a previous update comment, I am very much open to discussion on this point. I don't know if it is relevant to account for such corner cases in an example dialect.

[rriddle]

mlir/examples/standalone/lib/Standalone/StandaloneOps.cpp

23

It all depends on what you are trying to convey with your example. Given that examples are generally used as a template, I would rather do the right thing instead. For example, you could have defined the operation classes manually in C++ but you didn't. Why shouldn't the same apply to the assembly format?

[mehdi_amini]

This LGTM other than inline comments, you likely should try to wait for River's approval as well.

mlir/examples/standalone/README.md

11

Why is -DCMAKE_LINKER= needed here?

18

This is beyond this revision, but I think adding an option for having an external FileCheck just like for -DLLVM_EXTERNAL_LIT would help here.

mlir/examples/standalone/lib/Standalone/StandaloneOps.cpp

23

+1 with River here. If this is a template I would go with the most idiomatic way (otherwise you could just not use ODS at all).

mlir/examples/standalone/standalone-opt/CMakeLists.txt

33

The list seems much much too long here, why do you need LLVMAsmParser for instance?
I'm concerned about how this is unmaintainable.

[Kayjukh]

The custom standalone.foo operation now makes use of the declarative assembly syntax form instead of manually providing a parser and a printer.

I also removed an unneeded CMake definition in the build instructions and significantly reduced the list of libraries that get linked to standalone-opt. Since this list was a copy-pasted version of the CMakeLists.txt from the current mlir-opt tool, it might be a good idea to do a cleanup pass over the latter one.

[Kayjukh]

mlir/examples/standalone/README.md

11

It isn't. This was an artifact from one of my previous tests.

18

Yes, this would definitely help.

mlir/examples/standalone/lib/Standalone/StandaloneOps.cpp

23

Ok, yes, makes sense.

mlir/examples/standalone/standalone-opt/CMakeLists.txt

33

This was originally a simple copy-and-paste from the mlir-opt CMakeLists.txt file, which for some reason links against all of these libraries.

I updated the list to include the minimum amount of libraries so as not to produce a linker error and still make the tests pass. The user of the template will then be free to link to whatever additional libraries may be needed.

[Kayjukh]

Further simplify the standalone-opt CMakeLists.txt by reflecting the changes on master for mlir-opt (commit b8c260c38d0ae93f8ae037fc1e9b94695b06d7ec).

[rriddle]

mlir/examples/standalone/include/Standalone/StandaloneDialect.td

35

nit: I don't think you need the {}, you should be able to just close with ';'.

[Kayjukh]

Minor update: remove unneeded braces at the end of the TableGen description for Standalone_Op.

[marbre]

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

25

If it is an out-of-tree example, I would avoid using namespace.

58

One could avoid registering all core dialects and passes here, but it might be more useful to change this in a follow-up.

61

A standalone pass is out of scope of this example?

[Kayjukh]

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

25

Is there any particular reason for this? IMO the two using namespace directives make the code easier to read by removing a lot of syntactic overhead. I can understand that in a larger project there might be a potential issue with names colliding but if this is the case, then the maintainer of said project can remove those lines and adapt the code as needed.

58

Yes, agreed, a follow-up may be a better place for this. For now my goal was to have the same behavior as the one described in the documentation when adding your own in-tree dialect to mlir-opt.

61

I was thinking about adding one in a potential follow-up to this patch. As mentioned in the description, this is a bare bones example that could largely be expanded upon. But I think it makes more sense to add additional features one at a time so as not to make a huge patch with everything one would think of in one go. Would this approach make more sense?

[marbre]

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

25

It might not be necessary here, but I thought it might be nice to follow the C++ Core Guidelines. The Google C++ Style Guide gives a similar advice: "Do not use using-directives (e.g. using namespace foo)."
Further, Intel did avoid copying using namespace in their ngraph-opt and I didin the forked source for iree-opt.

61

Yes, I am fine with that :)

[Kayjukh]

Remove the using namespace directives in the standalone-opt source file. This follows standard coding guidelines and code styles of other out-of-tree MLIR projects.

[Kayjukh]

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

25

Ok, yes, it makes sense to follow the style guides of other out-of-tree projects.

[lattner]

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

25

In my work on an out of tree projects using MLIR, I found it to be pretty impractical to avoid using declarations in general. There is significant syntactic overhead for this, and (IIRC) tblgen output assumes MLIR is in scope in some cases. Similarly, LLVM datatypes like StringRef are pervasive and used by downstream projects.

I have always ended up using a project specific version of things like this file:
https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Support/LLVM.h

but which includes MLIR specific types in addition to LLVM.

[Kayjukh]

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

25

I think this mostly comes down to personal preferences and coding habits. Personally, I'm not really a fan of enforcing the "no using declarations" rule for every single piece of code, but I can understand that this is a rather controversial opinion in some places.

Maybe we should aim for a middle ground for this patch? The using declarations are still present in dialect-related source files (StandaloneDialect.cpp in this case), but not in the standalone-opt tool source code. This way we don't mess with TableGen regarding name scopes but still avoid using in the main executable.

[lattner]

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

25

Yes, I agree. I don't think that perfection is required here, this is an example not a requirement for using MLIR. I'd optimize towards something that lets the code look nice in the example.

People who have local standards that frown upon "using namespace" can and will enforce their local conventions if they base anything on the example.

-Chris

[marbre]

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

25

Actually, it was just a suggestion, which I thought would be worth to mention, and nothing I tried to enforce :)

[Kayjukh]

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

25

I will leave it like this for now then, and wait until everyone approves the patch.

[stephenneuendorffer]

I think at this point, further issues can be dealt with after this land. I don't think you should expect everyone to accept this, so I would go ahead and check it in. Thanks for doing this!

[Kayjukh]

Thanks for taking the time to comment on this.

I don't have commit access. Could someone push it to the main repository?

[lattner]

In D77133#1961370, @Kayjukh wrote:

Thanks for taking the time to comment on this.

I don't have commit access. Could someone push it to the main repository?

I'm happy to fix that problem :-). Please read http://llvm.org/docs/DeveloperPolicy.html and send me the requested info, thanks!

mlir/examples/standalone/CMakeLists.txt

+cmake_minimum_required(VERSION 3.10)
+
+if(POLICY CMP0068)
+  cmake_policy(SET CMP0068 NEW)
+  set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON)
+endif()
+
+if(POLICY CMP0075)
+  cmake_policy(SET CMP0075 NEW)
+endif()
+
+if(POLICY CMP0077)
+  cmake_policy(SET CMP0077 NEW)
+endif()
+
+project(standalone-dialect LANGUAGES CXX C)
+
+find_package(MLIR REQUIRED CONFIG)
+
+message(STATUS "Using MLIRConfig.cmake in: ${MLIR_DIR}")
+message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
+
+set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/bin)
+set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/lib)
+set(MLIR_BINARY_DIR ${CMAKE_BINARY_DIR})
+
+list(APPEND CMAKE_MODULE_PATH "${MLIR_CMAKE_DIR}")
+list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+include(TableGen)
+include(AddLLVM)
+include(AddMLIR)
+include(HandleLLVMOptions)
+
+include_directories(${LLVM_INCLUDE_DIRS})
+include_directories(${MLIR_INCLUDE_DIRS})
+include_directories(${PROJECT_SOURCE_DIR}/include)
+include_directories(${PROJECT_BINARY_DIR}/include)
+link_directories(${LLVM_BUILD_LIBRARY_DIR})
+add_definitions(${LLVM_DEFINITIONS})
+
+add_subdirectory(include)
+add_subdirectory(lib)
+add_subdirectory(test)
+add_subdirectory(standalone-opt)

mlir/examples/standalone/README.md

+# An out-of-tree MLIR dialect
+
+This is an example of an out-of-tree [MLIR](https://mlir.llvm.org/) dialect along with a standalone `opt`-like tool to operate on that dialect.
+
+## Building
+
+This setup assumes that you have built LLVM and MLIR in `$BUILD_DIR` and installed them to `$PREFIX`. To build and launch the tests, run
+```sh
+mkdir build && cd build
+cmake -G Ninja .. -DMLIR_DIR=$PREFIX/lib/cmake/mlir -DLLVM_EXTERNAL_LIT=$BUILD_DIR/bin/llvm-lit
+cmake --build . --target check-standalone
+```
+To build the documentation from the TableGen description of the dialect operations, run
+```sh
+cmake --build . --target mlir-doc
+```
+**Note**: Make sure to pass `-DLLVM_INSTALL_UTILS=ON` when building LLVM with CMake in order to install `FileCheck` to the chosen installation prefix.
+

mlir/examples/standalone/include/CMakeLists.txt

+add_subdirectory(Standalone)

mlir/examples/standalone/include/Standalone/CMakeLists.txt

+add_mlir_dialect(StandaloneOps standalone)
+add_mlir_doc(StandaloneDialect -gen-dialect-doc StandaloneDialect Standalone/)
+add_mlir_doc(StandaloneOps -gen-op-doc StandaloneOps Standalone/)

mlir/examples/standalone/include/Standalone/StandaloneDialect.h

+//===- StandaloneDialect.h - Standalone dialect -----------------*- C++ -*-===//
+//
+// This file is licensed 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 STANDALONE_STANDALONEDIALECT_H
+#define STANDALONE_STANDALONEDIALECT_H
+
+#include "mlir/IR/Dialect.h"
+
+namespace mlir {
+namespace standalone {
+
+#include "Standalone/StandaloneOpsDialect.h.inc"
+
+} // namespace standalone
+} // namespace mlir
+
+#endif // STANDALONE_STANDALONEDIALECT_H

mlir/examples/standalone/include/Standalone/StandaloneDialect.td

+//===- StandaloneDialect.td - Standalone dialect -----------*- tablegen -*-===//
+//
+// This file is licensed 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 STANDALONE_DIALECT
+#define STANDALONE_DIALECT
+
+include "mlir/IR/OpBase.td"
+
+//===----------------------------------------------------------------------===//
+// Standalone dialect definition.
+//===----------------------------------------------------------------------===//
+
+def Standalone_Dialect : Dialect {
+    let name = "standalone";
+    let summary = "A standalone out-of-tree MLIR dialect.";
+    let description = [{
+        This dialect is an example of an out-of-tree MLIR dialect designed to
+        illustrate the basic setup required to develop MLIR-based tools without
+        working inside of the LLVM source tree.
+    }];
+    let cppNamespace = "standalone";
+}
+
+//===----------------------------------------------------------------------===//
+// Base standalone operation definition.
+//===----------------------------------------------------------------------===//
+
+class Standalone_Op<string mnemonic, list<OpTrait> traits = []> :
+        Op<Standalone_Dialect, mnemonic, traits>;
+
+#endif // STANDALONE_DIALECT

mlir/examples/standalone/include/Standalone/StandaloneOps.h

+//===- StandaloneOps.h - Standalone dialect ops -----------------*- C++ -*-===//
+//
+// This file is licensed 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 STANDALONE_STANDALONEOPS_H
+#define STANDALONE_STANDALONEOPS_H
+
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/OpDefinition.h"
+#include "mlir/Interfaces/SideEffects.h"
+
+namespace mlir {
+namespace standalone {
+
+#define GET_OP_CLASSES
+#include "Standalone/StandaloneOps.h.inc"
+
+} // namespace standalone
+} // namespace mlir
+
+#endif // STANDALONE_STANDALONEOPS_H

mlir/examples/standalone/include/Standalone/StandaloneOps.td

+//===- StandaloneOps.td - Standalone dialect ops -----------*- tablegen -*-===//
+//
+// This file is licensed 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 STANDALONE_OPS
+#define STANDALONE_OPS
+
+include "StandaloneDialect.td"
+include "mlir/Interfaces/SideEffects.td"
+
+def Standalone_FooOp : Standalone_Op<"foo", [NoSideEffect,
+                                             SameOperandsAndResultType]> {
+    let summary = "Illustrates how to define an operation.";
+    let description = [{
+        The `standalone.foo` operation illustrates how to define a new
+        operation in a dialect. It uses an operation trait to declare that it
+        has no side effects.
+
+        This operation takes an integer argument and returns an integer.
+
+        Example:
+
+        ```mlir
+        %0 = constant 2 : i32
+        // Apply the foo operation to %0
+        %1 = standalone.foo %0 : i32
+        ```
+    }];
+
+    let arguments = (ins I32:$input);
+    let results = (outs I32:$res);
+
+    let assemblyFormat = [{
+        $input attr-dict `:` type($input)
+    }];
+}
+
+#endif // STANDALONE_OPS

mlir/examples/standalone/lib/CMakeLists.txt

+add_subdirectory(Standalone)

mlir/examples/standalone/lib/Standalone/CMakeLists.txt

+add_mlir_dialect_library(MLIRStandalone
+        StandaloneDialect.cpp
+        StandaloneOps.cpp
+
+        ADDITIONAL_HEADER_DIRS
+        ${PROJECT_SOURCE_DIR}/include/Standalone
+
+        DEPENDS
+        MLIRStandaloneOpsIncGen
+        )
+
+target_link_libraries(MLIRStandalone PUBLIC MLIRIR)

mlir/examples/standalone/lib/Standalone/StandaloneDialect.cpp

+//===- StandaloneDialect.cpp - Standalone dialect ---------------*- C++ -*-===//
+//
+// This file is licensed 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 "Standalone/StandaloneDialect.h"
+#include "Standalone/StandaloneOps.h"
+
+using namespace mlir;
+using namespace mlir::standalone;
+
+//===----------------------------------------------------------------------===//
+// Standalone dialect.
+//===----------------------------------------------------------------------===//
+
+StandaloneDialect::StandaloneDialect(mlir::MLIRContext *context)
+    : Dialect(getDialectNamespace(), context) {
+  addOperations<
+#define GET_OP_LIST
+#include "Standalone/StandaloneOps.cpp.inc"
+  >();
+}

mlir/examples/standalone/lib/Standalone/StandaloneOps.cpp

+//===- StandaloneOps.cpp - Standalone dialect ops ---------------*- C++ -*-===//
+//
+// This file is licensed 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 "Standalone/StandaloneOps.h"
+#include "Standalone/StandaloneDialect.h"
+#include "mlir/IR/OpImplementation.h"
+
+namespace mlir {
+namespace standalone {
+#define GET_OP_CLASSES
+#include "Standalone/StandaloneOps.cpp.inc"
+} // namespace standalone
+} // namespace mlir

mlir/examples/standalone/standalone-opt/CMakeLists.txt

+get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
+set(LIBS
+        ${dialect_libs}
+        ${conversion_libs}
+        MLIRQuantizerTransforms
+        MLIROptLib
+        MLIRStandalone
+        )
+add_llvm_executable(standalone-opt standalone-opt.cpp)
+
+llvm_update_compile_flags(standalone-opt)
+target_link_libraries(standalone-opt PRIVATE ${LIBS})

mlir/examples/standalone/standalone-opt/standalone-opt.cpp

+//===- standalone-opt.cpp ---------------------------------------*- C++ -*-===//
+//
+// This file is licensed 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/Dialect.h"
+#include "mlir/IR/MLIRContext.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"
+
+#include "Standalone/StandaloneDialect.h"
+
+using namespace llvm;
+using 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));
+
+static cl::opt<bool>
+    showDialects("show-dialects",
+                 cl::desc("Print the list of registered dialects"),
+                 cl::init(false));
+
+int main(int argc, char **argv) {
+  registerAllDialects();
+  registerAllPasses();
+
+  registerDialect<standalone::StandaloneDialect>();
+  // TODO: Register standalone passes here.
+
+  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");
+
+  MLIRContext context;
+  if (showDialects) {
+    llvm::outs() << "Registered Dialects:\n";
+    for (Dialect *dialect : context.getRegisteredDialects()) {
+      llvm::outs() << dialect->getNamespace() << "\n";
+    }
+    return 0;
+  }
+
+  // Set up the input file.
+  std::string errorMessage;
+  auto file = openInputFile(inputFilename, &errorMessage);
+  if (!file) {
+    llvm::errs() << errorMessage << "\n";
+    return 1;
+  }
+
+  auto output = openOutputFile(outputFilename, &errorMessage);
+  if (!output) {
+    llvm::errs() << errorMessage << "\n";
+    exit(1);
+  }
+
+  return failed(MlirOptMain(output->os(), std::move(file), passPipeline,
+                            splitInputFile, verifyDiagnostics, verifyPasses));
+}

mlir/examples/standalone/test/CMakeLists.txt

+configure_lit_site_cfg(
+        ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
+        ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
+        MAIN_CONFIG
+        ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
+)
+
+set(STANDALONE_OPT_TEST_DEPENDS
+        FileCheck count not
+        standalone-opt
+        )
+
+add_lit_testsuite(check-standalone-opt "Running the standalone-opt regression tests"
+        ${CMAKE_CURRENT_BINARY_DIR}
+        DEPENDS ${STANDALONE_OPT_TEST_DEPENDS}
+        )
+set_target_properties(check-standalone-opt PROPERTIES FOLDER "Tests")
+
+add_lit_testsuites(STANDALONE_OPT ${CMAKE_CURRENT_SOURCE_DIR} DEPENDS ${STANDALONE_OPT_TEST_DEPENDS})

mlir/examples/standalone/test/Standalone/dummy.mlir

+// RUN: standalone-opt %s | standalone-opt | FileCheck %s
+
+module {
+    // CHECK-LABEL: func @bar()
+    func @bar() {
+        %0 = constant 1 : i32
+        // CHECK: %{{.*}} = standalone.foo %{{.*}} : i32
+        %res = standalone.foo %0 : i32
+        return
+    }
+}

mlir/examples/standalone/test/lit.cfg.py

+# -*- Python -*-
+
+import os
+import platform
+import re
+import subprocess
+import tempfile
+
+import lit.formats
+import lit.util
+
+from lit.llvm import llvm_config
+from lit.llvm.subst import ToolSubst
+from lit.llvm.subst import FindTool
+
+# Configuration file for the 'lit' test runner.
+
+# name: The name of this test suite.
+config.name = 'STANDALONE_OPT'
+
+config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
+
+# suffixes: A list of file extensions to treat as test files.
+config.suffixes = ['.mlir']
+
+# test_source_root: The root path where tests are located.
+config.test_source_root = os.path.dirname(__file__)
+
+# test_exec_root: The root path where tests should be run.
+config.test_exec_root = os.path.join(config.standalone_obj_root, 'test')
+
+config.substitutions.append(('%PATH%', config.environment['PATH']))
+config.substitutions.append(('%shlibext', config.llvm_shlib_ext))
+
+llvm_config.with_system_environment(
+    ['HOME', 'INCLUDE', 'LIB', 'TMP', 'TEMP'])
+
+llvm_config.use_default_substitutions()
+
+# excludes: A list of directories to exclude from the testsuite. The 'Inputs'
+# subdirectories contain auxiliary inputs for various tests in their parent
+# directories.
+config.excludes = ['Inputs', 'Examples', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']
+
+# test_source_root: The root path where tests are located.
+config.test_source_root = os.path.dirname(__file__)
+
+# test_exec_root: The root path where tests should be run.
+config.test_exec_root = os.path.join(config.standalone_obj_root, 'test')
+config.standalone_tools_dir = os.path.join(config.standalone_obj_root, 'bin')
+
+# Tweak the PATH to include the tools dir.
+llvm_config.with_environment('PATH', config.llvm_tools_dir, append_path=True)
+
+tool_dirs = [config.standalone_tools_dir, config.llvm_tools_dir]
+tools = [
+    'standalone-opt'
+]
+
+llvm_config.add_tool_substitutions(tools, tool_dirs)

mlir/examples/standalone/test/lit.site.cfg.py.in

+@LIT_SITE_CFG_IN_HEADER@
+
+import sys
+
+config.host_triple = "@LLVM_HOST_TRIPLE@"
+config.target_triple = "@TARGET_TRIPLE@"
+config.llvm_src_root = "@LLVM_SOURCE_DIR@"
+config.llvm_obj_root = "@LLVM_BINARY_DIR@"
+config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
+config.llvm_lib_dir = "@LLVM_LIBRARY_DIR@"
+config.llvm_shlib_dir = "@SHLIBDIR@"
+config.llvm_shlib_ext = "@SHLIBEXT@"
+config.llvm_exe_ext = "@EXEEXT@"
+config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
+config.python_executable = "@PYTHON_EXECUTABLE@"
+config.gold_executable = "@GOLD_EXECUTABLE@"
+config.ld64_executable = "@LD64_EXECUTABLE@"
+config.enable_shared = @ENABLE_SHARED@
+config.enable_assertions = @ENABLE_ASSERTIONS@
+config.targets_to_build = "@TARGETS_TO_BUILD@"
+config.native_target = "@LLVM_NATIVE_ARCH@"
+config.llvm_bindings = "@LLVM_BINDINGS@".split(' ')
+config.host_os = "@HOST_OS@"
+config.host_cc = "@HOST_CC@"
+config.host_cxx = "@HOST_CXX@"
+# Note: ldflags can contain double-quoted paths, so must use single quotes here.
+config.host_ldflags = '@HOST_LDFLAGS@'
+config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
+config.llvm_host_triple = '@LLVM_HOST_TRIPLE@'
+config.host_arch = "@HOST_ARCH@"
+config.standalone_src_root = "@CMAKE_SOURCE_DIR@"
+config.standalone_obj_root = "@CMAKE_BINARY_DIR@"
+
+# Support substitution of the tools_dir with user parameters. This is
+# used when we can't determine the tool dir at configuration time.
+try:
+    config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
+    config.llvm_shlib_dir = config.llvm_shlib_dir % lit_config.params
+except KeyError:
+    e = sys.exc_info()[1]
+    key, = e.args
+    lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
+
+
+import lit.llvm
+lit.llvm.initialize(lit_config, config)
+
+# Let the main config do the real work.
+lit_config.load_config(config, "@CMAKE_SOURCE_DIR@/test/lit.cfg.py")