llvm-project/mlir/test/lib/CMakeLists.txt

add_subdirectory(Analysis)
add_subdirectory(Conversion)
add_subdirectory(Dialect)
add_subdirectory(IR)
add_subdirectory(Pass)
add_subdirectory(Reducer)
add_subdirectory(Rewrite)
add_subdirectory(Transforms)
[mlir] Add initial support for an alias analysis framework in MLIR This revision adds a new `AliasAnalysis` class that represents the main alias analysis interface in MLIR. The purpose of this class is not to hold the aliasing logic itself, but to provide an interface into various different alias analysis implementations. As it evolves this should allow for users to plug in specialized alias analysis implementations for their own needs, and have them immediately usable by other analyses and transformations. This revision also adds an initial simple generic alias, LocalAliasAnalysis, that provides support for performing stateless local alias queries between values. This class is similar in scope to LLVM's BasicAA. Differential Revision: https://reviews.llvm.org/D92343 2021-02-10 06:11:00 +08:00			`add_subdirectory(Analysis)`
[mlir][NFC] Move passes in test/lib/Transforms/ to a directory that mirrors what they test test/lib/Transforms/ has bitrot and become somewhat of a dumping grounds for testing pretty much any part of the project. This revision cleans this up, and moves the files within to a directory that reflects what is actually being tested. Differential Revision: https://reviews.llvm.org/D102456 2021-05-15 01:27:57 +08:00			`add_subdirectory(Conversion)`
[mlir][spirv] NFC: Move test passes to test/lib Previously C++ test passes for SPIR-V were put under test/Dialect/SPIRV. Move them to test/lib/Dialect/SPIRV to create a better structure. Also fixed one of the test pass to use new PassRegistration mechanism. Differential Revision: https://reviews.llvm.org/D75066 2020-02-25 02:35:33 +08:00			`add_subdirectory(Dialect)`
Add support for walking the uses of a symbol. MLIR uses symbol references to model references to many global entities, such as functions/variables/etc. Before this change, there is no way to actually reason about the uses of such entities. This change provides a walker for symbol references(via SymbolTable::walkSymbolUses), as well as 'use_empty' support(via SymbolTable::symbol_use_empty). It also resolves some deficiencies in the LangRef definition of SymbolRefAttr, namely the restrictions on where a SymbolRefAttr can be stored, ArrayAttr and DictionaryAttr, and the relationship with operations containing the SymbolTable trait. PiperOrigin-RevId: 273549331 2019-10-09 01:21:26 +08:00			`add_subdirectory(IR)`
Refactor PassTiming to support nested pipelines. This is done via a new set of instrumentation hooks runBeforePipeline/runAfterPipeline, that signal the lifetime of a pass pipeline on a specific operation type. These hooks also provide the parent thread of the pipeline, allowing for accurate merging of timers running on different threads. PiperOrigin-RevId: 267909193 2019-09-09 10:57:25 +08:00			`add_subdirectory(Pass)`
Create TestReducer pass - Create a pass that generates bugs based on trivially defined behavior for the purpose of testing the MLIR Reduce Tool. - Implement the functionality inside the pass to crash mlir-opt in the presence of an operation with the name "crashOp". - Register the pass as a test pass in the mlir-opt tool. Reviewed by: jpienaar Differential Revision: https://reviews.llvm.org/D83422 2020-07-11 08:46:55 +08:00			`add_subdirectory(Reducer)`
[mlir][PDL] Add support for PDL bytecode and expose PDL support to OwningRewritePatternList PDL patterns are now supported via a new `PDLPatternModule` class. This class contains a ModuleOp with the pdl::PatternOp operations representing the patterns, as well as a collection of registered C++ functions for native constraints/creations/rewrites/etc. that may be invoked via the pdl patterns. Instances of this class are added to an OwningRewritePatternList in the same fashion as C++ RewritePatterns, i.e. via the `insert` method. The PDL bytecode is an in-memory representation of the PDL interpreter dialect that can be efficiently interpreted/executed. The representation of the bytecode boils down to a code array(for opcodes/memory locations/etc) and a memory buffer(for storing attributes/operations/values/any other data necessary). The bytecode operations are effectively a 1-1 mapping to the PDLInterp dialect operations, with a few exceptions in cases where the in-memory representation of the bytecode can be more efficient than the MLIR representation. For example, a generic `AreEqual` bytecode op can be used to represent AreEqualOp, CheckAttributeOp, and CheckTypeOp. The execution of the bytecode is split into two phases: matching and rewriting. When matching, all of the matched patterns are collected to avoid the overhead of re-running parts of the matcher. These matched patterns are then considered alongside the native C++ patterns, which rewrite immediately in-place via `RewritePattern::matchAndRewrite`, for the given root operation. When a PDL pattern is matched and has the highest benefit, it is passed back to the bytecode to execute its rewriter. Differential Revision: https://reviews.llvm.org/D89107 2020-12-02 06:30:18 +08:00			`add_subdirectory(Rewrite)`
Split test-specific passes out of mlir-opt Instead put their impl in test/lib and link them into mlir-test-opt PiperOrigin-RevId: 254837439 2019-06-25 05:35:21 +08:00			`add_subdirectory(Transforms)`