This is an archive of the discontinued LLVM Phabricator instance.

Differential D134762

[mlir][arith] Change dialect name from Arithmetic to Arith
ClosedPublic

Authored by kuhar on Sep 27 2022, 2:10 PM.

Details

Reviewers
lattner
Mogball
rriddle
antiagainst
grosser
aartbik
jpienaar
ftynse
mravishankar
clementval
bondhugula
ThomasRaoux
nicolasvasilache
herhut
dcaballe
mehdi_amini
Commits
rGabc362a1077b: [mlir][arith] Change dialect name from Arithmetic to Arith
Summary

Suggested by @lattner in https://discourse.llvm.org/t/rfc-define-precise-arith-semantics/65507/22.

Tested with:
ninja check-mlir check-mlir-integration check-mlir-mlir-spirv-cpu-runner check-mlir-mlir-vulkan-runner check-mlir-examples

and bazel build --config=generic_clang @llvm-project//mlir:all.

Diff Detail

Event Timeline

kuhar created this revision.Sep 27 2022, 2:10 PM
Herald added a reviewer: grosser. · View Herald TranscriptSep 27 2022, 2:10 PM
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: jpienaar. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: mravishankar. · View Herald Transcript
Herald added a reviewer: clementval. · View Herald Transcript
Herald added a reviewer: bondhugula. · View Herald Transcript
Herald added a reviewer: ThomasRaoux. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: zero9178, anlunx, bzcheeseman and 34 others. · View Herald Transcript
kuhar requested review of this revision.Sep 27 2022, 2:10 PM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptSep 27 2022, 2:10 PM
Herald added a reviewer: herhut. · View Herald Transcript
Herald added a reviewer: dcaballe. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: • pcwang-thead, stephenneuendorffer, nicolasvasilache, jholewinski. · View Herald Transcript
Harbormaster completed remote builds in B189021: Diff 463336.Sep 27 2022, 2:29 PM
lattner accepted this revision.Sep 27 2022, 2:52 PM

+1 this makes sense to me, but I'd love for someone else's eyes to be on the details. Thank you!

Mogball requested changes to this revision.Sep 27 2022, 5:15 PM

I'm against this change. The dialect has always been called "the arithmetic dialect", which everyone just called "arith" for short. There are few other dialects whose name and namespaces don't match; "omp" for example

This revision now requires changes to proceed.Sep 27 2022, 5:15 PM
lattner added a comment.Sep 27 2022, 5:39 PM

Is there a reason to have two names for the same thing? Why shouldn't the omp dialect be moved into a directory "omp"?

People can still verbally refer to these things as openmp and arithmetic of course, but keeping the code mechanically consistent seems just better?

kuhar added a comment.Sep 27 2022, 6:09 PM
In D134762#3819530, @Mogball wrote:

I'm against this change. The dialect has always been called "the arithmetic dialect", which everyone just called "arith" for short. There are few other dialects whose name and namespaces don't match; "omp" for example

Without knowing the full this historical context, the current state of things seems needlessly inconsistent to me. For example, we have Math and Func instead of Mathematical/Function. Another example is that recently, we renamed changed all definitions in the SPIRV dialect from 'spv' to spirv for the sake of consistency. If the refactoring cost is low, I'd rather use the same dialect names and definition/op prefix.

Mogball accepted this revision.Sep 27 2022, 6:10 PM

I wasn't aware of the spv change. LGTM to them

This revision now requires review to proceed.Sep 27 2022, 6:10 PM
rriddle accepted this revision.Sep 27 2022, 6:17 PM

I only really hear this referred to as "Arith", so this rename seems good to me.

csigg added inline comments.Sep 28 2022, 12:36 AM
mlir/include/mlir/Dialect/Arith/IR/Arith.h
24

Could we have a type alias (using ArithmeticDialect = ArithDialect;) to help with the transition?

Maybe you already added it somewhere, I haven't checked all the files.

kuhar added a comment.Sep 28 2022, 8:05 AM

Based on internal feedback, I want to split this patch into a few more gradual changes:

  1. (This revision) Rename the dialect and paths, but add an alias for the old dialect name
  2. Remove the alias
  3. Rename passes/conversions (landed a few days later so that folks have time to catch up)

Does this work for other folks?

mlir/include/mlir/Dialect/Arith/IR/Arith.h
24

Sure, I can add this if it makes it easier to import this change

cota added a comment.Sep 28 2022, 10:03 AM
In D134762#3821046, @kuhar wrote:

Based on internal feedback, I want to split this patch into a few more gradual changes:

  1. (This revision) Rename the dialect and paths, but add an alias for the old dialect name
  2. Remove the alias
  3. Rename passes/conversions (landed a few days later so that folks have time to catch up)

Does this work for other folks?

An alternative, that is easier for you @kuhar as well as simpler for upstream, is just to land the patch as is, i.e. in a single commit that does the entire conversion.

This patch is large but the changes are quite mechanical, so perhaps splitting it into several patches is overkill. I remember the func -> func.func change was quite wide-ranging and therefore required a lot of work, but in this case we should be able to adapt downstream code relatively easily, even if it all comes in a single patch.

So, as a downstream user, I'd be happy with or without the split.

jpienaar accepted this revision.Sep 28 2022, 10:10 AM

LG for shape changes/removing blocker

This revision is now accepted and ready to land.Sep 28 2022, 10:10 AM
kuhar added a comment.Sep 28 2022, 12:26 PM

OK, so if I don't get any other requests to split this up, I'll land this as-is in one go tomorrow morning (Pacific Time).

tpopp added a subscriber: tpopp.Sep 29 2022, 12:39 AM
tpopp added inline comments.
mlir/include/mlir/Conversion/Passes.td
98–99

Just a warning that you'll have merge conflicts with this change: https://reviews.llvm.org/D134752

mehdi_amini added a comment.Sep 29 2022, 7:54 AM
In D134762#3821046, @kuhar wrote:

Based on internal feedback, I want to split this patch into a few more gradual changes:

  1. (This revision) Rename the dialect and paths, but add an alias for the old dialect name
  2. Remove the alias
  3. Rename passes/conversions (landed a few days later so that folks have time to catch up)

Does this work for other folks?

Seems reasonable to me to splits.

I am not sure about the “ a few days later so that folks have time to catch up)” part, that seems oddly specific to “some specific downstream” in terms of process/timeline (what if I integrate weekly? Every other week? …)

mehdi_amini accepted this revision.Sep 29 2022, 7:54 AM
mehdi_amini added a comment.Sep 29 2022, 8:04 AM

And thanks for the cleanup by the way :)

kuhar updated this revision to Diff 463912.Sep 29 2022, 8:12 AM

Rebased.

kuhar edited the summary of this revision. (Show Details)Sep 29 2022, 8:13 AM
This revision was landed with ongoing or failed builds.Sep 29 2022, 8:24 AM
Closed by commit rGabc362a1077b: [mlir][arith] Change dialect name from Arithmetic to Arith (authored by kuhar). · Explain Why
This revision was automatically updated to reflect the committed changes.
kuhar added a commit: rGabc362a1077b: [mlir][arith] Change dialect name from Arithmetic to Arith.
clementval added a comment.Sep 29 2022, 9:15 AM

This is breaking couple of flang buildbots.

Harbormaster completed remote builds in B189426: Diff 463912.Sep 29 2022, 9:32 AM
kuhar added a comment.Sep 29 2022, 10:16 AM
In D134762#3824231, @clementval wrote:

This is breaking couple of flang buildbots.

That should be fixed by https://reviews.llvm.org/rG6c8d8d10455a3d38a92102ae3a94e1c06d3eb363. I haven't received any builbot errors since submitting this fix, so I think that should do it. I'm not a flang developer, so please let me know if there are any remaining issues.

clementval added a comment.Sep 29 2022, 11:09 AM
In D134762#3824450, @kuhar wrote:
In D134762#3824231, @clementval wrote:

This is breaking couple of flang buildbots.

That should be fixed by https://reviews.llvm.org/rG6c8d8d10455a3d38a92102ae3a94e1c06d3eb363. I haven't received any builbot errors since submitting this fix, so I think that should do it. I'm not a flang developer, so please let me know if there are any remaining issues.

Thanks for the quick fix. I think everything is fine.

Revision Contents

PathSize
mlir/
docs/
6 lines
4 lines
Dialects/
2 lines
2 lines
2 lines
2 lines
Rationale/
2 lines
Tools/
8 lines
Tutorials/
Toy/
6 lines
2 lines
examples/
standalone/
standalone-opt/
2 lines
4 lines
toy/
Ch5/
mlir/
9 lines
Ch6/
mlir/
9 lines
7 lines
Ch7/
mlir/
9 lines
7 lines
include/
mlir/
Conversion/
ArithToLLVM/
ArithmeticToLLVM/
ArithToLLVM.h
ArithmeticToLLVM.h
14 lines
ArithToSPIRV/
32 lines
ArithmeticToLLVM/
ArithmeticToSPIRV/
4 lines
28 lines
Dialect/
Affine/
Analysis/
2 lines
IR/
2 lines
4 lines
2 lines
Arith/
Arithmetic/
IR/
Arith.h
Arithmetic.h
20 lines
ArithBase.td
ArithmeticBase.td
12 lines
ArithOps.td
ArithmeticOps.td
26 lines
Transforms/
6 lines
26 lines
26 lines
6 lines
Utils/
12 lines
Arith/
IR/
5 lines
Transforms/
5 lines
Arithmetic/
IR/
Transforms/
Utils/
Async/
2 lines
Bufferization/
Transforms/
2 lines
2 lines
Complex/
IR/
2 lines
ControlFlow/
IR/
2 lines
GPU/
IR/
2 lines
Linalg/
IR/
2 lines
MemRef/
IR/
2 lines
2 lines
SCF/
IR/
2 lines
Shape/
IR/
2 lines
Transforms/
5 lines
2 lines
SparseTensor/
Transforms/
6 lines
Tensor/
IR/
2 lines
Tosa/
Utils/
2 lines
Vector/
IR/
2 lines
6 lines
4 lines
Interfaces/
2 lines
lib/
Conversion/
AffineToStandard/
2 lines
2 lines
ArithToLLVM/
ArithmeticToLLVM/
ArithToLLVM.cpp
ArithmeticToLLVM.cpp
18 lines
8 lines
ArithToSPIRV/
ArithmeticToSPIRV/
ArithToSPIRV.cpp
ArithmeticToSPIRV.cpp
21 lines
8 lines
ArithmeticToLLVM/
ArithmeticToSPIRV/
ArmNeon2dToIntr/
2 lines
AsyncToLLVM/
2 lines
2 lines
BufferizationToMemRef/
2 lines
4 lines
ComplexToLLVM/
2 lines
ComplexToStandard/
2 lines
4 lines
FuncToLLVM/
2 lines
4 lines
GPUCommon/
2 lines
4 lines
GPUToNVVM/
2 lines
6 lines
GPUToROCDL/
2 lines
5 lines
GPUToSPIRV/
2 lines
4 lines
LinalgToStandard/
5 lines
MathToFuncs/
2 lines
4 lines
MathToLibm/
2 lines
6 lines
MemRefToLLVM/
2 lines
OpenACCToSCF/
2 lines
2 lines
OpenMPToLLVM/
2 lines
4 lines
SCFToControlFlow/
2 lines
2 lines
SCFToGPU/
2 lines
2 lines
2 lines
SCFToOpenMP/
2 lines
2 lines
SCFToSPIRV/
2 lines
4 lines
SPIRVToLLVM/
2 lines
5 lines
ShapeToStandard/
2 lines
4 lines
TensorToLinalg/
8 lines
TensorToSPIRV/
2 lines
4 lines
TosaToArith/
2 lines
2 lines
4 lines
TosaToLinalg/
2 lines
2 lines
2 lines
6 lines
6 lines
TosaToTensor/
2 lines
4 lines
VectorToGPU/
2 lines
2 lines
2 lines
VectorToLLVM/
2 lines
4 lines
6 lines
VectorToSCF/
2 lines
2 lines
Dialect/
Affine/
Analysis/
2 lines
2 lines
IR/
2 lines
Transforms/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Utils/
2 lines
2 lines
Arith/
Arithmetic/
IR/
ArithCanonicalization.td
ArithmeticCanonicalization.td
10 lines
ArithDialect.cpp
ArithmeticDialect.cpp
21 lines
ArithOps.cpp
ArithmeticOps.cpp
10 lines
2 lines
Transforms/
6 lines
32 lines
8 lines
19 lines
25 lines
21 lines
Utils/
4 lines
Arith/
IR/
21 lines
Utils/
11 lines
Arithmetic/
IR/
Transforms/
Utils/
Async/
Transforms/
2 lines
2 lines
2 lines
2 lines
Bufferization/
IR/
2 lines
Transforms/
2 lines
2 lines
Complex/
IR/
2 lines
2 lines
ControlFlow/
IR/
2 lines
2 lines
GPU/
4 lines
IR/
2 lines
Transforms/
2 lines
2 lines
2 lines
Linalg/
IR/
4 lines
2 lines
4 lines
4 lines
TransformOps/
2 lines
4 lines
Transforms/
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
Utils/
2 lines
4 lines
Math/
IR/
2 lines
2 lines
Transforms/
2 lines
2 lines
2 lines
2 lines
MemRef/
IR/
4 lines
2 lines
4 lines
TransformOps/
2 lines
4 lines
Transforms/
2 lines
6 lines
2 lines
2 lines
2 lines
NVGPU/
Transforms/
2 lines
2 lines
2 lines
SCF/
IR/
2 lines
4 lines
Transforms/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
Utils/
2 lines
2 lines
Shape/
IR/
2 lines
2 lines
Transforms/
2 lines
4 lines
SparseTensor/
IR/
2 lines
2 lines
Pipelines/
2 lines
5 lines
Transforms/
2 lines
2 lines
6 lines
2 lines
2 lines
Utils/
2 lines
2 lines
Tensor/
IR/
4 lines
2 lines
4 lines
2 lines
Transforms/
4 lines
8 lines
2 lines
4 lines
2 lines
2 lines
Utils/
2 lines
2 lines
Utils/
2 lines
2 lines
Vector/
IR/
2 lines
4 lines
Transforms/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
Utils/
2 lines
2 lines
X86Vector/
Transforms/
2 lines
2 lines
2 lines
Target/
Cpp/
2 lines
4 lines
2 lines
python/
2 lines
mlir/
dialects/
ArithOps.td
ArithmeticOps.td
8 lines
test/
CAPI/
2 lines
Conversion/
ArithToLLVM/
ArithmeticToLLVM/
ArithToSPIRV/
ArithmeticToSPIRV/
arith-to-spirv.mlir
arithmetic-to-spirv.mlir
ArithmeticToLLVM/
ArithmeticToSPIRV/
Dialect/
Arith/
Arithmetic/
Arithmetic/
Integration/
Dialect/
Arith/
CPU/
Arithmetic/
CPU/
Arithmetic/
CPU/
lib/
Dialect/
Arith/
Arithmetic/
6 lines
20 lines
Arithmetic/
2 lines
GPU/
4 lines
Linalg/
4 lines
2 lines
Math/
4 lines
4 lines
SCF/
4 lines
4 lines
Tensor/
2 lines
6 lines
Test/
2 lines
2 lines
IR/
2 lines
Interfaces/
TilingInterface/
2 lines
tools/
mlir-opt/
2 lines
4 lines
mlir-spirv-cpu-runner/
2 lines
4 lines
mlir-vulkan-runner/
2 lines
4 lines
unittests/
Conversion/
PDLToPDLInterp/
2 lines
4 lines
ExecutionEngine/
2 lines
4 lines
Interfaces/
4 lines
utils/
bazel/
llvm-project-overlay/
mlir/
304 lines
examples/
toy/
Ch5/
2 lines
Ch6/
4 lines
Ch7/
4 lines
python/
16 lines
test/
28 lines
unittests/
2 lines

Diff 463915

mlir/docs/AttributesAndTypes.md

# Defining Dialect Attributes and Types # Defining Dialect Attributes and Types
This document describes how to define dialect This document describes how to define dialect
[attributes](LangRef.md/#attributes) and [types](LangRef.md/#type-system). [attributes](LangRef.md/#attributes) and [types](LangRef.md/#type-system).
[TOC] [TOC]
## LangRef Refresher ## LangRef Refresher
Before diving into how to define these constructs, below is a quick refresher Before diving into how to define these constructs, below is a quick refresher
from the [MLIR LangRef](LangRef.md). from the [MLIR LangRef](LangRef.md).
### Attributes ### Attributes
Attributes are the mechanism for specifying constant data on operations in Attributes are the mechanism for specifying constant data on operations in
places where a variable is never allowed - e.g. the comparison predicate of a places where a variable is never allowed - e.g. the comparison predicate of a
[`arith.cmpi` operation](Dialects/ArithmeticOps.md#arithcmpi-mlirarithcmpiop), or [`arith.cmpi` operation](Dialects/ArithOps.md#arithcmpi-mlirarithcmpiop), or
the underlying value of a [`arith.constant` operation](Dialects/ArithmeticOps.md#arithconstant-mlirarithconstantop). the underlying value of a [`arith.constant` operation](Dialects/ArithOps.md#arithconstant-mlirarithconstantop).
Each operation has an attribute dictionary, which associates a set of attribute Each operation has an attribute dictionary, which associates a set of attribute
names to attribute values. names to attribute values.
### Types ### Types
Every SSA value, such as operation results or block arguments, in MLIR has a type Every SSA value, such as operation results or block arguments, in MLIR has a type
defined by the type system. MLIR has an open type system with no fixed list of types, defined by the type system. MLIR has an open type system with no fixed list of types,
and there are no restrictions on the abstractions they represent. For example, take and there are no restrictions on the abstractions they represent. For example, take
the following [Arithmetic AddI operation](Dialects/ArithmeticOps.md#arithaddi-mlirarithaddiop): the following [Arithmetic AddI operation](Dialects/ArithOps.md#arithaddi-mlirarithaddiop):
```mlir ```mlir
%result = arith.addi %lhs, %rhs : i64 %result = arith.addi %lhs, %rhs : i64
``` ```
It takes two input SSA values (`%lhs` and `%rhs`), and returns a single SSA It takes two input SSA values (`%lhs` and `%rhs`), and returns a single SSA
value (`%result`). The inputs and outputs of this operation are of type `i64`, value (`%result`). The inputs and outputs of this operation are of type `i64`,
which is an instance of the [Builtin IntegerType](Dialects/Builtin.md#integertype). which is an instance of the [Builtin IntegerType](Dialects/Builtin.md#integertype).
▲ Show 20 Lines • Show All 1,119 Lines • Show Last 20 Lines

mlir/docs/DefiningDialects.md

# Defining Dialects # Defining Dialects
This document describes how to define [Dialects](LangRef.md/#dialects). This document describes how to define [Dialects](LangRef.md/#dialects).
[TOC] [TOC]
## LangRef Refresher ## LangRef Refresher
Before diving into how to define these constructs, below is a quick refresher Before diving into how to define these constructs, below is a quick refresher
from the [MLIR LangRef](LangRef.md). from the [MLIR LangRef](LangRef.md).
Dialects are the mechanism by which to engage with and extend the MLIR Dialects are the mechanism by which to engage with and extend the MLIR
ecosystem. They allow for defining new [attributes](LangRef.md#attributes), ecosystem. They allow for defining new [attributes](LangRef.md#attributes),
[operations](LangRef.md#operations), and [types](LangRef.md#type-system). [operations](LangRef.md#operations), and [types](LangRef.md#type-system).
Dialects are used to model a variety of different abstractions; from traditional Dialects are used to model a variety of different abstractions; from traditional
[arithmetic](Dialects/ArithmeticOps.md) to [arithmetic](Dialects/ArithOps.md) to
[pattern rewrites](Dialects/PDLOps.md); and is one of the most fundamental [pattern rewrites](Dialects/PDLOps.md); and is one of the most fundamental
aspects of MLIR. aspects of MLIR.
## Defining a Dialect ## Defining a Dialect
At the most fundamental level, defining a dialect in MLIR is as simple as At the most fundamental level, defining a dialect in MLIR is as simple as
specializing the specializing the
[C++ `Dialect` class](https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/IR/Dialect.h). [C++ `Dialect` class](https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/IR/Dialect.h).
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
generally relies on the components of another dialect, a dialect dependency should be explicitly generally relies on the components of another dialect, a dialect dependency should be explicitly
recorded. An explicitly dependency ensures that dependent dialects are loaded alongside the recorded. An explicitly dependency ensures that dependent dialects are loaded alongside the
dialect. Dialect dependencies can be recorded using the `dependentDialects` dialects field: dialect. Dialect dependencies can be recorded using the `dependentDialects` dialects field:
```tablegen ```tablegen
def MyDialect : Dialect { def MyDialect : Dialect {
// Here we register the Arithmetic and Func dialect as dependencies of our `MyDialect`. // Here we register the Arithmetic and Func dialect as dependencies of our `MyDialect`.
let dependentDialects = [ let dependentDialects = [
"arith::ArithmeticDialect", "arith::ArithDialect",
"func::FuncDialect" "func::FuncDialect"
]; ];
} }
``` ```
### Extra declarations ### Extra declarations
The declarative Dialect definitions try to auto-generate as much logic and methods The declarative Dialect definitions try to auto-generate as much logic and methods
▲ Show 20 Lines • Show All 590 Lines • Show Last 20 Lines

mlir/docs/Dialects/SPIR-V.md

Show First 20 Lines • Show All 1,073 Lines • ▼ Show 20 Lines
method `mlir::spirv::getBuiltinVariableValue` creates a `spirv.GlobalVariable` for method `mlir::spirv::getBuiltinVariableValue` creates a `spirv.GlobalVariable` for
the builtin in the current `spirv.module` if it does not exist already, and the builtin in the current `spirv.module` if it does not exist already, and
returns an SSA value generated from an `spirv.mlir.addressof` operation. returns an SSA value generated from an `spirv.mlir.addressof` operation.
### Current conversions to SPIR-V ### Current conversions to SPIR-V
Using the above infrastructure, conversions are implemented from Using the above infrastructure, conversions are implemented from
* [Arithmetic Dialect][MlirArithmeticDialect] * [Arith Dialect][MlirArithDialect]
* [GPU Dialect][MlirGpuDialect] : A gpu.module is converted to a `spirv.module`. * [GPU Dialect][MlirGpuDialect] : A gpu.module is converted to a `spirv.module`.
A gpu.function within this module is lowered as an entry function. A gpu.function within this module is lowered as an entry function.
## Code organization ## Code organization
We aim to provide multiple libraries with clear dependencies for SPIR-V related We aim to provide multiple libraries with clear dependencies for SPIR-V related
functionalities in MLIR so developers can just choose the needed components functionalities in MLIR so developers can just choose the needed components
without pulling in the whole world. without pulling in the whole world.
▲ Show 20 Lines • Show All 341 Lines • Show Last 20 Lines

mlir/docs/Dialects/Vector.md

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
reasonable to have the same levels of abstraction for all targets and perform reasonable to have the same levels of abstraction for all targets and perform
cost-based lowering decisions in MLIR even for `LLVM`. Specialized `CPU` cost-based lowering decisions in MLIR even for `LLVM`. Specialized `CPU`
dialects that would capture specific features not well captured by LLVM peephole dialects that would capture specific features not well captured by LLVM peephole
optimizations of on different types that core MLIR supports (e.g. Scalable optimizations of on different types that core MLIR supports (e.g. Scalable
Vectors) are welcome future extensions. Vectors) are welcome future extensions.
### Virtual Vector Ops ### Virtual Vector Ops
Some existing Arithmetic and Vector Dialect on `n-D` `vector` types comprise: Some existing Arith and Vector Dialect on `n-D` `vector` types comprise:
```mlir ```mlir
// Produces a vector<3x7x8xf32> // Produces a vector<3x7x8xf32>
%a = arith.addf %0, %1 : vector<3x7x8xf32> %a = arith.addf %0, %1 : vector<3x7x8xf32>
// Produces a vector<3x7x8xf32> // Produces a vector<3x7x8xf32>
%b = arith.mulf %0, %1 : vector<3x7x8xf32> %b = arith.mulf %0, %1 : vector<3x7x8xf32>
// Produces a vector<3x7x8xf32> // Produces a vector<3x7x8xf32>
%c = vector.splat %1 : vector<3x7x8xf32> %c = vector.splat %1 : vector<3x7x8xf32>
▲ Show 20 Lines • Show All 395 Lines • Show Last 20 Lines

mlir/docs/LangRef.md

Show First 20 Lines • Show All 738 Lines • ▼ Show 20 Lines
``` ```
attribute-entry ::= (bare-id | string-literal) `=` attribute-value attribute-entry ::= (bare-id | string-literal) `=` attribute-value
attribute-value ::= attribute-alias | dialect-attribute | builtin-attribute attribute-value ::= attribute-alias | dialect-attribute | builtin-attribute
``` ```
Attributes are the mechanism for specifying constant data on operations in Attributes are the mechanism for specifying constant data on operations in
places where a variable is never allowed - e.g. the comparison predicate of a places where a variable is never allowed - e.g. the comparison predicate of a
[`cmpi` operation](Dialects/ArithmeticOps.md#arithcmpi-mlirarithcmpiop). Each operation has an [`cmpi` operation](Dialects/ArithOps.md#arithcmpi-mlirarithcmpiop). Each operation has an
attribute dictionary, which associates a set of attribute names to attribute attribute dictionary, which associates a set of attribute names to attribute
values. MLIR's builtin dialect provides a rich set of values. MLIR's builtin dialect provides a rich set of
[builtin attribute values](#builtin-attribute-values) out of the box (such as [builtin attribute values](#builtin-attribute-values) out of the box (such as
arrays, dictionaries, strings, etc.). Additionally, dialects can define their arrays, dictionaries, strings, etc.). Additionally, dialects can define their
own [dialect attribute values](#dialect-attribute-values). own [dialect attribute values](#dialect-attribute-values).
The top-level attribute dictionary attached to an operation has special The top-level attribute dictionary attached to an operation has special
semantics. The attribute entries are considered to be of two different kinds semantics. The attribute entries are considered to be of two different kinds
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

mlir/docs/Passes.md

Show All 20 Lines
[include "AsyncPasses.md"] [include "AsyncPasses.md"]
## `affine` Dialect Passes ## `affine` Dialect Passes
[include "AffinePasses.md"] [include "AffinePasses.md"]
## `arith` Dialect Passes ## `arith` Dialect Passes
[include "ArithmeticPasses.md"] [include "ArithPasses.md"]
## `func` Dialect Passes ## `func` Dialect Passes
[include "FuncPasses.md"] [include "FuncPasses.md"]
## `gpu` Dialect Passes ## `gpu` Dialect Passes
[include "GPUPasses.md"] [include "GPUPasses.md"]
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

mlir/docs/Rationale/Rationale.md

Show First 20 Lines • Show All 276 Lines • ▼ Show 20 Lines
LLVM 2.0. LLVM 2.0.
Note that this rationale only applies to the "standard ops" dialect in which we Note that this rationale only applies to the "standard ops" dialect in which we
can express an opinion about its design. Other dialects generally try to model can express an opinion about its design. Other dialects generally try to model
an external system, and should aim to reflect its design as closely as possible. an external system, and should aim to reflect its design as closely as possible.
### Splitting floating point vs integer operations ### Splitting floating point vs integer operations
The MLIR "Arithmetic" dialect splits many integer and floating point operations The MLIR "Arith" dialect splits many integer and floating point operations
into different categories, for example `arith.addf` vs `arith.addi` and into different categories, for example `arith.addf` vs `arith.addi` and
`arith.cmpf` vs `arith.cmpi` `arith.cmpf` vs `arith.cmpi`
([following the design of LLVM](http://llvm.org/docs/LangRef.html#binary-operations)). ([following the design of LLVM](http://llvm.org/docs/LangRef.html#binary-operations)).
These instructions *are* polymorphic on the number of elements in the type These instructions *are* polymorphic on the number of elements in the type
though, for example `addf` is used with scalar floats, vectors of floats, and though, for example `addf` is used with scalar floats, vectors of floats, and
tensors of floats (LLVM does the same thing with its scalar/vector types). tensors of floats (LLVM does the same thing with its scalar/vector types).
This split is important because floating point and integer operations are quite This split is important because floating point and integer operations are quite
▲ Show 20 Lines • Show All 772 Lines • Show Last 20 Lines

mlir/docs/Tools/MLIRLSP.md

Show First 20 Lines • Show All 152 Lines • ▼ Show 20 Lines
A PDLL compilation database is a YAML file, conventionally named A PDLL compilation database is a YAML file, conventionally named
`pdll_compile_commands.yml`, that contains a set of `FileInfo` documents `pdll_compile_commands.yml`, that contains a set of `FileInfo` documents
providing information for individiual `.pdll` files. providing information for individiual `.pdll` files.
Example: Example:
```yaml ```yaml
--- !FileInfo: --- !FileInfo:
filepath: "/home/user/llvm/mlir/lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.pdll" filepath: "/home/user/llvm/mlir/lib/Dialect/Arith/IR/ArithCanonicalization.pdll"
includes: "/home/user/llvm/mlir/lib/Dialect/Arithmetic/IR;/home/user/llvm/mlir/include" includes: "/home/user/llvm/mlir/lib/Dialect/Arith/IR;/home/user/llvm/mlir/include"
``` ```
- filepath: <string> - Absolute file path of the file. - filepath: <string> - Absolute file path of the file.
- includes: <string> - Semi-colon delimited list of absolute include - includes: <string> - Semi-colon delimited list of absolute include
directories. directories.
#### Build System Integration #### Build System Integration
▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Lines
A TableGen compilation database is a YAML file, conventionally named A TableGen compilation database is a YAML file, conventionally named
`tablegen_compile_commands.yml`, that contains a set of `FileInfo` documents `tablegen_compile_commands.yml`, that contains a set of `FileInfo` documents
providing information for individiual `.td` files. providing information for individiual `.td` files.
Example: Example:
```yaml ```yaml
--- !FileInfo: --- !FileInfo:
filepath: "/home/user/llvm/mlir/lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.td" filepath: "/home/user/llvm/mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td"
includes: "/home/user/llvm/mlir/lib/Dialect/Arithmetic/IR;/home/user/llvm/mlir/include" includes: "/home/user/llvm/mlir/lib/Dialect/Arith/IR;/home/user/llvm/mlir/include"
``` ```
- filepath: <string> - Absolute file path of the file. - filepath: <string> - Absolute file path of the file.
- includes: <string> - Semi-colon delimited list of absolute include - includes: <string> - Semi-colon delimited list of absolute include
directories. directories.
#### Build System Integration #### Build System Integration
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

mlir/docs/Tutorials/Toy/Ch-5.md

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
* Optionally, a [Type Converter](../../DialectConversion.md/#type-conversion). * Optionally, a [Type Converter](../../DialectConversion.md/#type-conversion).
- If provided, this is used to convert the types of block arguments. We - If provided, this is used to convert the types of block arguments. We
won't be needing this for our conversion. won't be needing this for our conversion.
## Conversion Target ## Conversion Target
For our purposes, we want to convert the compute-intensive `Toy` operations into For our purposes, we want to convert the compute-intensive `Toy` operations into
a combination of operations from the `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects a combination of operations from the `Affine`, `Arith`, `Func`, and `MemRef` dialects
for further optimization. To start off the lowering, we first define our for further optimization. To start off the lowering, we first define our
conversion target: conversion target:
```c++ ```c++
void ToyToAffineLoweringPass::runOnOperation() { void ToyToAffineLoweringPass::runOnOperation() {
// The first thing to define is the conversion target. This will define the // The first thing to define is the conversion target. This will define the
// final target for this lowering. // final target for this lowering.
mlir::ConversionTarget target(getContext()); mlir::ConversionTarget target(getContext());
// We define the specific operations, or dialects, that are legal targets for // We define the specific operations, or dialects, that are legal targets for
// this lowering. In our case, we are lowering to a combination of the // this lowering. In our case, we are lowering to a combination of the
// `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects. // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
target.addLegalDialect<AffineDialect, arith::ArithmeticDialect, target.addLegalDialect<AffineDialect, arith::ArithDialect,
func::FuncDialect, memref::MemRefDialect>(); func::FuncDialect, memref::MemRefDialect>();
// We also define the Toy dialect as Illegal so that the conversion will fail // We also define the Toy dialect as Illegal so that the conversion will fail
// if any of these operations are *not* converted. Given that we actually want // if any of these operations are *not* converted. Given that we actually want
// a partial lowering, we explicitly mark the Toy operations that don't want // a partial lowering, we explicitly mark the Toy operations that don't want
// to lower, `toy.print`, as *legal*. `toy.print` will still need its operands // to lower, `toy.print`, as *legal*. `toy.print` will still need its operands
// to be updated though (as we convert from TensorType to MemRefType), so we // to be updated though (as we convert from TensorType to MemRefType), so we
// only treat it as `legal` if its operands are legal. // only treat it as `legal` if its operands are legal.
▲ Show 20 Lines • Show All 275 Lines • Show Last 20 Lines

mlir/docs/Tutorials/Toy/Ch-6.md

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
to transform them into LLVM dialect. These patterns allow for lowering the IR in to transform them into LLVM dialect. These patterns allow for lowering the IR in
multiple stages by relying on multiple stages by relying on
[transitive lowering](../../../getting_started/Glossary.md/#transitive-lowering). [transitive lowering](../../../getting_started/Glossary.md/#transitive-lowering).
```c++ ```c++
mlir::RewritePatternSet patterns(&getContext()); mlir::RewritePatternSet patterns(&getContext());
mlir::populateAffineToStdConversionPatterns(patterns, &getContext()); mlir::populateAffineToStdConversionPatterns(patterns, &getContext());
mlir::cf::populateSCFToControlFlowConversionPatterns(patterns, &getContext()); mlir::cf::populateSCFToControlFlowConversionPatterns(patterns, &getContext());
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithToLLVMConversionPatterns(typeConverter,
patterns); patterns);
mlir::populateFuncToLLVMConversionPatterns(typeConverter, patterns); mlir::populateFuncToLLVMConversionPatterns(typeConverter, patterns);
mlir::cf::populateControlFlowToLLVMConversionPatterns(patterns, &getContext()); mlir::cf::populateControlFlowToLLVMConversionPatterns(patterns, &getContext());
// The only remaining operation, to lower from the `toy` dialect, is the // The only remaining operation, to lower from the `toy` dialect, is the
// PrintOp. // PrintOp.
patterns.add<PrintOpLowering>(&getContext()); patterns.add<PrintOpLowering>(&getContext());
``` ```
▲ Show 20 Lines • Show All 228 Lines • Show Last 20 Lines

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

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

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

//===- standalone-opt.cpp ---------------------------------------*- C++ -*-===// //===- standalone-opt.cpp ---------------------------------------*- C++ -*-===//
// //
// This file is licensed under the Apache License v2.0 with LLVM Exceptions. // This file is licensed under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/MLIRContext.h" #include "mlir/IR/MLIRContext.h"
#include "mlir/InitAllDialects.h" #include "mlir/InitAllDialects.h"
#include "mlir/InitAllPasses.h" #include "mlir/InitAllPasses.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
#include "mlir/Support/FileUtilities.h" #include "mlir/Support/FileUtilities.h"
#include "mlir/Tools/mlir-opt/MlirOptMain.h" #include "mlir/Tools/mlir-opt/MlirOptMain.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/InitLLVM.h" #include "llvm/Support/InitLLVM.h"
#include "llvm/Support/SourceMgr.h" #include "llvm/Support/SourceMgr.h"
#include "llvm/Support/ToolOutputFile.h" #include "llvm/Support/ToolOutputFile.h"
#include "Standalone/StandaloneDialect.h" #include "Standalone/StandaloneDialect.h"
int main(int argc, char **argv) { int main(int argc, char **argv) {
mlir::registerAllPasses(); mlir::registerAllPasses();
// TODO: Register standalone passes here. // TODO: Register standalone passes here.
mlir::DialectRegistry registry; mlir::DialectRegistry registry;
registry.insert<mlir::standalone::StandaloneDialect, registry.insert<mlir::standalone::StandaloneDialect,
mlir::arith::ArithmeticDialect, mlir::func::FuncDialect>(); mlir::arith::ArithDialect, mlir::func::FuncDialect>();
// Add the following to include *all* MLIR Core dialects, or selectively // Add the following to include *all* MLIR Core dialects, or selectively
// include what you need like above. You only need to register dialects that // include what you need like above. You only need to register dialects that
// will be *parsed* by the tool, not the one generated // will be *parsed* by the tool, not the one generated
// registerAllDialects(registry); // registerAllDialects(registry);
return mlir::asMainReturnCode( return mlir::asMainReturnCode(
mlir::MlirOptMain(argc, argv, "Standalone optimizer driver\n", registry)); mlir::MlirOptMain(argc, argv, "Standalone optimizer driver\n", registry));
} }

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp

Show All 11 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/IR/BuiltinDialect.h" #include "mlir/IR/BuiltinDialect.h"
#include "toy/Dialect.h" #include "toy/Dialect.h"
#include "toy/Passes.h" #include "toy/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 293 Lines • ▼ Show 20 Lines
void ToyToAffineLoweringPass::runOnOperation() { void ToyToAffineLoweringPass::runOnOperation() {
// The first thing to define is the conversion target. This will define the // The first thing to define is the conversion target. This will define the
// final target for this lowering. // final target for this lowering.
ConversionTarget target(getContext()); ConversionTarget target(getContext());
// We define the specific operations, or dialects, that are legal targets for // We define the specific operations, or dialects, that are legal targets for
// this lowering. In our case, we are lowering to a combination of the // this lowering. In our case, we are lowering to a combination of the
// `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects. // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
target target.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithDialect,
.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithmeticDialect,
func::FuncDialect, memref::MemRefDialect>(); func::FuncDialect, memref::MemRefDialect>();
// We also define the Toy dialect as Illegal so that the conversion will fail // We also define the Toy dialect as Illegal so that the conversion will fail
// if any of these operations are *not* converted. Given that we actually want // if any of these operations are *not* converted. Given that we actually want
// a partial lowering, we explicitly mark the Toy operations that don't want // a partial lowering, we explicitly mark the Toy operations that don't want
// to lower, `toy.print`, as `legal`. `toy.print` will still need its operands // to lower, `toy.print`, as `legal`. `toy.print` will still need its operands
// to be updated though (as we convert from TensorType to MemRefType), so we // to be updated though (as we convert from TensorType to MemRefType), so we
// only treat it as `legal` if its operands are legal. // only treat it as `legal` if its operands are legal.
target.addIllegalDialect<toy::ToyDialect>(); target.addIllegalDialect<toy::ToyDialect>();
Show All 25 Lines

mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp

Show All 11 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/IR/BuiltinDialect.h" #include "mlir/IR/BuiltinDialect.h"
#include "toy/Dialect.h" #include "toy/Dialect.h"
#include "toy/Passes.h" #include "toy/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 293 Lines • ▼ Show 20 Lines
void ToyToAffineLoweringPass::runOnOperation() { void ToyToAffineLoweringPass::runOnOperation() {
// The first thing to define is the conversion target. This will define the // The first thing to define is the conversion target. This will define the
// final target for this lowering. // final target for this lowering.
ConversionTarget target(getContext()); ConversionTarget target(getContext());
// We define the specific operations, or dialects, that are legal targets for // We define the specific operations, or dialects, that are legal targets for
// this lowering. In our case, we are lowering to a combination of the // this lowering. In our case, we are lowering to a combination of the
// `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects. // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
target target.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithDialect,
.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithmeticDialect,
func::FuncDialect, memref::MemRefDialect>(); func::FuncDialect, memref::MemRefDialect>();
// We also define the Toy dialect as Illegal so that the conversion will fail // We also define the Toy dialect as Illegal so that the conversion will fail
// if any of these operations are *not* converted. Given that we actually want // if any of these operations are *not* converted. Given that we actually want
// a partial lowering, we explicitly mark the Toy operations that don't want // a partial lowering, we explicitly mark the Toy operations that don't want
// to lower, `toy.print`, as `legal`. `toy.print` will still need its operands // to lower, `toy.print`, as `legal`. `toy.print` will still need its operands
// to be updated though (as we convert from TensorType to MemRefType), so we // to be updated though (as we convert from TensorType to MemRefType), so we
// only treat it as `legal` if its operands are legal. // only treat it as `legal` if its operands are legal.
target.addIllegalDialect<toy::ToyDialect>(); target.addIllegalDialect<toy::ToyDialect>();
Show All 25 Lines

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

Show All 20 Lines
// 'toy.print' --> Loop (SCF) -- // 'toy.print' --> Loop (SCF) --
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "toy/Dialect.h" #include "toy/Dialect.h"
#include "toy/Passes.h" #include "toy/Passes.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h" #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
▲ Show 20 Lines • Show All 153 Lines • ▼ Show 20 Linesvoid ToyToLLVMLoweringPass::runOnOperation() {
// are already exists a set of patterns to transform `affine` and `std` // are already exists a set of patterns to transform `affine` and `std`
// dialects. These patterns lowering in multiple stages, relying on transitive // dialects. These patterns lowering in multiple stages, relying on transitive
// lowerings. Transitive lowering, or A->B->C lowering, is when multiple // lowerings. Transitive lowering, or A->B->C lowering, is when multiple
// patterns must be applied to fully transform an illegal operation into a // patterns must be applied to fully transform an illegal operation into a
// set of legal ones. // set of legal ones.
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns); populateAffineToStdConversionPatterns(patterns);
populateSCFToControlFlowConversionPatterns(patterns); populateSCFToControlFlowConversionPatterns(patterns);
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns); cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
populateFuncToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
// The only remaining operation to lower from the `toy` dialect, is the // The only remaining operation to lower from the `toy` dialect, is the
// PrintOp. // PrintOp.
patterns.add<PrintOpLowering>(&getContext()); patterns.add<PrintOpLowering>(&getContext());
Show All 12 Lines

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

Show All 11 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/IR/BuiltinDialect.h" #include "mlir/IR/BuiltinDialect.h"
#include "toy/Dialect.h" #include "toy/Dialect.h"
#include "toy/Passes.h" #include "toy/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 293 Lines • ▼ Show 20 Lines
void ToyToAffineLoweringPass::runOnOperation() { void ToyToAffineLoweringPass::runOnOperation() {
// The first thing to define is the conversion target. This will define the // The first thing to define is the conversion target. This will define the
// final target for this lowering. // final target for this lowering.
ConversionTarget target(getContext()); ConversionTarget target(getContext());
// We define the specific operations, or dialects, that are legal targets for // We define the specific operations, or dialects, that are legal targets for
// this lowering. In our case, we are lowering to a combination of the // this lowering. In our case, we are lowering to a combination of the
// `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects. // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
target target.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithDialect,
.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithmeticDialect,
func::FuncDialect, memref::MemRefDialect>(); func::FuncDialect, memref::MemRefDialect>();
// We also define the Toy dialect as Illegal so that the conversion will fail // We also define the Toy dialect as Illegal so that the conversion will fail
// if any of these operations are *not* converted. Given that we actually want // if any of these operations are *not* converted. Given that we actually want
// a partial lowering, we explicitly mark the Toy operations that don't want // a partial lowering, we explicitly mark the Toy operations that don't want
// to lower, `toy.print`, as `legal`. `toy.print` will still need its operands // to lower, `toy.print`, as `legal`. `toy.print` will still need its operands
// to be updated though (as we convert from TensorType to MemRefType), so we // to be updated though (as we convert from TensorType to MemRefType), so we
// only treat it as `legal` if its operands are legal. // only treat it as `legal` if its operands are legal.
target.addIllegalDialect<toy::ToyDialect>(); target.addIllegalDialect<toy::ToyDialect>();
Show All 25 Lines

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

Show All 20 Lines
// 'toy.print' --> Loop (SCF) -- // 'toy.print' --> Loop (SCF) --
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "toy/Dialect.h" #include "toy/Dialect.h"
#include "toy/Passes.h" #include "toy/Passes.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h" #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
▲ Show 20 Lines • Show All 153 Lines • ▼ Show 20 Linesvoid ToyToLLVMLoweringPass::runOnOperation() {
// are already exists a set of patterns to transform `affine` and `std` // are already exists a set of patterns to transform `affine` and `std`
// dialects. These patterns lowering in multiple stages, relying on transitive // dialects. These patterns lowering in multiple stages, relying on transitive
// lowerings. Transitive lowering, or A->B->C lowering, is when multiple // lowerings. Transitive lowering, or A->B->C lowering, is when multiple
// patterns must be applied to fully transform an illegal operation into a // patterns must be applied to fully transform an illegal operation into a
// set of legal ones. // set of legal ones.
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns); populateAffineToStdConversionPatterns(patterns);
populateSCFToControlFlowConversionPatterns(patterns); populateSCFToControlFlowConversionPatterns(patterns);
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns); cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
populateFuncToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
// The only remaining operation to lower from the `toy` dialect, is the // The only remaining operation to lower from the `toy` dialect, is the
// PrintOp. // PrintOp.
patterns.add<PrintOpLowering>(&getContext()); patterns.add<PrintOpLowering>(&getContext());
Show All 12 Lines

mlir/include/mlir/Conversion/ArithToLLVM/ArithToLLVM.h

  • This file was moved from mlir/include/mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h.
//===- ArithmeticToLLVM.h - Arith to LLVM dialect conversion ----*- C++ -*-===// //===- ArithToLLVM.h - Arith to LLVM dialect conversion ----*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_ARITHMETICTOLLVM_ARITHMETICTOLLVM_H #ifndef MLIR_CONVERSION_ARITHTOLLVM_ARITHTOLLVM_H
#define MLIR_CONVERSION_ARITHMETICTOLLVM_ARITHMETICTOLLVM_H #define MLIR_CONVERSION_ARITHTOLLVM_ARITHTOLLVM_H
#include <memory> #include <memory>
namespace mlir { namespace mlir {
class LLVMTypeConverter; class LLVMTypeConverter;
class RewritePatternSet; class RewritePatternSet;
class Pass; class Pass;
#define GEN_PASS_DECL_ARITHMETICTOLLVMCONVERSIONPASS #define GEN_PASS_DECL_ARITHTOLLVMCONVERSIONPASS
#include "mlir/Conversion/Passes.h.inc" #include "mlir/Conversion/Passes.h.inc"
namespace arith { namespace arith {
void populateArithmeticToLLVMConversionPatterns(LLVMTypeConverter &converter, void populateArithToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns); RewritePatternSet &patterns);
} // namespace arith } // namespace arith
} // namespace mlir } // namespace mlir
#endif // MLIR_CONVERSION_ARITHMETICTOLLVM_ARITHMETICTOLLVM_H #endif // MLIR_CONVERSION_ARITHTOLLVM_ARITHTOLLVM_H

mlir/include/mlir/Conversion/ArithToSPIRV/ArithToSPIRV.h

  • This file was added.
//===- ArithToSPIRV.h - Convert Arith to SPIRV dialect -----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_ARITHTOSPIRV_ARITHTOSPIRV_H
#define MLIR_CONVERSION_ARITHTOSPIRV_ARITHTOSPIRV_H
#include "mlir/Pass/Pass.h"
#include <memory>
namespace mlir {
class SPIRVTypeConverter;
class RewritePatternSet;
class Pass;
#define GEN_PASS_DECL_CONVERTARITHTOSPIRV
#include "mlir/Conversion/Passes.h.inc"
namespace arith {
void populateArithToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
RewritePatternSet &patterns);
std::unique_ptr<OperationPass<>> createConvertArithToSPIRVPass();
} // namespace arith
} // namespace mlir
#endif // MLIR_CONVERSION_ARITHTOSPIRV_ARITHTOSPIRV_H

mlir/include/mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h

  • This file was moved to mlir/include/mlir/Conversion/ArithToLLVM/ArithToLLVM.h.

mlir/include/mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h

  • This file was deleted.
//===- ArithmeticToSPIRV.h - Convert Arith to SPIRV dialect -----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_ARITHMETICTOSPIRV_ARITHMETICTOSPIRV_H
#define MLIR_CONVERSION_ARITHMETICTOSPIRV_ARITHMETICTOSPIRV_H
#include "mlir/Pass/Pass.h"
#include <memory>
namespace mlir {
class SPIRVTypeConverter;
class RewritePatternSet;
class Pass;
#define GEN_PASS_DECL_CONVERTARITHMETICTOSPIRV
#include "mlir/Conversion/Passes.h.inc"
namespace arith {
void populateArithmeticToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
RewritePatternSet &patterns);
std::unique_ptr<OperationPass<>> createConvertArithmeticToSPIRVPass();
} // namespace arith
} // namespace mlir
#endif // MLIR_CONVERSION_ARITHMETICTOSPIRV_ARITHMETICTOSPIRV_H

mlir/include/mlir/Conversion/Passes.h

//===- Passes.h - Conversion Pass Construction and Registration -----------===// //===- Passes.h - Conversion Pass Construction and Registration -----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_PASSES_H #ifndef MLIR_CONVERSION_PASSES_H
#define MLIR_CONVERSION_PASSES_H #define MLIR_CONVERSION_PASSES_H
#include "mlir/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.h" #include "mlir/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h" #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h" #include "mlir/Conversion/ArithToSPIRV/ArithToSPIRV.h"
#include "mlir/Conversion/ArmNeon2dToIntr/ArmNeon2dToIntr.h" #include "mlir/Conversion/ArmNeon2dToIntr/ArmNeon2dToIntr.h"
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h" #include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
#include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h" #include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h"
#include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h" #include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h"
#include "mlir/Conversion/ComplexToLibm/ComplexToLibm.h" #include "mlir/Conversion/ComplexToLibm/ComplexToLibm.h"
#include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h" #include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h" #include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h"
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

mlir/include/mlir/Conversion/Passes.td

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines let dependentDialects = [
"ROCDL::ROCDLDialect", "ROCDL::ROCDLDialect",
]; ];
let options = [Option<"chipset", "chipset", "std::string", let options = [Option<"chipset", "chipset", "std::string",
/*default=*/"\"gfx000\"", /*default=*/"\"gfx000\"",
"Chipset that these operations will run on">]; "Chipset that these operations will run on">];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ArithmeticToLLVM // ArithToLLVM
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ArithmeticToLLVMConversionPass : Pass<"convert-arith-to-llvm"> { def ArithToLLVMConversionPass : Pass<"convert-arith-to-llvm"> {
tpoppUnsubmitted
Not Done
ReplyInline Actions

Just a warning that you'll have merge conflicts with this change: https://reviews.llvm.org/D134752

tpopp: Just a warning that you'll have merge conflicts with this change: https://reviews.llvm.
let summary = "Convert Arithmetic dialect to LLVM dialect"; let summary = "Convert Arith dialect to LLVM dialect";
let description = [{ let description = [{
This pass converts supported Arithmetic ops to LLVM dialect instructions. This pass converts supported Arith ops to LLVM dialect instructions.
}]; }];
let dependentDialects = ["LLVM::LLVMDialect"]; let dependentDialects = ["LLVM::LLVMDialect"];
let options = [ let options = [
Option<"indexBitwidth", "index-bitwidth", "unsigned", Option<"indexBitwidth", "index-bitwidth", "unsigned",
/*default=kDeriveIndexBitwidthFromDataLayout*/"0", /*default=kDeriveIndexBitwidthFromDataLayout*/"0",
"Bitwidth of the index type, 0 to use size of machine word">, "Bitwidth of the index type, 0 to use size of machine word">,
]; ];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ArithmeticToSPIRV // ArithToSPIRV
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertArithmeticToSPIRV : Pass<"convert-arith-to-spirv"> { def ConvertArithToSPIRV : Pass<"convert-arith-to-spirv"> {
let summary = "Convert Arithmetic dialect to SPIR-V dialect"; let summary = "Convert Arith dialect to SPIR-V dialect";
let constructor = "mlir::arith::createConvertArithmeticToSPIRVPass()"; let constructor = "mlir::arith::createConvertArithToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"]; let dependentDialects = ["spirv::SPIRVDialect"];
let options = [ let options = [
Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types", Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
"bool", /*default=*/"true", "bool", /*default=*/"true",
"Emulate non-32-bit scalar types with 32-bit ones if " "Emulate non-32-bit scalar types with 32-bit ones if "
"missing native support">, "missing native support">,
Option<"enableFastMath", "enable-fast-math", Option<"enableFastMath", "enable-fast-math",
"bool", /*default=*/"false", "bool", /*default=*/"false",
Show All 20 Linesdef ConvertAsyncToLLVM : Pass<"convert-async-to-llvm", "ModuleOp"> {
let summary = "Convert the operations from the async dialect into the LLVM " let summary = "Convert the operations from the async dialect into the LLVM "
"dialect"; "dialect";
let description = [{ let description = [{
Convert `async.execute` operations to LLVM coroutines and use async runtime Convert `async.execute` operations to LLVM coroutines and use async runtime
API to execute them. API to execute them.
}]; }];
let constructor = "mlir::createConvertAsyncToLLVMPass()"; let constructor = "mlir::createConvertAsyncToLLVMPass()";
let dependentDialects = [ let dependentDialects = [
"arith::ArithmeticDialect", "arith::ArithDialect",
"async::AsyncDialect", "async::AsyncDialect",
"LLVM::LLVMDialect", "LLVM::LLVMDialect",
]; ];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// BufferizationToMemRef // BufferizationToMemRef
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 21 Lines let description = [{
e.g.). e.g.).
Note that this pass only transforms the operation without any further Note that this pass only transforms the operation without any further
analyses. This pass does not consider any memory analysis or optimization analyses. This pass does not consider any memory analysis or optimization
and hence does not resolve any memory leaks. and hence does not resolve any memory leaks.
}]; }];
let constructor = "mlir::createBufferizationToMemRefPass()"; let constructor = "mlir::createBufferizationToMemRefPass()";
let dependentDialects = ["arith::ArithmeticDialect", "memref::MemRefDialect"]; let dependentDialects = ["arith::ArithDialect", "memref::MemRefDialect"];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ComplexToLLVM // ComplexToLLVM
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertComplexToLLVM : Pass<"convert-complex-to-llvm"> { def ConvertComplexToLLVM : Pass<"convert-complex-to-llvm"> {
let summary = "Convert Complex dialect to LLVM dialect"; let summary = "Convert Complex dialect to LLVM dialect";
▲ Show 20 Lines • Show All 279 Lines • ▼ Show 20 Lines
def ConvertMathToLibm : Pass<"convert-math-to-libm", "ModuleOp"> { def ConvertMathToLibm : Pass<"convert-math-to-libm", "ModuleOp"> {
let summary = "Convert Math dialect to libm calls"; let summary = "Convert Math dialect to libm calls";
let description = [{ let description = [{
This pass converts supported Math ops to libm calls. This pass converts supported Math ops to libm calls.
}]; }];
let constructor = "mlir::createConvertMathToLibmPass()"; let constructor = "mlir::createConvertMathToLibmPass()";
let dependentDialects = [ let dependentDialects = [
"arith::ArithmeticDialect", "arith::ArithDialect",
"func::FuncDialect", "func::FuncDialect",
"vector::VectorDialect", "vector::VectorDialect",
]; ];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// MathToLLVM // MathToLLVM
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 25 Linesdef ConvertMathToFuncs : Pass<"convert-math-to-funcs", "ModuleOp"> {
let summary = "Convert Math operations to calls of outlined implementations."; let summary = "Convert Math operations to calls of outlined implementations.";
let description = [{ let description = [{
This pass converts supported Math ops to calls of compiler generated This pass converts supported Math ops to calls of compiler generated
functions implementing these operations in software. functions implementing these operations in software.
The LLVM dialect is used for LinkonceODR linkage of the generated functions. The LLVM dialect is used for LinkonceODR linkage of the generated functions.
}]; }];
let constructor = "mlir::createConvertMathToFuncsPass()"; let constructor = "mlir::createConvertMathToFuncsPass()";
let dependentDialects = [ let dependentDialects = [
"arith::ArithmeticDialect", "arith::ArithDialect",
"cf::ControlFlowDialect", "cf::ControlFlowDialect",
"func::FuncDialect", "func::FuncDialect",
"vector::VectorDialect", "vector::VectorDialect",
"LLVM::LLVMDialect", "LLVM::LLVMDialect",
]; ];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 233 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TensorToLinalg // TensorToLinalg
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertTensorToLinalg : Pass<"convert-tensor-to-linalg", "ModuleOp"> { def ConvertTensorToLinalg : Pass<"convert-tensor-to-linalg", "ModuleOp"> {
let summary = "Convert some Tensor dialect ops to Linalg dialect"; let summary = "Convert some Tensor dialect ops to Linalg dialect";
let constructor = "mlir::createConvertTensorToLinalgPass()"; let constructor = "mlir::createConvertTensorToLinalgPass()";
let dependentDialects = [ let dependentDialects = [
"arith::ArithmeticDialect", "arith::ArithDialect",
"linalg::LinalgDialect", "linalg::LinalgDialect",
]; ];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TensorToSPIRV // TensorToSPIRV
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TosaToArith // TosaToArith
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def TosaToArith : Pass<"tosa-to-arith"> { def TosaToArith : Pass<"tosa-to-arith"> {
let summary = "Lower TOSA to the Arith dialect"; let summary = "Lower TOSA to the Arith dialect";
let dependentDialects = [ let dependentDialects = [
"arith::ArithmeticDialect", "arith::ArithDialect",
]; ];
let description = [{ let description = [{
Pass that converts TOSA operations to the equivalent operations using the Pass that converts TOSA operations to the equivalent operations using the
operations in the Arith dialect. The ApplyScale operator is optionally operations in the Arith dialect. The ApplyScale operator is optionally
included as it is often preserved until the final invocation. included as it is often preserved until the final invocation.
}]; }];
let options = [ let options = [
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Affine/Analysis/AffineAnalysis.h

Show All 9 Lines
// involving affine structures (AffineExprStorage, AffineMap, IntegerSet, etc.) // involving affine structures (AffineExprStorage, AffineMap, IntegerSet, etc.)
// and other IR structures that in turn use these. // and other IR structures that in turn use these.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_AFFINE_ANALYSIS_AFFINEANALYSIS_H #ifndef MLIR_DIALECT_AFFINE_ANALYSIS_AFFINEANALYSIS_H
#define MLIR_DIALECT_AFFINE_ANALYSIS_AFFINEANALYSIS_H #define MLIR_DIALECT_AFFINE_ANALYSIS_AFFINEANALYSIS_H
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Value.h" #include "mlir/IR/Value.h"
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
namespace mlir { namespace mlir {
class AffineApplyOp; class AffineApplyOp;
class AffineForOp; class AffineForOp;
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Affine/IR/AffineOps.h

Show All 9 Lines
// in the MLIR operation set. // in the MLIR operation set.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_AFFINE_IR_AFFINEOPS_H #ifndef MLIR_DIALECT_AFFINE_IR_AFFINEOPS_H
#define MLIR_DIALECT_AFFINE_IR_AFFINEOPS_H #define MLIR_DIALECT_AFFINE_IR_AFFINEOPS_H
#include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.h" #include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h" #include "mlir/Interfaces/ControlFlowInterfaces.h"
#include "mlir/Interfaces/LoopLikeInterface.h" #include "mlir/Interfaces/LoopLikeInterface.h"
namespace mlir { namespace mlir {
class AffineApplyOp; class AffineApplyOp;
class AffineBound; class AffineBound;
▲ Show 20 Lines • Show All 492 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

//===- AffineOps.td - Affine operation definitions ---------*- tablegen -*-===// //===- AffineOps.td - Affine operation definitions ---------*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Defines MLIR affine operations. // Defines MLIR affine operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef AFFINE_OPS #ifndef AFFINE_OPS
#define AFFINE_OPS #define AFFINE_OPS
include "mlir/Dialect/Arithmetic/IR/ArithmeticBase.td" include "mlir/Dialect/Arith/IR/ArithBase.td"
include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.td" include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.td"
include "mlir/Interfaces/ControlFlowInterfaces.td" include "mlir/Interfaces/ControlFlowInterfaces.td"
include "mlir/Interfaces/LoopLikeInterface.td" include "mlir/Interfaces/LoopLikeInterface.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
def Affine_Dialect : Dialect { def Affine_Dialect : Dialect {
let name = "affine"; let name = "affine";
let cppNamespace = "mlir"; let cppNamespace = "mlir";
let hasConstantMaterializer = 1; let hasConstantMaterializer = 1;
let dependentDialects = ["arith::ArithmeticDialect"]; let dependentDialects = ["arith::ArithDialect"];
} }
// Base class for Affine dialect ops. // Base class for Affine dialect ops.
class Affine_Op<string mnemonic, list<Trait> traits = []> : class Affine_Op<string mnemonic, list<Trait> traits = []> :
Op<Affine_Dialect, mnemonic, traits>; Op<Affine_Dialect, mnemonic, traits>;
// Require regions to have affine.yield. // Require regions to have affine.yield.
def ImplicitAffineTerminator def ImplicitAffineTerminator
▲ Show 20 Lines • Show All 1,071 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Affine/Passes.td

Show First 20 Lines • Show All 382 Lines • ▼ Show 20 Linesdef AffineLoopNormalize : Pass<"affine-loop-normalize", "func::FuncOp"> {
let summary = "Apply normalization transformations to affine loop-like ops"; let summary = "Apply normalization transformations to affine loop-like ops";
let constructor = "mlir::createAffineLoopNormalizePass()"; let constructor = "mlir::createAffineLoopNormalizePass()";
} }
def LoopCoalescing : Pass<"affine-loop-coalescing", "func::FuncOp"> { def LoopCoalescing : Pass<"affine-loop-coalescing", "func::FuncOp"> {
let summary = "Coalesce nested loops with independent bounds into a single " let summary = "Coalesce nested loops with independent bounds into a single "
"loop"; "loop";
let constructor = "mlir::createLoopCoalescingPass()"; let constructor = "mlir::createLoopCoalescingPass()";
let dependentDialects = ["arith::ArithmeticDialect"]; let dependentDialects = ["arith::ArithDialect"];
} }
def SimplifyAffineStructures : Pass<"affine-simplify-structures", "func::FuncOp"> { def SimplifyAffineStructures : Pass<"affine-simplify-structures", "func::FuncOp"> {
let summary = "Simplify affine expressions in maps/sets and normalize " let summary = "Simplify affine expressions in maps/sets and normalize "
"memrefs"; "memrefs";
let constructor = "mlir::createSimplifyAffineStructuresPass()"; let constructor = "mlir::createSimplifyAffineStructuresPass()";
} }
def AffineExpandIndexOps : Pass<"affine-expand-index-ops"> { def AffineExpandIndexOps : Pass<"affine-expand-index-ops"> {
let summary = "Lower affine operations operating on indices into more fundamental operations"; let summary = "Lower affine operations operating on indices into more fundamental operations";
let constructor = "mlir::createAffineExpandIndexOpsPass()"; let constructor = "mlir::createAffineExpandIndexOpsPass()";
} }
#endif // MLIR_DIALECT_AFFINE_PASSES #endif // MLIR_DIALECT_AFFINE_PASSES

mlir/include/mlir/Dialect/Arith/CMakeLists.txt

  • This file was moved from mlir/include/mlir/Dialect/Arithmetic/CMakeLists.txt.
The contents of this file were not changed.

mlir/include/mlir/Dialect/Arith/IR/Arith.h

  • This file was moved from mlir/include/mlir/Dialect/Arithmetic/IR/Arithmetic.h.
//===- Arithmetic.h - Arithmetic dialect --------------------------*- C++-*-==// //===- Arith.h - Arith dialect ----0000000000----------------------*- C++-*-==//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_ARITHMETIC_IR_ARITHMETIC_H_ #ifndef MLIR_DIALECT_ARITH_IR_ARITH_H_
#define MLIR_DIALECT_ARITHMETIC_IR_ARITHMETIC_H_ #define MLIR_DIALECT_ARITH_IR_ARITH_H_
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/OpDefinition.h" #include "mlir/IR/OpDefinition.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
#include "mlir/Interfaces/CastInterfaces.h" #include "mlir/Interfaces/CastInterfaces.h"
#include "mlir/Interfaces/InferIntRangeInterface.h" #include "mlir/Interfaces/InferIntRangeInterface.h"
#include "mlir/Interfaces/InferTypeOpInterface.h" #include "mlir/Interfaces/InferTypeOpInterface.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
#include "mlir/Interfaces/VectorInterfaces.h" #include "mlir/Interfaces/VectorInterfaces.h"
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ArithmeticDialect // ArithDialect
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/ArithmeticOpsDialect.h.inc" #include "mlir/Dialect/Arith/IR/ArithOpsDialect.h.inc"
csiggUnsubmitted
Not Done
ReplyInline Actions

Could we have a type alias (using ArithmeticDialect = ArithDialect;) to help with the transition?

Maybe you already added it somewhere, I haven't checked all the files.

csigg: Could we have a type alias (`using ArithmeticDialect = ArithDialect;`) to help with the…
kuharAuthorUnsubmitted
Done
ReplyInline Actions

Sure, I can add this if it makes it easier to import this change

kuhar: Sure, I can add this if it makes it easier to import this change
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Arithmetic Dialect Enum Attributes // Arith Dialect Enum Attributes
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/ArithmeticOpsEnums.h.inc" #include "mlir/Dialect/Arith/IR/ArithOpsEnums.h.inc"
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Arithmetic Dialect Operations // Arith Dialect Operations
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.h.inc" #include "mlir/Dialect/Arith/IR/ArithOps.h.inc"
namespace mlir { namespace mlir {
namespace arith { namespace arith {
/// Specialization of `arith.constant` op that returns an integer value. /// Specialization of `arith.constant` op that returns an integer value.
class ConstantIntOp : public arith::ConstantOp { class ConstantIntOp : public arith::ConstantOp {
public: public:
using arith::ConstantOp::ConstantOp; using arith::ConstantOp::ConstantOp;
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
/// associated with a binary AtomicRMWKind op to `lhs` and `rhs`. /// associated with a binary AtomicRMWKind op to `lhs` and `rhs`.
Value getReductionOp(AtomicRMWKind op, OpBuilder &builder, Location loc, Value getReductionOp(AtomicRMWKind op, OpBuilder &builder, Location loc,
Value lhs, Value rhs); Value lhs, Value rhs);
arith::CmpIPredicate invertPredicate(arith::CmpIPredicate pred); arith::CmpIPredicate invertPredicate(arith::CmpIPredicate pred);
} // namespace arith } // namespace arith
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_ARITHMETIC_IR_ARITHMETIC_H_ #endif // MLIR_DIALECT_ARITH_IR_ARITH_H_

mlir/include/mlir/Dialect/Arith/IR/ArithBase.td

  • This file was moved from mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td.
//===- ArithmeticBase.td - Base defs for arith dialect ------*- tablegen -*-==// //===- ArithBase.td - Base defs for arith dialect -----------*- tablegen -*-==//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef ARITHMETIC_BASE #ifndef ARITH_BASE
#define ARITHMETIC_BASE #define ARITH_BASE
include "mlir/IR/EnumAttr.td" include "mlir/IR/EnumAttr.td"
include "mlir/IR/OpBase.td" include "mlir/IR/OpBase.td"
def Arithmetic_Dialect : Dialect { def Arith_Dialect : Dialect {
let name = "arith"; let name = "arith";
let cppNamespace = "::mlir::arith"; let cppNamespace = "::mlir::arith";
let description = [{ let description = [{
The arithmetic dialect is intended to hold basic integer and floating point The arith dialect is intended to hold basic integer and floating point
mathematical operations. This includes unary, binary, and ternary arithmetic mathematical operations. This includes unary, binary, and ternary arithmetic
ops, bitwise and shift ops, cast ops, and compare ops. Operations in this ops, bitwise and shift ops, cast ops, and compare ops. Operations in this
dialect also accept vectors and tensors of integers or floats. dialect also accept vectors and tensors of integers or floats.
}]; }];
let hasConstantMaterializer = 1; let hasConstantMaterializer = 1;
} }
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesdef AtomicRMWKindAttr : I64EnumAttr<
[ATOMIC_RMW_KIND_ADDF, ATOMIC_RMW_KIND_ADDI, ATOMIC_RMW_KIND_ASSIGN, [ATOMIC_RMW_KIND_ADDF, ATOMIC_RMW_KIND_ADDI, ATOMIC_RMW_KIND_ASSIGN,
ATOMIC_RMW_KIND_MAXF, ATOMIC_RMW_KIND_MAXS, ATOMIC_RMW_KIND_MAXU, ATOMIC_RMW_KIND_MAXF, ATOMIC_RMW_KIND_MAXS, ATOMIC_RMW_KIND_MAXU,
ATOMIC_RMW_KIND_MINF, ATOMIC_RMW_KIND_MINS, ATOMIC_RMW_KIND_MINU, ATOMIC_RMW_KIND_MINF, ATOMIC_RMW_KIND_MINS, ATOMIC_RMW_KIND_MINU,
ATOMIC_RMW_KIND_MULF, ATOMIC_RMW_KIND_MULI, ATOMIC_RMW_KIND_ORI, ATOMIC_RMW_KIND_MULF, ATOMIC_RMW_KIND_MULI, ATOMIC_RMW_KIND_ORI,
ATOMIC_RMW_KIND_ANDI]> { ATOMIC_RMW_KIND_ANDI]> {
let cppNamespace = "::mlir::arith"; let cppNamespace = "::mlir::arith";
} }
#endif // ARITHMETIC_BASE #endif // ARITH_BASE

mlir/include/mlir/Dialect/Arith/IR/ArithOps.td

  • This file was moved from mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td.
//===- ArithmeticOps.td - Arithmetic op definitions --------*- tablegen -*-===// //===- ArithOps.td - Arith op definitions -------------*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef ARITHMETIC_OPS #ifndef ARITH_OPS
#define ARITHMETIC_OPS #define ARITH_OPS
include "mlir/Dialect/Arithmetic/IR/ArithmeticBase.td" include "mlir/Dialect/Arith/IR/ArithBase.td"
include "mlir/Interfaces/CastInterfaces.td" include "mlir/Interfaces/CastInterfaces.td"
include "mlir/Interfaces/InferIntRangeInterface.td" include "mlir/Interfaces/InferIntRangeInterface.td"
include "mlir/Interfaces/InferTypeOpInterface.td" include "mlir/Interfaces/InferTypeOpInterface.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
include "mlir/Interfaces/VectorInterfaces.td" include "mlir/Interfaces/VectorInterfaces.td"
include "mlir/IR/BuiltinAttributeInterfaces.td" include "mlir/IR/BuiltinAttributeInterfaces.td"
include "mlir/IR/OpAsmInterface.td" include "mlir/IR/OpAsmInterface.td"
// Base class for Arithmetic dialect ops. Ops in this dialect have no side // Base class for Arith dialect ops. Ops in this dialect have no side
// effects and can be applied element-wise to vectors and tensors. // effects and can be applied element-wise to vectors and tensors.
class Arith_Op<string mnemonic, list<Trait> traits = []> : class Arith_Op<string mnemonic, list<Trait> traits = []> :
Op<Arithmetic_Dialect, mnemonic, traits # [NoSideEffect, Op<Arith_Dialect, mnemonic, traits # [NoSideEffect,
DeclareOpInterfaceMethods<VectorUnrollOpInterface>] # DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
ElementwiseMappable.traits>; ElementwiseMappable.traits>;
// Base class for integer and floating point arithmetic ops. All ops have one // Base class for integer and floating point arithmetic ops. All ops have one
// result, require operands and results to be of the same type, and can accept // result, require operands and results to be of the same type, and can accept
// tensors or vectors of integers or floats. // tensors or vectors of integers or floats.
class Arith_ArithmeticOp<string mnemonic, list<Trait> traits = []> : class Arith_ArithOp<string mnemonic, list<Trait> traits = []> :
Arith_Op<mnemonic, traits # [SameOperandsAndResultType]>; Arith_Op<mnemonic, traits # [SameOperandsAndResultType]>;
// Base class for unary arithmetic operations. // Base class for unary arithmetic operations.
class Arith_UnaryOp<string mnemonic, list<Trait> traits = []> : class Arith_UnaryOp<string mnemonic, list<Trait> traits = []> :
Arith_ArithmeticOp<mnemonic, traits> { Arith_ArithOp<mnemonic, traits> {
let assemblyFormat = "$operand attr-dict `:` type($result)"; let assemblyFormat = "$operand attr-dict `:` type($result)";
} }
// Base class for binary arithmetic operations. // Base class for binary arithmetic operations.
class Arith_BinaryOp<string mnemonic, list<Trait> traits = []> : class Arith_BinaryOp<string mnemonic, list<Trait> traits = []> :
Arith_ArithmeticOp<mnemonic, traits> { Arith_ArithOp<mnemonic, traits> {
let assemblyFormat = "$lhs `,` $rhs attr-dict `:` type($result)"; let assemblyFormat = "$lhs `,` $rhs attr-dict `:` type($result)";
} }
// Base class for ternary arithmetic operations. // Base class for ternary arithmetic operations.
class Arith_TernaryOp<string mnemonic, list<Trait> traits = []> : class Arith_TernaryOp<string mnemonic, list<Trait> traits = []> :
Arith_ArithmeticOp<mnemonic, traits> { Arith_ArithOp<mnemonic, traits> {
let assemblyFormat = "$a `,` $b `,` $c attr-dict `:` type($result)"; let assemblyFormat = "$a `,` $b `,` $c attr-dict `:` type($result)";
} }
// Base class for integer binary operations. // Base class for integer binary operations.
class Arith_IntBinaryOp<string mnemonic, list<Trait> traits = []> : class Arith_IntBinaryOp<string mnemonic, list<Trait> traits = []> :
Arith_BinaryOp<mnemonic, traits # Arith_BinaryOp<mnemonic, traits #
[DeclareOpInterfaceMethods<InferIntRangeInterface>]>, [DeclareOpInterfaceMethods<InferIntRangeInterface>]>,
Arguments<(ins SignlessIntegerLike:$lhs, SignlessIntegerLike:$rhs)>, Arguments<(ins SignlessIntegerLike:$lhs, SignlessIntegerLike:$rhs)>,
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Linesclass Arith_CompareOpOfAnyRank<string mnemonic, list<Trait> traits = []> :
Arith_CompareOp<mnemonic, traits> { Arith_CompareOp<mnemonic, traits> {
let results = (outs BoolLikeOfAnyRank:$result); let results = (outs BoolLikeOfAnyRank:$result);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConstantOp // ConstantOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def Arith_ConstantOp : Op<Arithmetic_Dialect, "constant", def Arith_ConstantOp : Op<Arith_Dialect, "constant",
[ConstantLike, NoSideEffect, [ConstantLike, NoSideEffect,
DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>, DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
AllTypesMatch<["value", "result"]>, AllTypesMatch<["value", "result"]>,
DeclareOpInterfaceMethods<InferIntRangeInterface>]> { DeclareOpInterfaceMethods<InferIntRangeInterface>]> {
let summary = "integer or floating point constant"; let summary = "integer or floating point constant";
let description = [{ let description = [{
The `constant` operation produces an SSA value equal to some integer or The `constant` operation produces an SSA value equal to some integer or
floating-point constant specified by an attribute. This is the way MLIR floating-point constant specified by an attribute. This is the way MLIR
forms simple integer and floating point constants. forms simple integer and floating point constants.
Example: Example:
``` ```
// Integer constant // Integer constant
%1 = arith.constant 42 : i32 %1 = arith.constant 42 : i32
// Equivalent generic form // Equivalent generic form
%1 = "arith.constant"() {value = 42 : i32} : () -> i32 %1 = "arith.constant"() {value = 42 : i32} : () -> i32
``` ```
}]; }];
let arguments = (ins TypedAttrInterface:$value); let arguments = (ins TypedAttrInterface:$value);
// TODO: Disallow arith.constant to return anything other than a signless // TODO: Disallow arith.constant to return anything other than a signless
// integer or float like. Downstream users of Arithmetic should only be // integer or float like. Downstream users of Arith should only be
// working with signless integers, floats, or vectors/tensors thereof. // working with signless integers, floats, or vectors/tensors thereof.
// However, it is necessary to allow arith.constant to return vectors/tensors // However, it is necessary to allow arith.constant to return vectors/tensors
// of strings and signed/unsigned integers (for now) as an artefact of // of strings and signed/unsigned integers (for now) as an artefact of
// splitting the Standard dialect. // splitting the Standard dialect.
let results = (outs /*SignlessIntegerOrFloatLike*/AnyType:$result); let results = (outs /*SignlessIntegerOrFloatLike*/AnyType:$result);
let builders = [ let builders = [
OpBuilder<(ins "Attribute":$value, "Type":$type), OpBuilder<(ins "Attribute":$value, "Type":$type),
▲ Show 20 Lines • Show All 1,097 Lines • ▼ Show 20 Linesdef SelectOp : Arith_Op<"select", [
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
let hasFolder = 1; let hasFolder = 1;
let hasVerifier = 1; let hasVerifier = 1;
// FIXME: Switch this to use the declarative assembly format. // FIXME: Switch this to use the declarative assembly format.
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
} }
#endif // ARITHMETIC_OPS #endif // ARITH_OPS

mlir/include/mlir/Dialect/Arith/IR/CMakeLists.txt

  • This file was added.
set(LLVM_TARGET_DEFINITIONS ArithOps.td)
mlir_tablegen(ArithOpsEnums.h.inc -gen-enum-decls)
mlir_tablegen(ArithOpsEnums.cpp.inc -gen-enum-defs)
add_mlir_dialect(ArithOps arith)
add_mlir_doc(ArithOps ArithOps Dialects/ -gen-dialect-doc)

mlir/include/mlir/Dialect/Arith/Transforms/BufferizableOpInterfaceImpl.h

  • This file was moved from mlir/include/mlir/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.h.
//===- BufferizableOpInterfaceImpl.h - Impl. of BufferizableOpInterface ---===// //===- BufferizableOpInterfaceImpl.h - Impl. of BufferizableOpInterface ---===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_ARITHMETIC_BUFFERIZABLEOPINTERFACEIMPL_H #ifndef MLIR_DIALECT_ARITH_BUFFERIZABLEOPINTERFACEIMPL_H
#define MLIR_DIALECT_ARITHMETIC_BUFFERIZABLEOPINTERFACEIMPL_H #define MLIR_DIALECT_ARITH_BUFFERIZABLEOPINTERFACEIMPL_H
namespace mlir { namespace mlir {
class DialectRegistry; class DialectRegistry;
namespace arith { namespace arith {
void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry); void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry);
} // namespace arith } // namespace arith
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_ARITHMETIC_BUFFERIZABLEOPINTERFACEIMPL_H #endif // MLIR_DIALECT_ARITH_BUFFERIZABLEOPINTERFACEIMPL_H

mlir/include/mlir/Dialect/Arith/Transforms/CMakeLists.txt

  • This file was added.
set(LLVM_TARGET_DEFINITIONS Passes.td)
mlir_tablegen(Passes.h.inc -gen-pass-decls -name Arith)
add_public_tablegen_target(MLIRArithTransformsIncGen)
add_mlir_doc(Passes ArithPasses ./ -gen-pass-doc)

mlir/include/mlir/Dialect/Arith/Transforms/Passes.h

  • This file was moved from mlir/include/mlir/Dialect/Arithmetic/Transforms/Passes.h.
//===- Passes.h - Pass Entrypoints ------------------------------*- C++ -*-===// //===- Passes.h - Pass Entrypoints ------------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES_H_ #ifndef MLIR_DIALECT_ARITH_TRANSFORMS_PASSES_H_
#define MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES_H_ #define MLIR_DIALECT_ARITH_TRANSFORMS_PASSES_H_
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
namespace arith { namespace arith {
#define GEN_PASS_DECL #define GEN_PASS_DECL
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc" #include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
class WideIntEmulationConverter; class WideIntEmulationConverter;
/// Create a pass to bufferize Arithmetic ops. /// Create a pass to bufferize Arith ops.
std::unique_ptr<Pass> createArithmeticBufferizePass(); std::unique_ptr<Pass> createArithBufferizePass();
/// Create a pass to bufferize arith.constant ops. /// Create a pass to bufferize arith.constant ops.
std::unique_ptr<Pass> createConstantBufferizePass(uint64_t alignment = 0); std::unique_ptr<Pass> createConstantBufferizePass(uint64_t alignment = 0);
/// Adds patterns to emulate wide Arithmetic and Function ops over integer /// Adds patterns to emulate wide Arith and Function ops over integer
/// types into supported ones. This is done by splitting original power-of-two /// types into supported ones. This is done by splitting original power-of-two
/// i2N integer types into two iN halves. /// i2N integer types into two iN halves.
void populateWideIntEmulationPatterns(WideIntEmulationConverter &typeConverter, void populateWideIntEmulationPatterns(WideIntEmulationConverter &typeConverter,
RewritePatternSet &patterns); RewritePatternSet &patterns);
/// Add patterns to expand Arithmetic ops for LLVM lowering. /// Add patterns to expand Arith ops for LLVM lowering.
void populateArithmeticExpandOpsPatterns(RewritePatternSet &patterns); void populateArithExpandOpsPatterns(RewritePatternSet &patterns);
/// Create a pass to legalize Arithmetic ops for LLVM lowering. /// Create a pass to legalize Arith ops for LLVM lowering.
std::unique_ptr<Pass> createArithmeticExpandOpsPass(); std::unique_ptr<Pass> createArithExpandOpsPass();
/// Create a pass to replace signed ops with unsigned ones where they are proven /// Create a pass to replace signed ops with unsigned ones where they are proven
/// equivalent. /// equivalent.
std::unique_ptr<Pass> createArithmeticUnsignedWhenEquivalentPass(); std::unique_ptr<Pass> createArithUnsignedWhenEquivalentPass();
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Registration // Registration
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Generate the code for registering passes. /// Generate the code for registering passes.
#define GEN_PASS_REGISTRATION #define GEN_PASS_REGISTRATION
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc" #include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
} // namespace arith } // namespace arith
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES_H_ #endif // MLIR_DIALECT_ARITH_TRANSFORMS_PASSES_H_

mlir/include/mlir/Dialect/Arith/Transforms/Passes.td

  • This file was moved from mlir/include/mlir/Dialect/Arithmetic/Transforms/Passes.td.
//===-- Passes.td - Arithmetic pass definition file --------*- tablegen -*-===// //===-- Passes.td - Arith pass definition file --------*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES #ifndef MLIR_DIALECT_ARITH_TRANSFORMS_PASSES
#define MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES #define MLIR_DIALECT_ARITH_TRANSFORMS_PASSES
include "mlir/Pass/PassBase.td" include "mlir/Pass/PassBase.td"
def ArithmeticBufferize : Pass<"arith-bufferize", "ModuleOp"> { def ArithBufferize : Pass<"arith-bufferize", "ModuleOp"> {
let summary = "Bufferize Arithmetic dialect ops."; let summary = "Bufferize Arith dialect ops.";
let description = [{ let description = [{
This pass bufferizes arith dialect ops. This pass bufferizes arith dialect ops.
This pass needs to be a module pass because it inserts memref.global This pass needs to be a module pass because it inserts memref.global
ops into the module, which cannot be done safely from a function pass due to ops into the module, which cannot be done safely from a function pass due to
multi-threading. Most other bufferization passes can run in parallel at multi-threading. Most other bufferization passes can run in parallel at
function granularity. function granularity.
}]; }];
let constructor = "mlir::arith::createArithmeticBufferizePass()"; let constructor = "mlir::arith::createArithBufferizePass()";
let options = [ let options = [
Option<"alignment", "alignment", "unsigned", /*default=*/"0", Option<"alignment", "alignment", "unsigned", /*default=*/"0",
"Create global memrefs with a specified alignment">, "Create global memrefs with a specified alignment">,
]; ];
} }
def ArithmeticExpandOps : Pass<"arith-expand"> { def ArithExpandOps : Pass<"arith-expand"> {
let summary = "Legalize Arithmetic ops to be convertible to LLVM."; let summary = "Legalize Arith ops to be convertible to LLVM.";
let constructor = "mlir::arith::createArithmeticExpandOpsPass()"; let constructor = "mlir::arith::createArithExpandOpsPass()";
} }
def ArithmeticUnsignedWhenEquivalent : Pass<"arith-unsigned-when-equivalent"> { def ArithUnsignedWhenEquivalent : Pass<"arith-unsigned-when-equivalent"> {
let summary = "Replace signed ops with unsigned ones where they are proven equivalent"; let summary = "Replace signed ops with unsigned ones where they are proven equivalent";
let description = [{ let description = [{
Replace signed ops with their unsigned equivalents when integer range analysis Replace signed ops with their unsigned equivalents when integer range analysis
determines that their arguments and results are all guaranteed to be determines that their arguments and results are all guaranteed to be
non-negative when interpreted as signed integers. When this occurs, non-negative when interpreted as signed integers. When this occurs,
we know that the semantics of the signed and unsigned operations are the same, we know that the semantics of the signed and unsigned operations are the same,
since they share the same behavior when their operands and results are in the since they share the same behavior when their operands and results are in the
range [0, signed_max(type)]. range [0, signed_max(type)].
The affect ops include division, remainder, shifts, min, max, and integer The affect ops include division, remainder, shifts, min, max, and integer
comparisons. comparisons.
}]; }];
let constructor = "mlir::arith::createArithmeticUnsignedWhenEquivalentPass()"; let constructor = "mlir::arith::createArithUnsignedWhenEquivalentPass()";
} }
def ArithmeticEmulateWideInt : Pass<"arith-emulate-wide-int"> { def ArithEmulateWideInt : Pass<"arith-emulate-wide-int"> {
let summary = "Emulate 2*N-bit integer operations using N-bit operations"; let summary = "Emulate 2*N-bit integer operations using N-bit operations";
let description = [{ let description = [{
Emulate integer operations that use too wide integer types with equivalent Emulate integer operations that use too wide integer types with equivalent
operations on supported narrow integer types. This is done by splitting operations on supported narrow integer types. This is done by splitting
original integer values into two halves. original integer values into two halves.
This pass is intended preserve semantics but not necessarily provide the This pass is intended preserve semantics but not necessarily provide the
most efficient implementation. most efficient implementation.
TODO: Optimize op emulation. TODO: Optimize op emulation.
Currently, only power-of-two integer bitwidths are supported. Currently, only power-of-two integer bitwidths are supported.
}]; }];
let options = [ let options = [
Option<"widestIntSupported", "widest-int-supported", "unsigned", Option<"widestIntSupported", "widest-int-supported", "unsigned",
/*default=*/"32", "Widest integer type supported by the target">, /*default=*/"32", "Widest integer type supported by the target">,
]; ];
let dependentDialects = ["vector::VectorDialect"]; let dependentDialects = ["vector::VectorDialect"];
} }
#endif // MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES #endif // MLIR_DIALECT_ARITH_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/Arith/Transforms/WideIntEmulationConverter.h

  • This file was moved from mlir/include/mlir/Dialect/Arithmetic/Transforms/WideIntEmulationConverter.h.
//===- WideIntEmulationConverter.h - Type Converter for WIE -----*- C++ -*-===// //===- WideIntEmulationConverter.h - Type Converter for WIE -----*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_ARITHMETIC_WIDE_INT_EMULATION_CONVERTER_H_ #ifndef MLIR_DIALECT_ARITH_WIDE_INT_EMULATION_CONVERTER_H_
#define MLIR_DIALECT_ARITHMETIC_WIDE_INT_EMULATION_CONVERTER_H_ #define MLIR_DIALECT_ARITH_WIDE_INT_EMULATION_CONVERTER_H_
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
namespace mlir::arith { namespace mlir::arith {
/// Converts integer types that are too wide for the target by splitting them in /// Converts integer types that are too wide for the target by splitting them in
/// two halves and thus turning into supported ones, i.e., i2*N --> iN, where N /// two halves and thus turning into supported ones, i.e., i2*N --> iN, where N
/// is the widest integer bitwidth supported by the target. /// is the widest integer bitwidth supported by the target.
/// Currently, we only handle power-of-two integer types and support conversions /// Currently, we only handle power-of-two integer types and support conversions
/// of integers twice as wide as the maxium supported by the target. Wide /// of integers twice as wide as the maxium supported by the target. Wide
/// integers are represented as vectors, e.g., i64 --> vector<2xi32>, where the /// integers are represented as vectors, e.g., i64 --> vector<2xi32>, where the
/// first element is the low half of the original integer, and the second /// first element is the low half of the original integer, and the second
/// element the high half. /// element the high half.
class WideIntEmulationConverter : public TypeConverter { class WideIntEmulationConverter : public TypeConverter {
public: public:
explicit WideIntEmulationConverter(unsigned widestIntSupportedByTarget); explicit WideIntEmulationConverter(unsigned widestIntSupportedByTarget);
unsigned getMaxTargetIntBitWidth() const { return maxIntWidth; } unsigned getMaxTargetIntBitWidth() const { return maxIntWidth; }
private: private:
unsigned maxIntWidth; unsigned maxIntWidth;
}; };
} // namespace mlir::arith } // namespace mlir::arith
#endif // MLIR_DIALECT_ARITHMETIC_WIDE_INT_EMULATION_CONVERTER_H_ #endif // MLIR_DIALECT_ARITH_WIDE_INT_EMULATION_CONVERTER_H_

mlir/include/mlir/Dialect/Arith/Utils/Utils.h

  • This file was moved from mlir/include/mlir/Dialect/Arithmetic/Utils/Utils.h.
//===- Utils.h - General Arithmetic transformation utilities ----*- C++ -*-===// //===- Utils.h - General Arith transformation utilities ----*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This header file defines prototypes for various transformation utilities for // This header file defines prototypes for various transformation utilities for
// the Arithmetic dialect. These are not passes by themselves but are used // the Arith dialect. These are not passes by themselves but are used
// either by passes, optimization sequences, or in turn by other transformation // either by passes, optimization sequences, or in turn by other transformation
// utilities. // utilities.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_ARITHMETIC_UTILS_UTILS_H #ifndef MLIR_DIALECT_ARITH_UTILS_UTILS_H
#define MLIR_DIALECT_ARITHMETIC_UTILS_UTILS_H #define MLIR_DIALECT_ARITH_UTILS_UTILS_H
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/IR/Value.h" #include "mlir/IR/Value.h"
namespace mlir { namespace mlir {
/// Matches a ConstantIndexOp. /// Matches a ConstantIndexOp.
detail::op_matcher<arith::ConstantIndexOp> matchConstantIndex(); detail::op_matcher<arith::ConstantIndexOp> matchConstantIndex();
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Linesstruct ArithBuilder {
Value slt(Value lhs, Value rhs); Value slt(Value lhs, Value rhs);
private: private:
OpBuilder &b; OpBuilder &b;
Location loc; Location loc;
}; };
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_ARITHMETIC_UTILS_UTILS_H #endif // MLIR_DIALECT_ARITH_UTILS_UTILS_H

mlir/include/mlir/Dialect/Arithmetic/CMakeLists.txt

  • This file was moved to mlir/include/mlir/Dialect/Arith/CMakeLists.txt.

mlir/include/mlir/Dialect/Arithmetic/IR/Arithmetic.h

  • This file was moved to mlir/include/mlir/Dialect/Arith/IR/Arith.h.

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td

  • This file was moved to mlir/include/mlir/Dialect/Arith/IR/ArithBase.td.

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

  • This file was moved to mlir/include/mlir/Dialect/Arith/IR/ArithOps.td.

mlir/include/mlir/Dialect/Arithmetic/IR/CMakeLists.txt

  • This file was deleted.
set(LLVM_TARGET_DEFINITIONS ArithmeticOps.td)
mlir_tablegen(ArithmeticOpsEnums.h.inc -gen-enum-decls)
mlir_tablegen(ArithmeticOpsEnums.cpp.inc -gen-enum-defs)
add_mlir_dialect(ArithmeticOps arith)
add_mlir_doc(ArithmeticOps ArithmeticOps Dialects/ -gen-dialect-doc)

mlir/include/mlir/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.h

  • This file was moved to mlir/include/mlir/Dialect/Arith/Transforms/BufferizableOpInterfaceImpl.h.

mlir/include/mlir/Dialect/Arithmetic/Transforms/CMakeLists.txt

  • This file was deleted.
set(LLVM_TARGET_DEFINITIONS Passes.td)
mlir_tablegen(Passes.h.inc -gen-pass-decls -name Arithmetic)
add_public_tablegen_target(MLIRArithmeticTransformsIncGen)
add_mlir_doc(Passes ArithmeticPasses ./ -gen-pass-doc)

mlir/include/mlir/Dialect/Arithmetic/Transforms/Passes.h

  • This file was moved to mlir/include/mlir/Dialect/Arith/Transforms/Passes.h.

mlir/include/mlir/Dialect/Arithmetic/Transforms/Passes.td

  • This file was moved to mlir/include/mlir/Dialect/Arith/Transforms/Passes.td.

mlir/include/mlir/Dialect/Arithmetic/Transforms/WideIntEmulationConverter.h

  • This file was moved to mlir/include/mlir/Dialect/Arith/Transforms/WideIntEmulationConverter.h.

mlir/include/mlir/Dialect/Arithmetic/Utils/Utils.h

  • This file was moved to mlir/include/mlir/Dialect/Arith/Utils/Utils.h.

mlir/include/mlir/Dialect/Async/Passes.td

Show All 28 Lines Option<"numWorkerThreads", "num-workers",
"the value will be retrieved from the runtime.">, "the value will be retrieved from the runtime.">,
Option<"minTaskSize", "min-task-size", Option<"minTaskSize", "min-task-size",
"int32_t", /*default=*/"1000", "int32_t", /*default=*/"1000",
"The minimum task size for sharding parallel operation."> "The minimum task size for sharding parallel operation.">
]; ];
let dependentDialects = [ let dependentDialects = [
"arith::ArithmeticDialect", "arith::ArithDialect",
"async::AsyncDialect", "async::AsyncDialect",
"scf::SCFDialect" "scf::SCFDialect"
]; ];
} }
def AsyncToAsyncRuntime : Pass<"async-to-async-runtime", "ModuleOp"> { def AsyncToAsyncRuntime : Pass<"async-to-async-runtime", "ModuleOp"> {
let summary = "Lower high level async operations (e.g. async.execute) to the" let summary = "Lower high level async operations (e.g. async.execute) to the"
"explicit async.runtime and async.coro operations"; "explicit async.runtime and async.coro operations";
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Bufferization/Transforms/BufferUtils.h

Show All 9 Lines
// been converted to buffers. // been converted to buffers.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERUTILS_H #ifndef MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERUTILS_H
#define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERUTILS_H #define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERUTILS_H
#include "mlir/Analysis/Liveness.h" #include "mlir/Analysis/Liveness.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.h" #include "mlir/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Dominance.h" #include "mlir/IR/Dominance.h"
#include "mlir/IR/Operation.h" #include "mlir/IR/Operation.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
namespace mlir { namespace mlir {
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/CMakeLists.txt

add_subdirectory(AMDGPU) add_subdirectory(AMDGPU)
add_subdirectory(AMX) add_subdirectory(AMX)
add_subdirectory(Affine) add_subdirectory(Affine)
add_subdirectory(Arithmetic) add_subdirectory(Arith)
add_subdirectory(ArmNeon) add_subdirectory(ArmNeon)
add_subdirectory(ArmSVE) add_subdirectory(ArmSVE)
add_subdirectory(Async) add_subdirectory(Async)
add_subdirectory(Bufferization) add_subdirectory(Bufferization)
add_subdirectory(Complex) add_subdirectory(Complex)
add_subdirectory(ControlFlow) add_subdirectory(ControlFlow)
add_subdirectory(DLTI) add_subdirectory(DLTI)
add_subdirectory(EmitC) add_subdirectory(EmitC)
Show All 23 Lines

mlir/include/mlir/Dialect/Complex/IR/ComplexBase.td

Show All 13 Lines
def Complex_Dialect : Dialect { def Complex_Dialect : Dialect {
let name = "complex"; let name = "complex";
let cppNamespace = "::mlir::complex"; let cppNamespace = "::mlir::complex";
let description = [{ let description = [{
The complex dialect is intended to hold complex numbers creation and The complex dialect is intended to hold complex numbers creation and
arithmetic ops. arithmetic ops.
}]; }];
let dependentDialects = ["arith::ArithmeticDialect"]; let dependentDialects = ["arith::ArithDialect"];
let hasConstantMaterializer = 1; let hasConstantMaterializer = 1;
let useDefaultAttributePrinterParser = 1; let useDefaultAttributePrinterParser = 1;
} }
#endif // COMPLEX_BASE #endif // COMPLEX_BASE

mlir/include/mlir/Dialect/ControlFlow/IR/ControlFlowOps.td

Show All 16 Lines
include "mlir/IR/EnumAttr.td" include "mlir/IR/EnumAttr.td"
include "mlir/IR/OpAsmInterface.td" include "mlir/IR/OpAsmInterface.td"
include "mlir/Interfaces/ControlFlowInterfaces.td" include "mlir/Interfaces/ControlFlowInterfaces.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
def ControlFlow_Dialect : Dialect { def ControlFlow_Dialect : Dialect {
let name = "cf"; let name = "cf";
let cppNamespace = "::mlir::cf"; let cppNamespace = "::mlir::cf";
let dependentDialects = ["arith::ArithmeticDialect"]; let dependentDialects = ["arith::ArithDialect"];
let description = [{ let description = [{
This dialect contains low-level, i.e. non-region based, control flow This dialect contains low-level, i.e. non-region based, control flow
constructs. These constructs generally represent control flow directly constructs. These constructs generally represent control flow directly
on SSA blocks of a control flow graph. on SSA blocks of a control flow graph.
}]; }];
} }
class CF_Op<string mnemonic, list<Trait> traits = []> : class CF_Op<string mnemonic, list<Trait> traits = []> :
▲ Show 20 Lines • Show All 280 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/GPU/IR/GPUBase.td

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines let extraClassDeclaration = [{
/// space. /// space.
static unsigned getWorkgroupAddressSpace() { return 3; } static unsigned getWorkgroupAddressSpace() { return 3; }
/// Returns the numeric value used to identify the private memory address /// Returns the numeric value used to identify the private memory address
/// space. /// space.
static unsigned getPrivateAddressSpace() { return 5; } static unsigned getPrivateAddressSpace() { return 5; }
}]; }];
let dependentDialects = ["arith::ArithmeticDialect"]; let dependentDialects = ["arith::ArithDialect"];
let useDefaultAttributePrinterParser = 1; let useDefaultAttributePrinterParser = 1;
let useDefaultTypePrinterParser = 1; let useDefaultTypePrinterParser = 1;
// TODO: Update this to _Prefixed. // TODO: Update this to _Prefixed.
let emitAccessorPrefix = kEmitAccessorPrefix_Both; let emitAccessorPrefix = kEmitAccessorPrefix_Both;
} }
def GPU_AsyncToken : DialectType< def GPU_AsyncToken : DialectType<
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Linalg/IR/LinalgBase.td

Show All 29 Lines let description = [{
Documentation](https://mlir.llvm.org/docs/Dialects/Linalg) and a Documentation](https://mlir.llvm.org/docs/Dialects/Linalg) and a
[Rationale [Rationale
Document](https://mlir.llvm.org/docs/Rationale/RationaleLinalgDialect) are Document](https://mlir.llvm.org/docs/Rationale/RationaleLinalgDialect) are
are also available and should be read first before going in the details of are also available and should be read first before going in the details of
the op semantics. the op semantics.
}]; }];
let cppNamespace = "::mlir::linalg"; let cppNamespace = "::mlir::linalg";
let dependentDialects = [ let dependentDialects = [
"arith::ArithmeticDialect", "arith::ArithDialect",
"AffineDialect", "AffineDialect",
"math::MathDialect", "math::MathDialect",
"memref::MemRefDialect", "memref::MemRefDialect",
"tensor::TensorDialect", "tensor::TensorDialect",
]; ];
let useDefaultAttributePrinterParser = 1; let useDefaultAttributePrinterParser = 1;
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
let hasOperationAttrVerify = 1; let hasOperationAttrVerify = 1;
Show All 30 Lines

mlir/include/mlir/Dialect/MemRef/IR/MemRefBase.td

Show All 13 Lines
def MemRef_Dialect : Dialect { def MemRef_Dialect : Dialect {
let name = "memref"; let name = "memref";
let cppNamespace = "::mlir::memref"; let cppNamespace = "::mlir::memref";
let description = [{ let description = [{
The `memref` dialect is intended to hold core memref creation and The `memref` dialect is intended to hold core memref creation and
manipulation ops, which are not strongly associated with any particular manipulation ops, which are not strongly associated with any particular
other dialect or domain abstraction. other dialect or domain abstraction.
}]; }];
let dependentDialects = ["arith::ArithmeticDialect"]; let dependentDialects = ["arith::ArithDialect"];
let hasConstantMaterializer = 1; let hasConstantMaterializer = 1;
let emitAccessorPrefix = kEmitAccessorPrefix_Both; let emitAccessorPrefix = kEmitAccessorPrefix_Both;
} }
#endif // MEMREF_BASE #endif // MEMREF_BASE

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

//===- MemRefOps.td - MemRef op definitions ----------------*- tablegen -*-===// //===- MemRefOps.td - MemRef op definitions ----------------*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MEMREF_OPS #ifndef MEMREF_OPS
#define MEMREF_OPS #define MEMREF_OPS
include "mlir/Dialect/Arithmetic/IR/ArithmeticBase.td" include "mlir/Dialect/Arith/IR/ArithBase.td"
include "mlir/Dialect/MemRef/IR/MemRefBase.td" include "mlir/Dialect/MemRef/IR/MemRefBase.td"
include "mlir/Interfaces/CastInterfaces.td" include "mlir/Interfaces/CastInterfaces.td"
include "mlir/Interfaces/ControlFlowInterfaces.td" include "mlir/Interfaces/ControlFlowInterfaces.td"
include "mlir/Interfaces/CopyOpInterface.td" include "mlir/Interfaces/CopyOpInterface.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
include "mlir/Interfaces/ViewLikeInterface.td" include "mlir/Interfaces/ViewLikeInterface.td"
include "mlir/IR/SymbolInterfaces.td" include "mlir/IR/SymbolInterfaces.td"
▲ Show 20 Lines • Show All 2,067 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/SCF/IR/SCFOps.td

Show All 17 Lines
include "mlir/IR/RegionKindInterface.td" include "mlir/IR/RegionKindInterface.td"
include "mlir/Interfaces/ParallelCombiningOpInterface.td" include "mlir/Interfaces/ParallelCombiningOpInterface.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
include "mlir/Interfaces/ViewLikeInterface.td" include "mlir/Interfaces/ViewLikeInterface.td"
def SCF_Dialect : Dialect { def SCF_Dialect : Dialect {
let name = "scf"; let name = "scf";
let cppNamespace = "::mlir::scf"; let cppNamespace = "::mlir::scf";
let dependentDialects = ["arith::ArithmeticDialect"]; let dependentDialects = ["arith::ArithDialect"];
} }
// Base class for SCF dialect ops. // Base class for SCF dialect ops.
class SCF_Op<string mnemonic, list<Trait> traits = []> : class SCF_Op<string mnemonic, list<Trait> traits = []> :
Op<SCF_Dialect, mnemonic, traits>; Op<SCF_Dialect, mnemonic, traits>;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConditionOp // ConditionOp
▲ Show 20 Lines • Show All 978 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Shape/IR/ShapeBase.td

Show All 30 Lines let description = [{
shapes as input, return the invalid shape if one of its operands is an shapes as input, return the invalid shape if one of its operands is an
invalid shape. This avoids flagging multiple errors for one verification invalid shape. This avoids flagging multiple errors for one verification
failure. The dialect itself does not specify how errors should be combined failure. The dialect itself does not specify how errors should be combined
(there are multiple different options, from always choosing first operand, (there are multiple different options, from always choosing first operand,
concatting etc. on how to combine them). concatting etc. on how to combine them).
}]; }];
let cppNamespace = "::mlir::shape"; let cppNamespace = "::mlir::shape";
let dependentDialects = ["arith::ArithmeticDialect", "tensor::TensorDialect"]; let dependentDialects = ["arith::ArithDialect", "tensor::TensorDialect"];
let useDefaultTypePrinterParser = 1; let useDefaultTypePrinterParser = 1;
let hasConstantMaterializer = 1; let hasConstantMaterializer = 1;
let hasOperationAttrVerify = 1; let hasOperationAttrVerify = 1;
} }
class Shape_Type<string name, string typeMnemonic> : TypeDef<ShapeDialect, name> { class Shape_Type<string name, string typeMnemonic> : TypeDef<ShapeDialect, name> {
let mnemonic = typeMnemonic; let mnemonic = typeMnemonic;
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Shape/Transforms/Passes.h

Show All 24 Lines
} // namespace mlir } // namespace mlir
namespace mlir { namespace mlir {
#define GEN_PASS_DECL #define GEN_PASS_DECL
#include "mlir/Dialect/Shape/Transforms/Passes.h.inc" #include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
/// Creates an instance of the ShapeToShapeLowering pass that legalizes Shape /// Creates an instance of the ShapeToShapeLowering pass that legalizes Shape
/// dialect to be convertible to Arithmetic. For example, `shape.num_elements` /// dialect to be convertible to Arith. For example, `shape.num_elements` get
/// get transformed to `shape.reduce`, which can be lowered to SCF and /// transformed to `shape.reduce`, which can be lowered to SCF and Arith.
/// Arithmetic.
std::unique_ptr<Pass> createShapeToShapeLowering(); std::unique_ptr<Pass> createShapeToShapeLowering();
/// Collects a set of patterns to rewrite ops within the Shape dialect. /// Collects a set of patterns to rewrite ops within the Shape dialect.
void populateShapeRewritePatterns(RewritePatternSet &patterns); void populateShapeRewritePatterns(RewritePatternSet &patterns);
// Collects a set of patterns to replace all constraints with passing witnesses. // Collects a set of patterns to replace all constraints with passing witnesses.
// This is intended to then allow all ShapeConstraint related ops and data to // This is intended to then allow all ShapeConstraint related ops and data to
// have no effects and allow them to be freely removed such as through // have no effects and allow them to be freely removed such as through
Show All 24 Lines

mlir/include/mlir/Dialect/Shape/Transforms/Passes.td

Show All 11 Lines
include "mlir/Pass/PassBase.td" include "mlir/Pass/PassBase.td"
def RemoveShapeConstraints : Pass<"remove-shape-constraints", "func::FuncOp"> { def RemoveShapeConstraints : Pass<"remove-shape-constraints", "func::FuncOp"> {
let summary = "Replace all cstr_ ops with a true witness"; let summary = "Replace all cstr_ ops with a true witness";
let constructor = "mlir::createRemoveShapeConstraintsPass()"; let constructor = "mlir::createRemoveShapeConstraintsPass()";
} }
def ShapeToShapeLowering : Pass<"shape-to-shape-lowering", "func::FuncOp"> { def ShapeToShapeLowering : Pass<"shape-to-shape-lowering", "func::FuncOp"> {
let summary = "Legalize Shape dialect to be convertible to Arithmetic"; let summary = "Legalize Shape dialect to be convertible to Arith";
let constructor = "mlir::createShapeToShapeLowering()"; let constructor = "mlir::createShapeToShapeLowering()";
} }
// TODO: Generalize this to allow any type conversions desired. // TODO: Generalize this to allow any type conversions desired.
def ShapeBufferize : Pass<"shape-bufferize", "func::FuncOp"> { def ShapeBufferize : Pass<"shape-bufferize", "func::FuncOp"> {
let summary = "Bufferize the shape dialect."; let summary = "Bufferize the shape dialect.";
let constructor = "mlir::createShapeBufferizePass()"; let constructor = "mlir::createShapeBufferizePass()";
let dependentDialects = ["bufferization::BufferizationDialect", let dependentDialects = ["bufferization::BufferizationDialect",
"memref::MemRefDialect"]; "memref::MemRefDialect"];
} }
#endif // MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES #endif // MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/SparseTensor/Transforms/Passes.td

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines func.func @kernel_matvec(%arga: tensor<?x?xf64, #SparseMatrix>,
} -> tensor<?xf64> } -> tensor<?xf64>
return %0 : tensor<?xf64> return %0 : tensor<?xf64>
} }
``` ```
}]; }];
let constructor = "mlir::createSparsificationPass()"; let constructor = "mlir::createSparsificationPass()";
let dependentDialects = [ let dependentDialects = [
"AffineDialect", "AffineDialect",
"arith::ArithmeticDialect", "arith::ArithDialect",
"bufferization::BufferizationDialect", "bufferization::BufferizationDialect",
"LLVM::LLVMDialect", "LLVM::LLVMDialect",
"memref::MemRefDialect", "memref::MemRefDialect",
"scf::SCFDialect", "scf::SCFDialect",
"sparse_tensor::SparseTensorDialect", "sparse_tensor::SparseTensorDialect",
"vector::VectorDialect", "vector::VectorDialect",
]; ];
// TODO(57514): These enum options are duplicated in Passes.h. // TODO(57514): These enum options are duplicated in Passes.h.
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines ```mlir
After: After:
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%0 = call @sparsePointers(%arg0, %c1) : (!llvm.ptr<i8>, index) -> memref<?xindex> %0 = call @sparsePointers(%arg0, %c1) : (!llvm.ptr<i8>, index) -> memref<?xindex>
``` ```
}]; }];
let constructor = "mlir::createSparseTensorConversionPass()"; let constructor = "mlir::createSparseTensorConversionPass()";
let dependentDialects = [ let dependentDialects = [
"arith::ArithmeticDialect", "arith::ArithDialect",
"bufferization::BufferizationDialect", "bufferization::BufferizationDialect",
"LLVM::LLVMDialect", "LLVM::LLVMDialect",
"linalg::LinalgDialect", "linalg::LinalgDialect",
"memref::MemRefDialect", "memref::MemRefDialect",
"scf::SCFDialect", "scf::SCFDialect",
"sparse_tensor::SparseTensorDialect", "sparse_tensor::SparseTensorDialect",
"vector::VectorDialect", "vector::VectorDialect",
]; ];
Show All 18 Lines let description = [{
Example of the conversion: Example of the conversion:
```mlir ```mlir
TBD TBD
``` ```
}]; }];
let constructor = "mlir::createSparseTensorCodegenPass()"; let constructor = "mlir::createSparseTensorCodegenPass()";
let dependentDialects = [ let dependentDialects = [
"arith::ArithmeticDialect", "arith::ArithDialect",
"bufferization::BufferizationDialect", "bufferization::BufferizationDialect",
"linalg::LinalgDialect", "linalg::LinalgDialect",
"memref::MemRefDialect", "memref::MemRefDialect",
"scf::SCFDialect", "scf::SCFDialect",
"sparse_tensor::SparseTensorDialect", "sparse_tensor::SparseTensorDialect",
]; ];
} }
#endif // MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_PASSES #endif // MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/Tensor/IR/TensorBase.td

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines let description = [{
The `tensor` type is actually a builtin type (it lives in the builtin The `tensor` type is actually a builtin type (it lives in the builtin
dialect), and does not live in this dialect. dialect), and does not live in this dialect.
}]; }];
let hasConstantMaterializer = 1; let hasConstantMaterializer = 1;
let dependentDialects = [ let dependentDialects = [
"arith::ArithmeticDialect", "arith::ArithDialect",
"complex::ComplexDialect", "complex::ComplexDialect",
]; ];
} }
#endif // TENSOR_BASE #endif // TENSOR_BASE

mlir/include/mlir/Dialect/Tosa/Utils/CoversionUtils.h

//===- ConversionUtils.h - Helper functions for tosa conversion -*- C++ -*-===// //===- ConversionUtils.h - Helper functions for tosa conversion -*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Utility functions for TOSA lowering // Utility functions for TOSA lowering
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef DIALECT_TOSA_UTILS_COVERSION_UTILS_H_ #ifndef DIALECT_TOSA_UTILS_COVERSION_UTILS_H_
#define DIALECT_TOSA_UTILS_COVERSION_UTILS_H_ #define DIALECT_TOSA_UTILS_COVERSION_UTILS_H_
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/StructuredOpsUtils.h" #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
namespace mlir { namespace mlir {
namespace tosa { namespace tosa {
// Creates a SmallVector of Stringrefs for N parallel loops // Creates a SmallVector of Stringrefs for N parallel loops
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

Show All 20 Lines
include "mlir/Interfaces/ViewLikeInterface.td" include "mlir/Interfaces/ViewLikeInterface.td"
def Vector_Dialect : Dialect { def Vector_Dialect : Dialect {
let name = "vector"; let name = "vector";
let cppNamespace = "::mlir::vector"; let cppNamespace = "::mlir::vector";
let useDefaultAttributePrinterParser = 1; let useDefaultAttributePrinterParser = 1;
let hasConstantMaterializer = 1; let hasConstantMaterializer = 1;
let dependentDialects = ["arith::ArithmeticDialect"]; let dependentDialects = ["arith::ArithDialect"];
} }
// Base class for Vector dialect ops. // Base class for Vector dialect ops.
class Vector_Op<string mnemonic, list<Trait> traits = []> : class Vector_Op<string mnemonic, list<Trait> traits = []> :
Op<Vector_Dialect, mnemonic, traits>; Op<Vector_Dialect, mnemonic, traits>;
// The "kind" of combining function for contractions and reductions. // The "kind" of combining function for contractions and reductions.
def COMBINING_KIND_ADD : I32BitEnumAttrCaseBit<"ADD", 0, "add">; def COMBINING_KIND_ADD : I32BitEnumAttrCaseBit<"ADD", 0, "add">;
▲ Show 20 Lines • Show All 2,567 Lines • Show Last 20 Lines

mlir/include/mlir/InitAllDialects.h

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_INITALLDIALECTS_H_ #ifndef MLIR_INITALLDIALECTS_H_
#define MLIR_INITALLDIALECTS_H_ #define MLIR_INITALLDIALECTS_H_
#include "mlir/Dialect/AMDGPU/AMDGPUDialect.h" #include "mlir/Dialect/AMDGPU/AMDGPUDialect.h"
#include "mlir/Dialect/AMX/AMXDialect.h" #include "mlir/Dialect/AMX/AMXDialect.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.h" #include "mlir/Dialect/Arith/Transforms/BufferizableOpInterfaceImpl.h"
#include "mlir/Dialect/ArmNeon/ArmNeonDialect.h" #include "mlir/Dialect/ArmNeon/ArmNeonDialect.h"
#include "mlir/Dialect/ArmSVE/ArmSVEDialect.h" #include "mlir/Dialect/ArmSVE/ArmSVEDialect.h"
#include "mlir/Dialect/Async/IR/Async.h" #include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/TransformOps/BufferizationTransformOps.h" #include "mlir/Dialect/Bufferization/TransformOps/BufferizationTransformOps.h"
#include "mlir/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.h" #include "mlir/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
Show All 39 Lines
namespace mlir { namespace mlir {
/// Add all the MLIR dialects to the provided registry. /// Add all the MLIR dialects to the provided registry.
inline void registerAllDialects(DialectRegistry &registry) { inline void registerAllDialects(DialectRegistry &registry) {
// clang-format off // clang-format off
registry.insert<acc::OpenACCDialect, registry.insert<acc::OpenACCDialect,
AffineDialect, AffineDialect,
arith::ArithmeticDialect, arith::ArithDialect,
amdgpu::AMDGPUDialect, amdgpu::AMDGPUDialect,
amx::AMXDialect, amx::AMXDialect,
arm_neon::ArmNeonDialect, arm_neon::ArmNeonDialect,
async::AsyncDialect, async::AsyncDialect,
bufferization::BufferizationDialect, bufferization::BufferizationDialect,
cf::ControlFlowDialect, cf::ControlFlowDialect,
complex::ComplexDialect, complex::ComplexDialect,
DLTIDialect, DLTIDialect,
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

mlir/include/mlir/InitAllPasses.h

Show All 10 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_INITALLPASSES_H_ #ifndef MLIR_INITALLPASSES_H_
#define MLIR_INITALLPASSES_H_ #define MLIR_INITALLPASSES_H_
#include "mlir/Conversion/Passes.h" #include "mlir/Conversion/Passes.h"
#include "mlir/Dialect/Affine/Passes.h" #include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h" #include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Dialect/Async/Passes.h" #include "mlir/Dialect/Async/Passes.h"
#include "mlir/Dialect/Bufferization/Transforms/Passes.h" #include "mlir/Dialect/Bufferization/Transforms/Passes.h"
#include "mlir/Dialect/Func/Transforms/Passes.h" #include "mlir/Dialect/Func/Transforms/Passes.h"
#include "mlir/Dialect/GPU/Transforms/Passes.h" #include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/Dialect/LLVMIR/Transforms/Passes.h" #include "mlir/Dialect/LLVMIR/Transforms/Passes.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/MemRef/Transforms/Passes.h" #include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/NVGPU/Passes.h" #include "mlir/Dialect/NVGPU/Passes.h"
Show All 24 Linesinline void registerAllPasses() {
registerTransformsPasses(); registerTransformsPasses();
// Conversion passes // Conversion passes
registerConversionPasses(); registerConversionPasses();
// Dialect passes // Dialect passes
registerAffinePasses(); registerAffinePasses();
registerAsyncPasses(); registerAsyncPasses();
arith::registerArithmeticPasses(); arith::registerArithPasses();
bufferization::registerBufferizationPasses(); bufferization::registerBufferizationPasses();
func::registerFuncPasses(); func::registerFuncPasses();
registerGPUPasses(); registerGPUPasses();
registerGpuSerializeToCubinPass(); registerGpuSerializeToCubinPass();
registerGpuSerializeToHsacoPass(); registerGpuSerializeToHsacoPass();
registerLinalgPasses(); registerLinalgPasses();
registerNVGPUPasses(); registerNVGPUPasses();
registerSparseTensorPasses(); registerSparseTensorPasses();
Show All 17 Lines

mlir/include/mlir/Interfaces/InferIntRangeInterface.td

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines InterfaceMethod<[{
order. Non-integer arguments will have the an unbounded range of width-0 order. Non-integer arguments will have the an unbounded range of width-0
APInts in their `argRanges` element. APInts in their `argRanges` element.
}], }],
"void", "inferResultRanges", (ins "void", "inferResultRanges", (ins
"::llvm::ArrayRef<::mlir::ConstantIntRanges>":$argRanges, "::llvm::ArrayRef<::mlir::ConstantIntRanges>":$argRanges,
"::mlir::SetIntRangeFn":$setResultRanges) "::mlir::SetIntRangeFn":$setResultRanges)
>]; >];
} }
#endif // MLIR_DIALECT_ARITHMETIC_IR_INFERINTRANGEINTERFACE #endif // MLIR_INTERFACES_INFERINTRANGEINTERFACE

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

Show First 20 Lines • Show All 548 Lines • ▼ Show 20 Lines
namespace { namespace {
class LowerAffinePass class LowerAffinePass
: public impl::ConvertAffineToStandardBase<LowerAffinePass> { : public impl::ConvertAffineToStandardBase<LowerAffinePass> {
void runOnOperation() override { void runOnOperation() override {
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns); populateAffineToStdConversionPatterns(patterns);
populateAffineToVectorConversionPatterns(patterns); populateAffineToVectorConversionPatterns(patterns);
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addLegalDialect<arith::ArithmeticDialect, memref::MemRefDialect, target.addLegalDialect<arith::ArithDialect, memref::MemRefDialect,
scf::SCFDialect, VectorDialect>(); scf::SCFDialect, VectorDialect>();
if (failed(applyPartialConversion(getOperation(), target, if (failed(applyPartialConversion(getOperation(), target,
std::move(patterns)))) std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
}; };
} // namespace } // namespace
/// Lowers If and For operations within a function into their lower level CFG /// Lowers If and For operations within a function into their lower level CFG
/// equivalent blocks. /// equivalent blocks.
std::unique_ptr<Pass> mlir::createLowerAffinePass() { std::unique_ptr<Pass> mlir::createLowerAffinePass() {
return std::make_unique<LowerAffinePass>(); return std::make_unique<LowerAffinePass>();
} }

mlir/lib/Conversion/AffineToStandard/CMakeLists.txt

add_mlir_conversion_library(MLIRAffineToStandard add_mlir_conversion_library(MLIRAffineToStandard
AffineToStandard.cpp AffineToStandard.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/AffineToStandard ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/AffineToStandard
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineUtils MLIRAffineUtils
MLIRArithmeticDialect MLIRArithDialect
MLIRIR MLIRIR
MLIRMemRefDialect MLIRMemRefDialect
MLIRSCFDialect MLIRSCFDialect
MLIRPass MLIRPass
MLIRTransforms MLIRTransforms
MLIRVectorDialect MLIRVectorDialect
) )

mlir/lib/Conversion/ArithToLLVM/ArithToLLVM.cpp

  • This file was moved from mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp.
//===- ArithmeticToLLVM.cpp - Arithmetic to LLVM dialect conversion -------===// //===- ArithToLLVM.cpp - Arithmetic to LLVM dialect conversion -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h" #include "mlir/Conversion/LLVMCommon/VectorPattern.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_ARITHMETICTOLLVMCONVERSIONPASS #define GEN_PASS_DEF_ARITHTOLLVMCONVERSIONPASS
#include "mlir/Conversion/Passes.h.inc" #include "mlir/Conversion/Passes.h.inc"
} // namespace mlir } // namespace mlir
using namespace mlir; using namespace mlir;
namespace { namespace {
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 287 Lines • ▼ Show 20 Lines return LLVM::detail::handleMultidimensionalVectors(
rewriter); rewriter);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Pass Definition // Pass Definition
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace { namespace {
struct ArithmeticToLLVMConversionPass struct ArithToLLVMConversionPass
: public impl::ArithmeticToLLVMConversionPassBase< : public impl::ArithToLLVMConversionPassBase<ArithToLLVMConversionPass> {
ArithmeticToLLVMConversionPass> {
using Base::Base; using Base::Base;
void runOnOperation() override { void runOnOperation() override {
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
LowerToLLVMOptions options(&getContext()); LowerToLLVMOptions options(&getContext());
if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout) if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
options.overrideIndexBitwidth(indexBitwidth); options.overrideIndexBitwidth(indexBitwidth);
LLVMTypeConverter converter(&getContext(), options); LLVMTypeConverter converter(&getContext(), options);
mlir::arith::populateArithmeticToLLVMConversionPatterns(converter, mlir::arith::populateArithToLLVMConversionPatterns(converter, patterns);
patterns);
if (failed(applyPartialConversion(getOperation(), target, if (failed(applyPartialConversion(getOperation(), target,
std::move(patterns)))) std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
}; };
} // namespace } // namespace
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Pattern Population // Pattern Population
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void mlir::arith::populateArithmeticToLLVMConversionPatterns( void mlir::arith::populateArithToLLVMConversionPatterns(
LLVMTypeConverter &converter, RewritePatternSet &patterns) { LLVMTypeConverter &converter, RewritePatternSet &patterns) {
// clang-format off // clang-format off
patterns.add< patterns.add<
AddFOpLowering, AddFOpLowering,
AddIOpLowering, AddIOpLowering,
AndIOpLowering, AndIOpLowering,
AddUICarryOpLowering, AddUICarryOpLowering,
BitcastOpLowering, BitcastOpLowering,
Show All 39 Lines

mlir/lib/Conversion/ArithToLLVM/CMakeLists.txt

  • This file was moved from mlir/lib/Conversion/ArithmeticToLLVM/CMakeLists.txt.
add_mlir_conversion_library(MLIRArithmeticToLLVM add_mlir_conversion_library(MLIRArithToLLVM
ArithmeticToLLVM.cpp ArithToLLVM.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ArithmeticToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ArithToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMDialect MLIRLLVMDialect
) )

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

  • This file was moved from mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp.
//===- ArithmeticToSPIRV.cpp - Arithmetic to SPIRV dialect conversion -----===// //===- ArithToSPIRV.cpp - Arithmetic to SPIRV dialect conversion -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h" #include "mlir/Conversion/ArithToSPIRV/ArithToSPIRV.h"
#include "../SPIRVCommon/Pattern.h" #include "../SPIRVCommon/Pattern.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h" #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/IR/BuiltinAttributes.h" #include "mlir/IR/BuiltinAttributes.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_CONVERTARITHMETICTOSPIRV #define GEN_PASS_DEF_CONVERTARITHTOSPIRV
#include "mlir/Conversion/Passes.h.inc" #include "mlir/Conversion/Passes.h.inc"
} // namespace mlir } // namespace mlir
#define DEBUG_TYPE "arith-to-spirv-pattern" #define DEBUG_TYPE "arith-to-spirv-pattern"
using namespace mlir; using namespace mlir;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 918 Lines • ▼ Show 20 LinesLogicalResult MinMaxFOpPattern<Op, SPIRVOp>::matchAndRewrite(
rewriter.replaceOp(op, select2); rewriter.replaceOp(op, select2);
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Pattern Population // Pattern Population
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void mlir::arith::populateArithmeticToSPIRVPatterns( void mlir::arith::populateArithToSPIRVPatterns(
SPIRVTypeConverter &typeConverter, RewritePatternSet &patterns) { SPIRVTypeConverter &typeConverter, RewritePatternSet &patterns) {
// clang-format off // clang-format off
patterns.add< patterns.add<
ConstantCompositeOpPattern, ConstantCompositeOpPattern,
ConstantScalarOpPattern, ConstantScalarOpPattern,
spirv::ElementwiseOpPattern<arith::AddIOp, spirv::IAddOp>, spirv::ElementwiseOpPattern<arith::AddIOp, spirv::IAddOp>,
spirv::ElementwiseOpPattern<arith::SubIOp, spirv::ISubOp>, spirv::ElementwiseOpPattern<arith::SubIOp, spirv::ISubOp>,
spirv::ElementwiseOpPattern<arith::MulIOp, spirv::IMulOp>, spirv::ElementwiseOpPattern<arith::MulIOp, spirv::IMulOp>,
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines patterns.add<CmpFOpNanKernelPattern>(typeConverter, patterns.getContext(),
/*benefit=*/2); /*benefit=*/2);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Pass Definition // Pass Definition
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace { namespace {
struct ConvertArithmeticToSPIRVPass struct ConvertArithToSPIRVPass
: public impl::ConvertArithmeticToSPIRVBase<ConvertArithmeticToSPIRVPass> { : public impl::ConvertArithToSPIRVBase<ConvertArithToSPIRVPass> {
void runOnOperation() override { void runOnOperation() override {
Operation *op = getOperation(); Operation *op = getOperation();
auto targetAttr = spirv::lookupTargetEnvOrDefault(op); auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
auto target = SPIRVConversionTarget::get(targetAttr); auto target = SPIRVConversionTarget::get(targetAttr);
SPIRVConversionOptions options; SPIRVConversionOptions options;
options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes; options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
options.enableFastMathMode = this->enableFastMath; options.enableFastMathMode = this->enableFastMath;
SPIRVTypeConverter typeConverter(targetAttr, options); SPIRVTypeConverter typeConverter(targetAttr, options);
// Use UnrealizedConversionCast as the bridge so that we don't need to pull // Use UnrealizedConversionCast as the bridge so that we don't need to pull
// in patterns for other dialects. // in patterns for other dialects.
auto addUnrealizedCast = [](OpBuilder &builder, Type type, auto addUnrealizedCast = [](OpBuilder &builder, Type type,
ValueRange inputs, Location loc) { ValueRange inputs, Location loc) {
auto cast = builder.create<UnrealizedConversionCastOp>(loc, type, inputs); auto cast = builder.create<UnrealizedConversionCastOp>(loc, type, inputs);
return Optional<Value>(cast.getResult(0)); return Optional<Value>(cast.getResult(0));
}; };
typeConverter.addSourceMaterialization(addUnrealizedCast); typeConverter.addSourceMaterialization(addUnrealizedCast);
typeConverter.addTargetMaterialization(addUnrealizedCast); typeConverter.addTargetMaterialization(addUnrealizedCast);
target->addLegalOp<UnrealizedConversionCastOp>(); target->addLegalOp<UnrealizedConversionCastOp>();
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns); arith::populateArithToSPIRVPatterns(typeConverter, patterns);
if (failed(applyPartialConversion(op, *target, std::move(patterns)))) if (failed(applyPartialConversion(op, *target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
}; };
} // namespace } // namespace
std::unique_ptr<OperationPass<>> std::unique_ptr<OperationPass<>> mlir::arith::createConvertArithToSPIRVPass() {
mlir::arith::createConvertArithmeticToSPIRVPass() { return std::make_unique<ConvertArithToSPIRVPass>();
return std::make_unique<ConvertArithmeticToSPIRVPass>();
} }

mlir/lib/Conversion/ArithToSPIRV/CMakeLists.txt

  • This file was moved from mlir/lib/Conversion/ArithmeticToSPIRV/CMakeLists.txt.
add_mlir_conversion_library(MLIRArithmeticToSPIRV add_mlir_conversion_library(MLIRArithToSPIRV
ArithmeticToSPIRV.cpp ArithToSPIRV.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ArithmeticToSPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ArithToSPIRV
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRFuncToSPIRV MLIRFuncToSPIRV
MLIRSPIRVConversion MLIRSPIRVConversion
MLIRSPIRVDialect MLIRSPIRVDialect
) )

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

  • This file was moved to mlir/lib/Conversion/ArithToLLVM/ArithToLLVM.cpp.

mlir/lib/Conversion/ArithmeticToLLVM/CMakeLists.txt

  • This file was moved to mlir/lib/Conversion/ArithToLLVM/CMakeLists.txt.

mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp

  • This file was moved to mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp.

mlir/lib/Conversion/ArithmeticToSPIRV/CMakeLists.txt

  • This file was moved to mlir/lib/Conversion/ArithToSPIRV/CMakeLists.txt.

mlir/lib/Conversion/ArmNeon2dToIntr/CMakeLists.txt

add_mlir_conversion_library(MLIRArmNeon2dToIntr add_mlir_conversion_library(MLIRArmNeon2dToIntr
ArmNeon2dToIntr.cpp ArmNeon2dToIntr.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ArmNeon2dToIntr ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ArmNeon2dToIntr
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRArmNeonDialect MLIRArmNeonDialect
MLIRPass MLIRPass
MLIRTransforms MLIRTransforms
MLIRIR MLIRIR
MLIRVectorDialect MLIRVectorDialect
) )

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

//===- AsyncToLLVM.cpp - Convert Async to LLVM dialect --------------------===// //===- AsyncToLLVM.cpp - Convert Async to LLVM dialect --------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h" #include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Async/IR/Async.h" #include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/FuncConversions.h" #include "mlir/Dialect/Func/Transforms/FuncConversions.h"
#include "mlir/Dialect/LLVMIR/FunctionCallUtils.h" #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
▲ Show 20 Lines • Show All 1,120 Lines • Show Last 20 Lines

mlir/lib/Conversion/AsyncToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIRAsyncToLLVM add_mlir_conversion_library(MLIRAsyncToLLVM
AsyncToLLVM.cpp AsyncToLLVM.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/AsyncToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/AsyncToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRAsyncDialect MLIRAsyncDialect
MLIRFuncToLLVM MLIRFuncToLLVM
MLIRFuncTransforms MLIRFuncTransforms
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMDialect MLIRLLVMDialect
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/BufferizationToMemRef/BufferizationToMemRef.cpp

//===- BufferizationToMemRef.cpp - Bufferization to MemRef conversion -----===// //===- BufferizationToMemRef.cpp - Bufferization to MemRef conversion -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements patterns to convert Bufferization dialect to MemRef // This file implements patterns to convert Bufferization dialect to MemRef
// dialect. // dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h" #include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Support/LogicalResult.h" #include "mlir/Support/LogicalResult.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
namespace mlir { namespace mlir {
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

mlir/lib/Conversion/CMakeLists.txt

add_subdirectory(AffineToStandard) add_subdirectory(AffineToStandard)
add_subdirectory(AMDGPUToROCDL) add_subdirectory(AMDGPUToROCDL)
add_subdirectory(ArithmeticToLLVM) add_subdirectory(ArithToLLVM)
add_subdirectory(ArithmeticToSPIRV) add_subdirectory(ArithToSPIRV)
add_subdirectory(ArmNeon2dToIntr) add_subdirectory(ArmNeon2dToIntr)
add_subdirectory(AsyncToLLVM) add_subdirectory(AsyncToLLVM)
add_subdirectory(BufferizationToMemRef) add_subdirectory(BufferizationToMemRef)
add_subdirectory(ComplexToLLVM) add_subdirectory(ComplexToLLVM)
add_subdirectory(ComplexToLibm) add_subdirectory(ComplexToLibm)
add_subdirectory(ComplexToStandard) add_subdirectory(ComplexToStandard)
add_subdirectory(ControlFlowToLLVM) add_subdirectory(ControlFlowToLLVM)
add_subdirectory(ControlFlowToSPIRV) add_subdirectory(ControlFlowToSPIRV)
Show All 39 Lines

mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp

//===- ComplexToLLVM.cpp - conversion from Complex to LLVM dialect --------===// //===- ComplexToLLVM.cpp - conversion from Complex to LLVM dialect --------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h" #include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_CONVERTCOMPLEXTOLLVM #define GEN_PASS_DEF_CONVERTCOMPLEXTOLLVM
#include "mlir/Conversion/Passes.h.inc" #include "mlir/Conversion/Passes.h.inc"
} // namespace mlir } // namespace mlir
▲ Show 20 Lines • Show All 325 Lines • Show Last 20 Lines

mlir/lib/Conversion/ComplexToStandard/CMakeLists.txt

add_mlir_conversion_library(MLIRComplexToStandard add_mlir_conversion_library(MLIRComplexToStandard
ComplexToStandard.cpp ComplexToStandard.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ComplexToStandard ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ComplexToStandard
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRComplexDialect MLIRComplexDialect
MLIRIR MLIRIR
MLIRMathDialect MLIRMathDialect
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp

//===- ComplexToStandard.cpp - conversion from Complex to Standard dialect ===// //===- ComplexToStandard.cpp - conversion from Complex to Standard dialect ===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h" #include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
▲ Show 20 Lines • Show All 1,070 Lines • ▼ Show 20 Lines
}; };
void ConvertComplexToStandardPass::runOnOperation() { void ConvertComplexToStandardPass::runOnOperation() {
// Convert to the Standard dialect using the converter defined above. // Convert to the Standard dialect using the converter defined above.
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateComplexToStandardConversionPatterns(patterns); populateComplexToStandardConversionPatterns(patterns);
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addLegalDialect<arith::ArithmeticDialect, math::MathDialect>(); target.addLegalDialect<arith::ArithDialect, math::MathDialect>();
target.addLegalOp<complex::CreateOp, complex::ImOp, complex::ReOp>(); target.addLegalOp<complex::CreateOp, complex::ImOp, complex::ReOp>();
if (failed( if (failed(
applyPartialConversion(getOperation(), target, std::move(patterns)))) applyPartialConversion(getOperation(), target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
} // namespace } // namespace
std::unique_ptr<Pass> mlir::createConvertComplexToStandardPass() { std::unique_ptr<Pass> mlir::createConvertComplexToStandardPass() {
return std::make_unique<ConvertComplexToStandardPass>(); return std::make_unique<ConvertComplexToStandardPass>();
} }

mlir/lib/Conversion/FuncToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIRFuncToLLVM add_mlir_conversion_library(MLIRFuncToLLVM
FuncToLLVM.cpp FuncToLLVM.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/FuncToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/FuncToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
intrinsics_gen intrinsics_gen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAnalysis MLIRAnalysis
MLIRArithmeticToLLVM MLIRArithToLLVM
MLIRControlFlowToLLVM MLIRControlFlowToLLVM
MLIRDataLayoutInterfaces MLIRDataLayoutInterfaces
MLIRFuncDialect MLIRFuncDialect
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMDialect MLIRLLVMDialect
MLIRTransformUtils MLIRTransformUtils
) )

mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp

//===- FuncToLLVM.cpp - Func to LLVM dialect conversion -------------------===// //===- FuncToLLVM.cpp - Func to LLVM dialect conversion -------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to convert MLIR Func and builtin dialects // This file implements a pass to convert MLIR Func and builtin dialects
// into the LLVM IR dialect. // into the LLVM IR dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Analysis/DataLayoutAnalysis.h" #include "mlir/Analysis/DataLayoutAnalysis.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h" #include "mlir/Conversion/LLVMCommon/VectorPattern.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/FunctionCallUtils.h" #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
▲ Show 20 Lines • Show All 710 Lines • ▼ Show 20 Lines void runOnOperation() override {
LLVMTypeConverter typeConverter(&getContext(), options, LLVMTypeConverter typeConverter(&getContext(), options,
&dataLayoutAnalysis); &dataLayoutAnalysis);
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateFuncToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
// TODO: Remove these in favor of their dedicated conversion passes. // TODO: Remove these in favor of their dedicated conversion passes.
arith::populateArithmeticToLLVMConversionPatterns(typeConverter, patterns); arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns); cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
if (failed(applyPartialConversion(m, target, std::move(patterns)))) if (failed(applyPartialConversion(m, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
m->setAttr(LLVM::LLVMDialect::getDataLayoutAttrName(), m->setAttr(LLVM::LLVMDialect::getDataLayoutAttrName(),
StringAttr::get(m.getContext(), this->dataLayout)); StringAttr::get(m.getContext(), this->dataLayout));
Show All 21 Lines

mlir/lib/Conversion/GPUCommon/CMakeLists.txt

Show All 23 Linesadd_mlir_conversion_library(MLIRGPUToGPURuntimeTransforms
LINK_COMPONENTS LINK_COMPONENTS
Core Core
MC MC
${AMDGPU_LIBS} ${AMDGPU_LIBS}
${NVPTX_LIBS} ${NVPTX_LIBS}
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToLLVM MLIRArithToLLVM
MLIRAsyncToLLVM MLIRAsyncToLLVM
MLIRControlFlowToLLVM MLIRControlFlowToLLVM
MLIRFuncToLLVM MLIRFuncToLLVM
MLIRGPUTransforms MLIRGPUTransforms
MLIRIR MLIRIR
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMDialect MLIRLLVMDialect
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRPass MLIRPass
MLIRSupport MLIRSupport
MLIRVectorToLLVM MLIRVectorToLLVM
) )

mlir/lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp

Show All 9 Lines
// GPU runtime calls. As most of GPU runtimes does not have a stable published // GPU runtime calls. As most of GPU runtimes does not have a stable published
// ABI, this pass uses a slim runtime layer that builds on top of the public // ABI, this pass uses a slim runtime layer that builds on top of the public
// API from GPU runtime headers. // API from GPU runtime headers.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/GPUCommon/GPUCommonPass.h" #include "mlir/Conversion/GPUCommon/GPUCommonPass.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h" #include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h" #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
▲ Show 20 Lines • Show All 356 Lines • ▼ Show 20 Lines
void GpuToLLVMConversionPass::runOnOperation() { void GpuToLLVMConversionPass::runOnOperation() {
LLVMTypeConverter converter(&getContext()); LLVMTypeConverter converter(&getContext());
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addIllegalDialect<gpu::GPUDialect>(); target.addIllegalDialect<gpu::GPUDialect>();
mlir::arith::populateArithmeticToLLVMConversionPatterns(converter, patterns); mlir::arith::populateArithToLLVMConversionPatterns(converter, patterns);
mlir::cf::populateControlFlowToLLVMConversionPatterns(converter, patterns); mlir::cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
populateVectorToLLVMConversionPatterns(converter, patterns); populateVectorToLLVMConversionPatterns(converter, patterns);
populateMemRefToLLVMConversionPatterns(converter, patterns); populateMemRefToLLVMConversionPatterns(converter, patterns);
populateFuncToLLVMConversionPatterns(converter, patterns); populateFuncToLLVMConversionPatterns(converter, patterns);
populateAsyncStructuralTypeConversionsAndLegality(converter, patterns, populateAsyncStructuralTypeConversionsAndLegality(converter, patterns,
target); target);
populateGpuToLLVMConversionPatterns(converter, patterns, gpuBinaryAnnotation, populateGpuToLLVMConversionPatterns(converter, patterns, gpuBinaryAnnotation,
kernelBarePtrCallConv); kernelBarePtrCallConv);
▲ Show 20 Lines • Show All 529 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToNVVM/CMakeLists.txt

set(LLVM_TARGET_DEFINITIONS GPUToNVVM.td) set(LLVM_TARGET_DEFINITIONS GPUToNVVM.td)
mlir_tablegen(GPUToNVVM.cpp.inc -gen-rewriters) mlir_tablegen(GPUToNVVM.cpp.inc -gen-rewriters)
add_public_tablegen_target(MLIRGPUToNVVMIncGen) add_public_tablegen_target(MLIRGPUToNVVMIncGen)
add_mlir_conversion_library(MLIRGPUToNVVMTransforms add_mlir_conversion_library(MLIRGPUToNVVMTransforms
LowerGpuOpsToNVVMOps.cpp LowerGpuOpsToNVVMOps.cpp
WmmaOpsToNvvm.cpp WmmaOpsToNvvm.cpp
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
MLIRGPUToNVVMIncGen MLIRGPUToNVVMIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToLLVM MLIRArithToLLVM
MLIRFuncToLLVM MLIRFuncToLLVM
MLIRGPUOps MLIRGPUOps
MLIRGPUToGPURuntimeTransforms MLIRGPUToGPURuntimeTransforms
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMDialect MLIRLLVMDialect
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRNVVMDialect MLIRNVVMDialect
MLIRPass MLIRPass
MLIRTransformUtils MLIRTransformUtils
) )

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

//===- LowerGpuOpsToNVVMOps.cpp - MLIR GPU to NVVM lowering passes --------===// //===- LowerGpuOpsToNVVMOps.cpp - MLIR GPU to NVVM lowering passes --------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to generate NVVMIR operations for higher-level // This file implements a pass to generate NVVMIR operations for higher-level
// GPU operations. // GPU operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h" #include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h" #include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/GPU/Transforms/Passes.h" #include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/Dialect/LLVMIR/NVVMDialect.h" #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Lines void runOnOperation() override {
RewritePatternSet llvmPatterns(m.getContext()); RewritePatternSet llvmPatterns(m.getContext());
// Apply in-dialect lowering first. In-dialect lowering will replace ops // Apply in-dialect lowering first. In-dialect lowering will replace ops
// which need to be lowered further, which is not supported by a single // which need to be lowered further, which is not supported by a single
// conversion pass. // conversion pass.
populateGpuRewritePatterns(patterns); populateGpuRewritePatterns(patterns);
(void)applyPatternsAndFoldGreedily(m, std::move(patterns)); (void)applyPatternsAndFoldGreedily(m, std::move(patterns));
arith::populateArithmeticToLLVMConversionPatterns(converter, llvmPatterns); arith::populateArithToLLVMConversionPatterns(converter, llvmPatterns);
cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns); cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns);
populateFuncToLLVMConversionPatterns(converter, llvmPatterns); populateFuncToLLVMConversionPatterns(converter, llvmPatterns);
populateMemRefToLLVMConversionPatterns(converter, llvmPatterns); populateMemRefToLLVMConversionPatterns(converter, llvmPatterns);
populateGpuToNVVMConversionPatterns(converter, llvmPatterns); populateGpuToNVVMConversionPatterns(converter, llvmPatterns);
populateGpuWMMAToNVVMConversionPatterns(converter, llvmPatterns); populateGpuWMMAToNVVMConversionPatterns(converter, llvmPatterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
configureGpuToNVVMConversionLegality(target); configureGpuToNVVMConversionLegality(target);
if (failed(applyPartialConversion(m, target, std::move(llvmPatterns)))) if (failed(applyPartialConversion(m, target, std::move(llvmPatterns))))
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToROCDL/CMakeLists.txt

set(LLVM_TARGET_DEFINITIONS GPUToROCDL.td) set(LLVM_TARGET_DEFINITIONS GPUToROCDL.td)
mlir_tablegen(GPUToROCDL.cpp.inc -gen-rewriters) mlir_tablegen(GPUToROCDL.cpp.inc -gen-rewriters)
add_public_tablegen_target(MLIRGPUToROCDLIncGen) add_public_tablegen_target(MLIRGPUToROCDLIncGen)
add_mlir_conversion_library(MLIRGPUToROCDLTransforms add_mlir_conversion_library(MLIRGPUToROCDLTransforms
LowerGpuOpsToROCDLOps.cpp LowerGpuOpsToROCDLOps.cpp
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
MLIRGPUToROCDLIncGen MLIRGPUToROCDLIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToLLVM MLIRArithToLLVM
MLIRAMDGPUToROCDL MLIRAMDGPUToROCDL
MLIRFuncToLLVM MLIRFuncToLLVM
MLIRGPUOps MLIRGPUOps
MLIRGPUToGPURuntimeTransforms MLIRGPUToGPURuntimeTransforms
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMDialect MLIRLLVMDialect
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRROCDLDialect MLIRROCDLDialect
MLIRPass MLIRPass
) )

mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp

Show All 9 Lines
// GPU operations. // GPU operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h" #include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h"
#include "mlir/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.h" #include "mlir/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h" #include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h" #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines void runOnOperation() override {
LLVMTypeConverter converter(ctx, options); LLVMTypeConverter converter(ctx, options);
RewritePatternSet patterns(ctx); RewritePatternSet patterns(ctx);
RewritePatternSet llvmPatterns(ctx); RewritePatternSet llvmPatterns(ctx);
populateGpuRewritePatterns(patterns); populateGpuRewritePatterns(patterns);
(void)applyPatternsAndFoldGreedily(m, std::move(patterns)); (void)applyPatternsAndFoldGreedily(m, std::move(patterns));
mlir::arith::populateArithmeticToLLVMConversionPatterns(converter, mlir::arith::populateArithToLLVMConversionPatterns(converter, llvmPatterns);
llvmPatterns);
populateAMDGPUToROCDLConversionPatterns(converter, llvmPatterns, populateAMDGPUToROCDLConversionPatterns(converter, llvmPatterns,
*maybeChipset); *maybeChipset);
populateVectorToLLVMConversionPatterns(converter, llvmPatterns); populateVectorToLLVMConversionPatterns(converter, llvmPatterns);
cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns); cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns);
populateFuncToLLVMConversionPatterns(converter, llvmPatterns); populateFuncToLLVMConversionPatterns(converter, llvmPatterns);
populateMemRefToLLVMConversionPatterns(converter, llvmPatterns); populateMemRefToLLVMConversionPatterns(converter, llvmPatterns);
populateGpuToROCDLConversionPatterns(converter, llvmPatterns, runtime); populateGpuToROCDLConversionPatterns(converter, llvmPatterns, runtime);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToSPIRV/CMakeLists.txt

add_mlir_conversion_library(MLIRGPUToSPIRV add_mlir_conversion_library(MLIRGPUToSPIRV
GPUToSPIRV.cpp GPUToSPIRV.cpp
GPUToSPIRVPass.cpp GPUToSPIRVPass.cpp
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToSPIRV MLIRArithToSPIRV
MLIRGPUOps MLIRGPUOps
MLIRFuncToSPIRV MLIRFuncToSPIRV
MLIRIR MLIRIR
MLIRPass MLIRPass
MLIRSCFToSPIRV MLIRSCFToSPIRV
MLIRSPIRVDialect MLIRSPIRVDialect
MLIRSPIRVConversion MLIRSPIRVConversion
MLIRSupport MLIRSupport
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRVPass.cpp

//===- GPUToSPIRVPass.cpp - GPU to SPIR-V Passes --------------------------===// //===- GPUToSPIRVPass.cpp - GPU to SPIR-V Passes --------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to convert a kernel function in the GPU Dialect // This file implements a pass to convert a kernel function in the GPU Dialect
// into a spirv.module operation. // into a spirv.module operation.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h" #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h" #include "mlir/Conversion/ArithToSPIRV/ArithToSPIRV.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h" #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRV.h" #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRV.h"
#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h" #include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines std::unique_ptr<ConversionTarget> target =
SPIRVConversionTarget::get(targetAttr); SPIRVConversionTarget::get(targetAttr);
SPIRVTypeConverter typeConverter(targetAttr); SPIRVTypeConverter typeConverter(targetAttr);
RewritePatternSet patterns(context); RewritePatternSet patterns(context);
populateGPUToSPIRVPatterns(typeConverter, patterns); populateGPUToSPIRVPatterns(typeConverter, patterns);
// TODO: Change SPIR-V conversion to be progressive and remove the following // TODO: Change SPIR-V conversion to be progressive and remove the following
// patterns. // patterns.
mlir::arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns); mlir::arith::populateArithToSPIRVPatterns(typeConverter, patterns);
populateMemRefToSPIRVPatterns(typeConverter, patterns); populateMemRefToSPIRVPatterns(typeConverter, patterns);
populateFuncToSPIRVPatterns(typeConverter, patterns); populateFuncToSPIRVPatterns(typeConverter, patterns);
if (failed(applyFullConversion(gpuModules, *target, std::move(patterns)))) if (failed(applyFullConversion(gpuModules, *target, std::move(patterns))))
return signalPassFailure(); return signalPassFailure();
} }
std::unique_ptr<OperationPass<ModuleOp>> std::unique_ptr<OperationPass<ModuleOp>>
mlir::createConvertGPUToSPIRVPass(bool mapMemorySpace) { mlir::createConvertGPUToSPIRVPass(bool mapMemorySpace) {
return std::make_unique<GPUToSPIRVPass>(mapMemorySpace); return std::make_unique<GPUToSPIRVPass>(mapMemorySpace);
} }

mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Linesstruct ConvertLinalgToStandardPass
: public impl::ConvertLinalgToStandardBase<ConvertLinalgToStandardPass> { : public impl::ConvertLinalgToStandardBase<ConvertLinalgToStandardPass> {
void runOnOperation() override; void runOnOperation() override;
}; };
} // namespace } // namespace
void ConvertLinalgToStandardPass::runOnOperation() { void ConvertLinalgToStandardPass::runOnOperation() {
auto module = getOperation(); auto module = getOperation();
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addLegalDialect<AffineDialect, arith::ArithmeticDialect, target.addLegalDialect<AffineDialect, arith::ArithDialect, func::FuncDialect,
func::FuncDialect, memref::MemRefDialect, memref::MemRefDialect, scf::SCFDialect>();
scf::SCFDialect>();
target.addLegalOp<ModuleOp, func::FuncOp, func::ReturnOp>(); target.addLegalOp<ModuleOp, func::FuncOp, func::ReturnOp>();
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateLinalgToStandardConversionPatterns(patterns); populateLinalgToStandardConversionPatterns(patterns);
if (failed(applyFullConversion(module, target, std::move(patterns)))) if (failed(applyFullConversion(module, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
std::unique_ptr<OperationPass<ModuleOp>> std::unique_ptr<OperationPass<ModuleOp>>
mlir::createConvertLinalgToStandardPass() { mlir::createConvertLinalgToStandardPass() {
return std::make_unique<ConvertLinalgToStandardPass>(); return std::make_unique<ConvertLinalgToStandardPass>();
} }

mlir/lib/Conversion/MathToFuncs/CMakeLists.txt

add_mlir_conversion_library(MLIRMathToFuncs add_mlir_conversion_library(MLIRMathToFuncs
MathToFuncs.cpp MathToFuncs.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/MathToFuncs ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/MathToFuncs
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRControlFlowDialect MLIRControlFlowDialect
MLIRFuncDialect MLIRFuncDialect
MLIRLLVMDialect MLIRLLVMDialect
MLIRMathDialect MLIRMathDialect
MLIRPass MLIRPass
MLIRTransforms MLIRTransforms
MLIRVectorDialect MLIRVectorDialect
MLIRVectorUtils MLIRVectorUtils
) )

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

//===- MathToFuncs.cpp - Math to outlined implementation conversion -------===// //===- MathToFuncs.cpp - Math to outlined implementation conversion -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/MathToFuncs/MathToFuncs.h" #include "mlir/Conversion/MathToFuncs/MathToFuncs.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Utils/IndexingUtils.h" #include "mlir/Dialect/Utils/IndexingUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
▲ Show 20 Lines • Show All 352 Lines • ▼ Show 20 Lines auto getPowerFuncOpByType = [&](Type type) -> func::FuncOp {
if (it == powerFuncs.end()) if (it == powerFuncs.end())
return {}; return {};
return it->second; return it->second;
}; };
patterns.add<IPowIOpLowering>(patterns.getContext(), getPowerFuncOpByType); patterns.add<IPowIOpLowering>(patterns.getContext(), getPowerFuncOpByType);
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addLegalDialect<arith::ArithmeticDialect, cf::ControlFlowDialect, target.addLegalDialect<arith::ArithDialect, cf::ControlFlowDialect,
func::FuncDialect, vector::VectorDialect>(); func::FuncDialect, vector::VectorDialect>();
target.addIllegalOp<math::IPowIOp>(); target.addIllegalOp<math::IPowIOp>();
if (failed(applyPartialConversion(module, target, std::move(patterns)))) if (failed(applyPartialConversion(module, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
std::unique_ptr<Pass> mlir::createConvertMathToFuncsPass() { std::unique_ptr<Pass> mlir::createConvertMathToFuncsPass() {
return std::make_unique<ConvertMathToFuncsPass>(); return std::make_unique<ConvertMathToFuncsPass>();
} }

mlir/lib/Conversion/MathToLibm/CMakeLists.txt

add_mlir_conversion_library(MLIRMathToLibm add_mlir_conversion_library(MLIRMathToLibm
MathToLibm.cpp MathToLibm.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/MathToLibm ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/MathToLibm
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRDialectUtils MLIRDialectUtils
MLIRFuncDialect MLIRFuncDialect
MLIRMathDialect MLIRMathDialect
MLIRTransformUtils MLIRTransformUtils
MLIRVectorDialect MLIRVectorDialect
MLIRVectorUtils MLIRVectorUtils
) )

mlir/lib/Conversion/MathToLibm/MathToLibm.cpp

//===-- MathToLibm.cpp - conversion from Math to libm calls ---------------===// //===-- MathToLibm.cpp - conversion from Math to libm calls ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/MathToLibm/MathToLibm.h" #include "mlir/Conversion/MathToLibm/MathToLibm.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Utils/IndexingUtils.h" #include "mlir/Dialect/Utils/IndexingUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/BuiltinDialect.h" #include "mlir/IR/BuiltinDialect.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines
void ConvertMathToLibmPass::runOnOperation() { void ConvertMathToLibmPass::runOnOperation() {
auto module = getOperation(); auto module = getOperation();
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateMathToLibmConversionPatterns(patterns, /*benefit=*/1); populateMathToLibmConversionPatterns(patterns, /*benefit=*/1);
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addLegalDialect<arith::ArithmeticDialect, BuiltinDialect, target.addLegalDialect<arith::ArithDialect, BuiltinDialect, func::FuncDialect,
func::FuncDialect, vector::VectorDialect>(); vector::VectorDialect>();
target.addIllegalDialect<math::MathDialect>(); target.addIllegalDialect<math::MathDialect>();
if (failed(applyPartialConversion(module, target, std::move(patterns)))) if (failed(applyPartialConversion(module, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertMathToLibmPass() { std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertMathToLibmPass() {
return std::make_unique<ConvertMathToLibmPass>(); return std::make_unique<ConvertMathToLibmPass>();
} }

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

//===- MemRefToLLVM.cpp - MemRef to LLVM dialect conversion ---------------===// //===- MemRefToLLVM.cpp - MemRef to LLVM dialect conversion ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Analysis/DataLayoutAnalysis.h" #include "mlir/Analysis/DataLayoutAnalysis.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/AllocLikeConversion.h" #include "mlir/Conversion/MemRefToLLVM/AllocLikeConversion.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/FunctionCallUtils.h" #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "llvm/ADT/SmallBitVector.h" #include "llvm/ADT/SmallBitVector.h"
▲ Show 20 Lines • Show All 2,135 Lines • Show Last 20 Lines

mlir/lib/Conversion/OpenACCToSCF/CMakeLists.txt

add_mlir_conversion_library(MLIROpenACCToSCF add_mlir_conversion_library(MLIROpenACCToSCF
OpenACCToSCF.cpp OpenACCToSCF.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/OpenACCToSCF ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/OpenACCToSCF
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRIR MLIRIR
MLIROpenACCDialect MLIROpenACCDialect
MLIRSCFDialect MLIRSCFDialect
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/OpenACCToSCF/OpenACCToSCF.cpp

//===- OpenACCToSCF.cpp - OpenACC condition to SCF if conversion ----------===// //===- OpenACCToSCF.cpp - OpenACC condition to SCF if conversion ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h" #include "mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/OpenACC/OpenACC.h" #include "mlir/Dialect/OpenACC/OpenACC.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_CONVERTOPENACCTOSCF #define GEN_PASS_DEF_CONVERTOPENACCTOSCF
#include "mlir/Conversion/Passes.h.inc" #include "mlir/Conversion/Passes.h.inc"
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

mlir/lib/Conversion/OpenMPToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIROpenMPToLLVM add_mlir_conversion_library(MLIROpenMPToLLVM
OpenMPToLLVM.cpp OpenMPToLLVM.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/OpenMPToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/OpenMPToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
intrinsics_gen intrinsics_gen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToLLVM MLIRArithToLLVM
MLIRFuncToLLVM MLIRFuncToLLVM
MLIRIR MLIRIR
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMDialect MLIRLLVMDialect
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIROpenMPDialect MLIROpenMPDialect
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp

//===- OpenMPToLLVM.cpp - conversion from OpenMP to LLVM dialect ----------===// //===- OpenMPToLLVM.cpp - conversion from OpenMP to LLVM dialect ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h" #include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/OpenMP/OpenMPDialect.h" #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines
} // namespace } // namespace
void ConvertOpenMPToLLVMPass::runOnOperation() { void ConvertOpenMPToLLVMPass::runOnOperation() {
auto module = getOperation(); auto module = getOperation();
// Convert to OpenMP operations with LLVM IR dialect // Convert to OpenMP operations with LLVM IR dialect
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
LLVMTypeConverter converter(&getContext()); LLVMTypeConverter converter(&getContext());
arith::populateArithmeticToLLVMConversionPatterns(converter, patterns); arith::populateArithToLLVMConversionPatterns(converter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(converter, patterns); cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
populateMemRefToLLVMConversionPatterns(converter, patterns); populateMemRefToLLVMConversionPatterns(converter, patterns);
populateFuncToLLVMConversionPatterns(converter, patterns); populateFuncToLLVMConversionPatterns(converter, patterns);
populateOpenMPToLLVMConversionPatterns(converter, patterns); populateOpenMPToLLVMConversionPatterns(converter, patterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addLegalOp<omp::TerminatorOp, omp::TaskyieldOp, omp::FlushOp, target.addLegalOp<omp::TerminatorOp, omp::TaskyieldOp, omp::FlushOp,
omp::BarrierOp, omp::TaskwaitOp>(); omp::BarrierOp, omp::TaskwaitOp>();
configureOpenMPToLLVMConversionLegality(target, converter); configureOpenMPToLLVMConversionLegality(target, converter);
if (failed(applyPartialConversion(module, target, std::move(patterns)))) if (failed(applyPartialConversion(module, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertOpenMPToLLVMPass() { std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertOpenMPToLLVMPass() {
return std::make_unique<ConvertOpenMPToLLVMPass>(); return std::make_unique<ConvertOpenMPToLLVMPass>();
} }

mlir/lib/Conversion/SCFToControlFlow/CMakeLists.txt

add_mlir_conversion_library(MLIRSCFToControlFlow add_mlir_conversion_library(MLIRSCFToControlFlow
SCFToControlFlow.cpp SCFToControlFlow.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToControlFlow ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToControlFlow
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRControlFlowDialect MLIRControlFlowDialect
MLIRSCFDialect MLIRSCFDialect
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/SCFToControlFlow/SCFToControlFlow.cpp

//===- SCFToControlFlow.cpp - SCF to CF conversion ------------------------===// //===- SCFToControlFlow.cpp - SCF to CF conversion ------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to convert scf.for, scf.if and loop.terminator // This file implements a pass to convert scf.for, scf.if and loop.terminator
// ops into standard CFG ops. // ops into standard CFG ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/MLIRContext.h" #include "mlir/IR/MLIRContext.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
▲ Show 20 Lines • Show All 617 Lines • Show Last 20 Lines

mlir/lib/Conversion/SCFToGPU/CMakeLists.txt

add_mlir_conversion_library(MLIRSCFToGPU add_mlir_conversion_library(MLIRSCFToGPU
SCFToGPU.cpp SCFToGPU.cpp
SCFToGPUPass.cpp SCFToGPUPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToGPU ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToGPU
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineToStandard MLIRAffineToStandard
MLIRArithmeticDialect MLIRArithDialect
MLIRComplexDialect MLIRComplexDialect
MLIRGPUTransforms MLIRGPUTransforms
MLIRIR MLIRIR
MLIRLinalgDialect MLIRLinalgDialect
MLIRMemRefDialect MLIRMemRefDialect
MLIRPass MLIRPass
MLIRSupport MLIRSupport
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp

Show All 10 Lines
// or to further transform the kernel to ensure correctness. // or to further transform the kernel to ensure correctness.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/SCFToGPU/SCFToGPU.h" #include "mlir/Conversion/SCFToGPU/SCFToGPU.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h" #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/GPU/Transforms/ParallelLoopMapper.h" #include "mlir/Dialect/GPU/Transforms/ParallelLoopMapper.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
▲ Show 20 Lines • Show All 666 Lines • Show Last 20 Lines

mlir/lib/Conversion/SCFToGPU/SCFToGPUPass.cpp

//===- SCFToGPUPass.cpp - Convert a loop nest to a GPU kernel -----------===// //===- SCFToGPUPass.cpp - Convert a loop nest to a GPU kernel -----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h" #include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h"
#include "mlir/Conversion/SCFToGPU/SCFToGPU.h" #include "mlir/Conversion/SCFToGPU/SCFToGPU.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

mlir/lib/Conversion/SCFToOpenMP/CMakeLists.txt

add_mlir_conversion_library(MLIRSCFToOpenMP add_mlir_conversion_library(MLIRSCFToOpenMP
SCFToOpenMP.cpp SCFToOpenMP.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToStandard ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToStandard
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAnalysis MLIRAnalysis
MLIRArithmeticDialect MLIRArithDialect
MLIRLLVMDialect MLIRLLVMDialect
MLIROpenMPDialect MLIROpenMPDialect
MLIRSCFDialect MLIRSCFDialect
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp

Show All 9 Lines
// parallel loops. // parallel loops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h" #include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h"
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h" #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/OpenMP/OpenMPDialect.h" #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/SymbolTable.h" #include "mlir/IR/SymbolTable.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
▲ Show 20 Lines • Show All 438 Lines • Show Last 20 Lines

mlir/lib/Conversion/SCFToSPIRV/CMakeLists.txt

add_mlir_conversion_library(MLIRSCFToSPIRV add_mlir_conversion_library(MLIRSCFToSPIRV
SCFToSPIRV.cpp SCFToSPIRV.cpp
SCFToSPIRVPass.cpp SCFToSPIRVPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToSPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToSPIRV
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToSPIRV MLIRArithToSPIRV
MLIRFuncToSPIRV MLIRFuncToSPIRV
MLIRMemRefToSPIRV MLIRMemRefToSPIRV
MLIRSPIRVDialect MLIRSPIRVDialect
MLIRSPIRVConversion MLIRSPIRVConversion
MLIRIR MLIRIR
MLIRPass MLIRPass
MLIRSCFDialect MLIRSCFDialect
MLIRSupport MLIRSupport
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRVPass.cpp

//===- SCFToSPIRVPass.cpp - SCF to SPIR-V Passes --------------------------===// //===- SCFToSPIRVPass.cpp - SCF to SPIR-V Passes --------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to convert SCF dialect into SPIR-V dialect. // This file implements a pass to convert SCF dialect into SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h" #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h"
#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h" #include "mlir/Conversion/ArithToSPIRV/ArithToSPIRV.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h" #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h" #include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
#include "mlir/Conversion/SCFToSPIRV/SCFToSPIRV.h" #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRV.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
namespace mlir { namespace mlir {
Show All 19 Linesvoid SCFToSPIRVPass::runOnOperation() {
SPIRVTypeConverter typeConverter(targetAttr); SPIRVTypeConverter typeConverter(targetAttr);
ScfToSPIRVContext scfContext; ScfToSPIRVContext scfContext;
RewritePatternSet patterns(context); RewritePatternSet patterns(context);
populateSCFToSPIRVPatterns(typeConverter, scfContext, patterns); populateSCFToSPIRVPatterns(typeConverter, scfContext, patterns);
// TODO: Change SPIR-V conversion to be progressive and remove the following // TODO: Change SPIR-V conversion to be progressive and remove the following
// patterns. // patterns.
mlir::arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns); mlir::arith::populateArithToSPIRVPatterns(typeConverter, patterns);
populateFuncToSPIRVPatterns(typeConverter, patterns); populateFuncToSPIRVPatterns(typeConverter, patterns);
populateMemRefToSPIRVPatterns(typeConverter, patterns); populateMemRefToSPIRVPatterns(typeConverter, patterns);
populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns); populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns);
if (failed(applyPartialConversion(op, *target, std::move(patterns)))) if (failed(applyPartialConversion(op, *target, std::move(patterns))))
return signalPassFailure(); return signalPassFailure();
} }
std::unique_ptr<OperationPass<>> mlir::createConvertSCFToSPIRVPass() { std::unique_ptr<OperationPass<>> mlir::createConvertSCFToSPIRVPass() {
return std::make_unique<SCFToSPIRVPass>(); return std::make_unique<SCFToSPIRVPass>();
} }

mlir/lib/Conversion/SPIRVToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIRSPIRVToLLVM add_mlir_conversion_library(MLIRSPIRVToLLVM
ConvertLaunchFuncToLLVMCalls.cpp ConvertLaunchFuncToLLVMCalls.cpp
SPIRVToLLVM.cpp SPIRVToLLVM.cpp
SPIRVToLLVMPass.cpp SPIRVToLLVMPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SPIRVToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SPIRVToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
intrinsics_gen intrinsics_gen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToLLVM MLIRArithToLLVM
MLIRFuncToLLVM MLIRFuncToLLVM
MLIRGPUOps MLIRGPUOps
MLIRIR MLIRIR
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMDialect MLIRLLVMDialect
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRSPIRVDialect MLIRSPIRVDialect
MLIRSPIRVUtils MLIRSPIRVUtils
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

//===- ConvertLaunchFuncToLLVMCalls.cpp - MLIR GPU launch to LLVM pass ----===// //===- ConvertLaunchFuncToLLVMCalls.cpp - MLIR GPU launch to LLVM pass ----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements passes to convert `gpu.launch_func` op into a sequence // This file implements passes to convert `gpu.launch_func` op into a sequence
// of LLVM calls that emulate the host and device sides. // of LLVM calls that emulate the host and device sides.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h" #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h" #include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVM.h" #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVM.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
▲ Show 20 Lines • Show All 267 Lines • ▼ Show 20 Lines for (auto func : module.getOps<func::FuncOp>()) {
UnitAttr::get(&getContext())); UnitAttr::get(&getContext()));
} }
// Specify options to lower to LLVM and pull in the conversion patterns. // Specify options to lower to LLVM and pull in the conversion patterns.
LowerToLLVMOptions options(module.getContext()); LowerToLLVMOptions options(module.getContext());
auto *context = module.getContext(); auto *context = module.getContext();
RewritePatternSet patterns(context); RewritePatternSet patterns(context);
LLVMTypeConverter typeConverter(context, options); LLVMTypeConverter typeConverter(context, options);
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
populateFuncToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
patterns.add<GPULaunchLowering>(typeConverter); patterns.add<GPULaunchLowering>(typeConverter);
// Pull in SPIR-V type conversion patterns to convert SPIR-V global // Pull in SPIR-V type conversion patterns to convert SPIR-V global
// variable's type to LLVM dialect type. // variable's type to LLVM dialect type.
populateSPIRVToLLVMTypeConversion(typeConverter); populateSPIRVToLLVMTypeConversion(typeConverter);
Show All 17 Lines

mlir/lib/Conversion/ShapeToStandard/CMakeLists.txt

Show All 11 Linesadd_mlir_conversion_library(MLIRShapeToStandard
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
ShapeToStandardIncGen ShapeToStandardIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRIR MLIRIR
MLIRShapeDialect MLIRShapeDialect
MLIRTensorDialect MLIRTensorDialect
MLIRPass MLIRPass
MLIRSCFDialect MLIRSCFDialect
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp

//===- ShapeToStandard.cpp - conversion from Shape to Standard dialect ----===// //===- ShapeToStandard.cpp - conversion from Shape to Standard dialect ----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h" #include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Shape/IR/Shape.h" #include "mlir/Dialect/Shape/IR/Shape.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
▲ Show 20 Lines • Show All 670 Lines • ▼ Show 20 Linesclass ConvertShapeToStandardPass
void runOnOperation() override; void runOnOperation() override;
}; };
} // namespace } // namespace
void ConvertShapeToStandardPass::runOnOperation() { void ConvertShapeToStandardPass::runOnOperation() {
// Setup target legality. // Setup target legality.
MLIRContext &ctx = getContext(); MLIRContext &ctx = getContext();
ConversionTarget target(ctx); ConversionTarget target(ctx);
target.addLegalDialect<arith::ArithmeticDialect, SCFDialect, target.addLegalDialect<arith::ArithDialect, SCFDialect,
tensor::TensorDialect>(); tensor::TensorDialect>();
target.addLegalOp<CstrRequireOp, func::FuncOp, ModuleOp>(); target.addLegalOp<CstrRequireOp, func::FuncOp, ModuleOp>();
// Setup conversion patterns. // Setup conversion patterns.
RewritePatternSet patterns(&ctx); RewritePatternSet patterns(&ctx);
populateShapeToStandardConversionPatterns(patterns); populateShapeToStandardConversionPatterns(patterns);
// Apply conversion. // Apply conversion.
Show All 32 Lines

mlir/lib/Conversion/TensorToLinalg/TensorToLinalgPass.cpp

//===- TensorToLinalgPass.cpp - Tensor to Linalg Passes -------------------===// //===- TensorToLinalgPass.cpp - Tensor to Linalg Passes -------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to convert Tensor dialect to Linalg dialect. // This file implements a pass to convert Tensor dialect to Linalg dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/TensorToLinalg/TensorToLinalgPass.h" #include "mlir/Conversion/TensorToLinalg/TensorToLinalgPass.h"
#include "mlir/Conversion/TensorToLinalg/TensorToLinalg.h" #include "mlir/Conversion/TensorToLinalg/TensorToLinalg.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_CONVERTTENSORTOLINALG #define GEN_PASS_DEF_CONVERTTENSORTOLINALG
#include "mlir/Conversion/Passes.h.inc" #include "mlir/Conversion/Passes.h.inc"
} // namespace mlir } // namespace mlir
using namespace mlir; using namespace mlir;
namespace { namespace {
/// A pass converting MLIR Tensor operations into the Linalg dialect. /// A pass converting MLIR Tensor operations into the Linalg dialect.
class ConvertTensorToLinalgPass class ConvertTensorToLinalgPass
: public impl::ConvertTensorToLinalgBase<ConvertTensorToLinalgPass> { : public impl::ConvertTensorToLinalgBase<ConvertTensorToLinalgPass> {
void runOnOperation() override { void runOnOperation() override {
auto &context = getContext(); auto &context = getContext();
ConversionTarget target(context); ConversionTarget target(context);
target.addLegalDialect<mlir::arith::ArithmeticDialect, target
mlir::linalg::LinalgDialect, .addLegalDialect<mlir::arith::ArithDialect, mlir::linalg::LinalgDialect,
mlir::tensor::TensorDialect>(); mlir::tensor::TensorDialect>();
target.addIllegalOp<mlir::tensor::PadOp>(); target.addIllegalOp<mlir::tensor::PadOp>();
RewritePatternSet patterns(&context); RewritePatternSet patterns(&context);
populateTensorToLinalgPatterns(patterns); populateTensorToLinalgPatterns(patterns);
if (failed(applyPartialConversion(getOperation(), target, if (failed(applyPartialConversion(getOperation(), target,
std::move(patterns)))) std::move(patterns))))
return signalPassFailure(); return signalPassFailure();
} }
}; };
} // namespace } // namespace
std::unique_ptr<OperationPass<ModuleOp>> std::unique_ptr<OperationPass<ModuleOp>>
mlir::createConvertTensorToLinalgPass() { mlir::createConvertTensorToLinalgPass() {
return std::make_unique<ConvertTensorToLinalgPass>(); return std::make_unique<ConvertTensorToLinalgPass>();
} }

mlir/lib/Conversion/TensorToSPIRV/CMakeLists.txt

add_mlir_conversion_library(MLIRTensorToSPIRV add_mlir_conversion_library(MLIRTensorToSPIRV
TensorToSPIRV.cpp TensorToSPIRV.cpp
TensorToSPIRVPass.cpp TensorToSPIRVPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
${MLIR_MAIN_INCLUDE_DIR}/mlir/IR ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToSPIRV MLIRArithToSPIRV
MLIRFuncToSPIRV MLIRFuncToSPIRV
MLIRIR MLIRIR
MLIRPass MLIRPass
MLIRSPIRVDialect MLIRSPIRVDialect
MLIRSPIRVConversion MLIRSPIRVConversion
MLIRSupport MLIRSupport
MLIRTransformUtils MLIRTransformUtils
MLIRTensorDialect MLIRTensorDialect
) )

mlir/lib/Conversion/TensorToSPIRV/TensorToSPIRVPass.cpp

//===- TensorToSPIRVPass.cpp - Tensor to SPIR-V Passes ----------------===// //===- TensorToSPIRVPass.cpp - Tensor to SPIR-V Passes ----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to convert Tensor dialect to SPIR-V dialect. // This file implements a pass to convert Tensor dialect to SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/TensorToSPIRV/TensorToSPIRVPass.h" #include "mlir/Conversion/TensorToSPIRV/TensorToSPIRVPass.h"
#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h" #include "mlir/Conversion/ArithToSPIRV/ArithToSPIRV.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h" #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Conversion/TensorToSPIRV/TensorToSPIRV.h" #include "mlir/Conversion/TensorToSPIRV/TensorToSPIRV.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_CONVERTTENSORTOSPIRV #define GEN_PASS_DEF_CONVERTTENSORTOSPIRV
#include "mlir/Conversion/Passes.h.inc" #include "mlir/Conversion/Passes.h.inc"
Show All 13 Lines void runOnOperation() override {
std::unique_ptr<ConversionTarget> target = std::unique_ptr<ConversionTarget> target =
SPIRVConversionTarget::get(targetAttr); SPIRVConversionTarget::get(targetAttr);
SPIRVConversionOptions options; SPIRVConversionOptions options;
options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes; options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
SPIRVTypeConverter typeConverter(targetAttr, options); SPIRVTypeConverter typeConverter(targetAttr, options);
RewritePatternSet patterns(context); RewritePatternSet patterns(context);
arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns); arith::populateArithToSPIRVPatterns(typeConverter, patterns);
populateFuncToSPIRVPatterns(typeConverter, patterns); populateFuncToSPIRVPatterns(typeConverter, patterns);
populateTensorToSPIRVPatterns(typeConverter, /*byteCountThreshold=*/64, populateTensorToSPIRVPatterns(typeConverter, /*byteCountThreshold=*/64,
patterns); patterns);
populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns); populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns);
if (failed(applyPartialConversion(op, *target, std::move(patterns)))) if (failed(applyPartialConversion(op, *target, std::move(patterns))))
return signalPassFailure(); return signalPassFailure();
} }
}; };
} // namespace } // namespace
std::unique_ptr<OperationPass<>> mlir::createConvertTensorToSPIRVPass() { std::unique_ptr<OperationPass<>> mlir::createConvertTensorToSPIRVPass() {
return std::make_unique<ConvertTensorToSPIRVPass>(); return std::make_unique<ConvertTensorToSPIRVPass>();
} }

mlir/lib/Conversion/TosaToArith/CMakeLists.txt

add_mlir_conversion_library(MLIRTosaToArith add_mlir_conversion_library(MLIRTosaToArith
TosaToArith.cpp TosaToArith.cpp
TosaToArithPass.cpp TosaToArithPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tosa ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tosa
${MLIR_MAIN_INCLUDE_DIR}/mlir/IR ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRIR MLIRIR
MLIRPass MLIRPass
MLIRTosaDialect MLIRTosaDialect
MLIRTosaTransforms MLIRTosaTransforms
MLIRSupport MLIRSupport
) )

mlir/lib/Conversion/TosaToArith/TosaToArith.cpp

//===- TosaToArith.cpp - Lowering Tosa to Arith Dialect -------------===// //===- TosaToArith.cpp - Lowering Tosa to Arith Dialect -------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// These rewriters lower from the Tosa to the Arith dialect. // These rewriters lower from the Tosa to the Arith dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToArith/TosaToArith.h" #include "mlir/Conversion/TosaToArith/TosaToArith.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h" #include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
using namespace mlir; using namespace mlir;
using namespace tosa; using namespace tosa;
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

mlir/lib/Conversion/TosaToArith/TosaToArithPass.cpp

//===- TosaToArithPass.cpp - Lowering Tosa to Linalg Dialect -----------===// //===- TosaToArithPass.cpp - Lowering Tosa to Linalg Dialect -----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This transformation pass legalizes Tosa operations to the Arith dialect. // This transformation pass legalizes Tosa operations to the Arith dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToArith/TosaToArith.h" #include "mlir/Conversion/TosaToArith/TosaToArith.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h" #include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h" #include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_TOSATOARITH #define GEN_PASS_DEF_TOSATOARITH
#include "mlir/Conversion/Passes.h.inc" #include "mlir/Conversion/Passes.h.inc"
} // namespace mlir } // namespace mlir
using namespace mlir; using namespace mlir;
using namespace tosa; using namespace tosa;
namespace { namespace {
struct TosaToArith : public impl::TosaToArithBase<TosaToArith> { struct TosaToArith : public impl::TosaToArithBase<TosaToArith> {
public: public:
TosaToArith(TosaToArithOptions &options) : TosaToArithBase(options) {} TosaToArith(TosaToArithOptions &options) : TosaToArithBase(options) {}
void runOnOperation() override { void runOnOperation() override {
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addIllegalOp<tosa::ConstOp>(); target.addIllegalOp<tosa::ConstOp>();
target.addLegalDialect<arith::ArithmeticDialect>(); target.addLegalDialect<arith::ArithDialect>();
mlir::tosa::populateTosaToArithConversionPatterns(&patterns); mlir::tosa::populateTosaToArithConversionPatterns(&patterns);
if (this->includeApplyRescale) { if (this->includeApplyRescale) {
mlir::tosa::populateTosaRescaleToArithConversionPatterns(&patterns, mlir::tosa::populateTosaRescaleToArithConversionPatterns(&patterns,
this->use32Bit); this->use32Bit);
target.addIllegalOp<tosa::ApplyScaleOp>(); target.addIllegalOp<tosa::ApplyScaleOp>();
} }
Show All 13 Lines

mlir/lib/Conversion/TosaToLinalg/CMakeLists.txt

add_mlir_conversion_library(MLIRTosaToLinalg add_mlir_conversion_library(MLIRTosaToLinalg
TosaToLinalg.cpp TosaToLinalg.cpp
TosaToLinalgNamed.cpp TosaToLinalgNamed.cpp
TosaToLinalgNamedPass.cpp TosaToLinalgNamedPass.cpp
TosaToLinalgPass.cpp TosaToLinalgPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tosa ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tosa
${MLIR_MAIN_INCLUDE_DIR}/mlir/IR ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRDialectUtils MLIRDialectUtils
MLIRIR MLIRIR
MLIRLinalgDialect MLIRLinalgDialect
MLIRLinalgUtils MLIRLinalgUtils
MLIRMathDialect MLIRMathDialect
MLIRPass MLIRPass
MLIRTensorDialect MLIRTensorDialect
MLIRTransforms MLIRTransforms
MLIRTosaDialect MLIRTosaDialect
MLIRTosaTransforms MLIRTosaTransforms
MLIRSupport MLIRSupport
) )

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

//===- TosaToLinalg.cpp - Lowering Tosa to Linalg Dialect -----------------===// //===- TosaToLinalg.cpp - Lowering Tosa to Linalg Dialect -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// These rewriters lower from the Tosa to the Linalg dialect. // These rewriters lower from the Tosa to the Linalg dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h" #include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Utils/Utils.h" #include "mlir/Dialect/Tensor/Utils/Utils.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h" #include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/Dialect/Tosa/Utils/CoversionUtils.h" #include "mlir/Dialect/Tosa/Utils/CoversionUtils.h"
#include "mlir/Dialect/Utils/ReshapeOpsUtils.h" #include "mlir/Dialect/Utils/ReshapeOpsUtils.h"
▲ Show 20 Lines • Show All 2,219 Lines • Show Last 20 Lines

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamed.cpp

//===- TosaToLinalgNamed.cpp - Lowering Tosa to Linalg Named Ops ----------===// //===- TosaToLinalgNamed.cpp - Lowering Tosa to Linalg Named Ops ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// These rewriters lower from the Tosa to the Linalg named ops. // These rewriters lower from the Tosa to the Linalg named ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h" #include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Utils/Utils.h" #include "mlir/Dialect/Tensor/Utils/Utils.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h" #include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/Dialect/Tosa/Utils/CoversionUtils.h" #include "mlir/Dialect/Tosa/Utils/CoversionUtils.h"
#include "mlir/Dialect/Utils/ReshapeOpsUtils.h" #include "mlir/Dialect/Utils/ReshapeOpsUtils.h"
▲ Show 20 Lines • Show All 955 Lines • Show Last 20 Lines

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamedPass.cpp

//===- TosaToLinalgPass.cpp - Lowering Tosa to Linalg Dialect -------------===// //===- TosaToLinalgPass.cpp - Lowering Tosa to Linalg Dialect -------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This transformation pass legalizes Tosa operations to the Linalg dialect. // This transformation pass legalizes Tosa operations to the Linalg dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h" #include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h" #include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h" #include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/Dialect/Tosa/Utils/QuantUtils.h" #include "mlir/Dialect/Tosa/Utils/QuantUtils.h"
Show All 10 Lines
using namespace mlir; using namespace mlir;
namespace { namespace {
struct TosaToLinalgNamed struct TosaToLinalgNamed
: public impl::TosaToLinalgNamedBase<TosaToLinalgNamed> { : public impl::TosaToLinalgNamedBase<TosaToLinalgNamed> {
public: public:
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry registry
.insert<arith::ArithmeticDialect, linalg::LinalgDialect, .insert<arith::ArithDialect, linalg::LinalgDialect, math::MathDialect,
math::MathDialect, tensor::TensorDialect, scf::SCFDialect>(); tensor::TensorDialect, scf::SCFDialect>();
} }
void runOnOperation() override { void runOnOperation() override {
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addLegalDialect<linalg::LinalgDialect, tosa::TosaDialect, target.addLegalDialect<linalg::LinalgDialect, tosa::TosaDialect,
tensor::TensorDialect, scf::SCFDialect>(); tensor::TensorDialect, scf::SCFDialect>();
Show All 21 Lines

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgPass.cpp

//===- TosaToLinalgPass.cpp - Lowering Tosa to Linalg Dialect -------------===// //===- TosaToLinalgPass.cpp - Lowering Tosa to Linalg Dialect -------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This transformation pass legalizes Tosa operations to the Linalg dialect. // This transformation pass legalizes Tosa operations to the Linalg dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h" #include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h" #include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h" #include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/Dialect/Tosa/Utils/QuantUtils.h" #include "mlir/Dialect/Tosa/Utils/QuantUtils.h"
Show All 10 Lines
using namespace mlir; using namespace mlir;
namespace { namespace {
struct TosaToLinalg : public impl::TosaToLinalgBase<TosaToLinalg> { struct TosaToLinalg : public impl::TosaToLinalgBase<TosaToLinalg> {
public: public:
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry registry
.insert<arith::ArithmeticDialect, linalg::LinalgDialect, .insert<arith::ArithDialect, linalg::LinalgDialect, math::MathDialect,
math::MathDialect, tensor::TensorDialect, scf::SCFDialect>(); tensor::TensorDialect, scf::SCFDialect>();
} }
void runOnOperation() override { void runOnOperation() override {
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addLegalDialect<linalg::LinalgDialect, tensor::TensorDialect, target.addLegalDialect<linalg::LinalgDialect, tensor::TensorDialect,
scf::SCFDialect>(); scf::SCFDialect>();
target.addIllegalDialect<tosa::TosaDialect>(); target.addIllegalDialect<tosa::TosaDialect>();
Show All 37 Lines

mlir/lib/Conversion/TosaToTensor/TosaToTensor.cpp

//===- TosaToTensor.cpp - Lowering Tosa to Tensor Dialect -------------===// //===- TosaToTensor.cpp - Lowering Tosa to Tensor Dialect -------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// These rewriters lower from the Tosa to the Tensor dialect. // These rewriters lower from the Tosa to the Tensor dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToTensor/TosaToTensor.h" #include "mlir/Conversion/TosaToTensor/TosaToTensor.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h" #include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
using namespace mlir; using namespace mlir;
using namespace tosa; using namespace tosa;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

mlir/lib/Conversion/TosaToTensor/TosaToTensorPass.cpp

//===- TosaToTensorPass.cpp - Lowering Tosa to Tensor Dialect -------------===// //===- TosaToTensorPass.cpp - Lowering Tosa to Tensor Dialect -------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This transformation pass legalizes Tosa operations to the Tensor dialect. // This transformation pass legalizes Tosa operations to the Tensor dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToTensor/TosaToTensor.h" #include "mlir/Conversion/TosaToTensor/TosaToTensor.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h" #include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h" #include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_TOSATOTENSOR #define GEN_PASS_DEF_TOSATOTENSOR
#include "mlir/Conversion/Passes.h.inc" #include "mlir/Conversion/Passes.h.inc"
} // namespace mlir } // namespace mlir
using namespace mlir; using namespace mlir;
using namespace tosa; using namespace tosa;
namespace { namespace {
struct TosaToTensor : public impl::TosaToTensorBase<TosaToTensor> { struct TosaToTensor : public impl::TosaToTensorBase<TosaToTensor> {
public: public:
void runOnOperation() override { void runOnOperation() override {
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addIllegalOp<tosa::SliceOp>(); target.addIllegalOp<tosa::SliceOp>();
target.addLegalDialect<arith::ArithmeticDialect>(); target.addLegalDialect<arith::ArithDialect>();
target.addLegalDialect<tensor::TensorDialect>(); target.addLegalDialect<tensor::TensorDialect>();
mlir::tosa::populateTosaToTensorConversionPatterns(&patterns); mlir::tosa::populateTosaToTensorConversionPatterns(&patterns);
if (failed(applyPartialConversion(getOperation(), target, if (failed(applyPartialConversion(getOperation(), target,
std::move(patterns)))) std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
}; };
} // namespace } // namespace
std::unique_ptr<Pass> mlir::tosa::createTosaToTensor() { std::unique_ptr<Pass> mlir::tosa::createTosaToTensor() {
return std::make_unique<TosaToTensor>(); return std::make_unique<TosaToTensor>();
} }

mlir/lib/Conversion/VectorToGPU/CMakeLists.txt

add_mlir_conversion_library(MLIRVectorToGPU add_mlir_conversion_library(MLIRVectorToGPU
VectorToGPU.cpp VectorToGPU.cpp
NvGpuSupport.cpp NvGpuSupport.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToGPU ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToGPU
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRGPUOps MLIRGPUOps
MLIRLLVMDialect MLIRLLVMDialect
MLIRMemRefDialect MLIRMemRefDialect
MLIRNVGPUDialect MLIRNVGPUDialect
MLIRTransforms MLIRTransforms
MLIRVectorDialect MLIRVectorDialect
MLIRVectorUtils MLIRVectorUtils
) )

mlir/lib/Conversion/VectorToGPU/NvGpuSupport.cpp

//===- NvGpuSupport.cpp - MLIR Vector to GPU lowering support --------===// //===- NvGpuSupport.cpp - MLIR Vector to GPU lowering support --------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file provides utilities to assist in the lowering of Vector operations // This file provides utilities to assist in the lowering of Vector operations
// to NvGPU dialect MMA operations. // to NvGPU dialect MMA operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NvGpuSupport.h" #include "NvGpuSupport.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h" #include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
namespace mlir { namespace mlir {
namespace nvgpu { namespace nvgpu {
namespace { namespace {
/// There are always 4 threads per [128|256|512] bit row. /// There are always 4 threads per [128|256|512] bit row.
▲ Show 20 Lines • Show All 312 Lines • Show Last 20 Lines

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <type_traits> #include <type_traits>
#include "NvGpuSupport.h" #include "NvGpuSupport.h"
#include "mlir/Conversion/VectorToGPU/VectorToGPU.h" #include "mlir/Conversion/VectorToGPU/VectorToGPU.h"
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h" #include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Utils/StructuredOpsUtils.h" #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
▲ Show 20 Lines • Show All 888 Lines • Show Last 20 Lines

mlir/lib/Conversion/VectorToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIRVectorToLLVM add_mlir_conversion_library(MLIRVectorToLLVM
ConvertVectorToLLVM.cpp ConvertVectorToLLVM.cpp
ConvertVectorToLLVMPass.cpp ConvertVectorToLLVMPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
intrinsics_gen intrinsics_gen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRArmNeonDialect MLIRArmNeonDialect
MLIRArmSVEDialect MLIRArmSVEDialect
MLIRArmSVETransforms MLIRArmSVETransforms
MLIRAMXDialect MLIRAMXDialect
MLIRAMXTransforms MLIRAMXTransforms
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMDialect MLIRLLVMDialect
MLIRMemRefDialect MLIRMemRefDialect
MLIRTargetLLVMIRExport MLIRTargetLLVMIRExport
MLIRTransforms MLIRTransforms
MLIRVectorDialect MLIRVectorDialect
MLIRVectorTransforms MLIRVectorTransforms
MLIRX86VectorDialect MLIRX86VectorDialect
MLIRX86VectorTransforms MLIRX86VectorTransforms
) )

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

//===- VectorToLLVM.cpp - Conversion from Vector to the LLVM dialect ------===// //===- VectorToLLVM.cpp - Conversion from Vector to the LLVM dialect ------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h" #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h" #include "mlir/Conversion/LLVMCommon/VectorPattern.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/LLVMIR/FunctionCallUtils.h" #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Vector/Transforms/VectorTransforms.h" #include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include "mlir/Support/MathExtras.h" #include "mlir/Support/MathExtras.h"
#include "mlir/Target/LLVMIR/TypeToLLVM.h" #include "mlir/Target/LLVMIR/TypeToLLVM.h"
▲ Show 20 Lines • Show All 1,320 Lines • Show Last 20 Lines

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVMPass.cpp

//===- VectorToLLVM.cpp - Conversion from Vector to the LLVM dialect ------===// //===- VectorToLLVM.cpp - Conversion from Vector to the LLVM dialect ------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h" #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Dialect/AMX/AMXDialect.h" #include "mlir/Dialect/AMX/AMXDialect.h"
#include "mlir/Dialect/AMX/Transforms.h" #include "mlir/Dialect/AMX/Transforms.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ArmNeon/ArmNeonDialect.h" #include "mlir/Dialect/ArmNeon/ArmNeonDialect.h"
#include "mlir/Dialect/ArmSVE/ArmSVEDialect.h" #include "mlir/Dialect/ArmSVE/ArmSVEDialect.h"
#include "mlir/Dialect/ArmSVE/Transforms.h" #include "mlir/Dialect/ArmSVE/Transforms.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Vector/Transforms/VectorRewritePatterns.h" #include "mlir/Dialect/Vector/Transforms/VectorRewritePatterns.h"
#include "mlir/Dialect/X86Vector/Transforms.h" #include "mlir/Dialect/X86Vector/Transforms.h"
Show All 18 Lines LowerVectorToLLVMPass(const LowerVectorToLLVMOptions &options) {
this->armNeon = options.armNeon; this->armNeon = options.armNeon;
this->armSVE = options.armSVE; this->armSVE = options.armSVE;
this->amx = options.amx; this->amx = options.amx;
this->x86Vector = options.x86Vector; this->x86Vector = options.x86Vector;
} }
// Override explicitly to allow conditional dialect dependence. // Override explicitly to allow conditional dialect dependence.
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry.insert<LLVM::LLVMDialect>(); registry.insert<LLVM::LLVMDialect>();
registry.insert<arith::ArithmeticDialect>(); registry.insert<arith::ArithDialect>();
registry.insert<memref::MemRefDialect>(); registry.insert<memref::MemRefDialect>();
if (armNeon) if (armNeon)
registry.insert<arm_neon::ArmNeonDialect>(); registry.insert<arm_neon::ArmNeonDialect>();
if (armSVE) if (armSVE)
registry.insert<arm_sve::ArmSVEDialect>(); registry.insert<arm_sve::ArmSVEDialect>();
if (amx) if (amx)
registry.insert<amx::AMXDialect>(); registry.insert<amx::AMXDialect>();
if (x86Vector) if (x86Vector)
Show All 26 Linesvoid LowerVectorToLLVMPass::runOnOperation() {
populateVectorTransferLoweringPatterns(patterns); populateVectorTransferLoweringPatterns(patterns);
populateVectorToLLVMMatrixConversionPatterns(converter, patterns); populateVectorToLLVMMatrixConversionPatterns(converter, patterns);
populateVectorToLLVMConversionPatterns( populateVectorToLLVMConversionPatterns(
converter, patterns, reassociateFPReductions, force32BitVectorIndices); converter, patterns, reassociateFPReductions, force32BitVectorIndices);
populateVectorToLLVMMatrixConversionPatterns(converter, patterns); populateVectorToLLVMMatrixConversionPatterns(converter, patterns);
// Architecture specific augmentations. // Architecture specific augmentations.
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addLegalDialect<arith::ArithmeticDialect>(); target.addLegalDialect<arith::ArithDialect>();
target.addLegalDialect<memref::MemRefDialect>(); target.addLegalDialect<memref::MemRefDialect>();
target.addLegalOp<UnrealizedConversionCastOp>(); target.addLegalOp<UnrealizedConversionCastOp>();
if (armNeon) { if (armNeon) {
// TODO: we may or may not want to include in-dialect lowering to // TODO: we may or may not want to include in-dialect lowering to
// LLVM-compatible operations here. So far, all operations in the dialect // LLVM-compatible operations here. So far, all operations in the dialect
// can be translated to LLVM IR so there is no conversion necessary. // can be translated to LLVM IR so there is no conversion necessary.
target.addLegalDialect<arm_neon::ArmNeonDialect>(); target.addLegalDialect<arm_neon::ArmNeonDialect>();
} }
Show All 22 Lines

mlir/lib/Conversion/VectorToSCF/CMakeLists.txt

add_mlir_conversion_library(MLIRVectorToSCF add_mlir_conversion_library(MLIRVectorToSCF
VectorToSCF.cpp VectorToSCF.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToSCF ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToSCF
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRLLVMDialect MLIRLLVMDialect
MLIRMemRefDialect MLIRMemRefDialect
MLIRTransforms MLIRTransforms
MLIRVectorDialect MLIRVectorDialect
MLIRVectorTransforms MLIRVectorTransforms
) )

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

Show All 9 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <type_traits> #include <type_traits>
#include "mlir/Conversion/VectorToSCF/VectorToSCF.h" #include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Vector/Transforms/VectorTransforms.h" #include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/Passes.h" #include "mlir/Transforms/Passes.h"
▲ Show 20 Lines • Show All 1,298 Lines • Show Last 20 Lines

mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h" #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Analysis/Presburger/LinearTransform.h" #include "mlir/Analysis/Presburger/LinearTransform.h"
#include "mlir/Analysis/Presburger/Simplex.h" #include "mlir/Analysis/Presburger/Simplex.h"
#include "mlir/Analysis/Presburger/Utils.h" #include "mlir/Analysis/Presburger/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h" #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/AffineExprVisitor.h" #include "mlir/IR/AffineExprVisitor.h"
#include "mlir/IR/IntegerSet.h" #include "mlir/IR/IntegerSet.h"
#include "mlir/Support/LLVM.h" #include "mlir/Support/LLVM.h"
#include "mlir/Support/MathExtras.h" #include "mlir/Support/MathExtras.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
▲ Show 20 Lines • Show All 1,804 Lines • Show Last 20 Lines

mlir/lib/Dialect/Affine/Analysis/Utils.cpp

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/Analysis/Utils.h" #include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Analysis/Presburger/PresburgerRelation.h" #include "mlir/Analysis/Presburger/PresburgerRelation.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h" #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h" #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h" #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/IntegerSet.h" #include "mlir/IR/IntegerSet.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#define DEBUG_TYPE "analysis-utils" #define DEBUG_TYPE "analysis-utils"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 1,336 Lines • Show Last 20 Lines

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

add_mlir_dialect_library(MLIRAffineDialect add_mlir_dialect_library(MLIRAffineDialect
AffineMemoryOpInterfaces.cpp AffineMemoryOpInterfaces.cpp
AffineOps.cpp AffineOps.cpp
AffineValueMap.cpp AffineValueMap.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Affine ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Affine
DEPENDS DEPENDS
MLIRAffineMemoryOpInterfacesIncGen MLIRAffineMemoryOpInterfacesIncGen
MLIRAffineOpsIncGen MLIRAffineOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRDialectUtils MLIRDialectUtils
MLIRIR MLIRIR
MLIRLoopLikeInterface MLIRLoopLikeInterface
MLIRMemRefDialect MLIRMemRefDialect
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRTensorDialect MLIRTensorDialect
) )

mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp

Show All 18 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/Passes.h" #include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h" #include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "llvm/ADT/MapVector.h" #include "llvm/ADT/MapVector.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include <algorithm> #include <algorithm>
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp

Show All 14 Lines
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h" #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h" #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h" #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h" #include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Affine/Utils.h" #include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseSet.h" #include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

mlir/lib/Dialect/Affine/Transforms/CMakeLists.txt

Show All 20 Linesadd_mlir_dialect_library(MLIRAffineTransforms
MLIRAffineOpsIncGen MLIRAffineOpsIncGen
MLIRAffinePassIncGen MLIRAffinePassIncGen
MLIRLoopLikeInterfaceIncGen MLIRLoopLikeInterfaceIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineAnalysis MLIRAffineAnalysis
MLIRAffineUtils MLIRAffineUtils
MLIRArithmeticDialect MLIRArithDialect
MLIRIR MLIRIR
MLIRMemRefDialect MLIRMemRefDialect
MLIRPass MLIRPass
MLIRSCFUtils MLIRSCFUtils
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRTransformUtils MLIRTransformUtils
MLIRVectorDialect MLIRVectorDialect
MLIRVectorUtils MLIRVectorUtils
MLIRVectorToLLVM MLIRVectorToLLVM
) )

mlir/lib/Dialect/Affine/Transforms/LoopCoalescing.cpp

//===- LoopCoalescing.cpp - Pass transforming loop nests into single loops-===// //===- LoopCoalescing.cpp - Pass transforming loop nests into single loops-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/Passes.h" #include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Transforms/Passes.h" #include "mlir/Transforms/Passes.h"
#include "mlir/Transforms/RegionUtils.h" #include "mlir/Transforms/RegionUtils.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
namespace mlir { namespace mlir {
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

mlir/lib/Dialect/Affine/Transforms/PipelineDataTransfer.cpp

Show All 12 Lines
#include "mlir/Dialect/Affine/Passes.h" #include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h" #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h" #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h" #include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Affine/Utils.h" #include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/Transforms/Passes.h" #include "mlir/Transforms/Passes.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
namespace mlir { namespace mlir {
▲ Show 20 Lines • Show All 347 Lines • Show Last 20 Lines

mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp

Show All 13 Lines
#include "mlir/Dialect/Affine/Passes.h" #include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h" #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h" #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/NestedMatcher.h" #include "mlir/Dialect/Affine/Analysis/NestedMatcher.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/Utils.h" #include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Support/LLVM.h" #include "mlir/Support/LLVM.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
▲ Show 20 Lines • Show All 1,853 Lines • Show Last 20 Lines

mlir/lib/Dialect/Affine/Utils/CMakeLists.txt

add_mlir_dialect_library(MLIRAffineUtils add_mlir_dialect_library(MLIRAffineUtils
LoopFusionUtils.cpp LoopFusionUtils.cpp
LoopUtils.cpp LoopUtils.cpp
Utils.cpp Utils.cpp
ViewLikeInterfaceUtils.cpp ViewLikeInterfaceUtils.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Affine ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Affine
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineAnalysis MLIRAffineAnalysis
MLIRAnalysis MLIRAnalysis
MLIRArithmeticUtils MLIRArithUtils
MLIRMemRefDialect MLIRMemRefDialect
MLIRTransformUtils MLIRTransformUtils
MLIRViewLikeInterface MLIRViewLikeInterface
) )

mlir/lib/Dialect/Affine/Utils/Utils.cpp

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/Utils.h" #include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h" #include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h" #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/AffineExprVisitor.h" #include "mlir/IR/AffineExprVisitor.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Dominance.h" #include "mlir/IR/Dominance.h"
#include "mlir/IR/IntegerSet.h" #include "mlir/IR/IntegerSet.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
▲ Show 20 Lines • Show All 1,844 Lines • Show Last 20 Lines

mlir/lib/Dialect/Arith/CMakeLists.txt

  • This file was moved from mlir/lib/Dialect/Arithmetic/CMakeLists.txt.
The contents of this file were not changed.

mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td

  • This file was moved from mlir/lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.td.
//===- ArithmeticPatterns.td - Arithmetic dialect patterns -*- tablegen -*-===// //===- ArithPatterns.td - Arith dialect patterns -*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef ARITHMETIC_PATTERNS #ifndef ARITH_PATTERNS
#define ARITHMETIC_PATTERNS #define ARITH_PATTERNS
include "mlir/IR/PatternBase.td" include "mlir/IR/PatternBase.td"
include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.td" include "mlir/Dialect/Arith/IR/ArithOps.td"
// Create zero attribute of type matching the argument's type. // Create zero attribute of type matching the argument's type.
def GetZeroAttr : NativeCodeCall<"$_builder.getZeroAttr($0.getType())">; def GetZeroAttr : NativeCodeCall<"$_builder.getZeroAttr($0.getType())">;
// Add two integer attributes and create a new one with the result. // Add two integer attributes and create a new one with the result.
def AddIntAttrs : NativeCodeCall<"addIntegerAttrs($_builder, $0, $1, $2)">; def AddIntAttrs : NativeCodeCall<"addIntegerAttrs($_builder, $0, $1, $2)">;
// Subtract two integer attributes and createa a new one with the result. // Subtract two integer attributes and createa a new one with the result.
▲ Show 20 Lines • Show All 186 Lines • ▼ Show 20 Lines
// DivFOp // DivFOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// divf(negf(x), negf(y)) -> divf(x,y) // divf(negf(x), negf(y)) -> divf(x,y)
def DivFOfNegF : def DivFOfNegF :
Pat<(Arith_DivFOp (Arith_NegFOp $x), (Arith_NegFOp $y)), (Arith_DivFOp $x, $y), Pat<(Arith_DivFOp (Arith_NegFOp $x), (Arith_NegFOp $y)), (Arith_DivFOp $x, $y),
[(Constraint<CPred<"$0.getType() == $1.getType()">> $x, $y)]>; [(Constraint<CPred<"$0.getType() == $1.getType()">> $x, $y)]>;
#endif // ARITHMETIC_PATTERNS #endif // ARITH_PATTERNS

mlir/lib/Dialect/Arith/IR/ArithDialect.cpp

  • This file was moved from mlir/lib/Dialect/Arithmetic/IR/ArithmeticDialect.cpp.
//===- ArithmeticDialect.cpp - MLIR Arithmetic dialect implementation -----===// //===- ArithDialect.cpp - MLIR Arith dialect implementation -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/Transforms/InliningUtils.h" #include "mlir/Transforms/InliningUtils.h"
using namespace mlir; using namespace mlir;
using namespace mlir::arith; using namespace mlir::arith;
#include "mlir/Dialect/Arithmetic/IR/ArithmeticOpsDialect.cpp.inc" #include "mlir/Dialect/Arith/IR/ArithOpsDialect.cpp.inc"
namespace { namespace {
/// This class defines the interface for handling inlining for arithmetic /// This class defines the interface for handling inlining for arithmetic
/// dialect operations. /// dialect operations.
struct ArithmeticInlinerInterface : public DialectInlinerInterface { struct ArithInlinerInterface : public DialectInlinerInterface {
using DialectInlinerInterface::DialectInlinerInterface; using DialectInlinerInterface::DialectInlinerInterface;
/// All arithmetic dialect ops can be inlined. /// All arithmetic dialect ops can be inlined.
bool isLegalToInline(Operation *, Region *, bool, bool isLegalToInline(Operation *, Region *, bool,
BlockAndValueMapping &) const final { BlockAndValueMapping &) const final {
return true; return true;
} }
}; };
} // namespace } // namespace
void arith::ArithmeticDialect::initialize() { void arith::ArithDialect::initialize() {
addOperations< addOperations<
#define GET_OP_LIST #define GET_OP_LIST
#include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc" #include "mlir/Dialect/Arith/IR/ArithOps.cpp.inc"
>(); >();
addInterfaces<ArithmeticInlinerInterface>(); addInterfaces<ArithInlinerInterface>();
} }
/// Materialize an integer or floating point constant. /// Materialize an integer or floating point constant.
Operation *arith::ArithmeticDialect::materializeConstant(OpBuilder &builder, Operation *arith::ArithDialect::materializeConstant(OpBuilder &builder,
Attribute value, Attribute value, Type type,
Type type,
Location loc) { Location loc) {
return builder.create<arith::ConstantOp>(loc, value, type); return builder.create<arith::ConstantOp>(loc, value, type);
} }

mlir/lib/Dialect/Arith/IR/ArithOps.cpp

  • This file was moved from mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp.
//===- ArithmeticOps.cpp - MLIR Arithmetic dialect ops implementation -----===// //===- ArithOps.cpp - MLIR Arith dialect ops implementation -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <cassert> #include <cassert>
#include <utility> #include <utility>
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/CommonFolders.h" #include "mlir/Dialect/CommonFolders.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include "llvm/ADT/APSInt.h" #include "llvm/ADT/APSInt.h"
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines return arith::CmpIPredicateAttr::get(pred.getContext(),
invertPredicate(pred.getValue())); invertPredicate(pred.getValue()));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TableGen'd canonicalization patterns // TableGen'd canonicalization patterns
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace { namespace {
#include "ArithmeticCanonicalization.inc" #include "ArithCanonicalization.inc"
} // namespace } // namespace
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConstantOp // ConstantOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void arith::ConstantOp::getAsmResultNames( void arith::ConstantOp::getAsmResultNames(
function_ref<void(Value, StringRef)> setNameFn) { function_ref<void(Value, StringRef)> setNameFn) {
▲ Show 20 Lines • Show All 2,058 Lines • ▼ Show 20 LinesValue mlir::arith::getReductionOp(AtomicRMWKind op, OpBuilder &builder,
return nullptr; return nullptr;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TableGen'd op method definitions // TableGen'd op method definitions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc" #include "mlir/Dialect/Arith/IR/ArithOps.cpp.inc"
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TableGen'd enum attribute definitions // TableGen'd enum attribute definitions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/ArithmeticOpsEnums.cpp.inc" #include "mlir/Dialect/Arith/IR/ArithOpsEnums.cpp.inc"

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

  • This file was added.
set(LLVM_TARGET_DEFINITIONS ArithCanonicalization.td)
mlir_tablegen(ArithCanonicalization.inc -gen-rewriters)
add_public_tablegen_target(MLIRArithCanonicalizationIncGen)
add_mlir_dialect_library(MLIRArithDialect
ArithOps.cpp
ArithDialect.cpp
InferIntRangeInterfaceImpls.cpp
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arith
DEPENDS
MLIRArithOpsIncGen
LINK_LIBS PUBLIC
MLIRDialect
MLIRInferIntRangeInterface
MLIRInferTypeOpInterface
MLIRIR
)

mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp

  • This file was moved from mlir/lib/Dialect/Arithmetic/IR/InferIntRangeInterfaceImpls.cpp.
//===- InferIntRangeInterfaceImpls.cpp - Integer range impls for arith -===// //===- InferIntRangeInterfaceImpls.cpp - Integer range impls for arith -===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Interfaces/InferIntRangeInterface.h" #include "mlir/Interfaces/InferIntRangeInterface.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#define DEBUG_TYPE "int-range-analysis" #define DEBUG_TYPE "int-range-analysis"
using namespace mlir; using namespace mlir;
using namespace mlir::arith; using namespace mlir::arith;
▲ Show 20 Lines • Show All 667 Lines • Show Last 20 Lines

mlir/lib/Dialect/Arith/Transforms/BufferizableOpInterfaceImpl.cpp

  • This file was moved from mlir/lib/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.cpp.
//===- BufferizableOpInterfaceImpl.cpp - Impl. of BufferizableOpInterface -===// //===- BufferizableOpInterfaceImpl.cpp - Impl. of BufferizableOpInterface -===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.h" #include "mlir/Dialect/Arith/Transforms/BufferizableOpInterfaceImpl.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h" #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/Transforms/BufferUtils.h" #include "mlir/Dialect/Bufferization/Transforms/BufferUtils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/Operation.h" #include "mlir/IR/Operation.h"
using namespace mlir; using namespace mlir;
using namespace mlir::bufferization; using namespace mlir::bufferization;
▲ Show 20 Lines • Show All 186 Lines • ▼ Show 20 Lines BufferRelation bufferRelation(Operation *op, OpResult opResult,
return BufferRelation::None; return BufferRelation::None;
} }
}; };
} // namespace } // namespace
void mlir::arith::registerBufferizableOpInterfaceExternalModels( void mlir::arith::registerBufferizableOpInterfaceExternalModels(
DialectRegistry &registry) { DialectRegistry &registry) {
registry.addExtension(+[](MLIRContext *ctx, ArithmeticDialect *dialect) { registry.addExtension(+[](MLIRContext *ctx, ArithDialect *dialect) {
ConstantOp::attachInterface<ConstantOpInterface>(*ctx); ConstantOp::attachInterface<ConstantOpInterface>(*ctx);
IndexCastOp::attachInterface<IndexCastOpInterface>(*ctx); IndexCastOp::attachInterface<IndexCastOpInterface>(*ctx);
SelectOp::attachInterface<SelectOpInterface>(*ctx); SelectOp::attachInterface<SelectOpInterface>(*ctx);
}); });
} }

mlir/lib/Dialect/Arith/Transforms/Bufferize.cpp

  • This file was moved from mlir/lib/Dialect/Arithmetic/Transforms/Bufferize.cpp.
//===- Bufferize.cpp - Bufferization for Arithmetic ops ---------*- C++ -*-===// //===- Bufferize.cpp - Bufferization for Arith ops ---------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h" #include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.h" #include "mlir/Dialect/Arith/Transforms/BufferizableOpInterfaceImpl.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h" #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h" #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
namespace mlir { namespace mlir {
namespace arith { namespace arith {
#define GEN_PASS_DEF_ARITHMETICBUFFERIZE #define GEN_PASS_DEF_ARITHBUFFERIZE
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc" #include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
} // namespace arith } // namespace arith
} // namespace mlir } // namespace mlir
using namespace mlir; using namespace mlir;
using namespace bufferization; using namespace bufferization;
namespace { namespace {
/// Pass to bufferize Arithmetic ops. /// Pass to bufferize Arith ops.
struct ArithmeticBufferizePass struct ArithBufferizePass
: public arith::impl::ArithmeticBufferizeBase<ArithmeticBufferizePass> { : public arith::impl::ArithBufferizeBase<ArithBufferizePass> {
ArithmeticBufferizePass(uint64_t alignment = 0, bool constantOpOnly = false) ArithBufferizePass(uint64_t alignment = 0, bool constantOpOnly = false)
: constantOpOnly(constantOpOnly) { : constantOpOnly(constantOpOnly) {
this->alignment = alignment; this->alignment = alignment;
} }
void runOnOperation() override { void runOnOperation() override {
BufferizationOptions options = getPartialBufferizationOptions(); BufferizationOptions options = getPartialBufferizationOptions();
if (constantOpOnly) { if (constantOpOnly) {
options.opFilter.allowOperation<arith::ConstantOp>(); options.opFilter.allowOperation<arith::ConstantOp>();
} else { } else {
options.opFilter.allowDialect<arith::ArithmeticDialect>(); options.opFilter.allowDialect<arith::ArithDialect>();
} }
options.bufferAlignment = alignment; options.bufferAlignment = alignment;
if (failed(bufferizeOp(getOperation(), options))) if (failed(bufferizeOp(getOperation(), options)))
signalPassFailure(); signalPassFailure();
} }
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry.insert<bufferization::BufferizationDialect, memref::MemRefDialect, registry.insert<bufferization::BufferizationDialect, memref::MemRefDialect,
arith::ArithmeticDialect>(); arith::ArithDialect>();
arith::registerBufferizableOpInterfaceExternalModels(registry); arith::registerBufferizableOpInterfaceExternalModels(registry);
} }
private: private:
bool constantOpOnly; bool constantOpOnly;
}; };
} // namespace } // namespace
std::unique_ptr<Pass> mlir::arith::createArithmeticBufferizePass() { std::unique_ptr<Pass> mlir::arith::createArithBufferizePass() {
return std::make_unique<ArithmeticBufferizePass>(); return std::make_unique<ArithBufferizePass>();
} }
std::unique_ptr<Pass> std::unique_ptr<Pass>
mlir::arith::createConstantBufferizePass(uint64_t alignment) { mlir::arith::createConstantBufferizePass(uint64_t alignment) {
return std::make_unique<ArithmeticBufferizePass>(alignment, return std::make_unique<ArithBufferizePass>(alignment,
/*constantOpOnly=*/true); /*constantOpOnly=*/true);
} }

mlir/lib/Dialect/Arith/Transforms/CMakeLists.txt

  • This file was moved from mlir/lib/Dialect/Arithmetic/Transforms/CMakeLists.txt.
add_mlir_dialect_library(MLIRArithmeticTransforms add_mlir_dialect_library(MLIRArithTransforms
BufferizableOpInterfaceImpl.cpp BufferizableOpInterfaceImpl.cpp
Bufferize.cpp Bufferize.cpp
EmulateWideInt.cpp EmulateWideInt.cpp
ExpandOps.cpp ExpandOps.cpp
UnsignedWhenEquivalent.cpp UnsignedWhenEquivalent.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
{$MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arithmetic/Transforms {$MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arith/Transforms
DEPENDS DEPENDS
MLIRArithmeticTransformsIncGen MLIRArithTransformsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAnalysis MLIRAnalysis
MLIRArithmeticDialect MLIRArithDialect
MLIRBufferizationDialect MLIRBufferizationDialect
MLIRBufferizationTransforms MLIRBufferizationTransforms
MLIRFuncDialect MLIRFuncDialect
MLIRFuncTransforms MLIRFuncTransforms
MLIRInferIntRangeInterface MLIRInferIntRangeInterface
MLIRIR MLIRIR
MLIRMemRefDialect MLIRMemRefDialect
MLIRPass MLIRPass
MLIRTransforms MLIRTransforms
MLIRTransformUtils MLIRTransformUtils
MLIRVectorDialect MLIRVectorDialect
) )

mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp

  • This file was moved from mlir/lib/Dialect/Arithmetic/Transforms/EmulateWideInt.cpp.
//===- EmulateWideInt.cpp - Wide integer operation emulation ----*- C++ -*-===// //===- EmulateWideInt.cpp - Wide integer operation emulation ----*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h" #include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Transforms/WideIntEmulationConverter.h" #include "mlir/Dialect/Arith/Transforms/WideIntEmulationConverter.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/FuncConversions.h" #include "mlir/Dialect/Func/Transforms/FuncConversions.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/Support/MathExtras.h" #include "llvm/Support/MathExtras.h"
#include <cassert> #include <cassert>
namespace mlir::arith { namespace mlir::arith {
#define GEN_PASS_DEF_ARITHMETICEMULATEWIDEINT #define GEN_PASS_DEF_ARITHEMULATEWIDEINT
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc" #include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
} // namespace mlir::arith } // namespace mlir::arith
using namespace mlir; using namespace mlir;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Common Helper Functions // Common Helper Functions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 546 Lines • ▼ Show 20 Linesstruct ConvertVectorPrint final : OpConversionPattern<vector::PrintOp> {
} }
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Pass Definition // Pass Definition
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
struct EmulateWideIntPass final struct EmulateWideIntPass final
: arith::impl::ArithmeticEmulateWideIntBase<EmulateWideIntPass> { : arith::impl::ArithEmulateWideIntBase<EmulateWideIntPass> {
using ArithmeticEmulateWideIntBase::ArithmeticEmulateWideIntBase; using ArithEmulateWideIntBase::ArithEmulateWideIntBase;
void runOnOperation() override { void runOnOperation() override {
if (!llvm::isPowerOf2_32(widestIntSupported) || widestIntSupported < 2) { if (!llvm::isPowerOf2_32(widestIntSupported) || widestIntSupported < 2) {
signalPassFailure(); signalPassFailure();
return; return;
} }
Operation *op = getOperation(); Operation *op = getOperation();
MLIRContext *ctx = op->getContext(); MLIRContext *ctx = op->getContext();
arith::WideIntEmulationConverter typeConverter(widestIntSupported); arith::WideIntEmulationConverter typeConverter(widestIntSupported);
ConversionTarget target(*ctx); ConversionTarget target(*ctx);
target.addDynamicallyLegalOp<func::FuncOp>([&typeConverter](Operation *op) { target.addDynamicallyLegalOp<func::FuncOp>([&typeConverter](Operation *op) {
return typeConverter.isLegal(cast<func::FuncOp>(op).getFunctionType()); return typeConverter.isLegal(cast<func::FuncOp>(op).getFunctionType());
}); });
auto opLegalCallback = [&typeConverter](Operation *op) { auto opLegalCallback = [&typeConverter](Operation *op) {
return typeConverter.isLegal(op); return typeConverter.isLegal(op);
}; };
target.addDynamicallyLegalOp<func::CallOp, func::ReturnOp>(opLegalCallback); target.addDynamicallyLegalOp<func::CallOp, func::ReturnOp>(opLegalCallback);
target.addDynamicallyLegalDialect<arith::ArithmeticDialect, target
vector::VectorDialect>(opLegalCallback); .addDynamicallyLegalDialect<arith::ArithDialect, vector::VectorDialect>(
opLegalCallback);
RewritePatternSet patterns(ctx); RewritePatternSet patterns(ctx);
arith::populateWideIntEmulationPatterns(typeConverter, patterns); arith::populateWideIntEmulationPatterns(typeConverter, patterns);
if (failed(applyPartialConversion(op, target, std::move(patterns)))) if (failed(applyPartialConversion(op, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
}; };
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

mlir/lib/Dialect/Arith/Transforms/ExpandOps.cpp

  • This file was moved from mlir/lib/Dialect/Arithmetic/Transforms/ExpandOps.cpp.
//===- ExpandOps.cpp - Pass to legalize Arithmetic ops for LLVM lowering --===// //===- ExpandOps.cpp - Pass to legalize Arith ops for LLVM lowering --===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h" #include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
namespace mlir { namespace mlir {
namespace arith { namespace arith {
#define GEN_PASS_DEF_ARITHMETICEXPANDOPS #define GEN_PASS_DEF_ARITHEXPANDOPS
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc" #include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
} // namespace arith } // namespace arith
} // namespace mlir } // namespace mlir
using namespace mlir; using namespace mlir;
/// Create an integer or index constant. /// Create an integer or index constant.
static Value createConst(Location loc, Type type, int value, static Value createConst(Location loc, Type type, int value,
PatternRewriter &rewriter) { PatternRewriter &rewriter) {
▲ Show 20 Lines • Show All 163 Lines • ▼ Show 20 Lines LogicalResult matchAndRewrite(OpTy op,
Location loc = op.getLoc(); Location loc = op.getLoc();
Value cmp = rewriter.create<arith::CmpIOp>(loc, pred, lhs, rhs); Value cmp = rewriter.create<arith::CmpIOp>(loc, pred, lhs, rhs);
rewriter.replaceOpWithNewOp<arith::SelectOp>(op, cmp, lhs, rhs); rewriter.replaceOpWithNewOp<arith::SelectOp>(op, cmp, lhs, rhs);
return success(); return success();
} }
}; };
struct ArithmeticExpandOpsPass struct ArithExpandOpsPass
: public arith::impl::ArithmeticExpandOpsBase<ArithmeticExpandOpsPass> { : public arith::impl::ArithExpandOpsBase<ArithExpandOpsPass> {
void runOnOperation() override { void runOnOperation() override {
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
ConversionTarget target(getContext()); ConversionTarget target(getContext());
arith::populateArithmeticExpandOpsPatterns(patterns); arith::populateArithExpandOpsPatterns(patterns);
target.addLegalDialect<arith::ArithmeticDialect>(); target.addLegalDialect<arith::ArithDialect>();
// clang-format off // clang-format off
target.addIllegalOp< target.addIllegalOp<
arith::CeilDivSIOp, arith::CeilDivSIOp,
arith::CeilDivUIOp, arith::CeilDivUIOp,
arith::FloorDivSIOp, arith::FloorDivSIOp,
arith::MaxFOp, arith::MaxFOp,
arith::MaxSIOp, arith::MaxSIOp,
arith::MaxUIOp, arith::MaxUIOp,
arith::MinFOp, arith::MinFOp,
arith::MinSIOp, arith::MinSIOp,
arith::MinUIOp arith::MinUIOp
>(); >();
// clang-format on // clang-format on
if (failed(applyPartialConversion(getOperation(), target, if (failed(applyPartialConversion(getOperation(), target,
std::move(patterns)))) std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
}; };
} // namespace } // namespace
void mlir::arith::populateArithmeticExpandOpsPatterns( void mlir::arith::populateArithExpandOpsPatterns(RewritePatternSet &patterns) {
RewritePatternSet &patterns) {
// clang-format off // clang-format off
patterns.add< patterns.add<
CeilDivSIOpConverter, CeilDivSIOpConverter,
CeilDivUIOpConverter, CeilDivUIOpConverter,
FloorDivSIOpConverter, FloorDivSIOpConverter,
MaxMinFOpConverter<MaxFOp, arith::CmpFPredicate::UGT>, MaxMinFOpConverter<MaxFOp, arith::CmpFPredicate::UGT>,
MaxMinFOpConverter<MinFOp, arith::CmpFPredicate::ULT>, MaxMinFOpConverter<MinFOp, arith::CmpFPredicate::ULT>,
MaxMinIOpConverter<MaxSIOp, arith::CmpIPredicate::sgt>, MaxMinIOpConverter<MaxSIOp, arith::CmpIPredicate::sgt>,
MaxMinIOpConverter<MaxUIOp, arith::CmpIPredicate::ugt>, MaxMinIOpConverter<MaxUIOp, arith::CmpIPredicate::ugt>,
MaxMinIOpConverter<MinSIOp, arith::CmpIPredicate::slt>, MaxMinIOpConverter<MinSIOp, arith::CmpIPredicate::slt>,
MaxMinIOpConverter<MinUIOp, arith::CmpIPredicate::ult> MaxMinIOpConverter<MinUIOp, arith::CmpIPredicate::ult>
>(patterns.getContext()); >(patterns.getContext());
// clang-format on // clang-format on
} }
std::unique_ptr<Pass> mlir::arith::createArithmeticExpandOpsPass() { std::unique_ptr<Pass> mlir::arith::createArithExpandOpsPass() {
return std::make_unique<ArithmeticExpandOpsPass>(); return std::make_unique<ArithExpandOpsPass>();
} }

mlir/lib/Dialect/Arith/Transforms/UnsignedWhenEquivalent.cpp

  • This file was moved from mlir/lib/Dialect/Arithmetic/Transforms/UnsignedWhenEquivalent.cpp.
//===- UnsignedWhenEquivalent.cpp - Pass to replace signed operations with //===- UnsignedWhenEquivalent.cpp - Pass to replace signed operations with
// unsigned // unsigned
// ones when all their arguments and results are statically non-negative --===// // ones when all their arguments and results are statically non-negative --===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h" #include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Analysis/DataFlow/DeadCodeAnalysis.h" #include "mlir/Analysis/DataFlow/DeadCodeAnalysis.h"
#include "mlir/Analysis/DataFlow/IntegerRangeAnalysis.h" #include "mlir/Analysis/DataFlow/IntegerRangeAnalysis.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
namespace mlir { namespace mlir {
namespace arith { namespace arith {
#define GEN_PASS_DEF_ARITHMETICUNSIGNEDWHENEQUIVALENT #define GEN_PASS_DEF_ARITHUNSIGNEDWHENEQUIVALENT
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc" #include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
} // namespace arith } // namespace arith
} // namespace mlir } // namespace mlir
using namespace mlir; using namespace mlir;
using namespace mlir::arith; using namespace mlir::arith;
using namespace mlir::dataflow; using namespace mlir::dataflow;
/// Succeeds when a value is statically non-negative in that it has a lower /// Succeeds when a value is statically non-negative in that it has a lower
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Linesstruct ConvertCmpIToUnsigned : OpConversionPattern<CmpIOp> {
LogicalResult matchAndRewrite(CmpIOp op, CmpIOpAdaptor adaptor, LogicalResult matchAndRewrite(CmpIOp op, CmpIOpAdaptor adaptor,
ConversionPatternRewriter &rw) const override { ConversionPatternRewriter &rw) const override {
rw.replaceOpWithNewOp<CmpIOp>(op, toUnsignedPred(op.getPredicate()), rw.replaceOpWithNewOp<CmpIOp>(op, toUnsignedPred(op.getPredicate()),
op.getLhs(), op.getRhs()); op.getLhs(), op.getRhs());
return success(); return success();
} }
}; };
struct ArithmeticUnsignedWhenEquivalentPass struct ArithUnsignedWhenEquivalentPass
: public arith::impl::ArithmeticUnsignedWhenEquivalentBase< : public arith::impl::ArithUnsignedWhenEquivalentBase<
ArithmeticUnsignedWhenEquivalentPass> { ArithUnsignedWhenEquivalentPass> {
/// Implementation structure: first find all equivalent ops and collect them, /// Implementation structure: first find all equivalent ops and collect them,
/// then perform all the rewrites in a second pass over the target op. This /// then perform all the rewrites in a second pass over the target op. This
/// ensures that analysis results are not invalidated during rewriting. /// ensures that analysis results are not invalidated during rewriting.
void runOnOperation() override { void runOnOperation() override {
Operation *op = getOperation(); Operation *op = getOperation();
MLIRContext *ctx = op->getContext(); MLIRContext *ctx = op->getContext();
DataFlowSolver solver; DataFlowSolver solver;
solver.load<DeadCodeAnalysis>(); solver.load<DeadCodeAnalysis>();
solver.load<IntegerRangeAnalysis>(); solver.load<IntegerRangeAnalysis>();
if (failed(solver.initializeAndRun(op))) if (failed(solver.initializeAndRun(op)))
return signalPassFailure(); return signalPassFailure();
ConversionTarget target(*ctx); ConversionTarget target(*ctx);
target.addLegalDialect<ArithmeticDialect>(); target.addLegalDialect<ArithDialect>();
target target
.addDynamicallyLegalOp<DivSIOp, CeilDivSIOp, CeilDivUIOp, FloorDivSIOp, .addDynamicallyLegalOp<DivSIOp, CeilDivSIOp, CeilDivUIOp, FloorDivSIOp,
RemSIOp, MinSIOp, MaxSIOp, ExtSIOp>( RemSIOp, MinSIOp, MaxSIOp, ExtSIOp>(
[&solver](Operation *op) -> Optional<bool> { [&solver](Operation *op) -> Optional<bool> {
return failed(staticallyNonNegative(solver, op)); return failed(staticallyNonNegative(solver, op));
}); });
target.addDynamicallyLegalOp<CmpIOp>( target.addDynamicallyLegalOp<CmpIOp>(
[&solver](CmpIOp op) -> Optional<bool> { [&solver](CmpIOp op) -> Optional<bool> {
Show All 12 Lines void runOnOperation() override {
if (failed(applyPartialConversion(op, target, std::move(patterns)))) { if (failed(applyPartialConversion(op, target, std::move(patterns)))) {
signalPassFailure(); signalPassFailure();
} }
} }
}; };
} // end anonymous namespace } // end anonymous namespace
std::unique_ptr<Pass> std::unique_ptr<Pass> mlir::arith::createArithUnsignedWhenEquivalentPass() {
mlir::arith::createArithmeticUnsignedWhenEquivalentPass() { return std::make_unique<ArithUnsignedWhenEquivalentPass>();
return std::make_unique<ArithmeticUnsignedWhenEquivalentPass>();
} }

mlir/lib/Dialect/Arith/Utils/CMakeLists.txt

  • This file was added.
add_mlir_dialect_library(MLIRArithUtils
Utils.cpp
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arith/Utils
LINK_LIBS PUBLIC
MLIRArithDialect
MLIRDialect
MLIRIR
)

mlir/lib/Dialect/Arith/Utils/Utils.cpp

  • This file was moved from mlir/lib/Dialect/Arithmetic/Utils/Utils.cpp.
//===- Utils.cpp - Utilities to support the Linalg dialect ----------------===// //===- Utils.cpp - Utilities to support the Linalg dialect ----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements utilities for the Linalg dialect. // This file implements utilities for the Linalg dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "llvm/ADT/SmallBitVector.h" #include "llvm/ADT/SmallBitVector.h"
using namespace mlir; using namespace mlir;
/// Matches a ConstantIndexOp. /// Matches a ConstantIndexOp.
/// TODO: This should probably just be a general matcher that uses matchConstant /// TODO: This should probably just be a general matcher that uses matchConstant
/// and checks the operation for an index type. /// and checks the operation for an index type.
detail::op_matcher<arith::ConstantIndexOp> mlir::matchConstantIndex() { detail::op_matcher<arith::ConstantIndexOp> mlir::matchConstantIndex() {
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

mlir/lib/Dialect/Arithmetic/CMakeLists.txt

  • This file was moved to mlir/lib/Dialect/Arith/CMakeLists.txt.

mlir/lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.td

  • This file was moved to mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td.

mlir/lib/Dialect/Arithmetic/IR/ArithmeticDialect.cpp

  • This file was moved to mlir/lib/Dialect/Arith/IR/ArithDialect.cpp.

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

  • This file was moved to mlir/lib/Dialect/Arith/IR/ArithOps.cpp.

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

  • This file was deleted.
set(LLVM_TARGET_DEFINITIONS ArithmeticCanonicalization.td)
mlir_tablegen(ArithmeticCanonicalization.inc -gen-rewriters)
add_public_tablegen_target(MLIRArithmeticCanonicalizationIncGen)
add_mlir_dialect_library(MLIRArithmeticDialect
ArithmeticOps.cpp
ArithmeticDialect.cpp
InferIntRangeInterfaceImpls.cpp
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arithmetic
DEPENDS
MLIRArithmeticOpsIncGen
LINK_LIBS PUBLIC
MLIRDialect
MLIRInferIntRangeInterface
MLIRInferTypeOpInterface
MLIRIR
)

mlir/lib/Dialect/Arithmetic/IR/InferIntRangeInterfaceImpls.cpp

  • This file was moved to mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp.

mlir/lib/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.cpp

  • This file was moved to mlir/lib/Dialect/Arith/Transforms/BufferizableOpInterfaceImpl.cpp.

mlir/lib/Dialect/Arithmetic/Transforms/Bufferize.cpp

  • This file was moved to mlir/lib/Dialect/Arith/Transforms/Bufferize.cpp.

mlir/lib/Dialect/Arithmetic/Transforms/CMakeLists.txt

  • This file was moved to mlir/lib/Dialect/Arith/Transforms/CMakeLists.txt.

mlir/lib/Dialect/Arithmetic/Transforms/EmulateWideInt.cpp

  • This file was moved to mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp.

mlir/lib/Dialect/Arithmetic/Transforms/ExpandOps.cpp

  • This file was moved to mlir/lib/Dialect/Arith/Transforms/ExpandOps.cpp.

mlir/lib/Dialect/Arithmetic/Transforms/UnsignedWhenEquivalent.cpp

  • This file was moved to mlir/lib/Dialect/Arith/Transforms/UnsignedWhenEquivalent.cpp.

mlir/lib/Dialect/Arithmetic/Utils/CMakeLists.txt

  • This file was deleted.
add_mlir_dialect_library(MLIRArithmeticUtils
Utils.cpp
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arithmetic/Utils
LINK_LIBS PUBLIC
MLIRArithmeticDialect
MLIRDialect
MLIRIR
)

mlir/lib/Dialect/Arithmetic/Utils/Utils.cpp

  • This file was moved to mlir/lib/Dialect/Arith/Utils/Utils.cpp.

mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp

//===- AsyncParallelFor.cpp - Implementation of Async Parallel For --------===// //===- AsyncParallelFor.cpp - Implementation of Async Parallel For --------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements scf.parallel to scf.for + async.execute conversion pass. // This file implements scf.parallel to scf.for + async.execute conversion pass.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Async/Passes.h" #include "mlir/Dialect/Async/Passes.h"
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Async/IR/Async.h" #include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/Async/Transforms.h" #include "mlir/Dialect/Async/Transforms.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
▲ Show 20 Lines • Show All 936 Lines • Show Last 20 Lines

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

Show All 9 Lines
// and async.runtime operations. // and async.runtime operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Async/Passes.h" #include "mlir/Dialect/Async/Passes.h"
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Async/IR/Async.h" #include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
▲ Show 20 Lines • Show All 805 Lines • Show Last 20 Lines

mlir/lib/Dialect/Async/Transforms/CMakeLists.txt

add_mlir_dialect_library(MLIRAsyncTransforms add_mlir_dialect_library(MLIRAsyncTransforms
AsyncParallelFor.cpp AsyncParallelFor.cpp
AsyncRuntimeRefCounting.cpp AsyncRuntimeRefCounting.cpp
AsyncRuntimeRefCountingOpt.cpp AsyncRuntimeRefCountingOpt.cpp
AsyncToAsyncRuntime.cpp AsyncToAsyncRuntime.cpp
PassDetail.cpp PassDetail.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Async ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Async
DEPENDS DEPENDS
MLIRAsyncPassIncGen MLIRAsyncPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRAsyncDialect MLIRAsyncDialect
MLIRFuncDialect MLIRFuncDialect
MLIRIR MLIRIR
MLIRPass MLIRPass
MLIRSCFDialect MLIRSCFDialect
MLIRSCFToControlFlow MLIRSCFToControlFlow
MLIRTransforms MLIRTransforms
MLIRTransformUtils MLIRTransformUtils
) )

mlir/lib/Dialect/Async/Transforms/PassDetail.h

Show All 10 Lines
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
namespace arith { namespace arith {
class ArithmeticDialect; class ArithDialect;
} // namespace arith } // namespace arith
namespace async { namespace async {
class AsyncDialect; class AsyncDialect;
} // namespace async } // namespace async
namespace scf { namespace scf {
class SCFDialect; class SCFDialect;
Show All 23 Lines

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h" #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/MemRef/Utils/MemRefUtils.h" #include "mlir/Dialect/MemRef/Utils/MemRefUtils.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h" #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
▲ Show 20 Lines • Show All 672 Lines • Show Last 20 Lines

mlir/lib/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.cpp

//======- BufferViewFlowAnalysis.cpp - Buffer alias analysis -*- C++ -*-======// //======- BufferViewFlowAnalysis.cpp - Buffer alias analysis -*- C++ -*-======//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.h" #include "mlir/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h" #include "mlir/Interfaces/ControlFlowInterfaces.h"
#include "mlir/Interfaces/ViewLikeInterface.h" #include "mlir/Interfaces/ViewLikeInterface.h"
#include "llvm/ADT/SetOperations.h" #include "llvm/ADT/SetOperations.h"
using namespace mlir; using namespace mlir;
/// Constructs a new alias analysis using the op provided. /// Constructs a new alias analysis using the op provided.
BufferViewFlowAnalysis::BufferViewFlowAnalysis(Operation *op) { build(op); } BufferViewFlowAnalysis::BufferViewFlowAnalysis(Operation *op) { build(op); }
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

mlir/lib/Dialect/CMakeLists.txt

add_subdirectory(Affine) add_subdirectory(Affine)
add_subdirectory(AMDGPU) add_subdirectory(AMDGPU)
add_subdirectory(Arithmetic) add_subdirectory(Arith)
add_subdirectory(ArmNeon) add_subdirectory(ArmNeon)
add_subdirectory(ArmSVE) add_subdirectory(ArmSVE)
add_subdirectory(Async) add_subdirectory(Async)
add_subdirectory(AMX) add_subdirectory(AMX)
add_subdirectory(Bufferization) add_subdirectory(Bufferization)
add_subdirectory(Complex) add_subdirectory(Complex)
add_subdirectory(ControlFlow) add_subdirectory(ControlFlow)
add_subdirectory(DLTI) add_subdirectory(DLTI)
Show All 38 Lines

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

add_mlir_dialect_library(MLIRComplexDialect add_mlir_dialect_library(MLIRComplexDialect
ComplexOps.cpp ComplexOps.cpp
ComplexDialect.cpp ComplexDialect.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Complex ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Complex
DEPENDS DEPENDS
MLIRComplexOpsIncGen MLIRComplexOpsIncGen
MLIRComplexAttributesIncGen MLIRComplexAttributesIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRDialect MLIRDialect
MLIRInferTypeOpInterface MLIRInferTypeOpInterface
MLIRIR MLIRIR
) )

mlir/lib/Dialect/Complex/IR/ComplexDialect.cpp

//===- ComplexDialect.cpp - MLIR Complex Dialect --------------------------===// //===- ComplexDialect.cpp - MLIR Complex Dialect --------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/DialectImplementation.h" #include "mlir/IR/DialectImplementation.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/TypeSwitch.h" #include "llvm/ADT/TypeSwitch.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

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

add_mlir_dialect_library(MLIRControlFlowDialect add_mlir_dialect_library(MLIRControlFlowDialect
ControlFlowOps.cpp ControlFlowOps.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/ControlFlow/IR ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/ControlFlow/IR
DEPENDS DEPENDS
MLIRControlFlowOpsIncGen MLIRControlFlowOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRControlFlowInterfaces MLIRControlFlowInterfaces
MLIRIR MLIRIR
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
) )

mlir/lib/Dialect/ControlFlow/IR/ControlFlowOps.cpp

//===- ControlFlowOps.cpp - ControlFlow Operations ------------------------===// //===- ControlFlowOps.cpp - ControlFlow Operations ------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/CommonFolders.h" #include "mlir/Dialect/CommonFolders.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
▲ Show 20 Lines • Show All 885 Lines • Show Last 20 Lines

mlir/lib/Dialect/GPU/CMakeLists.txt

Show All 27 Linesadd_mlir_dialect_library(MLIRGPUOps
DEPENDS DEPENDS
MLIRGPUOpsIncGen MLIRGPUOpsIncGen
MLIRGPUOpsAttributesIncGen MLIRGPUOpsAttributesIncGen
MLIRGPUOpsEnumsGen MLIRGPUOpsEnumsGen
MLIRGPUOpInterfacesIncGen MLIRGPUOpInterfacesIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRDLTIDialect MLIRDLTIDialect
MLIRInferIntRangeInterface MLIRInferIntRangeInterface
MLIRIR MLIRIR
MLIRMemRefDialect MLIRMemRefDialect
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRSupport MLIRSupport
) )
Show All 17 Linesadd_mlir_dialect_library(MLIRGPUTransforms
${AMDGPU_LIBS} ${AMDGPU_LIBS}
DEPENDS DEPENDS
MLIRGPUPassIncGen MLIRGPUPassIncGen
MLIRParallelLoopMapperEnumsGen MLIRParallelLoopMapperEnumsGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineUtils MLIRAffineUtils
MLIRArithmeticDialect MLIRArithDialect
MLIRAsyncDialect MLIRAsyncDialect
MLIRDataLayoutInterfaces MLIRDataLayoutInterfaces
MLIRExecutionEngineUtils MLIRExecutionEngineUtils
MLIRGPUOps MLIRGPUOps
MLIRIR MLIRIR
MLIRLLVMDialect MLIRLLVMDialect
MLIRLLVMToLLVMIRTranslation MLIRLLVMToLLVMIRTranslation
MLIRMemRefDialect MLIRMemRefDialect
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

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

//===- GPUDialect.cpp - MLIR Dialect for GPU Kernels implementation -------===// //===- GPUDialect.cpp - MLIR Dialect for GPU Kernels implementation -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the GPU kernel-related dialect and its operations. // This file implements the GPU kernel-related dialect and its operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/Attributes.h" #include "mlir/IR/Attributes.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/DialectImplementation.h" #include "mlir/IR/DialectImplementation.h"
#include "mlir/IR/FunctionImplementation.h" #include "mlir/IR/FunctionImplementation.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
▲ Show 20 Lines • Show All 1,382 Lines • Show Last 20 Lines

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

//===- AllReduceLowering.cpp - Implementation of all-reduce lowering ------===// //===- AllReduceLowering.cpp - Implementation of all-reduce lowering ------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements in-dialect lowering of the all-reduce op to a block of // This file implements in-dialect lowering of the all-reduce op to a block of
// simpler instructions. // simpler instructions.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/GPU/Transforms/Passes.h" #include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
▲ Show 20 Lines • Show All 390 Lines • Show Last 20 Lines

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

//===- KernelOutlining.cpp - Implementation of GPU kernel outlining -------===// //===- KernelOutlining.cpp - Implementation of GPU kernel outlining -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the GPU dialect kernel outlining pass. // This file implements the GPU dialect kernel outlining pass.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/GPU/Transforms/Passes.h" #include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/AsmParser/AsmParser.h" #include "mlir/AsmParser/AsmParser.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/DLTI/DLTI.h" #include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/GPU/Transforms/Utils.h" #include "mlir/Dialect/GPU/Transforms/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
▲ Show 20 Lines • Show All 374 Lines • Show Last 20 Lines

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

//===- MemoryPromotion.cpp - Utilities for moving data across GPU memories ===// //===- MemoryPromotion.cpp - Utilities for moving data across GPU memories ===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements utilities that allow one to create IR moving the data // This file implements utilities that allow one to create IR moving the data
// across different levels of the GPU memory hierarchy. // across different levels of the GPU memory hierarchy.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/GPU/Transforms/MemoryPromotion.h" #include "mlir/Dialect/GPU/Transforms/MemoryPromotion.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
using namespace mlir; using namespace mlir;
using namespace mlir::gpu; using namespace mlir::gpu;
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

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

Show All 9 Linesadd_mlir_dialect_library(MLIRLinalgDialect
MLIRLinalgInterfacesIncGen MLIRLinalgInterfacesIncGen
MLIRLinalgOpsAttributesIncGen MLIRLinalgOpsAttributesIncGen
MLIRLinalgOpsEnumsIncGen MLIRLinalgOpsEnumsIncGen
MLIRLinalgOpsIncGen MLIRLinalgOpsIncGen
MLIRLinalgStructuredOpsIncGen MLIRLinalgStructuredOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRArithmeticDialect MLIRArithDialect
MLIRArithmeticUtils MLIRArithUtils
MLIRBufferizationDialect MLIRBufferizationDialect
MLIRDialectUtils MLIRDialectUtils
MLIRInferTypeOpInterface MLIRInferTypeOpInterface
MLIRIR MLIRIR
MLIRParser MLIRParser
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRSparseTensorDialect MLIRSparseTensorDialect
MLIRSCFDialect MLIRSCFDialect
MLIRMathDialect MLIRMathDialect
MLIRMemRefDialect MLIRMemRefDialect
MLIRTensorDialect MLIRTensorDialect
MLIRTilingInterface MLIRTilingInterface
MLIRViewLikeInterface MLIRViewLikeInterface
) )

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

//===- Dialect.cpp - Implementation of the linalg dialect and types -------===// //===- Dialect.cpp - Implementation of the linalg dialect and types -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the Linalg dialect types and dialect. // This file implements the Linalg dialect types and dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h" #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/DialectImplementation.h" #include "mlir/IR/DialectImplementation.h"
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

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

//===- LinalgInterfaces.cpp - Linalg interfaces implementation ------------===// //===- LinalgInterfaces.cpp - Linalg interfaces implementation ------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/IR/LinalgInterfaces.h" #include "mlir/Dialect/Linalg/IR/LinalgInterfaces.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/AffineExprVisitor.h" #include "mlir/IR/AffineExprVisitor.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include "llvm/ADT/SmallBitVector.h" #include "llvm/ADT/SmallBitVector.h"
▲ Show 20 Lines • Show All 804 Lines • Show Last 20 Lines

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

//===- LinalgOps.cpp - Implementation of the linalg operations ------------===// //===- LinalgOps.cpp - Implementation of the linalg operations ------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the Linalg operations. // This file implements the Linalg operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/AsmParser/AsmParser.h" #include "mlir/AsmParser/AsmParser.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h" #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/ReshapeOpsUtils.h" #include "mlir/Dialect/Utils/ReshapeOpsUtils.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
▲ Show 20 Lines • Show All 2,101 Lines • Show Last 20 Lines

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

add_mlir_dialect_library(MLIRLinalgTransformOps add_mlir_dialect_library(MLIRLinalgTransformOps
LinalgTransformOps.cpp LinalgTransformOps.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Linalg/TransformOps ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Linalg/TransformOps
DEPENDS DEPENDS
MLIRLinalgTransformOpsIncGen MLIRLinalgTransformOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRArithmeticDialect MLIRArithDialect
MLIRIR MLIRIR
MLIRLinalgDialect MLIRLinalgDialect
MLIRLinalgTransforms MLIRLinalgTransforms
MLIRParser MLIRParser
MLIRPDLDialect MLIRPDLDialect
MLIRSCFDialect MLIRSCFDialect
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRTransformDialect MLIRTransformDialect
MLIRVectorDialect MLIRVectorDialect
) )

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

//===- LinalgTransformOps.cpp - Implementation of Linalg transform ops ----===// //===- LinalgTransformOps.cpp - Implementation of Linalg transform ops ----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.h" #include "mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.h"
#include "mlir/AsmParser/AsmParser.h" #include "mlir/AsmParser/AsmParser.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/PDL/IR/PDL.h" #include "mlir/Dialect/PDL/IR/PDL.h"
#include "mlir/Dialect/PDL/IR/PDLTypes.h" #include "mlir/Dialect/PDL/IR/PDLTypes.h"
#include "mlir/Dialect/Transform/IR/TransformDialect.h" #include "mlir/Dialect/Transform/IR/TransformDialect.h"
#include "mlir/Dialect/Transform/IR/TransformInterfaces.h" #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
#include "mlir/Interfaces/TilingInterface.h" #include "mlir/Interfaces/TilingInterface.h"
▲ Show 20 Lines • Show All 1,747 Lines • ▼ Show 20 Lines : public transform::TransformDialectExtension<
LinalgTransformDialectExtension> { LinalgTransformDialectExtension> {
public: public:
using Base::Base; using Base::Base;
void init() { void init() {
declareDependentDialect<pdl::PDLDialect>(); declareDependentDialect<pdl::PDLDialect>();
declareDependentDialect<LinalgDialect>(); declareDependentDialect<LinalgDialect>();
declareGeneratedDialect<AffineDialect>(); declareGeneratedDialect<AffineDialect>();
declareGeneratedDialect<arith::ArithmeticDialect>(); declareGeneratedDialect<arith::ArithDialect>();
declareGeneratedDialect<scf::SCFDialect>(); declareGeneratedDialect<scf::SCFDialect>();
declareGeneratedDialect<vector::VectorDialect>(); declareGeneratedDialect<vector::VectorDialect>();
declareGeneratedDialect<gpu::GPUDialect>(); declareGeneratedDialect<gpu::GPUDialect>();
registerTransformOps< registerTransformOps<
#define GET_OP_LIST #define GET_OP_LIST
#include "mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp.inc" #include "mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp.inc"
>(); >();
Show All 13 Lines

mlir/lib/Dialect/Linalg/Transforms/BubbleUpExtractSlice.cpp

//===- BubbleUpExtractSlice.cpp - bubble up tensor.extract_slice ----------===// //===- BubbleUpExtractSlice.cpp - bubble up tensor.extract_slice ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements patterns that transforms linalg.<op> + // This file implements patterns that transforms linalg.<op> +
// tensor.extract_slice into tensor.extract_slice + linalg.<op> to reduce // tensor.extract_slice into tensor.extract_slice + linalg.<op> to reduce
// the computation for the linalg op. // the computation for the linalg op.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
using namespace mlir; using namespace mlir;
using namespace mlir::linalg; using namespace mlir::linalg;
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

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

Show All 34 Linesadd_mlir_dialect_library(MLIRLinalgTransforms
DEPENDS DEPENDS
MLIRLinalgPassIncGen MLIRLinalgPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineUtils MLIRAffineUtils
MLIRAnalysis MLIRAnalysis
MLIRArithmeticDialect MLIRArithDialect
MLIRArithmeticTransforms MLIRArithTransforms
MLIRArithmeticUtils MLIRArithUtils
MLIRBufferizationDialect MLIRBufferizationDialect
MLIRBufferizationTransforms MLIRBufferizationTransforms
MLIRComplexDialect MLIRComplexDialect
MLIRDialectUtils MLIRDialectUtils
MLIRFuncDialect MLIRFuncDialect
MLIRFuncToLLVM MLIRFuncToLLVM
MLIRFuncTransforms MLIRFuncTransforms
MLIRInferTypeOpInterface MLIRInferTypeOpInterface
Show All 21 Lines

mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp

Show All 9 Lines
// to specify broadcasting in favor of more canonical representation of the // to specify broadcasting in favor of more canonical representation of the
// computation // computation
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/Transforms/FoldUtils.h" #include "mlir/Transforms/FoldUtils.h"
▲ Show 20 Lines • Show All 541 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp

//===- ElementwiseOpFusion.cpp - Implementation of linalg Fusion ---------===/// //===- ElementwiseOpFusion.cpp - Implementation of linalg Fusion ---------===///
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the linalg dialect Fusion on tensors operations pass. // This file implements the linalg dialect Fusion on tensors operations pass.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h" #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Support/LLVM.h" #include "mlir/Support/LLVM.h"
▲ Show 20 Lines • Show All 1,777 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/ElementwiseToLinalg.cpp

//===- ElementwiseToLinalg.cpp - conversion of elementwise to linalg ------===// //===- ElementwiseToLinalg.cpp - conversion of elementwise to linalg ------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_CONVERTELEMENTWISETOLINALG #define GEN_PASS_DEF_CONVERTELEMENTWISETOLINALG
#include "mlir/Dialect/Linalg/Passes.h.inc" #include "mlir/Dialect/Linalg/Passes.h.inc"
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp

//===- Fusion.cpp - Implementation of linalg Fusion -----------------------===// //===- Fusion.cpp - Implementation of linalg Fusion -----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the linalg dialect Fusion pass. // This file implements the linalg dialect Fusion pass.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h" #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
▲ Show 20 Lines • Show All 437 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp

Show All 9 Lines
// in the context of Linalg transformations. // in the context of Linalg transformations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Transforms/Hoisting.h" #include "mlir/Dialect/Linalg/Transforms/Hoisting.h"
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h" #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h" #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
▲ Show 20 Lines • Show All 504 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/InlineScalarOperands.cpp

//===- InlineScalarOperands.cpp - Pass to inline scalar operands =============// //===- InlineScalarOperands.cpp - Pass to inline scalar operands =============//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements patterns/pass to inline scalar operands into a generic // This file implements patterns/pass to inline scalar operands into a generic
// operation. A scalar operand is an operand whose indexing map has a constant // operation. A scalar operand is an operand whose indexing map has a constant
// rhs. // rhs.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
namespace mlir { namespace mlir {
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/Loops.cpp

//===- Loops.cpp - conversion from Linalg named and generic ops to loops --===// //===- Loops.cpp - conversion from Linalg named and generic ops to loops --===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h" #include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h" #include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
▲ Show 20 Lines • Show All 360 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp

//===- Promotion.cpp - Implementation of linalg Promotion -----------------===// //===- Promotion.cpp - Implementation of linalg Promotion -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the linalg dialect Promotion pass. // This file implements the linalg dialect Promotion pass.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineExprVisitor.h" #include "mlir/IR/AffineExprVisitor.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
▲ Show 20 Lines • Show All 376 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/SplitReduction.cpp

//===-------- SplitReduction.cpp - Split reduction dimesion ---------------===// //===-------- SplitReduction.cpp - Split reduction dimesion ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements linalg transformation to break a reduction dimension // This file implements linalg transformation to break a reduction dimension
// between a parallel and a reduction dimension. // between a parallel and a reduction dimension.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <utility> #include <utility>
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Utils/Utils.h" #include "mlir/Dialect/Tensor/Utils/Utils.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
▲ Show 20 Lines • Show All 485 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

//===- Tiling.cpp - Implementation of linalg Tiling -----------------------===// //===- Tiling.cpp - Implementation of linalg Tiling -----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the linalg dialect Tiling pass. // This file implements the linalg dialect Tiling pass.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h" #include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/IndexingUtils.h" #include "mlir/Dialect/Utils/IndexingUtils.h"
▲ Show 20 Lines • Show All 786 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/TilingInterfaceImpl.cpp

//===- TilingInterfaceImpl.cpp - Implementation of TilingInterface -------===// //===- TilingInterfaceImpl.cpp - Implementation of TilingInterface -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Transforms/TilingInterfaceImpl.h" #include "mlir/Dialect/Linalg/Transforms/TilingInterfaceImpl.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/Interfaces/TilingInterface.h" #include "mlir/Interfaces/TilingInterface.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp

//===- Transforms.cpp - Linalg transformations as patterns ----------------===// //===- Transforms.cpp - Linalg transformations as patterns ----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements logic and helpers to expose Linalg transforms as rewrite // This file implements logic and helpers to expose Linalg transforms as rewrite
// patterns. // patterns.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h" #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/HoistPadding.h" #include "mlir/Dialect/Linalg/Transforms/HoistPadding.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h" #include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/IR/TensorTilingInterfaceImpl.h" #include "mlir/Dialect/Tensor/IR/TensorTilingInterfaceImpl.h"
▲ Show 20 Lines • Show All 965 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

//===- Vectorization.cpp - Implementation of linalg Vectorization ---------===// //===- Vectorization.cpp - Implementation of linalg Vectorization ---------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the linalg dialect Vectorization transformations. // This file implements the linalg dialect Vectorization transformations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h" #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h" #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/StructuredOpsUtils.h" #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
▲ Show 20 Lines • Show All 1,767 Lines • Show Last 20 Lines

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

add_mlir_dialect_library(MLIRLinalgUtils add_mlir_dialect_library(MLIRLinalgUtils
Utils.cpp Utils.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Linalg ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Linalg
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineAnalysis MLIRAffineAnalysis
MLIRAffineUtils MLIRAffineUtils
MLIRArithmeticDialect MLIRArithDialect
MLIRFuncDialect MLIRFuncDialect
MLIRIR MLIRIR
MLIRLinalgDialect MLIRLinalgDialect
MLIRSCFDialect MLIRSCFDialect
MLIRPass MLIRPass
MLIRTensorUtils MLIRTensorUtils
MLIRTransformUtils MLIRTransformUtils
) )

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

Show All 11 Lines
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h" #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h" #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Utils/Utils.h" #include "mlir/Dialect/Tensor/Utils/Utils.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
▲ Show 20 Lines • Show All 1,042 Lines • Show Last 20 Lines

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

add_mlir_dialect_library(MLIRMathDialect add_mlir_dialect_library(MLIRMathDialect
MathOps.cpp MathOps.cpp
MathDialect.cpp MathDialect.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Math ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Math
DEPENDS DEPENDS
MLIRMathOpsIncGen MLIRMathOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRDialect MLIRDialect
MLIRIR MLIRIR
) )

mlir/lib/Dialect/Math/IR/MathOps.cpp

//===- MathOps.cpp - MLIR operations for math implementation --------------===// //===- MathOps.cpp - MLIR operations for math implementation --------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/CommonFolders.h" #include "mlir/Dialect/CommonFolders.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
using namespace mlir; using namespace mlir;
using namespace mlir::math; using namespace mlir::math;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 502 Lines • Show Last 20 Lines

mlir/lib/Dialect/Math/Transforms/AlgebraicSimplification.cpp

//===- AlgebraicSimplification.cpp - Simplify algebraic expressions -------===// //===- AlgebraicSimplification.cpp - Simplify algebraic expressions -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements rewrites based on the basic rules of algebra // This file implements rewrites based on the basic rules of algebra
// (Commutativity, associativity, etc...) and strength reductions for math // (Commutativity, associativity, etc...) and strength reductions for math
// operations. // operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Math/Transforms/Passes.h" #include "mlir/Dialect/Math/Transforms/Passes.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include <climits> #include <climits>
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

mlir/lib/Dialect/Math/Transforms/CMakeLists.txt

add_mlir_dialect_library(MLIRMathTransforms add_mlir_dialect_library(MLIRMathTransforms
AlgebraicSimplification.cpp AlgebraicSimplification.cpp
ExpandPatterns.cpp ExpandPatterns.cpp
PolynomialApproximation.cpp PolynomialApproximation.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Math/Transforms ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Math/Transforms
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRDialectUtils MLIRDialectUtils
MLIRIR MLIRIR
MLIRMathDialect MLIRMathDialect
MLIRPass MLIRPass
MLIRTransforms MLIRTransforms
MLIRX86VectorDialect MLIRX86VectorDialect
MLIRVectorDialect MLIRVectorDialect
MLIRVectorUtils MLIRVectorUtils
) )

mlir/lib/Dialect/Math/Transforms/ExpandPatterns.cpp

//===- ExpandTanh.cpp - Code to perform expanding tanh op -----------------===// //===- ExpandTanh.cpp - Code to perform expanding tanh op -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements expansion of tanh op. // This file implements expansion of tanh op.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Math/Transforms/Passes.h" #include "mlir/Dialect/Math/Transforms/Passes.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

mlir/lib/Dialect/Math/Transforms/PolynomialApproximation.cpp

//===- PolynomialApproximation.cpp - Approximate math operations ----------===// //===- PolynomialApproximation.cpp - Approximate math operations ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements expansion of math operations to fast approximations // This file implements expansion of math operations to fast approximations
// that do not rely on any of the library functions. // that do not rely on any of the library functions.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <climits> #include <climits>
#include <cstddef> #include <cstddef>
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Math/Transforms/Approximation.h" #include "mlir/Dialect/Math/Transforms/Approximation.h"
#include "mlir/Dialect/Math/Transforms/Passes.h" #include "mlir/Dialect/Math/Transforms/Passes.h"
#include "mlir/Dialect/Utils/IndexingUtils.h" #include "mlir/Dialect/Utils/IndexingUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/Dialect/X86Vector/X86VectorDialect.h" #include "mlir/Dialect/X86Vector/X86VectorDialect.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
▲ Show 20 Lines • Show All 1,265 Lines • Show Last 20 Lines

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

add_mlir_dialect_library(MLIRMemRefDialect add_mlir_dialect_library(MLIRMemRefDialect
MemRefDialect.cpp MemRefDialect.cpp
MemRefOps.cpp MemRefOps.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${PROJECT_SOURCE_DIR}/inlude/mlir/Dialect/MemRefDialect ${PROJECT_SOURCE_DIR}/inlude/mlir/Dialect/MemRefDialect
DEPENDS DEPENDS
MLIRMemRefOpsIncGen MLIRMemRefOpsIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRArithmeticUtils MLIRArithUtils
MLIRControlFlowInterfaces MLIRControlFlowInterfaces
MLIRDialect MLIRDialect
MLIRDialectUtils MLIRDialectUtils
MLIRInferTypeOpInterface MLIRInferTypeOpInterface
MLIRIR MLIRIR
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRViewLikeInterface MLIRViewLikeInterface
) )

mlir/lib/Dialect/MemRef/IR/MemRefDialect.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
#include "mlir/Transforms/InliningUtils.h" #include "mlir/Transforms/InliningUtils.h"
using namespace mlir; using namespace mlir;
using namespace mlir::memref; using namespace mlir::memref;
#include "mlir/Dialect/MemRef/IR/MemRefOpsDialect.cpp.inc" #include "mlir/Dialect/MemRef/IR/MemRefOpsDialect.cpp.inc"
Show All 40 Lines

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/MemRef/Utils/MemRefUtils.h" #include "mlir/Dialect/MemRef/Utils/MemRefUtils.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
▲ Show 20 Lines • Show All 2,985 Lines • Show Last 20 Lines

mlir/lib/Dialect/MemRef/TransformOps/CMakeLists.txt

add_mlir_dialect_library(MLIRMemRefTransformOps add_mlir_dialect_library(MLIRMemRefTransformOps
MemRefTransformOps.cpp MemRefTransformOps.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/MemRef/TransformOps ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/MemRef/TransformOps
DEPENDS DEPENDS
MLIRMemRefTransformOpsIncGen MLIRMemRefTransformOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRArithmeticDialect MLIRArithDialect
MLIRIR MLIRIR
MLIRPDLDialect MLIRPDLDialect
MLIRMemRefDialect MLIRMemRefDialect
MLIRMemRefTransforms MLIRMemRefTransforms
MLIRTransformDialect MLIRTransformDialect
) )

mlir/lib/Dialect/MemRef/TransformOps/MemRefTransformOps.cpp

//===- MemRefTransformOps.cpp - Implementation of Memref transform ops ----===// //===- MemRefTransformOps.cpp - Implementation of Memref transform ops ----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/MemRef/TransformOps/MemRefTransformOps.h" #include "mlir/Dialect/MemRef/TransformOps/MemRefTransformOps.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/MemRef/Transforms/Passes.h" #include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/PDL/IR/PDL.h" #include "mlir/Dialect/PDL/IR/PDL.h"
#include "mlir/Dialect/Transform/IR/TransformDialect.h" #include "mlir/Dialect/Transform/IR/TransformDialect.h"
#include "mlir/Dialect/Transform/IR/TransformInterfaces.h" #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
using namespace mlir; using namespace mlir;
Show All 25 Linesclass MemRefTransformDialectExtension
: public transform::TransformDialectExtension< : public transform::TransformDialectExtension<
MemRefTransformDialectExtension> { MemRefTransformDialectExtension> {
public: public:
using Base::Base; using Base::Base;
void init() { void init() {
declareDependentDialect<pdl::PDLDialect>(); declareDependentDialect<pdl::PDLDialect>();
declareGeneratedDialect<AffineDialect>(); declareGeneratedDialect<AffineDialect>();
declareGeneratedDialect<arith::ArithmeticDialect>(); declareGeneratedDialect<arith::ArithDialect>();
registerTransformOps< registerTransformOps<
#define GET_OP_LIST #define GET_OP_LIST
#include "mlir/Dialect/MemRef/TransformOps/MemRefTransformOps.cpp.inc" #include "mlir/Dialect/MemRef/TransformOps/MemRefTransformOps.cpp.inc"
>(); >();
} }
}; };
} // namespace } // namespace
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/Dialect/MemRef/TransformOps/MemRefTransformOps.cpp.inc" #include "mlir/Dialect/MemRef/TransformOps/MemRefTransformOps.cpp.inc"
void mlir::memref::registerTransformDialectExtension( void mlir::memref::registerTransformDialectExtension(
DialectRegistry &registry) { DialectRegistry &registry) {
registry.addExtensions<MemRefTransformDialectExtension>(); registry.addExtensions<MemRefTransformDialectExtension>();
} }

mlir/lib/Dialect/MemRef/Transforms/CMakeLists.txt

Show All 10 Linesadd_mlir_dialect_library(MLIRMemRefTransforms
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/MemRef ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/MemRef
DEPENDS DEPENDS
MLIRMemRefPassIncGen MLIRMemRefPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineUtils MLIRAffineUtils
MLIRArithmeticDialect MLIRArithDialect
MLIRFuncDialect MLIRFuncDialect
MLIRInferTypeOpInterface MLIRInferTypeOpInterface
MLIRLoopLikeInterface MLIRLoopLikeInterface
MLIRMemRefDialect MLIRMemRefDialect
MLIRPass MLIRPass
MLIRTensorDialect MLIRTensorDialect
MLIRTransforms MLIRTransforms
MLIRVectorDialect MLIRVectorDialect
) )

mlir/lib/Dialect/MemRef/Transforms/ExpandOps.cpp

//===- StdExpandDivs.cpp - Code to prepare Std for lowering Divs to LLVM -===// //===- StdExpandDivs.cpp - Code to prepare Std for lowering Divs to LLVM -===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file Std transformations to expand Divs operation to help for the // This file Std transformations to expand Divs operation to help for the
// lowering to LLVM. Currently implemented transformations are Ceil and Floor // lowering to LLVM. Currently implemented transformations are Ceil and Floor
// for Signed Integers. // for Signed Integers.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/MemRef/Transforms/Passes.h" #include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h" #include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
namespace mlir { namespace mlir {
namespace memref { namespace memref {
#define GEN_PASS_DEF_EXPANDOPS #define GEN_PASS_DEF_EXPANDOPS
#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc" #include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
struct ExpandOpsPass : public memref::impl::ExpandOpsBase<ExpandOpsPass> { struct ExpandOpsPass : public memref::impl::ExpandOpsBase<ExpandOpsPass> {
void runOnOperation() override { void runOnOperation() override {
MLIRContext &ctx = getContext(); MLIRContext &ctx = getContext();
RewritePatternSet patterns(&ctx); RewritePatternSet patterns(&ctx);
memref::populateExpandOpsPatterns(patterns); memref::populateExpandOpsPatterns(patterns);
ConversionTarget target(ctx); ConversionTarget target(ctx);
target.addLegalDialect<arith::ArithmeticDialect, memref::MemRefDialect>(); target.addLegalDialect<arith::ArithDialect, memref::MemRefDialect>();
target.addDynamicallyLegalOp<memref::AtomicRMWOp>( target.addDynamicallyLegalOp<memref::AtomicRMWOp>(
[](memref::AtomicRMWOp op) { [](memref::AtomicRMWOp op) {
return op.getKind() != arith::AtomicRMWKind::maxf && return op.getKind() != arith::AtomicRMWKind::maxf &&
op.getKind() != arith::AtomicRMWKind::minf; op.getKind() != arith::AtomicRMWKind::minf;
}); });
target.addDynamicallyLegalOp<memref::ReshapeOp>([](memref::ReshapeOp op) { target.addDynamicallyLegalOp<memref::ReshapeOp>([](memref::ReshapeOp op) {
return !op.getShape().getType().cast<MemRefType>().hasStaticShape(); return !op.getShape().getType().cast<MemRefType>().hasStaticShape();
}); });
Show All 16 Lines

mlir/lib/Dialect/MemRef/Transforms/FoldMemRefAliasOps.cpp

//===- FoldMemRefAliasOps.cpp - Fold memref alias ops -----===// //===- FoldMemRefAliasOps.cpp - Fold memref alias ops -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This transformation pass folds loading/storing from/to subview ops into // This transformation pass folds loading/storing from/to subview ops into
// loading/storing from/to the original memref. // loading/storing from/to the original memref.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/MemRef/Transforms/Passes.h" #include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Utils/IndexingUtils.h" #include "mlir/Dialect/Utils/IndexingUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "llvm/ADT/SmallBitVector.h" #include "llvm/ADT/SmallBitVector.h"
#include "llvm/ADT/TypeSwitch.h" #include "llvm/ADT/TypeSwitch.h"
▲ Show 20 Lines • Show All 537 Lines • Show Last 20 Lines

mlir/lib/Dialect/MemRef/Transforms/ResolveShapedTypeResultDims.cpp

//===- ResolveShapedTypeResultDims.cpp - Resolve dim ops of result values -===// //===- ResolveShapedTypeResultDims.cpp - Resolve dim ops of result values -===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This pass resolves `memref.dim` operations of result values in terms of // This pass resolves `memref.dim` operations of result values in terms of
// shapes of their operands using the `InferShapedTypeOpInterface`. // shapes of their operands using the `InferShapedTypeOpInterface`.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/MemRef/Transforms/Passes.h" #include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Interfaces/InferTypeOpInterface.h" #include "mlir/Interfaces/InferTypeOpInterface.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
namespace mlir { namespace mlir {
namespace memref { namespace memref {
#define GEN_PASS_DEF_RESOLVERANKEDSHAPETYPERESULTDIMS #define GEN_PASS_DEF_RESOLVERANKEDSHAPETYPERESULTDIMS
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

mlir/lib/Dialect/MemRef/Transforms/SimplifyExtractStridedMetadata.cpp

//===- SimplifyExtractStridedMetadata.cpp - Simplify this operation -------===// //===- SimplifyExtractStridedMetadata.cpp - Simplify this operation -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
/// This pass simplifies extract_strided_metadata(other_op(memref) to /// This pass simplifies extract_strided_metadata(other_op(memref) to
/// extract_strided_metadata(memref) when it is possible to express the effect /// extract_strided_metadata(memref) when it is possible to express the effect
// of other_op using affine apply on the results of // of other_op using affine apply on the results of
// extract_strided_metadata(memref). // extract_strided_metadata(memref).
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/MemRef/Transforms/Passes.h" #include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallBitVector.h" #include "llvm/ADT/SmallBitVector.h"
namespace mlir { namespace mlir {
▲ Show 20 Lines • Show All 609 Lines • Show Last 20 Lines

mlir/lib/Dialect/NVGPU/Transforms/CMakeLists.txt

add_mlir_dialect_library(MLIRNVGPUTransforms add_mlir_dialect_library(MLIRNVGPUTransforms
OptimizeSharedMemory.cpp OptimizeSharedMemory.cpp
MmaSyncTF32Transform.cpp MmaSyncTF32Transform.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/NVGPU ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/NVGPU
DEPENDS DEPENDS
MLIRNVGPUPassIncGen MLIRNVGPUPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRGPUOps MLIRGPUOps
MLIRIR MLIRIR
MLIRMemRefDialect MLIRMemRefDialect
MLIRNVGPUDialect MLIRNVGPUDialect
MLIRPass MLIRPass
MLIRTransforms MLIRTransforms
MLIRVectorDialect MLIRVectorDialect
MLIRVectorUtils MLIRVectorUtils
) )

mlir/lib/Dialect/NVGPU/Transforms/MmaSyncTF32Transform.cpp

//===- OptimizeSharedMemory.cpp - MLIR NVGPU pass implementation ----------===// //===- OptimizeSharedMemory.cpp - MLIR NVGPU pass implementation ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements transforms to enable 1xtf32 and 3xtf32 nvgpu.mma sync // This file implements transforms to enable 1xtf32 and 3xtf32 nvgpu.mma sync
// operations on f32 input datatype // operations on f32 input datatype
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h" #include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
#include "mlir/Dialect/NVGPU/Passes.h" #include "mlir/Dialect/NVGPU/Passes.h"
#include "mlir/Dialect/NVGPU/Transforms/Transforms.h" #include "mlir/Dialect/NVGPU/Transforms/Transforms.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
#include "mlir/Support/LogicalResult.h" #include "mlir/Support/LogicalResult.h"
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/lib/Dialect/NVGPU/Transforms/OptimizeSharedMemory.cpp

//===- OptimizeSharedMemory.cpp - MLIR NVGPU pass implementation ----------===// //===- OptimizeSharedMemory.cpp - MLIR NVGPU pass implementation ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements transforms to optimize accesses to shared memory. // This file implements transforms to optimize accesses to shared memory.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/NVGPU/Passes.h" #include "mlir/Dialect/NVGPU/Passes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h" #include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
#include "mlir/Dialect/NVGPU/Transforms/Transforms.h" #include "mlir/Dialect/NVGPU/Transforms/Transforms.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
#include "mlir/Support/LogicalResult.h" #include "mlir/Support/LogicalResult.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
▲ Show 20 Lines • Show All 257 Lines • Show Last 20 Lines

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

add_mlir_dialect_library(MLIRSCFDialect add_mlir_dialect_library(MLIRSCFDialect
SCF.cpp SCF.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/SCF ${MLIR_MAIN_INCLUDE_DIR}/mlir/SCF
DEPENDS DEPENDS
MLIRSCFOpsIncGen MLIRSCFOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRBufferizationDialect MLIRBufferizationDialect
MLIRControlFlowDialect MLIRControlFlowDialect
MLIRIR MLIRIR
MLIRLoopLikeInterface MLIRLoopLikeInterface
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
) )

mlir/lib/Dialect/SCF/IR/SCF.cpp

//===- SCF.cpp - Structured Control Flow Operations -----------------------===// //===- SCF.cpp - Structured Control Flow Operations -----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/FunctionInterfaces.h" #include "mlir/IR/FunctionInterfaces.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
▲ Show 20 Lines • Show All 3,378 Lines • Show Last 20 Lines

mlir/lib/Dialect/SCF/Transforms/CMakeLists.txt

Show All 15 Linesadd_mlir_dialect_library(MLIRSCFTransforms
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SCF ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SCF
DEPENDS DEPENDS
MLIRSCFPassIncGen MLIRSCFPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineAnalysis MLIRAffineAnalysis
MLIRArithmeticDialect MLIRArithDialect
MLIRBufferizationDialect MLIRBufferizationDialect
MLIRBufferizationTransforms MLIRBufferizationTransforms
MLIRDialectUtils MLIRDialectUtils
MLIRIR MLIRIR
MLIRMemRefDialect MLIRMemRefDialect
MLIRPass MLIRPass
MLIRSCFDialect MLIRSCFDialect
MLIRSCFUtils MLIRSCFUtils
MLIRSupport MLIRSupport
MLIRTensorDialect MLIRTensorDialect
MLIRTensorTransforms MLIRTensorTransforms
MLIRTilingInterface MLIRTilingInterface
MLIRTransforms MLIRTransforms
MLIRTransformUtils MLIRTransformUtils
) )

mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp

//===- ForToWhile.cpp - scf.for to scf.while loop conversion --------------===// //===- ForToWhile.cpp - scf.for to scf.while loop conversion --------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Transforms SCF.ForOp's into SCF.WhileOp's. // Transforms SCF.ForOp's into SCF.WhileOp's.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SCF/Transforms/Passes.h" #include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h" #include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_SCFFORTOWHILELOOP #define GEN_PASS_DEF_SCFFORTOWHILELOOP
#include "mlir/Dialect/SCF/Transforms/Passes.h.inc" #include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp

//===- LoopPipelining.cpp - Code to perform loop software pipelining-------===// //===- LoopPipelining.cpp - Code to perform loop software pipelining-------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements loop software pipelining // This file implements loop software pipelining
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Patterns.h" #include "mlir/Dialect/SCF/Transforms/Patterns.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h" #include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Support/MathExtras.h" #include "mlir/Support/MathExtras.h"
#include "mlir/Transforms/RegionUtils.h" #include "mlir/Transforms/RegionUtils.h"
▲ Show 20 Lines • Show All 557 Lines • Show Last 20 Lines

mlir/lib/Dialect/SCF/Transforms/LoopRangeFolding.cpp

//===- LoopRangeFolding.cpp - Code to perform loop range folding-----------===// //===- LoopRangeFolding.cpp - Code to perform loop range folding-----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements loop range folding. // This file implements loop range folding.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SCF/Transforms/Passes.h" #include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h" #include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_SCFFORLOOPRANGEFOLDING #define GEN_PASS_DEF_SCFFORLOOPRANGEFOLDING
#include "mlir/Dialect/SCF/Transforms/Passes.h.inc" #include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp

Show All 9 Lines
// vectorization. // vectorization.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SCF/Transforms/Passes.h" #include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h" #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h" #include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h" #include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
▲ Show 20 Lines • Show All 261 Lines • Show Last 20 Lines

mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp

//===- ParallelLoopTiling.cpp - Tiles scf.parallel ------------------------===// //===- ParallelLoopTiling.cpp - Tiles scf.parallel ------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements loop tiling on parallel loops. // This file implements loop tiling on parallel loops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SCF/Transforms/Passes.h" #include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h" #include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.h"
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_SCFPARALLELLOOPTILING #define GEN_PASS_DEF_SCFPARALLELLOOPTILING
#include "mlir/Dialect/SCF/Transforms/Passes.h.inc" #include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
} // namespace mlir } // namespace mlir
▲ Show 20 Lines • Show All 190 Lines • Show Last 20 Lines

mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp

//===- Tiling.cpp - Implementation of tiling using TilingInterface -------===// //===- Tiling.cpp - Implementation of tiling using TilingInterface -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the tiling using TilingInterface. // This file implements the tiling using TilingInterface.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SCF/Transforms/TileUsingInterface.h" #include "mlir/Dialect/SCF/Transforms/TileUsingInterface.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Interfaces/TilingInterface.h" #include "mlir/Interfaces/TilingInterface.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
▲ Show 20 Lines • Show All 600 Lines • Show Last 20 Lines

mlir/lib/Dialect/SCF/Utils/CMakeLists.txt

add_mlir_dialect_library(MLIRSCFUtils add_mlir_dialect_library(MLIRSCFUtils
AffineCanonicalizationUtils.cpp AffineCanonicalizationUtils.cpp
Utils.cpp Utils.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SCF ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SCF
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineAnalysis MLIRAffineAnalysis
MLIRAnalysis MLIRAnalysis
MLIRArithmeticDialect MLIRArithDialect
MLIRDialectUtils MLIRDialectUtils
MLIRFuncDialect MLIRFuncDialect
MLIRIR MLIRIR
MLIRSCFDialect MLIRSCFDialect
MLIRSupport MLIRSupport
MLIRTransforms MLIRTransforms
) )

mlir/lib/Dialect/SCF/Utils/Utils.cpp

//===- Utils.cpp ---- Misc utilities for loop transformation ----------===// //===- Utils.cpp ---- Misc utilities for loop transformation ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements miscellaneous loop transformation routines. // This file implements miscellaneous loop transformation routines.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Support/MathExtras.h" #include "mlir/Support/MathExtras.h"
#include "mlir/Transforms/RegionUtils.h" #include "mlir/Transforms/RegionUtils.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
▲ Show 20 Lines • Show All 978 Lines • Show Last 20 Lines

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

set(LLVM_TARGET_DEFINITIONS ShapeCanonicalization.td) set(LLVM_TARGET_DEFINITIONS ShapeCanonicalization.td)
mlir_tablegen(ShapeCanonicalization.inc -gen-rewriters) mlir_tablegen(ShapeCanonicalization.inc -gen-rewriters)
add_public_tablegen_target(MLIRShapeCanonicalizationIncGen) add_public_tablegen_target(MLIRShapeCanonicalizationIncGen)
add_mlir_dialect_library(MLIRShapeDialect add_mlir_dialect_library(MLIRShapeDialect
Shape.cpp Shape.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Shape ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Shape
DEPENDS DEPENDS
MLIRShapeOpsIncGen MLIRShapeOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRCallInterfaces MLIRCallInterfaces
MLIRCastInterfaces MLIRCastInterfaces
MLIRControlFlowInterfaces MLIRControlFlowInterfaces
MLIRDialect MLIRDialect
MLIRFuncDialect MLIRFuncDialect
MLIRInferTypeOpInterface MLIRInferTypeOpInterface
MLIRIR MLIRIR
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRTensorDialect MLIRTensorDialect
) )

mlir/lib/Dialect/Shape/IR/Shape.cpp

//===- Shape.cpp - MLIR Shape Operations ----------------------------------===// //===- Shape.cpp - MLIR Shape Operations ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <utility> #include <utility>
#include "mlir/Dialect/Shape/IR/Shape.h" #include "mlir/Dialect/Shape/IR/Shape.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/CommonFolders.h" #include "mlir/Dialect/CommonFolders.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Traits.h" #include "mlir/Dialect/Traits.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/DialectImplementation.h" #include "mlir/IR/DialectImplementation.h"
#include "mlir/IR/FunctionImplementation.h" #include "mlir/IR/FunctionImplementation.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
▲ Show 20 Lines • Show All 1,984 Lines • Show Last 20 Lines

mlir/lib/Dialect/Shape/Transforms/CMakeLists.txt

add_mlir_dialect_library(MLIRShapeOpsTransforms add_mlir_dialect_library(MLIRShapeOpsTransforms
BufferizableOpInterfaceImpl.cpp BufferizableOpInterfaceImpl.cpp
Bufferize.cpp Bufferize.cpp
RemoveShapeConstraints.cpp RemoveShapeConstraints.cpp
ShapeToShapeLowering.cpp ShapeToShapeLowering.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/ShapeOps/Transforms ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/ShapeOps/Transforms
DEPENDS DEPENDS
MLIRShapeTransformsIncGen MLIRShapeTransformsIncGen
) )
target_link_libraries(MLIRShapeOpsTransforms target_link_libraries(MLIRShapeOpsTransforms
PUBLIC PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRBufferizationDialect MLIRBufferizationDialect
MLIRBufferizationTransforms MLIRBufferizationTransforms
MLIRIR MLIRIR
MLIRMemRefDialect MLIRMemRefDialect
MLIRPass MLIRPass
MLIRShapeDialect MLIRShapeDialect
MLIRSupport MLIRSupport
MLIRTransforms MLIRTransforms
) )

mlir/lib/Dialect/Shape/Transforms/ShapeToShapeLowering.cpp

//===- ShapeToShapeLowering.cpp - Prepare for lowering to Standard --------===// //===- ShapeToShapeLowering.cpp - Prepare for lowering to Standard --------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Shape/Transforms/Passes.h" #include "mlir/Dialect/Shape/Transforms/Passes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Shape/IR/Shape.h" #include "mlir/Dialect/Shape/IR/Shape.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
namespace mlir { namespace mlir {
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
void ShapeToShapeLowering::runOnOperation() { void ShapeToShapeLowering::runOnOperation() {
MLIRContext &ctx = getContext(); MLIRContext &ctx = getContext();
RewritePatternSet patterns(&ctx); RewritePatternSet patterns(&ctx);
populateShapeRewritePatterns(patterns); populateShapeRewritePatterns(patterns);
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addLegalDialect<arith::ArithmeticDialect, ShapeDialect>(); target.addLegalDialect<arith::ArithDialect, ShapeDialect>();
target.addIllegalOp<NumElementsOp>(); target.addIllegalOp<NumElementsOp>();
if (failed(mlir::applyPartialConversion(getOperation(), target, if (failed(mlir::applyPartialConversion(getOperation(), target,
std::move(patterns)))) std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
void mlir::populateShapeRewritePatterns(RewritePatternSet &patterns) { void mlir::populateShapeRewritePatterns(RewritePatternSet &patterns) {
patterns.add<NumElementsOpConverter>(patterns.getContext()); patterns.add<NumElementsOpConverter>(patterns.getContext());
} }
std::unique_ptr<Pass> mlir::createShapeToShapeLowering() { std::unique_ptr<Pass> mlir::createShapeToShapeLowering() {
return std::make_unique<ShapeToShapeLowering>(); return std::make_unique<ShapeToShapeLowering>();
} }

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

add_mlir_dialect_library(MLIRSparseTensorDialect add_mlir_dialect_library(MLIRSparseTensorDialect
SparseTensorDialect.cpp SparseTensorDialect.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor
DEPENDS DEPENDS
MLIRSparseTensorAttrDefsIncGen MLIRSparseTensorAttrDefsIncGen
MLIRSparseTensorOpsIncGen MLIRSparseTensorOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRDialect MLIRDialect
MLIRIR MLIRIR
MLIRInferTypeOpInterface MLIRInferTypeOpInterface
MLIRSupport MLIRSupport
) )

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

//===- SparseTensorDialect.cpp - Sparse tensor dialect implementation -----===// //===- SparseTensorDialect.cpp - Sparse tensor dialect implementation -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h" #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/DialectImplementation.h" #include "mlir/IR/DialectImplementation.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
#include "llvm/ADT/TypeSwitch.h" #include "llvm/ADT/TypeSwitch.h"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 698 Lines • Show Last 20 Lines

mlir/lib/Dialect/SparseTensor/Pipelines/CMakeLists.txt

add_mlir_dialect_library(MLIRSparseTensorPipelines add_mlir_dialect_library(MLIRSparseTensorPipelines
SparseTensorPipelines.cpp SparseTensorPipelines.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticTransforms MLIRArithTransforms
MLIRAffineToStandard MLIRAffineToStandard
MLIRBufferizationTransforms MLIRBufferizationTransforms
MLIRComplexToLLVM MLIRComplexToLLVM
MLIRComplexToLibm MLIRComplexToLibm
MLIRComplexToStandard MLIRComplexToStandard
MLIRFuncTransforms MLIRFuncTransforms
MLIRLinalgTransforms MLIRLinalgTransforms
MLIRMathToLibm MLIRMathToLibm
Show All 11 Lines

mlir/lib/Dialect/SparseTensor/Pipelines/SparseTensorPipelines.cpp

//===- SparseTensorPipelines.cpp - Pipelines for sparse tensor code -------===// //===- SparseTensorPipelines.cpp - Pipelines for sparse tensor code -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SparseTensor/Pipelines/Passes.h" #include "mlir/Dialect/SparseTensor/Pipelines/Passes.h"
#include "mlir/Conversion/Passes.h" #include "mlir/Conversion/Passes.h"
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h" #include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h" #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
#include "mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h" #include "mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h"
#include "mlir/Dialect/Bufferization/Transforms/Passes.h" #include "mlir/Dialect/Bufferization/Transforms/Passes.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h" #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/Dialect/SparseTensor/Transforms/Passes.h" #include "mlir/Dialect/SparseTensor/Transforms/Passes.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Linesvoid mlir::sparse_tensor::buildSparseCompiler(
// it to this pipeline. // it to this pipeline.
pm.addNestedPass<func::FuncOp>(createConvertLinalgToLoopsPass()); pm.addNestedPass<func::FuncOp>(createConvertLinalgToLoopsPass());
pm.addNestedPass<func::FuncOp>(createConvertVectorToSCFPass()); pm.addNestedPass<func::FuncOp>(createConvertVectorToSCFPass());
pm.addNestedPass<func::FuncOp>(createConvertSCFToCFPass()); pm.addNestedPass<func::FuncOp>(createConvertSCFToCFPass());
pm.addPass(createLowerAffinePass()); pm.addPass(createLowerAffinePass());
pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions())); pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions()));
pm.addPass(createMemRefToLLVMConversionPass()); pm.addPass(createMemRefToLLVMConversionPass());
pm.addNestedPass<func::FuncOp>(createConvertComplexToStandardPass()); pm.addNestedPass<func::FuncOp>(createConvertComplexToStandardPass());
pm.addNestedPass<mlir::func::FuncOp>( pm.addNestedPass<mlir::func::FuncOp>(mlir::arith::createArithExpandOpsPass());
mlir::arith::createArithmeticExpandOpsPass());
pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass()); pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass());
pm.addPass(createConvertMathToLibmPass()); pm.addPass(createConvertMathToLibmPass());
pm.addPass(createConvertComplexToLibmPass()); pm.addPass(createConvertComplexToLibmPass());
pm.addPass(createConvertComplexToLLVMPass()); pm.addPass(createConvertComplexToLLVMPass());
pm.addPass(createConvertFuncToLLVMPass()); pm.addPass(createConvertFuncToLLVMPass());
pm.addPass(createReconcileUnrealizedCastsPass()); pm.addPass(createReconcileUnrealizedCastsPass());
} }
Show All 12 Lines

mlir/lib/Dialect/SparseTensor/Transforms/CMakeLists.txt

Show All 9 Linesadd_mlir_dialect_library(MLIRSparseTensorTransforms
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor
DEPENDS DEPENDS
MLIRSparseTensorPassIncGen MLIRSparseTensorPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRBufferizationDialect MLIRBufferizationDialect
MLIRBufferizationTransforms MLIRBufferizationTransforms
MLIRComplexDialect MLIRComplexDialect
MLIRFuncDialect MLIRFuncDialect
MLIRIR MLIRIR
MLIRLLVMDialect MLIRLLVMDialect
MLIRLinalgDialect MLIRLinalgDialect
MLIRLinalgTransforms MLIRLinalgTransforms
Show All 11 Lines

mlir/lib/Dialect/SparseTensor/Transforms/CodegenUtils.h

//===- CodegenUtils.h - Utilities for generating MLIR -----------*- C++ -*-===// //===- CodegenUtils.h - Utilities for generating MLIR -----------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This header file defines utilities for generating MLIR. // This header file defines utilities for generating MLIR.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_CODEGENUTILS_H_ #ifndef MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_CODEGENUTILS_H_
#define MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_CODEGENUTILS_H_ #define MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_CODEGENUTILS_H_
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h" #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/ExecutionEngine/SparseTensorUtils.h" #include "mlir/ExecutionEngine/SparseTensorUtils.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
namespace mlir { namespace mlir {
class Location; class Location;
class Type; class Type;
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorPasses.cpp

//===- SparseTensorPasses.cpp - Pass for autogen sparse tensor code -------===// //===- SparseTensorPasses.cpp - Pass for autogen sparse tensor code -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/FuncConversions.h" #include "mlir/Dialect/Func/Transforms/FuncConversions.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h" #include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h" #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines target.addDynamicallyLegalOp<bufferization::DeallocTensorOp>(
[&](bufferization::DeallocTensorOp op) { [&](bufferization::DeallocTensorOp op) {
return converter.isLegal(op.getTensor().getType()); return converter.isLegal(op.getTensor().getType());
}); });
// The following operations and dialects may be introduced by the // The following operations and dialects may be introduced by the
// rewriting rules, and are therefore marked as legal. // rewriting rules, and are therefore marked as legal.
target.addLegalOp<complex::ConstantOp, complex::NotEqualOp, linalg::FillOp, target.addLegalOp<complex::ConstantOp, complex::NotEqualOp, linalg::FillOp,
linalg::YieldOp, tensor::ExtractOp>(); linalg::YieldOp, tensor::ExtractOp>();
target.addLegalDialect< target.addLegalDialect<
arith::ArithmeticDialect, bufferization::BufferizationDialect, arith::ArithDialect, bufferization::BufferizationDialect,
LLVM::LLVMDialect, memref::MemRefDialect, scf::SCFDialect>(); LLVM::LLVMDialect, memref::MemRefDialect, scf::SCFDialect>();
// Translate strategy flags to strategy options. // Translate strategy flags to strategy options.
SparseTensorConversionOptions options( SparseTensorConversionOptions options(
sparseToSparseConversionStrategy(sparseToSparse)); sparseToSparseConversionStrategy(sparseToSparse));
// Populate with rules and apply rewriting rules. // Populate with rules and apply rewriting rules.
populateFunctionOpInterfaceTypeConversionPattern<func::FuncOp>(patterns, populateFunctionOpInterfaceTypeConversionPattern<func::FuncOp>(patterns,
converter); converter);
populateCallOpTypeConversionPattern(patterns, converter); populateCallOpTypeConversionPattern(patterns, converter);
Show All 38 Lines target.addDynamicallyLegalOp<bufferization::AllocTensorOp>(
}); });
target.addDynamicallyLegalOp<bufferization::DeallocTensorOp>( target.addDynamicallyLegalOp<bufferization::DeallocTensorOp>(
[&](bufferization::DeallocTensorOp op) { [&](bufferization::DeallocTensorOp op) {
return converter.isLegal(op.getTensor().getType()); return converter.isLegal(op.getTensor().getType());
}); });
// The following operations and dialects may be introduced by the // The following operations and dialects may be introduced by the
// codegen rules, and are therefore marked as legal. // codegen rules, and are therefore marked as legal.
target.addLegalOp<linalg::FillOp>(); target.addLegalOp<linalg::FillOp>();
target.addLegalDialect<arith::ArithmeticDialect, target.addLegalDialect<arith::ArithDialect,
bufferization::BufferizationDialect, bufferization::BufferizationDialect,
memref::MemRefDialect, scf::SCFDialect>(); memref::MemRefDialect, scf::SCFDialect>();
target.addLegalOp<UnrealizedConversionCastOp>(); target.addLegalOp<UnrealizedConversionCastOp>();
// Populate with rules and apply rewriting rules. // Populate with rules and apply rewriting rules.
populateFunctionOpInterfaceTypeConversionPattern<func::FuncOp>(patterns, populateFunctionOpInterfaceTypeConversionPattern<func::FuncOp>(patterns,
converter); converter);
scf::populateSCFStructuralTypeConversionsAndLegality(converter, patterns, scf::populateSCFStructuralTypeConversionsAndLegality(converter, patterns,
target); target);
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp

//===- SparseTensorRewriting.cpp - Sparse tensor rewriting rules ----------===// //===- SparseTensorRewriting.cpp - Sparse tensor rewriting rules ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements rewriting rules that are specific to sparse tensors. // This file implements rewriting rules that are specific to sparse tensors.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CodegenUtils.h" #include "CodegenUtils.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h" #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/Dialect/SparseTensor/Transforms/Passes.h" #include "mlir/Dialect/SparseTensor/Transforms/Passes.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/Support/LLVM.h" #include "mlir/Support/LLVM.h"
▲ Show 20 Lines • Show All 286 Lines • Show Last 20 Lines

mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp

//===- Sparsification.cpp - Implementation of sparsification --------------===// //===- Sparsification.cpp - Implementation of sparsification --------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements converting sparse tensor types to actual sparse code. // This file implements converting sparse tensor types to actual sparse code.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CodegenUtils.h" #include "CodegenUtils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h" #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
▲ Show 20 Lines • Show All 1,925 Lines • Show Last 20 Lines

mlir/lib/Dialect/SparseTensor/Utils/CMakeLists.txt

add_mlir_dialect_library(MLIRSparseTensorUtils add_mlir_dialect_library(MLIRSparseTensorUtils
Merger.cpp Merger.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRComplexDialect MLIRComplexDialect
MLIRIR MLIRIR
MLIRLinalgDialect MLIRLinalgDialect
) )

mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp

//===- Merger.cpp - Implementation of iteration lattices ------------------===// //===- Merger.cpp - Implementation of iteration lattices ------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SparseTensor/Utils/Merger.h" #include "mlir/Dialect/SparseTensor/Utils/Merger.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h" #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/IR/Operation.h" #include "mlir/IR/Operation.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
namespace mlir { namespace mlir {
▲ Show 20 Lines • Show All 1,224 Lines • Show Last 20 Lines

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

Show All 13 Linesadd_mlir_dialect_library(MLIRTensorDialect
DEPENDS DEPENDS
MLIRTensorOpsIncGen MLIRTensorOpsIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRArithmeticUtils MLIRArithUtils
MLIRCastInterfaces MLIRCastInterfaces
MLIRComplexDialect MLIRComplexDialect
MLIRDialectUtils MLIRDialectUtils
MLIRIR MLIRIR
MLIRInferTypeOpInterface MLIRInferTypeOpInterface
MLIRParallelCombiningOpInterface MLIRParallelCombiningOpInterface
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRSupport MLIRSupport
Show All 32 Lines

mlir/lib/Dialect/Tensor/IR/TensorDialect.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Transforms/InliningUtils.h" #include "mlir/Transforms/InliningUtils.h"
using namespace mlir; using namespace mlir;
using namespace mlir::tensor; using namespace mlir::tensor;
#include "mlir/Dialect/Tensor/IR/TensorOpsDialect.cpp.inc" #include "mlir/Dialect/Tensor/IR/TensorOpsDialect.cpp.inc"
Show All 30 Lines

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/ReshapeOpsUtils.h" #include "mlir/Dialect/Utils/ReshapeOpsUtils.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinAttributeInterfaces.h" #include "mlir/IR/BuiltinAttributeInterfaces.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
▲ Show 20 Lines • Show All 2,479 Lines • Show Last 20 Lines

mlir/lib/Dialect/Tensor/IR/TensorTilingInterfaceImpl.cpp

//===- TensorTilingInterface.cpp - Tiling Interface models *- C++ ------*-===// //===- TensorTilingInterface.cpp - Tiling Interface models *- C++ ------*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Tensor/IR/TensorTilingInterfaceImpl.h" #include "mlir/Dialect/Tensor/IR/TensorTilingInterfaceImpl.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Interfaces/TilingInterface.h" #include "mlir/Interfaces/TilingInterface.h"
using namespace mlir; using namespace mlir;
using namespace mlir::tensor; using namespace mlir::tensor;
▲ Show 20 Lines • Show All 282 Lines • Show Last 20 Lines

mlir/lib/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.cpp

//===- BufferizableOpInterfaceImpl.cpp - Impl. of BufferizableOpInterface -===// //===- BufferizableOpInterfaceImpl.cpp - Impl. of BufferizableOpInterface -===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.h" #include "mlir/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h" #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/Operation.h" #include "mlir/IR/Operation.h"
▲ Show 20 Lines • Show All 1,026 Lines • ▼ Show 20 Lines registry.addExtension(+[](MLIRContext *ctx, tensor::TensorDialect *dialect) {
InsertSliceOp::attachInterface<InsertSliceOpInterface>(*ctx); InsertSliceOp::attachInterface<InsertSliceOpInterface>(*ctx);
PadOp::attachInterface<PadOpInterface>(*ctx); PadOp::attachInterface<PadOpInterface>(*ctx);
ParallelInsertSliceOp::attachInterface<ParallelInsertSliceOpInterface>( ParallelInsertSliceOp::attachInterface<ParallelInsertSliceOpInterface>(
*ctx); *ctx);
RankOp::attachInterface<RankOpInterface>(*ctx); RankOp::attachInterface<RankOpInterface>(*ctx);
ReshapeOp::attachInterface<ReshapeOpInterface>(*ctx); ReshapeOp::attachInterface<ReshapeOpInterface>(*ctx);
// Load additional dialects of which ops may get created. // Load additional dialects of which ops may get created.
ctx->loadDialect<arith::ArithmeticDialect, scf::SCFDialect>(); ctx->loadDialect<arith::ArithDialect, scf::SCFDialect>();
}); });
} }

mlir/lib/Dialect/Tensor/Transforms/Bufferize.cpp

//===- Bufferize.cpp - Bufferization for `tensor` dialect ops -------------===// //===- Bufferize.cpp - Bufferization for `tensor` dialect ops -------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements bufferization of `tensor` dialect ops // This file implements bufferization of `tensor` dialect ops
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h" #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h" #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.h" #include "mlir/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.h"
#include "mlir/Dialect/Tensor/Transforms/Passes.h" #include "mlir/Dialect/Tensor/Transforms/Passes.h"
Show All 17 Lines void runOnOperation() override {
BufferizationOptions options = getPartialBufferizationOptions(); BufferizationOptions options = getPartialBufferizationOptions();
options.opFilter.allowDialect<tensor::TensorDialect>(); options.opFilter.allowDialect<tensor::TensorDialect>();
if (failed(bufferizeOp(getOperation(), options))) if (failed(bufferizeOp(getOperation(), options)))
signalPassFailure(); signalPassFailure();
} }
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry.insert<bufferization::BufferizationDialect, memref::MemRefDialect, registry
tensor::TensorDialect, scf::SCFDialect, .insert<bufferization::BufferizationDialect, memref::MemRefDialect,
arith::ArithmeticDialect>(); tensor::TensorDialect, scf::SCFDialect, arith::ArithDialect>();
tensor::registerBufferizableOpInterfaceExternalModels(registry); tensor::registerBufferizableOpInterfaceExternalModels(registry);
} }
}; };
} // namespace } // namespace
std::unique_ptr<Pass> mlir::createTensorBufferizePass() { std::unique_ptr<Pass> mlir::createTensorBufferizePass() {
return std::make_unique<TensorBufferizePass>(); return std::make_unique<TensorBufferizePass>();
} }

mlir/lib/Dialect/Tensor/Transforms/CMakeLists.txt

Show All 9 Linesadd_mlir_dialect_library(MLIRTensorTransforms
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tensor/Transforms ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tensor/Transforms
DEPENDS DEPENDS
MLIRTensorTransformsIncGen MLIRTensorTransformsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineUtils MLIRAffineUtils
MLIRArithmeticDialect MLIRArithDialect
MLIRBufferizationDialect MLIRBufferizationDialect
MLIRBufferizationTransforms MLIRBufferizationTransforms
MLIRIR MLIRIR
MLIRMemRefDialect MLIRMemRefDialect
MLIRPass MLIRPass
MLIRSCFDialect MLIRSCFDialect
MLIRTensorDialect MLIRTensorDialect
MLIRTilingInterface MLIRTilingInterface
MLIRTransforms MLIRTransforms
) )

mlir/lib/Dialect/Tensor/Transforms/ExtractSliceFromReshapeUtils.cpp

//===- ExtractSliceFromReshapeUtils.cpp - Slice reshape rewrites ----------===// //===- ExtractSliceFromReshapeUtils.cpp - Slice reshape rewrites ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements rewrites that replace slices of reshape results with // This file implements rewrites that replace slices of reshape results with
// aggregated slices of the reshape source. // aggregated slices of the reshape source.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Transforms/TransformUtils.h" #include "mlir/Dialect/Tensor/Transforms/TransformUtils.h"
#include "mlir/Dialect/Tensor/Transforms/Transforms.h" #include "mlir/Dialect/Tensor/Transforms/Transforms.h"
#include "mlir/Dialect/Utils/ReshapeOpsUtils.h" #include "mlir/Dialect/Utils/ReshapeOpsUtils.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/OpDefinition.h" #include "mlir/IR/OpDefinition.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

mlir/lib/Dialect/Tensor/Transforms/SplitPaddingPatterns.cpp

//===- SplitPaddingPatterns.cpp - Splitting tensor.pad Op -----------------===// //===- SplitPaddingPatterns.cpp - Splitting tensor.pad Op -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements patterns to wrap a tensor.pad op with an scf.if op // This file implements patterns to wrap a tensor.pad op with an scf.if op
/// to separate the cases where we don't need padding (all pad sizes are /// to separate the cases where we don't need padding (all pad sizes are
/// actually zeros) and where we indeed need padding. /// actually zeros) and where we indeed need padding.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Transforms/Transforms.h" #include "mlir/Dialect/Tensor/Transforms/Transforms.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#define DEBUG_TYPE "mlir-tensor-split-padding" #define DEBUG_TYPE "mlir-tensor-split-padding"
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

mlir/lib/Dialect/Tensor/Transforms/SwapExtractSliceWithProducerPatterns.cpp

//===- SwapExtractSliceWithProducerPatterns.cpp ---------------------------===// //===- SwapExtractSliceWithProducerPatterns.cpp ---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Swap a `tensor.extract_slice` with the producer of the source if the producer // Swap a `tensor.extract_slice` with the producer of the source if the producer
// implements the `TilingInterface`. When used in conjunction with tiling this // implements the `TilingInterface`. When used in conjunction with tiling this
// effectively tiles + fuses the producer with its consumer. // effectively tiles + fuses the producer with its consumer.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Transforms/Transforms.h" #include "mlir/Dialect/Tensor/Transforms/Transforms.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/Interfaces/TilingInterface.h" #include "mlir/Interfaces/TilingInterface.h"
using namespace mlir; using namespace mlir;
FailureOr<Value> tensor::replaceExtractSliceWithTiledProducer( FailureOr<Value> tensor::replaceExtractSliceWithTiledProducer(
Show All 19 Lines

mlir/lib/Dialect/Tensor/Utils/CMakeLists.txt

add_mlir_dialect_library(MLIRTensorUtils add_mlir_dialect_library(MLIRTensorUtils
Utils.cpp Utils.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tensor ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tensor
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRArithmeticDialect MLIRArithDialect
MLIRIR MLIRIR
MLIRTensorDialect MLIRTensorDialect
) )

mlir/lib/Dialect/Tensor/Utils/Utils.cpp

//===- Utils.cpp - Utilities to support the Tensor dialect ----------------===// //===- Utils.cpp - Utilities to support the Tensor dialect ----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements utilities for the Tensor dialect. // This file implements utilities for the Tensor dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Tensor/Utils/Utils.h" #include "mlir/Dialect/Tensor/Utils/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
using namespace mlir; using namespace mlir;
using namespace mlir::tensor; using namespace mlir::tensor;
PadOp mlir::tensor::createPadScalarOp(Type type, Value source, Value pad, PadOp mlir::tensor::createPadScalarOp(Type type, Value source, Value pad,
ArrayRef<OpFoldResult> low, ArrayRef<OpFoldResult> low,
ArrayRef<OpFoldResult> high, bool nofold, ArrayRef<OpFoldResult> high, bool nofold,
Location loc, OpBuilder &builder) { Location loc, OpBuilder &builder) {
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

mlir/lib/Dialect/Utils/CMakeLists.txt

add_mlir_library(MLIRDialectUtils add_mlir_library(MLIRDialectUtils
IndexingUtils.cpp IndexingUtils.cpp
ReshapeOpsUtils.cpp ReshapeOpsUtils.cpp
StructuredOpsUtils.cpp StructuredOpsUtils.cpp
StaticValueUtils.cpp StaticValueUtils.cpp
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticUtils MLIRArithUtils
MLIRIR MLIRIR
) )

mlir/lib/Dialect/Utils/StaticValueUtils.cpp

//===- StaticValueUtils.cpp - Utilities for dealing with static values ----===// //===- StaticValueUtils.cpp - Utilities for dealing with static values ----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/Support/LLVM.h" #include "mlir/Support/LLVM.h"
#include "llvm/ADT/APSInt.h" #include "llvm/ADT/APSInt.h"
namespace mlir { namespace mlir {
std::tuple<SmallVector<OpFoldResult>, SmallVector<OpFoldResult>, std::tuple<SmallVector<OpFoldResult>, SmallVector<OpFoldResult>,
SmallVector<OpFoldResult>> SmallVector<OpFoldResult>>
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

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

add_mlir_dialect_library(MLIRVectorDialect add_mlir_dialect_library(MLIRVectorDialect
VectorOps.cpp VectorOps.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Vector/IR ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Vector/IR
DEPENDS DEPENDS
MLIRVectorOpsIncGen MLIRVectorOpsIncGen
MLIRVectorOpsEnumsIncGen MLIRVectorOpsEnumsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRControlFlowInterfaces MLIRControlFlowInterfaces
MLIRDataLayoutInterfaces MLIRDataLayoutInterfaces
MLIRDialectUtils MLIRDialectUtils
MLIRIR MLIRIR
MLIRMemRefDialect MLIRMemRefDialect
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRTensorDialect MLIRTensorDialect
MLIRVectorInterfaces MLIRVectorInterfaces
) )

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

//===- VectorOps.cpp - MLIR Vector Dialect Operations ---------------------===// //===- VectorOps.cpp - MLIR Vector Dialect Operations ---------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements convenience types for working with super-vectorization // This file implements convenience types for working with super-vectorization
// operations, in particular super-vector loads and stores. // operations, in particular super-vector loads and stores.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/IndexingUtils.h" #include "mlir/Dialect/Utils/IndexingUtils.h"
#include "mlir/Dialect/Utils/StructuredOpsUtils.h" #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
▲ Show 20 Lines • Show All 5,090 Lines • Show Last 20 Lines

mlir/lib/Dialect/Vector/Transforms/CMakeLists.txt

Show All 15 Linesadd_mlir_dialect_library(MLIRVectorTransforms
DEPENDS DEPENDS
MLIRVectorTransformsIncGen MLIRVectorTransformsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineAnalysis MLIRAffineAnalysis
MLIRAffineUtils MLIRAffineUtils
MLIRArithmeticDialect MLIRArithDialect
MLIRBufferizationDialect MLIRBufferizationDialect
MLIRBufferizationTransforms MLIRBufferizationTransforms
MLIRDialectUtils MLIRDialectUtils
MLIRGPUOps MLIRGPUOps
MLIRIR MLIRIR
MLIRLinalgDialect MLIRLinalgDialect
MLIRMemRefDialect MLIRMemRefDialect
MLIRSCFDialect MLIRSCFDialect
MLIRTransforms MLIRTransforms
MLIRVectorDialect MLIRVectorDialect
MLIRVectorInterfaces MLIRVectorInterfaces
MLIRVectorUtils MLIRVectorUtils
) )

mlir/lib/Dialect/Vector/Transforms/VectorDistribute.cpp

//===- VectorDistribute.cpp - patterns to do vector distribution ----------===// //===- VectorDistribute.cpp - patterns to do vector distribution ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Transforms/VectorDistribution.h" #include "mlir/Dialect/Vector/Transforms/VectorDistribution.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/Transforms/SideEffectUtils.h" #include "mlir/Transforms/SideEffectUtils.h"
#include "llvm/ADT/SetVector.h" #include "llvm/ADT/SetVector.h"
#include <utility> #include <utility>
▲ Show 20 Lines • Show All 1,116 Lines • Show Last 20 Lines

mlir/lib/Dialect/Vector/Transforms/VectorInsertExtractStridedSliceRewritePatterns.cpp

//===- VectorInsertExtractStridedSliceRewritePatterns.cpp - Rewrites ------===// //===- VectorInsertExtractStridedSliceRewritePatterns.cpp - Rewrites ------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Utils/IndexingUtils.h" #include "mlir/Dialect/Utils/IndexingUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Transforms/VectorRewritePatterns.h" #include "mlir/Dialect/Vector/Transforms/VectorRewritePatterns.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 285 Lines • Show Last 20 Lines

mlir/lib/Dialect/Vector/Transforms/VectorMultiDimReductionTransforms.cpp

//===- VectorMultiDimReductionTransforms.cpp - Multi-Reduction Transforms -===// //===- VectorMultiDimReductionTransforms.cpp - Multi-Reduction Transforms -===//
// //
/// Part of the LLVM Project, under the Apache License v2.0 with LLVM /// Part of the LLVM Project, under the Apache License v2.0 with LLVM
/// Exceptions. See https://llvm.org/LICENSE.txt for license information. /// Exceptions. See https://llvm.org/LICENSE.txt for license information.
/// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception /// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
/// This file implements target-independent rewrites of MultiDimReductionOp. /// This file implements target-independent rewrites of MultiDimReductionOp.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Vector/Transforms/VectorRewritePatterns.h" #include "mlir/Dialect/Vector/Transforms/VectorRewritePatterns.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#define DEBUG_TYPE "vector-multi-reduction" #define DEBUG_TYPE "vector-multi-reduction"
▲ Show 20 Lines • Show All 333 Lines • Show Last 20 Lines

mlir/lib/Dialect/Vector/Transforms/VectorTransferOpTransforms.cpp

//===- VectorTransferOpTransforms.cpp - transfer op transforms ------------===// //===- VectorTransferOpTransforms.cpp - transfer op transforms ------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements functions concerned with optimizing transfer_read and // This file implements functions concerned with optimizing transfer_read and
// transfer_write ops. // transfer_write ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Transforms/VectorTransforms.h" #include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Dominance.h" #include "mlir/IR/Dominance.h"
#include "mlir/Transforms/SideEffectUtils.h" #include "mlir/Transforms/SideEffectUtils.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
▲ Show 20 Lines • Show All 569 Lines • Show Last 20 Lines

mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp

//===- VectorTransferSplitRewritePatterns.cpp - Transfer Split Rewrites ---===// //===- VectorTransferSplitRewritePatterns.cpp - Transfer Split Rewrites ---===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements target-independent patterns to rewrite a vector.transfer // This file implements target-independent patterns to rewrite a vector.transfer
// op into a fully in-bounds part and a partial part. // op into a fully in-bounds part and a partial part.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <type_traits> #include <type_traits>
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Utils/StructuredOpsUtils.h" #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
#include "mlir/Dialect/Vector/Transforms/VectorTransforms.h" #include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
▲ Show 20 Lines • Show All 619 Lines • Show Last 20 Lines

mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp

Show All 9 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Vector/Transforms/VectorTransforms.h" #include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
#include <type_traits> #include <type_traits>
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h" #include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Utils/IndexingUtils.h" #include "mlir/Dialect/Utils/IndexingUtils.h"
#include "mlir/Dialect/Utils/StructuredOpsUtils.h" #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/BuiltinAttributeInterfaces.h" #include "mlir/IR/BuiltinAttributeInterfaces.h"
▲ Show 20 Lines • Show All 2,940 Lines • Show Last 20 Lines

mlir/lib/Dialect/Vector/Utils/CMakeLists.txt

add_mlir_dialect_library(MLIRVectorUtils add_mlir_dialect_library(MLIRVectorUtils
VectorUtils.cpp VectorUtils.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Vector/Utils ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Vector/Utils
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRAffineAnalysis MLIRAffineAnalysis
MLIRArithmeticDialect MLIRArithDialect
MLIRDialectUtils MLIRDialectUtils
MLIRFuncDialect MLIRFuncDialect
MLIRIR MLIRIR
MLIRMemRefDialect MLIRMemRefDialect
MLIRTensorDialect MLIRTensorDialect
MLIRVectorDialect MLIRVectorDialect
MLIRVectorInterfaces MLIRVectorInterfaces
) )

mlir/lib/Dialect/Vector/Utils/VectorUtils.cpp

//===- VectorUtils.cpp - MLIR Utilities for VectorOps ------------------===// //===- VectorUtils.cpp - MLIR Utilities for VectorOps ------------------===//
// //
// Part of the MLIR Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the MLIR Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements utility methods for working with the Vector dialect. // This file implements utility methods for working with the Vector dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h" #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/IntegerSet.h" #include "mlir/IR/IntegerSet.h"
#include "mlir/IR/Operation.h" #include "mlir/IR/Operation.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines

mlir/lib/Dialect/X86Vector/Transforms/AVXTranspose.cpp

//===- AVXTranspose.cpp - Lower Vector transpose to AVX -------------------===// //===- AVXTranspose.cpp - Lower Vector transpose to AVX -------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements vector.transpose rewrites as AVX patterns for particular // This file implements vector.transpose rewrites as AVX patterns for particular
// sizes of interest. // sizes of interest.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/X86Vector/Transforms.h" #include "mlir/Dialect/X86Vector/Transforms.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "llvm/Support/Format.h" #include "llvm/Support/Format.h"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
▲ Show 20 Lines • Show All 315 Lines • Show Last 20 Lines

mlir/lib/Dialect/X86Vector/Transforms/CMakeLists.txt

add_mlir_dialect_library(MLIRX86VectorTransforms add_mlir_dialect_library(MLIRX86VectorTransforms
AVXTranspose.cpp AVXTranspose.cpp
LegalizeForLLVMExport.cpp LegalizeForLLVMExport.cpp
DEPENDS DEPENDS
MLIRX86VectorConversionsIncGen MLIRX86VectorConversionsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRX86VectorDialect MLIRX86VectorDialect
MLIRIR MLIRIR
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMDialect MLIRLLVMDialect
MLIRVectorDialect MLIRVectorDialect
) )

mlir/lib/Dialect/X86Vector/Transforms/LegalizeForLLVMExport.cpp

//===- LegalizeForLLVMExport.cpp - Prepare X86Vector for LLVM translation -===// //===- LegalizeForLLVMExport.cpp - Prepare X86Vector for LLVM translation -===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/X86Vector/Transforms.h" #include "mlir/Dialect/X86Vector/Transforms.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/X86Vector/X86VectorDialect.h" #include "mlir/Dialect/X86Vector/X86VectorDialect.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
using namespace mlir; using namespace mlir;
using namespace mlir::x86vector; using namespace mlir::x86vector;
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

mlir/lib/Target/Cpp/CMakeLists.txt

add_mlir_translation_library(MLIRTargetCpp add_mlir_translation_library(MLIRTargetCpp
TranslateRegistration.cpp TranslateRegistration.cpp
TranslateToCpp.cpp TranslateToCpp.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${EMITC_MAIN_INCLUDE_DIR}/emitc/Target/Cpp ${EMITC_MAIN_INCLUDE_DIR}/emitc/Target/Cpp
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRControlFlowDialect MLIRControlFlowDialect
MLIREmitCDialect MLIREmitCDialect
MLIRFuncDialect MLIRFuncDialect
MLIRIR MLIRIR
MLIRMathDialect MLIRMathDialect
MLIRSCFDialect MLIRSCFDialect
MLIRSupport MLIRSupport
MLIRTranslateLib MLIRTranslateLib
) )

mlir/lib/Target/Cpp/TranslateRegistration.cpp

//===- TranslateRegistration.cpp - Register translation -------------------===// //===- TranslateRegistration.cpp - Register translation -------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h" #include "mlir/Dialect/EmitC/IR/EmitC.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/Target/Cpp/CppEmitter.h" #include "mlir/Target/Cpp/CppEmitter.h"
Show All 18 Lines TranslateFromMLIRRegistration reg(
"mlir-to-cpp", "mlir-to-cpp",
[](ModuleOp module, raw_ostream &output) { [](ModuleOp module, raw_ostream &output) {
return emitc::translateToCpp( return emitc::translateToCpp(
module, output, module, output,
/*declareVariablesAtTop=*/declareVariablesAtTop); /*declareVariablesAtTop=*/declareVariablesAtTop);
}, },
[](DialectRegistry &registry) { [](DialectRegistry &registry) {
// clang-format off // clang-format off
registry.insert<arith::ArithmeticDialect, registry.insert<arith::ArithDialect,
cf::ControlFlowDialect, cf::ControlFlowDialect,
emitc::EmitCDialect, emitc::EmitCDialect,
func::FuncDialect, func::FuncDialect,
math::MathDialect, math::MathDialect,
scf::SCFDialect>(); scf::SCFDialect>();
// clang-format on // clang-format on
}); });
} }
} // namespace mlir } // namespace mlir

mlir/lib/Target/Cpp/TranslateToCpp.cpp

//===- TranslateToCpp.cpp - Translating to C++ calls ----------------------===// //===- TranslateToCpp.cpp - Translating to C++ calls ----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h" #include "mlir/Dialect/EmitC/IR/EmitC.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/Operation.h" #include "mlir/IR/Operation.h"
▲ Show 20 Lines • Show All 1,027 Lines • Show Last 20 Lines

mlir/python/CMakeLists.txt

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 Linesdeclare_mlir_dialect_python_bindings(
ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir" ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir"
TD_FILE dialects/MathOps.td TD_FILE dialects/MathOps.td
SOURCES dialects/math.py SOURCES dialects/math.py
DIALECT_NAME math) DIALECT_NAME math)
declare_mlir_dialect_python_bindings( declare_mlir_dialect_python_bindings(
ADD_TO_PARENT MLIRPythonSources.Dialects ADD_TO_PARENT MLIRPythonSources.Dialects
ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir" ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir"
TD_FILE dialects/ArithmeticOps.td TD_FILE dialects/ArithOps.td
SOURCES SOURCES
dialects/arith.py dialects/arith.py
dialects/_arith_ops_ext.py dialects/_arith_ops_ext.py
DIALECT_NAME arith) DIALECT_NAME arith)
declare_mlir_dialect_python_bindings( declare_mlir_dialect_python_bindings(
ADD_TO_PARENT MLIRPythonSources.Dialects ADD_TO_PARENT MLIRPythonSources.Dialects
ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir" ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir"
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

mlir/python/mlir/dialects/ArithOps.td

  • This file was moved from mlir/python/mlir/dialects/ArithmeticOps.td.
//===-- ArithmeticOps.td - Entry point for ArithmeticOps bindings ---------===// //===-- ArithOps.td - Entry point for ArithOps bindings ---------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef PYTHON_BINDINGS_ARITHMETIC_OPS #ifndef PYTHON_BINDINGS_ARITH_OPS
#define PYTHON_BINDINGS_ARITHMETIC_OPS #define PYTHON_BINDINGS_ARITH_OPS
include "mlir/Bindings/Python/Attributes.td" include "mlir/Bindings/Python/Attributes.td"
include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.td" include "mlir/Dialect/Arith/IR/ArithOps.td"
#endif #endif

mlir/python/mlir/dialects/ArithmeticOps.td

  • This file was moved to mlir/python/mlir/dialects/ArithOps.td.

mlir/test/CAPI/execution_engine.c

Show All 30 Lines
} }
void lowerModuleToLLVM(MlirContext ctx, MlirModule module) { void lowerModuleToLLVM(MlirContext ctx, MlirModule module) {
MlirPassManager pm = mlirPassManagerCreate(ctx); MlirPassManager pm = mlirPassManagerCreate(ctx);
MlirOpPassManager opm = mlirPassManagerGetNestedUnder( MlirOpPassManager opm = mlirPassManagerGetNestedUnder(
pm, mlirStringRefCreateFromCString("func.func")); pm, mlirStringRefCreateFromCString("func.func"));
mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVM()); mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVM());
mlirOpPassManagerAddOwnedPass( mlirOpPassManagerAddOwnedPass(
opm, mlirCreateConversionArithmeticToLLVMConversionPass()); opm, mlirCreateConversionArithToLLVMConversionPass());
MlirLogicalResult status = mlirPassManagerRun(pm, module); MlirLogicalResult status = mlirPassManagerRun(pm, module);
if (mlirLogicalResultIsFailure(status)) { if (mlirLogicalResultIsFailure(status)) {
fprintf(stderr, "Unexpected failure running pass pipeline\n"); fprintf(stderr, "Unexpected failure running pass pipeline\n");
exit(2); exit(2);
} }
mlirPassManagerDestroy(pm); mlirPassManagerDestroy(pm);
} }
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir

  • This file was moved from mlir/test/Conversion/ArithmeticToLLVM/arith-to-llvm.mlir.
The contents of this file were not changed.

mlir/test/Conversion/ArithToLLVM/convert-nd-vector-to-llvmir.mlir

  • This file was moved from mlir/test/Conversion/ArithmeticToLLVM/convert-nd-vector-to-llvmir.mlir.
The contents of this file were not changed.

mlir/test/Conversion/ArithToSPIRV/arith-to-spirv.mlir

  • This file was moved from mlir/test/Conversion/ArithmeticToSPIRV/arithmetic-to-spirv.mlir.
The contents of this file were not changed.

mlir/test/Conversion/ArithToSPIRV/fast-math.mlir

  • This file was moved from mlir/test/Conversion/ArithmeticToSPIRV/fast-math.mlir.
The contents of this file were not changed.

mlir/test/Conversion/ArithmeticToLLVM/arith-to-llvm.mlir

  • This file was moved to mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir.

mlir/test/Conversion/ArithmeticToLLVM/convert-nd-vector-to-llvmir.mlir

  • This file was moved to mlir/test/Conversion/ArithToLLVM/convert-nd-vector-to-llvmir.mlir.

mlir/test/Conversion/ArithmeticToSPIRV/arithmetic-to-spirv.mlir

  • This file was moved to mlir/test/Conversion/ArithToSPIRV/arith-to-spirv.mlir.

mlir/test/Conversion/ArithmeticToSPIRV/fast-math.mlir

  • This file was moved to mlir/test/Conversion/ArithToSPIRV/fast-math.mlir.

mlir/test/Dialect/Arith/bufferize.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/bufferize.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arith/canonicalize.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/canonicalize.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arith/emulate-wide-int-very-wide.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/emulate-wide-int-very-wide.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arith/emulate-wide-int.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/emulate-wide-int.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arith/expand-ops.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/expand-ops.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arith/int-range-interface.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/int-range-interface.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arith/invalid.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/invalid.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arith/one-shot-bufferize-memory-space-invalid.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/one-shot-bufferize-memory-space-invalid.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arith/one-shot-bufferize.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/one-shot-bufferize.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arith/ops.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/ops.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arith/test-emulate-wide-int-pass.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/test-emulate-wide-int-pass.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arith/unsigned-when-equivalent.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/unsigned-when-equivalent.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Arithmetic/bufferize.mlir

  • This file was moved to mlir/test/Dialect/Arith/bufferize.mlir.

mlir/test/Dialect/Arithmetic/canonicalize.mlir

  • This file was moved to mlir/test/Dialect/Arith/canonicalize.mlir.

mlir/test/Dialect/Arithmetic/emulate-wide-int-very-wide.mlir

  • This file was moved to mlir/test/Dialect/Arith/emulate-wide-int-very-wide.mlir.

mlir/test/Dialect/Arithmetic/emulate-wide-int.mlir

  • This file was moved to mlir/test/Dialect/Arith/emulate-wide-int.mlir.

mlir/test/Dialect/Arithmetic/expand-ops.mlir

  • This file was moved to mlir/test/Dialect/Arith/expand-ops.mlir.

mlir/test/Dialect/Arithmetic/int-range-interface.mlir

  • This file was moved to mlir/test/Dialect/Arith/int-range-interface.mlir.

mlir/test/Dialect/Arithmetic/invalid.mlir

  • This file was moved to mlir/test/Dialect/Arith/invalid.mlir.

mlir/test/Dialect/Arithmetic/one-shot-bufferize-memory-space-invalid.mlir

  • This file was moved to mlir/test/Dialect/Arith/one-shot-bufferize-memory-space-invalid.mlir.

mlir/test/Dialect/Arithmetic/one-shot-bufferize.mlir

  • This file was moved to mlir/test/Dialect/Arith/one-shot-bufferize.mlir.

mlir/test/Dialect/Arithmetic/ops.mlir

  • This file was moved to mlir/test/Dialect/Arith/ops.mlir.

mlir/test/Dialect/Arithmetic/test-emulate-wide-int-pass.mlir

  • This file was moved to mlir/test/Dialect/Arith/test-emulate-wide-int-pass.mlir.

mlir/test/Dialect/Arithmetic/unsigned-when-equivalent.mlir

  • This file was moved to mlir/test/Dialect/Arith/unsigned-when-equivalent.mlir.

mlir/test/Integration/Dialect/Arith/CPU/lit.local.cfg

  • This file was moved from mlir/test/Integration/Dialect/Arithmetic/CPU/lit.local.cfg.
The contents of this file were not changed.

mlir/test/Integration/Dialect/Arith/CPU/test-wide-int-emulation-addi-i16.mlir

  • This file was moved from mlir/test/Integration/Dialect/Arithmetic/CPU/test-wide-int-emulation-addi-i16.mlir.
The contents of this file were not changed.

mlir/test/Integration/Dialect/Arith/CPU/test-wide-int-emulation-compare-results-i16.mlir

  • This file was moved from mlir/test/Integration/Dialect/Arithmetic/CPU/test-wide-int-emulation-compare-results-i16.mlir.
The contents of this file were not changed.

mlir/test/Integration/Dialect/Arith/CPU/test-wide-int-emulation-constants-i16.mlir

  • This file was moved from mlir/test/Integration/Dialect/Arithmetic/CPU/test-wide-int-emulation-constants-i16.mlir.
The contents of this file were not changed.

mlir/test/Integration/Dialect/Arith/CPU/test-wide-int-emulation-muli-i16.mlir

  • This file was moved from mlir/test/Integration/Dialect/Arithmetic/CPU/test-wide-int-emulation-muli-i16.mlir.
The contents of this file were not changed.

mlir/test/Integration/Dialect/Arith/CPU/test-wide-int-emulation-shrui-i16.mlir

  • This file was moved from mlir/test/Integration/Dialect/Arithmetic/CPU/test-wide-int-emulation-shrui-i16.mlir.
The contents of this file were not changed.

mlir/test/Integration/Dialect/Arithmetic/CPU/lit.local.cfg

  • This file was moved to mlir/test/Integration/Dialect/Arith/CPU/lit.local.cfg.

mlir/test/Integration/Dialect/Arithmetic/CPU/test-wide-int-emulation-addi-i16.mlir

  • This file was moved to mlir/test/Integration/Dialect/Arith/CPU/test-wide-int-emulation-addi-i16.mlir.

mlir/test/Integration/Dialect/Arithmetic/CPU/test-wide-int-emulation-compare-results-i16.mlir

  • This file was moved to mlir/test/Integration/Dialect/Arith/CPU/test-wide-int-emulation-compare-results-i16.mlir.

mlir/test/Integration/Dialect/Arithmetic/CPU/test-wide-int-emulation-constants-i16.mlir

  • This file was moved to mlir/test/Integration/Dialect/Arith/CPU/test-wide-int-emulation-constants-i16.mlir.

mlir/test/Integration/Dialect/Arithmetic/CPU/test-wide-int-emulation-muli-i16.mlir

  • This file was moved to mlir/test/Integration/Dialect/Arith/CPU/test-wide-int-emulation-muli-i16.mlir.

mlir/test/Integration/Dialect/Arithmetic/CPU/test-wide-int-emulation-shrui-i16.mlir

  • This file was moved to mlir/test/Integration/Dialect/Arith/CPU/test-wide-int-emulation-shrui-i16.mlir.

mlir/test/lib/Dialect/Arith/CMakeLists.txt

  • This file was moved from mlir/test/lib/Dialect/Arithmetic/CMakeLists.txt.
# Exclude tests from libMLIR.so # Exclude tests from libMLIR.so
add_mlir_library(MLIRArithmeticTestPasses add_mlir_library(MLIRArithTestPasses
TestEmulateWideInt.cpp TestEmulateWideInt.cpp
EXCLUDE_FROM_LIBMLIR EXCLUDE_FROM_LIBMLIR
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRArithmeticTransforms MLIRArithTransforms
MLIRFuncDialect MLIRFuncDialect
MLIRLLVMDialect MLIRLLVMDialect
MLIRPass MLIRPass
MLIRVectorDialect MLIRVectorDialect
) )

mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp

  • This file was moved from mlir/test/lib/Dialect/Arithmetic/TestEmulateWideInt.cpp.
//===- TestWideIntEmulation.cpp - Test Wide Int Emulation ------*- c++ -*-===// //===- TestWideIntEmulation.cpp - Test Wide Int Emulation ------*- c++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass for integration testing of wide integer // This file implements a pass for integration testing of wide integer
// emulation patterns. Applies conversion patterns only to functions whose // emulation patterns. Applies conversion patterns only to functions whose
// names start with a specified prefix. // names start with a specified prefix.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h" #include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Dialect/Arithmetic/Transforms/WideIntEmulationConverter.h" #include "mlir/Dialect/Arith/Transforms/WideIntEmulationConverter.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
struct TestEmulateWideIntPass struct TestEmulateWideIntPass
: public PassWrapper<TestEmulateWideIntPass, OperationPass<func::FuncOp>> { : public PassWrapper<TestEmulateWideIntPass, OperationPass<func::FuncOp>> {
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestEmulateWideIntPass) MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestEmulateWideIntPass)
TestEmulateWideIntPass() = default; TestEmulateWideIntPass() = default;
TestEmulateWideIntPass(const TestEmulateWideIntPass &pass) TestEmulateWideIntPass(const TestEmulateWideIntPass &pass)
: PassWrapper(pass) {} : PassWrapper(pass) {}
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry.insert<arith::ArithmeticDialect, func::FuncDialect, registry.insert<arith::ArithDialect, func::FuncDialect, LLVM::LLVMDialect,
LLVM::LLVMDialect, vector::VectorDialect>(); vector::VectorDialect>();
} }
StringRef getArgument() const final { return "test-arith-emulate-wide-int"; } StringRef getArgument() const final { return "test-arith-emulate-wide-int"; }
StringRef getDescription() const final { StringRef getDescription() const final {
return "Function pass to test Wide Integer Emulation"; return "Function pass to test Wide Integer Emulation";
} }
void runOnOperation() override { void runOnOperation() override {
if (!llvm::isPowerOf2_32(widestIntSupported) || widestIntSupported < 2) { if (!llvm::isPowerOf2_32(widestIntSupported) || widestIntSupported < 2) {
Show All 16 Lines auto addBitcast = [](OpBuilder &builder, Type type, ValueRange inputs,
Location loc) -> Optional<Value> { Location loc) -> Optional<Value> {
auto cast = builder.create<LLVM::BitcastOp>(loc, type, inputs); auto cast = builder.create<LLVM::BitcastOp>(loc, type, inputs);
return cast->getResult(0); return cast->getResult(0);
}; };
typeConverter.addSourceMaterialization(addBitcast); typeConverter.addSourceMaterialization(addBitcast);
typeConverter.addTargetMaterialization(addBitcast); typeConverter.addTargetMaterialization(addBitcast);
ConversionTarget target(*ctx); ConversionTarget target(*ctx);
target.addDynamicallyLegalDialect<arith::ArithmeticDialect, target
vector::VectorDialect>( .addDynamicallyLegalDialect<arith::ArithDialect, vector::VectorDialect>(
[&typeConverter](Operation *op) { return typeConverter.isLegal(op); }); [&typeConverter](Operation *op) {
return typeConverter.isLegal(op);
});
RewritePatternSet patterns(ctx); RewritePatternSet patterns(ctx);
arith::populateWideIntEmulationPatterns(typeConverter, patterns); arith::populateWideIntEmulationPatterns(typeConverter, patterns);
if (failed(applyPartialConversion(op, target, std::move(patterns)))) if (failed(applyPartialConversion(op, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
Option<std::string> testFunctionPrefix{ Option<std::string> testFunctionPrefix{
*this, "function-prefix", *this, "function-prefix",
llvm::cl::desc("Prefix of functions to run the emulation pass on"), llvm::cl::desc("Prefix of functions to run the emulation pass on"),
llvm::cl::init("emulate_")}; llvm::cl::init("emulate_")};
Option<unsigned> widestIntSupported{ Option<unsigned> widestIntSupported{
*this, "widest-int-supported", *this, "widest-int-supported",
llvm::cl::desc("Maximum integer bit width supported by the target"), llvm::cl::desc("Maximum integer bit width supported by the target"),
llvm::cl::init(32)}; llvm::cl::init(32)};
}; };
} // namespace } // namespace
namespace mlir::test { namespace mlir::test {
void registerTestArithmeticEmulateWideIntPass() { void registerTestArithEmulateWideIntPass() {
PassRegistration<TestEmulateWideIntPass>(); PassRegistration<TestEmulateWideIntPass>();
} }
} // namespace mlir::test } // namespace mlir::test

mlir/test/lib/Dialect/Arithmetic/CMakeLists.txt

  • This file was moved to mlir/test/lib/Dialect/Arith/CMakeLists.txt.

mlir/test/lib/Dialect/Arithmetic/TestEmulateWideInt.cpp

  • This file was moved to mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp.

mlir/test/lib/Dialect/CMakeLists.txt

add_subdirectory(Affine) add_subdirectory(Affine)
add_subdirectory(Arithmetic) add_subdirectory(Arith)
add_subdirectory(DLTI) add_subdirectory(DLTI)
add_subdirectory(Func) add_subdirectory(Func)
add_subdirectory(GPU) add_subdirectory(GPU)
add_subdirectory(Linalg) add_subdirectory(Linalg)
add_subdirectory(Math) add_subdirectory(Math)
add_subdirectory(MemRef) add_subdirectory(MemRef)
add_subdirectory(NVGPU) add_subdirectory(NVGPU)
add_subdirectory(SCF) add_subdirectory(SCF)
add_subdirectory(Shape) add_subdirectory(Shape)
add_subdirectory(SPIRV) add_subdirectory(SPIRV)
add_subdirectory(Tensor) add_subdirectory(Tensor)
add_subdirectory(Test) add_subdirectory(Test)
add_subdirectory(TestDyn) add_subdirectory(TestDyn)
add_subdirectory(Tosa) add_subdirectory(Tosa)
add_subdirectory(Transform) add_subdirectory(Transform)
add_subdirectory(Vector) add_subdirectory(Vector)

mlir/test/lib/Dialect/GPU/TestGpuRewrite.cpp

//===- TestAllReduceLowering.cpp - Test gpu.all_reduce lowering -----------===// //===- TestAllReduceLowering.cpp - Test gpu.all_reduce lowering -----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains test passes for lowering the gpu.all_reduce op. // This file contains test passes for lowering the gpu.all_reduce op.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/Transforms/Passes.h" #include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
struct TestGpuRewritePass struct TestGpuRewritePass
: public PassWrapper<TestGpuRewritePass, OperationPass<ModuleOp>> { : public PassWrapper<TestGpuRewritePass, OperationPass<ModuleOp>> {
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestGpuRewritePass) MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestGpuRewritePass)
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry.insert<arith::ArithmeticDialect, func::FuncDialect, registry.insert<arith::ArithDialect, func::FuncDialect,
memref::MemRefDialect>(); memref::MemRefDialect>();
} }
StringRef getArgument() const final { return "test-gpu-rewrite"; } StringRef getArgument() const final { return "test-gpu-rewrite"; }
StringRef getDescription() const final { StringRef getDescription() const final {
return "Applies all rewrite patterns within the GPU dialect."; return "Applies all rewrite patterns within the GPU dialect.";
} }
void runOnOperation() override { void runOnOperation() override {
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
Show All 11 Lines

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

# Exclude tests from libMLIR.so # Exclude tests from libMLIR.so
add_mlir_library(MLIRLinalgTestPasses add_mlir_library(MLIRLinalgTestPasses
TestLinalgDecomposeOps.cpp TestLinalgDecomposeOps.cpp
TestLinalgElementwiseFusion.cpp TestLinalgElementwiseFusion.cpp
TestLinalgFusionTransforms.cpp TestLinalgFusionTransforms.cpp
TestLinalgHoisting.cpp TestLinalgHoisting.cpp
TestLinalgTransforms.cpp TestLinalgTransforms.cpp
TestPadFusion.cpp TestPadFusion.cpp
EXCLUDE_FROM_LIBMLIR EXCLUDE_FROM_LIBMLIR
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRArithmeticDialect MLIRArithDialect
MLIRArithmeticTransforms MLIRArithTransforms
MLIRBufferizationDialect MLIRBufferizationDialect
MLIRBufferizationTransforms MLIRBufferizationTransforms
MLIRGPUTransforms MLIRGPUTransforms
MLIRLinalgDialect MLIRLinalgDialect
MLIRLinalgTransforms MLIRLinalgTransforms
MLIRLLVMToLLVMIRTranslation MLIRLLVMToLLVMIRTranslation
MLIRMemRefDialect MLIRMemRefDialect
MLIRParser MLIRParser
Show All 10 Lines

mlir/test/lib/Dialect/Linalg/TestLinalgTransforms.cpp

//===- TestLinalgTransforms.cpp - Test Linalg transformation patterns -----===// //===- TestLinalgTransforms.cpp - Test Linalg transformation patterns -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements logic for testing Linalg transformations. // This file implements logic for testing Linalg transformations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/HoistPadding.h" #include "mlir/Dialect/Linalg/Transforms/HoistPadding.h"
#include "mlir/Dialect/Linalg/Transforms/Hoisting.h" #include "mlir/Dialect/Linalg/Transforms/Hoisting.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
▲ Show 20 Lines • Show All 573 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Math/TestExpandMath.cpp

//===- TestExpandMath.cpp - Test expand math op into exp form -------------===// //===- TestExpandMath.cpp - Test expand math op into exp form -------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains test passes for expanding math operations. // This file contains test passes for expanding math operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Math/Transforms/Passes.h" #include "mlir/Dialect/Math/Transforms/Passes.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
struct TestExpandMathPass struct TestExpandMathPass
: public PassWrapper<TestExpandMathPass, OperationPass<>> { : public PassWrapper<TestExpandMathPass, OperationPass<>> {
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestExpandMathPass) MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestExpandMathPass)
void runOnOperation() override; void runOnOperation() override;
StringRef getArgument() const final { return "test-expand-math"; } StringRef getArgument() const final { return "test-expand-math"; }
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry.insert<arith::ArithmeticDialect, scf::SCFDialect>(); registry.insert<arith::ArithDialect, scf::SCFDialect>();
} }
StringRef getDescription() const final { return "Test expanding math"; } StringRef getDescription() const final { return "Test expanding math"; }
}; };
} // namespace } // namespace
void TestExpandMathPass::runOnOperation() { void TestExpandMathPass::runOnOperation() {
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateExpandCtlzPattern(patterns); populateExpandCtlzPattern(patterns);
Show All 9 Lines

mlir/test/lib/Dialect/Math/TestPolynomialApproximation.cpp

//===- TestPolynomialApproximation.cpp - Test math ops approximations -----===// //===- TestPolynomialApproximation.cpp - Test math ops approximations -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains test passes for expanding math operations into // This file contains test passes for expanding math operations into
// polynomial approximations. // polynomial approximations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Math/Transforms/Passes.h" #include "mlir/Dialect/Math/Transforms/Passes.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/X86Vector/X86VectorDialect.h" #include "mlir/Dialect/X86Vector/X86VectorDialect.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
struct TestMathPolynomialApproximationPass struct TestMathPolynomialApproximationPass
: public PassWrapper<TestMathPolynomialApproximationPass, OperationPass<>> { : public PassWrapper<TestMathPolynomialApproximationPass, OperationPass<>> {
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID( MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
TestMathPolynomialApproximationPass) TestMathPolynomialApproximationPass)
TestMathPolynomialApproximationPass() = default; TestMathPolynomialApproximationPass() = default;
TestMathPolynomialApproximationPass( TestMathPolynomialApproximationPass(
const TestMathPolynomialApproximationPass &pass) const TestMathPolynomialApproximationPass &pass)
: PassWrapper(pass) {} : PassWrapper(pass) {}
void runOnOperation() override; void runOnOperation() override;
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry.insert<arith::ArithmeticDialect, math::MathDialect, registry.insert<arith::ArithDialect, math::MathDialect,
vector::VectorDialect>(); vector::VectorDialect>();
if (enableAvx2) if (enableAvx2)
registry.insert<x86vector::X86VectorDialect>(); registry.insert<x86vector::X86VectorDialect>();
} }
StringRef getArgument() const final { StringRef getArgument() const final {
return "test-math-polynomial-approximation"; return "test-math-polynomial-approximation";
} }
StringRef getDescription() const final { StringRef getDescription() const final {
Show All 26 Lines

mlir/test/lib/Dialect/SCF/TestLoopUnrolling.cpp

//===-------- TestLoopUnrolling.cpp --- loop unrolling test pass ----------===// //===-------- TestLoopUnrolling.cpp --- loop unrolling test pass ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to unroll loops by a specified unroll factor. // This file implements a pass to unroll loops by a specified unroll factor.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
Show All 22 Lines explicit TestLoopUnrollingPass(uint64_t unrollFactorParam,
unsigned loopDepthParam, unsigned loopDepthParam,
bool annotateLoopParam) { bool annotateLoopParam) {
unrollFactor = unrollFactorParam; unrollFactor = unrollFactorParam;
loopDepth = loopDepthParam; loopDepth = loopDepthParam;
annotateLoop = annotateLoopParam; annotateLoop = annotateLoopParam;
} }
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry.insert<arith::ArithmeticDialect>(); registry.insert<arith::ArithDialect>();
} }
void runOnOperation() override { void runOnOperation() override {
SmallVector<scf::ForOp, 4> loops; SmallVector<scf::ForOp, 4> loops;
getOperation()->walk([&](scf::ForOp forOp) { getOperation()->walk([&](scf::ForOp forOp) {
if (getNestingDepth(forOp) == loopDepth) if (getNestingDepth(forOp) == loopDepth)
loops.push_back(forOp); loops.push_back(forOp);
}); });
Show All 29 Lines

mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp

//===- TestSCFUtils.cpp --- Pass to test independent SCF dialect utils ----===// //===- TestSCFUtils.cpp --- Pass to test independent SCF dialect utils ----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to test SCF dialect utils. // This file implements a pass to test SCF dialect utils.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h" #include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines case mlir::scf::PipeliningOption::PipelinerPart::Epilogue:
op->setAttr(kTestPipeliningAnnotationPart, b.getStringAttr("epilogue")); op->setAttr(kTestPipeliningAnnotationPart, b.getStringAttr("epilogue"));
break; break;
} }
op->setAttr(kTestPipeliningAnnotationIteration, op->setAttr(kTestPipeliningAnnotationIteration,
b.getI32IntegerAttr(iteration)); b.getI32IntegerAttr(iteration));
} }
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry.insert<arith::ArithmeticDialect, memref::MemRefDialect>(); registry.insert<arith::ArithDialect, memref::MemRefDialect>();
} }
void runOnOperation() override { void runOnOperation() override {
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
mlir::scf::PipeliningOption options; mlir::scf::PipeliningOption options;
options.getScheduleFn = getSchedule; options.getScheduleFn = getSchedule;
if (annotatePipeline) if (annotatePipeline)
options.annotateFn = annotate; options.annotateFn = annotate;
Show All 24 Lines

mlir/test/lib/Dialect/Tensor/CMakeLists.txt

# Exclude tests from libMLIR.so # Exclude tests from libMLIR.so
add_mlir_library(MLIRTensorTestPasses add_mlir_library(MLIRTensorTestPasses
TestTensorTransforms.cpp TestTensorTransforms.cpp
EXCLUDE_FROM_LIBMLIR EXCLUDE_FROM_LIBMLIR
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticDialect MLIRArithDialect
MLIRLinalgDialect MLIRLinalgDialect
MLIRPass MLIRPass
MLIRSCFDialect MLIRSCFDialect
MLIRTensorDialect MLIRTensorDialect
MLIRTensorTransforms MLIRTensorTransforms
MLIRTransforms MLIRTransforms
) )

mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp

//===- TestTensorTransforms.cpp - Test Tensor transformation patterns -----===// //===- TestTensorTransforms.cpp - Test Tensor transformation patterns -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements logic for testing Tensor transformations. // This file implements logic for testing Tensor transformations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Transforms/TransformUtils.h" #include "mlir/Dialect/Tensor/Transforms/TransformUtils.h"
#include "mlir/Dialect/Tensor/Transforms/Transforms.h" #include "mlir/Dialect/Tensor/Transforms/Transforms.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
struct TestTensorTransforms struct TestTensorTransforms
: public PassWrapper<TestTensorTransforms, OperationPass<>> { : public PassWrapper<TestTensorTransforms, OperationPass<>> {
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTensorTransforms) MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTensorTransforms)
TestTensorTransforms() = default; TestTensorTransforms() = default;
TestTensorTransforms(const TestTensorTransforms &pass) : PassWrapper(pass) {} TestTensorTransforms(const TestTensorTransforms &pass) : PassWrapper(pass) {}
void getDependentDialects(DialectRegistry &registry) const override { void getDependentDialects(DialectRegistry &registry) const override {
registry.insert<arith::ArithmeticDialect, scf::SCFDialect, registry
linalg::LinalgDialect>(); .insert<arith::ArithDialect, scf::SCFDialect, linalg::LinalgDialect>();
} }
StringRef getArgument() const final { StringRef getArgument() const final {
return "test-tensor-transform-patterns"; return "test-tensor-transform-patterns";
} }
StringRef getDescription() const final { StringRef getDescription() const final {
return "Test Tensor transformation patterns by applying them greedily."; return "Test Tensor transformation patterns by applying them greedily.";
} }
▲ Show 20 Lines • Show All 221 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Test/TestDialect.cpp

//===- TestDialect.cpp - MLIR Dialect for Testing -------------------------===// //===- TestDialect.cpp - MLIR Dialect for Testing -------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TestDialect.h" #include "TestDialect.h"
#include "TestAttributes.h" #include "TestAttributes.h"
#include "TestInterfaces.h" #include "TestInterfaces.h"
#include "TestTypes.h" #include "TestTypes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/DLTI/DLTI.h" #include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/AsmState.h" #include "mlir/IR/AsmState.h"
#include "mlir/IR/BuiltinAttributes.h" #include "mlir/IR/BuiltinAttributes.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Diagnostics.h" #include "mlir/IR/Diagnostics.h"
#include "mlir/IR/DialectImplementation.h" #include "mlir/IR/DialectImplementation.h"
▲ Show 20 Lines • Show All 1,555 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Test/TestPatterns.cpp

//===- TestPatterns.cpp - Test dialect pattern driver ---------------------===// //===- TestPatterns.cpp - Test dialect pattern driver ---------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TestDialect.h" #include "TestDialect.h"
#include "TestTypes.h" #include "TestTypes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/FuncConversions.h" #include "mlir/Dialect/Func/Transforms/FuncConversions.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/FoldUtils.h" #include "mlir/Transforms/FoldUtils.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
▲ Show 20 Lines • Show All 1,558 Lines • Show Last 20 Lines

mlir/test/lib/IR/TestMatchers.cpp

//===- TestMatchers.cpp - Pass to test matchers ---------------------------===// //===- TestMatchers.cpp - Pass to test matchers ---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/FunctionInterfaces.h" #include "mlir/IR/FunctionInterfaces.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

mlir/test/lib/Interfaces/TilingInterface/CMakeLists.txt

add_mlir_library(MLIRTilingInterfaceTestPasses add_mlir_library(MLIRTilingInterfaceTestPasses
TestTilingInterface.cpp TestTilingInterface.cpp
EXCLUDE_FROM_LIBMLIR EXCLUDE_FROM_LIBMLIR
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineDialect MLIRAffineDialect
MLIRArithmeticDialect MLIRArithDialect
MLIRLinalgDialect MLIRLinalgDialect
MLIRLinalgTransforms MLIRLinalgTransforms
MLIRMemRefDialect MLIRMemRefDialect
MLIRSCFDialect MLIRSCFDialect
MLIRSCFTransforms MLIRSCFTransforms
MLIRTensorDialect MLIRTensorDialect
MLIRTensorTilingInterfaceImpl MLIRTensorTilingInterfaceImpl
) )

mlir/tools/mlir-opt/CMakeLists.txt

set(LLVM_OPTIONAL_SOURCES set(LLVM_OPTIONAL_SOURCES
null.cpp null.cpp
) )
get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS) get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS) get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
set(LLVM_LINK_COMPONENTS set(LLVM_LINK_COMPONENTS
Core Core
Support Support
AsmParser AsmParser
) )
if(MLIR_INCLUDE_TESTS) if(MLIR_INCLUDE_TESTS)
set(test_libs set(test_libs
MLIRTestFuncToLLVM MLIRTestFuncToLLVM
MLIRAffineTransformsTestPasses MLIRAffineTransformsTestPasses
MLIRArithmeticTestPasses MLIRArithTestPasses
MLIRDLTITestPasses MLIRDLTITestPasses
MLIRFuncTestPasses MLIRFuncTestPasses
MLIRGPUTestPasses MLIRGPUTestPasses
MLIRLinalgTestPasses MLIRLinalgTestPasses
MLIRMathTestPasses MLIRMathTestPasses
MLIRMemRefTestPasses MLIRMemRefTestPasses
MLIRNVGPUTestPasses MLIRNVGPUTestPasses
MLIRSCFTestPasses MLIRSCFTestPasses
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
namespace test { namespace test {
void registerCommutativityUtils(); void registerCommutativityUtils();
void registerConvertCallOpPass(); void registerConvertCallOpPass();
void registerInliner(); void registerInliner();
void registerMemRefBoundCheck(); void registerMemRefBoundCheck();
void registerPatternsTestPass(); void registerPatternsTestPass();
void registerSimpleParametricTilingPass(); void registerSimpleParametricTilingPass();
void registerTestAffineLoopParametricTilingPass(); void registerTestAffineLoopParametricTilingPass();
void registerTestArithmeticEmulateWideIntPass(); void registerTestArithEmulateWideIntPass();
void registerTestAliasAnalysisPass(); void registerTestAliasAnalysisPass();
void registerTestBuiltinAttributeInterfaces(); void registerTestBuiltinAttributeInterfaces();
void registerTestCallGraphPass(); void registerTestCallGraphPass();
void registerTestConstantFold(); void registerTestConstantFold();
void registerTestControlFlowSink(); void registerTestControlFlowSink();
void registerTestGpuSerializeToCubinPass(); void registerTestGpuSerializeToCubinPass();
void registerTestGpuSerializeToHsacoPass(); void registerTestGpuSerializeToHsacoPass();
void registerTestDataLayoutQuery(); void registerTestDataLayoutQuery();
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Linesvoid registerTestPasses() {
mlir::test::registerCommutativityUtils(); mlir::test::registerCommutativityUtils();
mlir::test::registerConvertCallOpPass(); mlir::test::registerConvertCallOpPass();
mlir::test::registerInliner(); mlir::test::registerInliner();
mlir::test::registerMemRefBoundCheck(); mlir::test::registerMemRefBoundCheck();
mlir::test::registerPatternsTestPass(); mlir::test::registerPatternsTestPass();
mlir::test::registerSimpleParametricTilingPass(); mlir::test::registerSimpleParametricTilingPass();
mlir::test::registerTestAffineLoopParametricTilingPass(); mlir::test::registerTestAffineLoopParametricTilingPass();
mlir::test::registerTestAliasAnalysisPass(); mlir::test::registerTestAliasAnalysisPass();
mlir::test::registerTestArithmeticEmulateWideIntPass(); mlir::test::registerTestArithEmulateWideIntPass();
mlir::test::registerTestBuiltinAttributeInterfaces(); mlir::test::registerTestBuiltinAttributeInterfaces();
mlir::test::registerTestCallGraphPass(); mlir::test::registerTestCallGraphPass();
mlir::test::registerTestConstantFold(); mlir::test::registerTestConstantFold();
mlir::test::registerTestControlFlowSink(); mlir::test::registerTestControlFlowSink();
mlir::test::registerTestDiagnosticsPass(); mlir::test::registerTestDiagnosticsPass();
#if MLIR_CUDA_CONVERSIONS_ENABLED #if MLIR_CUDA_CONVERSIONS_ENABLED
mlir::test::registerTestGpuSerializeToCubinPass(); mlir::test::registerTestGpuSerializeToCubinPass();
#endif #endif
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

Show All 10 Linesif (MLIR_ENABLE_SPIRV_CPU_RUNNER)
llvm_update_compile_flags(mlir-spirv-cpu-runner) llvm_update_compile_flags(mlir-spirv-cpu-runner)
get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS) get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
target_link_libraries(mlir-spirv-cpu-runner PRIVATE target_link_libraries(mlir-spirv-cpu-runner PRIVATE
${conversion_libs} ${conversion_libs}
MLIRAnalysis MLIRAnalysis
MLIRArithmeticDialect MLIRArithDialect
MLIRExecutionEngine MLIRExecutionEngine
MLIRFuncDialect MLIRFuncDialect
MLIRGPUOps MLIRGPUOps
MLIRIR MLIRIR
MLIRJitRunner MLIRJitRunner
MLIRLLVMDialect MLIRLLVMDialect
MLIRLLVMToLLVMIRTranslation MLIRLLVMToLLVMIRTranslation
MLIRMemRefDialect MLIRMemRefDialect
MLIRParser MLIRParser
MLIRSPIRVDialect MLIRSPIRVDialect
MLIRTargetLLVMIRExport MLIRTargetLLVMIRExport
MLIRTransforms MLIRTransforms
MLIRTranslateLib MLIRTranslateLib
MLIRSupport MLIRSupport
) )
endif() endif()

mlir/tools/mlir-spirv-cpu-runner/mlir-spirv-cpu-runner.cpp

Show All 9 Lines
// CPU by translating MLIR GPU module and host part to LLVM IR before // CPU by translating MLIR GPU module and host part to LLVM IR before
// JIT-compiling and executing. // JIT-compiling and executing.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h" #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h" #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/GPU/Transforms/Passes.h" #include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/Transforms/Passes.h" #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Linesint main(int argc, char **argv) {
llvm::InitializeNativeTarget(); llvm::InitializeNativeTarget();
llvm::InitializeNativeTargetAsmPrinter(); llvm::InitializeNativeTargetAsmPrinter();
mlir::JitRunnerConfig jitRunnerConfig; mlir::JitRunnerConfig jitRunnerConfig;
jitRunnerConfig.mlirTransformer = runMLIRPasses; jitRunnerConfig.mlirTransformer = runMLIRPasses;
jitRunnerConfig.llvmModuleBuilder = convertMLIRModule; jitRunnerConfig.llvmModuleBuilder = convertMLIRModule;
mlir::DialectRegistry registry; mlir::DialectRegistry registry;
registry.insert<mlir::arith::ArithmeticDialect, mlir::LLVM::LLVMDialect, registry.insert<mlir::arith::ArithDialect, mlir::LLVM::LLVMDialect,
mlir::gpu::GPUDialect, mlir::spirv::SPIRVDialect, mlir::gpu::GPUDialect, mlir::spirv::SPIRVDialect,
mlir::func::FuncDialect, mlir::memref::MemRefDialect>(); mlir::func::FuncDialect, mlir::memref::MemRefDialect>();
mlir::registerLLVMDialectTranslation(registry); mlir::registerLLVMDialectTranslation(registry);
return mlir::JitRunnerMain(argc, argv, registry, jitRunnerConfig); return mlir::JitRunnerMain(argc, argv, registry, jitRunnerConfig);
} }

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

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines target_link_libraries(vulkan-runtime-wrappers
PUBLIC PUBLIC
${Vulkan_LIBRARY} ${Vulkan_LIBRARY}
) )
get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS) get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
set(LIBS set(LIBS
${conversion_libs} ${conversion_libs}
MLIRAnalysis MLIRAnalysis
MLIRArithmeticDialect MLIRArithDialect
MLIRExecutionEngine MLIRExecutionEngine
MLIRFuncDialect MLIRFuncDialect
MLIRGPUOps MLIRGPUOps
MLIRIR MLIRIR
MLIRJitRunner MLIRJitRunner
MLIRLLVMDialect MLIRLLVMDialect
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMToLLVMIRTranslation MLIRLLVMToLLVMIRTranslation
Show All 33 Lines

mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp

Show All 13 Lines
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRVPass.h" #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRVPass.h"
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h" #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
#include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h" #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h" #include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h" #include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h" #include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/GPU/Transforms/Passes.h" #include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/LLVMIR/Transforms/RequestCWrappers.h" #include "mlir/Dialect/LLVMIR/Transforms/RequestCWrappers.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/MemRef/Transforms/Passes.h" #include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
Show All 40 Linesint main(int argc, char **argv) {
llvm::InitLLVM y(argc, argv); llvm::InitLLVM y(argc, argv);
llvm::InitializeNativeTarget(); llvm::InitializeNativeTarget();
llvm::InitializeNativeTargetAsmPrinter(); llvm::InitializeNativeTargetAsmPrinter();
mlir::JitRunnerConfig jitRunnerConfig; mlir::JitRunnerConfig jitRunnerConfig;
jitRunnerConfig.mlirTransformer = runMLIRPasses; jitRunnerConfig.mlirTransformer = runMLIRPasses;
mlir::DialectRegistry registry; mlir::DialectRegistry registry;
registry.insert<mlir::arith::ArithmeticDialect, mlir::LLVM::LLVMDialect, registry.insert<mlir::arith::ArithDialect, mlir::LLVM::LLVMDialect,
mlir::gpu::GPUDialect, mlir::spirv::SPIRVDialect, mlir::gpu::GPUDialect, mlir::spirv::SPIRVDialect,
mlir::func::FuncDialect, mlir::memref::MemRefDialect>(); mlir::func::FuncDialect, mlir::memref::MemRefDialect>();
mlir::registerLLVMDialectTranslation(registry); mlir::registerLLVMDialectTranslation(registry);
return mlir::JitRunnerMain(argc, argv, registry, jitRunnerConfig); return mlir::JitRunnerMain(argc, argv, registry, jitRunnerConfig);
} }

mlir/unittests/Conversion/PDLToPDLInterp/CMakeLists.txt

add_mlir_unittest(MLIRPDLToPDLInterpTests add_mlir_unittest(MLIRPDLToPDLInterpTests
RootOrderingTest.cpp RootOrderingTest.cpp
) )
target_link_libraries(MLIRPDLToPDLInterpTests target_link_libraries(MLIRPDLToPDLInterpTests
PRIVATE PRIVATE
MLIRArithmeticDialect MLIRArithDialect
MLIRPDLToPDLInterp MLIRPDLToPDLInterp
) )

mlir/unittests/Conversion/PDLToPDLInterp/RootOrderingTest.cpp

//===- RootOrderingTest.cpp - unit tests for optimal branching ------------===// //===- RootOrderingTest.cpp - unit tests for optimal branching ------------===//
// //
// Part of the LLVM Project, under the Apache License v[1].0 with LLVM // Part of the LLVM Project, under the Apache License v[1].0 with LLVM
// Exceptions. See https://llvm.org/LICENSE.txt for license information. // Exceptions. See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../lib/Conversion/PDLToPDLInterp/RootOrdering.h" #include "../lib/Conversion/PDLToPDLInterp/RootOrdering.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/MLIRContext.h" #include "mlir/IR/MLIRContext.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
using namespace mlir; using namespace mlir;
using namespace mlir::arith; using namespace mlir::arith;
using namespace mlir::pdl_to_pdl_interp; using namespace mlir::pdl_to_pdl_interp;
namespace { namespace {
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Test Fixture // Test Fixture
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// The test fixture for constructing root ordering tests and verifying results. /// The test fixture for constructing root ordering tests and verifying results.
/// This fixture constructs the test values v. The test populates the graph /// This fixture constructs the test values v. The test populates the graph
/// with the desired costs and then calls check(), passing the expected optimal /// with the desired costs and then calls check(), passing the expected optimal
/// cost and the list of edges in the preorder traversal of the optimal /// cost and the list of edges in the preorder traversal of the optimal
/// branching. /// branching.
class RootOrderingTest : public ::testing::Test { class RootOrderingTest : public ::testing::Test {
protected: protected:
RootOrderingTest() { RootOrderingTest() {
context.loadDialect<ArithmeticDialect>(); context.loadDialect<ArithDialect>();
createValues(); createValues();
} }
/// Creates the test values. These values simply act as vertices / vertex IDs /// Creates the test values. These values simply act as vertices / vertex IDs
/// in the cost graph, rather than being a part of an IR. /// in the cost graph, rather than being a part of an IR.
void createValues() { void createValues() {
OpBuilder builder(&context); OpBuilder builder(&context);
builder.setInsertionPointToStart(&block); builder.setInsertionPointToStart(&block);
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

mlir/unittests/ExecutionEngine/CMakeLists.txt

add_mlir_unittest(MLIRExecutionEngineTests add_mlir_unittest(MLIRExecutionEngineTests
DynamicMemRef.cpp DynamicMemRef.cpp
Invoke.cpp Invoke.cpp
) )
get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS) get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
target_link_libraries(MLIRExecutionEngineTests target_link_libraries(MLIRExecutionEngineTests
PRIVATE PRIVATE
MLIRArithmeticToLLVM MLIRArithToLLVM
MLIRExecutionEngine MLIRExecutionEngine
MLIRLinalgToLLVM MLIRLinalgToLLVM
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRReconcileUnrealizedCasts MLIRReconcileUnrealizedCasts
${dialect_libs} ${dialect_libs}
) )

mlir/unittests/ExecutionEngine/Invoke.cpp

//===- Invoke.cpp ------------------------------------*- C++ -*-===// //===- Invoke.cpp ------------------------------------*- C++ -*-===//
// //
// This file is licensed under the Apache License v2.0 with LLVM Exceptions. // This file is licensed under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h" #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h" #include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h" #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
#include "mlir/Conversion/VectorToSCF/VectorToSCF.h" #include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
Show All 31 Linesstatic struct LLVMInitializer {
} }
} initializer; } initializer;
/// Simple conversion pipeline for the purpose of testing sources written in /// Simple conversion pipeline for the purpose of testing sources written in
/// dialects lowering to LLVM Dialect. /// dialects lowering to LLVM Dialect.
static LogicalResult lowerToLLVMDialect(ModuleOp module) { static LogicalResult lowerToLLVMDialect(ModuleOp module) {
PassManager pm(module.getContext()); PassManager pm(module.getContext());
pm.addPass(mlir::createMemRefToLLVMConversionPass()); pm.addPass(mlir::createMemRefToLLVMConversionPass());
pm.addNestedPass<func::FuncOp>(mlir::createArithmeticToLLVMConversionPass()); pm.addNestedPass<func::FuncOp>(mlir::createArithToLLVMConversionPass());
pm.addPass(mlir::createConvertFuncToLLVMPass()); pm.addPass(mlir::createConvertFuncToLLVMPass());
pm.addPass(mlir::createReconcileUnrealizedCastsPass()); pm.addPass(mlir::createReconcileUnrealizedCastsPass());
return pm.run(module); return pm.run(module);
} }
TEST(MLIRExecutionEngine, SKIP_WITHOUT_JIT(AddInteger)) { TEST(MLIRExecutionEngine, SKIP_WITHOUT_JIT(AddInteger)) {
std::string moduleStr = R"mlir( std::string moduleStr = R"mlir(
func.func @foo(%arg0 : i32) -> i32 attributes { llvm.emit_c_interface } { func.func @foo(%arg0 : i32) -> i32 attributes { llvm.emit_c_interface } {
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

mlir/unittests/Interfaces/InferTypeOpInterfaceTest.cpp

//===- InferTypeOpInterfaceTest.cpp - Unit Test for type interface --------===// //===- InferTypeOpInterfaceTest.cpp - Unit Test for type interface --------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Interfaces/InferTypeOpInterface.h" #include "mlir/Interfaces/InferTypeOpInterface.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/DialectImplementation.h" #include "mlir/IR/DialectImplementation.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/OpDefinition.h" #include "mlir/IR/OpDefinition.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
Show All 9 Lines void SetUp() override {
const char *ir = R"MLIR( const char *ir = R"MLIR(
func.func @map(%arg : tensor<1xi64>) { func.func @map(%arg : tensor<1xi64>) {
%0 = arith.constant dense<[10]> : tensor<1xi64> %0 = arith.constant dense<[10]> : tensor<1xi64>
%1 = arith.addi %arg, %0 : tensor<1xi64> %1 = arith.addi %arg, %0 : tensor<1xi64>
return return
} }
)MLIR"; )MLIR";
registry.insert<func::FuncDialect, arith::ArithmeticDialect>(); registry.insert<func::FuncDialect, arith::ArithDialect>();
ctx.appendDialectRegistry(registry); ctx.appendDialectRegistry(registry);
module = parseSourceString<ModuleOp>(ir, &ctx); module = parseSourceString<ModuleOp>(ir, &ctx);
mapFn = cast<func::FuncOp>(module->front()); mapFn = cast<func::FuncOp>(module->front());
} }
// Create ValueShapeRange on the arith.addi operation. // Create ValueShapeRange on the arith.addi operation.
ValueShapeRange addiRange() { ValueShapeRange addiRange() {
auto &fnBody = mapFn.getBody(); auto &fnBody = mapFn.getBody();
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

Show First 20 Lines • Show All 1,041 Lines • ▼ Show 20 Lines
td_library( td_library(
name = "AffineOpsTdFiles", name = "AffineOpsTdFiles",
srcs = [ srcs = [
"include/mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.td", "include/mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.td",
"include/mlir/Dialect/Affine/IR/AffineOps.td", "include/mlir/Dialect/Affine/IR/AffineOps.td",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticOpsTdFiles", ":ArithOpsTdFiles",
":FuncTdFiles", ":FuncTdFiles",
":LoopLikeInterfaceTdFiles", ":LoopLikeInterfaceTdFiles",
":OpBaseTdFiles", ":OpBaseTdFiles",
":SideEffectInterfacesTdFiles", ":SideEffectInterfacesTdFiles",
], ],
) )
gentbl_cc_library( gentbl_cc_library(
▲ Show 20 Lines • Show All 207 Lines • ▼ Show 20 Lines
cc_library( cc_library(
name = "TargetCpp", name = "TargetCpp",
srcs = glob([ srcs = glob([
"lib/Target/Cpp/*.cpp", "lib/Target/Cpp/*.cpp",
"lib/Target/Cpp/*.h", "lib/Target/Cpp/*.h",
]), ]),
hdrs = glob(["include/mlir/Target/Cpp/*.h"]), hdrs = glob(["include/mlir/Target/Cpp/*.h"]),
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ControlFlowDialect", ":ControlFlowDialect",
":EmitCDialect", ":EmitCDialect",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MathDialect", ":MathDialect",
":SCFDialect", ":SCFDialect",
":Support", ":Support",
":TranslateLib", ":TranslateLib",
▲ Show 20 Lines • Show All 197 Lines • ▼ Show 20 Lines
td_library( td_library(
name = "ArmSVETdFiles", name = "ArmSVETdFiles",
srcs = [ srcs = [
"include/mlir/Dialect/ArmSVE/ArmSVE.td", "include/mlir/Dialect/ArmSVE/ArmSVE.td",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticOpsTdFiles", ":ArithOpsTdFiles",
":FuncTdFiles", ":FuncTdFiles",
":LLVMOpsTdFiles", ":LLVMOpsTdFiles",
":OpBaseTdFiles", ":OpBaseTdFiles",
":SideEffectInterfacesTdFiles", ":SideEffectInterfacesTdFiles",
], ],
) )
gentbl_cc_library( gentbl_cc_library(
▲ Show 20 Lines • Show All 245 Lines • ▼ Show 20 Lines
) )
cc_library( cc_library(
name = "X86VectorTransforms", name = "X86VectorTransforms",
srcs = glob(["lib/Dialect/X86Vector/Transforms/*.cpp"]), srcs = glob(["lib/Dialect/X86Vector/Transforms/*.cpp"]),
hdrs = ["include/mlir/Dialect/X86Vector/Transforms.h"], hdrs = ["include/mlir/Dialect/X86Vector/Transforms.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LLVMCommonConversion", ":LLVMCommonConversion",
":LLVMDialect", ":LLVMDialect",
":VectorDialect", ":VectorDialect",
":X86VectorDialect", ":X86VectorDialect",
"//llvm:Core", "//llvm:Core",
"//llvm:Support", "//llvm:Support",
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Linescc_library(
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Dialect/SCF/Transforms/*.h", "include/mlir/Dialect/SCF/Transforms/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineAnalysis", ":AffineAnalysis",
":AffineDialect", ":AffineDialect",
":ArithmeticDialect", ":ArithDialect",
":ArithmeticUtils", ":ArithUtils",
":BufferizationDialect", ":BufferizationDialect",
":BufferizationTransforms", ":BufferizationTransforms",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Lines
) )
cc_library( cc_library(
name = "SparseTensorDialect", name = "SparseTensorDialect",
srcs = ["lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp"], srcs = ["lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp"],
hdrs = ["include/mlir/Dialect/SparseTensor/IR/SparseTensor.h"], hdrs = ["include/mlir/Dialect/SparseTensor/IR/SparseTensor.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
":SparseTensorAttrDefsIncGen", ":SparseTensorAttrDefsIncGen",
":SparseTensorOpsIncGen", ":SparseTensorOpsIncGen",
"//llvm:Support", "//llvm:Support",
], ],
) )
cc_library( cc_library(
name = "SparseTensorUtils", name = "SparseTensorUtils",
srcs = glob(["lib/Dialect/SparseTensor/Utils/*.cpp"]), srcs = glob(["lib/Dialect/SparseTensor/Utils/*.cpp"]),
hdrs = glob(["include/mlir/Dialect/SparseTensor/Utils/*.h"]), hdrs = glob(["include/mlir/Dialect/SparseTensor/Utils/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ComplexDialect", ":ComplexDialect",
":IR", ":IR",
":LinalgDialect", ":LinalgDialect",
":MathDialect", ":MathDialect",
":SparseTensorDialect", ":SparseTensorDialect",
"//llvm:Support", "//llvm:Support",
], ],
) )
cc_library( cc_library(
name = "SparseTensorTransforms", name = "SparseTensorTransforms",
srcs = glob([ srcs = glob([
"lib/Dialect/SparseTensor/Transforms/*.cpp", "lib/Dialect/SparseTensor/Transforms/*.cpp",
"lib/Dialect/SparseTensor/Transforms/*.h", "lib/Dialect/SparseTensor/Transforms/*.h",
]), ]),
hdrs = [ hdrs = [
"include/mlir/Dialect/SparseTensor/Transforms/BufferizableOpInterfaceImpl.h", "include/mlir/Dialect/SparseTensor/Transforms/BufferizableOpInterfaceImpl.h",
"include/mlir/Dialect/SparseTensor/Transforms/Passes.h", "include/mlir/Dialect/SparseTensor/Transforms/Passes.h",
"include/mlir/ExecutionEngine/SparseTensorUtils.h", "include/mlir/ExecutionEngine/SparseTensorUtils.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":ArithmeticDialect", ":ArithDialect",
":BufferizationDialect", ":BufferizationDialect",
":BufferizationTransforms", ":BufferizationTransforms",
":ComplexDialect", ":ComplexDialect",
":FuncDialect", ":FuncDialect",
":FuncTransforms", ":FuncTransforms",
":IR", ":IR",
":LLVMDialect", ":LLVMDialect",
":LinalgDialect", ":LinalgDialect",
Show All 16 Lines
) )
cc_library( cc_library(
name = "SparseTensorPipelines", name = "SparseTensorPipelines",
srcs = glob(["lib/Dialect/SparseTensor/Pipelines/*.cpp"]), srcs = glob(["lib/Dialect/SparseTensor/Pipelines/*.cpp"]),
hdrs = ["include/mlir/Dialect/SparseTensor/Pipelines/Passes.h"], hdrs = ["include/mlir/Dialect/SparseTensor/Pipelines/Passes.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticTransforms", ":ArithTransforms",
":BufferizationTransforms", ":BufferizationTransforms",
":ConversionPasses", ":ConversionPasses",
":FuncDialect", ":FuncDialect",
":FuncTransforms", ":FuncTransforms",
":LinalgTransforms", ":LinalgTransforms",
":Pass", ":Pass",
":SparseTensorDialect", ":SparseTensorDialect",
":SparseTensorTransforms", ":SparseTensorTransforms",
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Linescc_library(
], ],
hdrs = [ hdrs = [
"include/mlir/Dialect/NVGPU/Passes.h", "include/mlir/Dialect/NVGPU/Passes.h",
"include/mlir/Dialect/NVGPU/Transforms/Transforms.h", "include/mlir/Dialect/NVGPU/Transforms/Transforms.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":ArithmeticDialect", ":ArithDialect",
":FuncDialect", ":FuncDialect",
":GPUDialect", ":GPUDialect",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":NVGPUDialect", ":NVGPUDialect",
":NVGPUPassIncGen", ":NVGPUPassIncGen",
":Pass", ":Pass",
":SideEffectInterfaces", ":SideEffectInterfaces",
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Lines srcs = glob([
"lib/Dialect/Utils/*.cpp", "lib/Dialect/Utils/*.cpp",
"lib/Dialect/Utils/*.h", "lib/Dialect/Utils/*.h",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Dialect/Utils/*.h", "include/mlir/Dialect/Utils/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticUtils", ":ArithUtils",
":DialectUtilsIncGen", ":DialectUtilsIncGen",
":IR", ":IR",
":Support", ":Support",
"//llvm:Support", "//llvm:Support",
], ],
) )
cc_library( cc_library(
name = "AffineDialect", name = "AffineDialect",
srcs = glob([ srcs = glob([
"lib/Dialect/Affine/IR/*.cpp", "lib/Dialect/Affine/IR/*.cpp",
"lib/Dialect/Affine/IR/*.h", "lib/Dialect/Affine/IR/*.h",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Dialect/Affine/IR/*.h", "include/mlir/Dialect/Affine/IR/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineMemoryOpInterfacesIncGen", ":AffineMemoryOpInterfacesIncGen",
":AffineOpsIncGen", ":AffineOpsIncGen",
":ArithmeticDialect", ":ArithDialect",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":DialectUtils", ":DialectUtils",
":IR", ":IR",
":LoopLikeInterface", ":LoopLikeInterface",
":MemRefDialect", ":MemRefDialect",
":SideEffectInterfaces", ":SideEffectInterfaces",
":TensorDialect", ":TensorDialect",
"//llvm:Support", "//llvm:Support",
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linescc_library(
]), ]),
hdrs = [ hdrs = [
"include/mlir/Dialect/Async/Passes.h", "include/mlir/Dialect/Async/Passes.h",
"include/mlir/Dialect/Async/Transforms.h", "include/mlir/Dialect/Async/Transforms.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":AsyncDialect", ":AsyncDialect",
":AsyncPassIncGen", ":AsyncPassIncGen",
":ControlFlowDialect", ":ControlFlowDialect",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
":SCFToControlFlow", ":SCFToControlFlow",
Show All 12 Lines srcs = glob([
"lib/Dialect/Affine/Analysis/*.cpp", "lib/Dialect/Affine/Analysis/*.cpp",
"lib/Dialect/Affine/Analysis/*.h", "lib/Dialect/Affine/Analysis/*.h",
]), ]),
hdrs = glob(["include/mlir/Dialect/Affine/Analysis/*.h"]), hdrs = glob(["include/mlir/Dialect/Affine/Analysis/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":Support", ":Support",
":ViewLikeInterface", ":ViewLikeInterface",
"//llvm:Support", "//llvm:Support",
], ],
) )
Show All 11 Lines hdrs = [
"include/mlir/Dialect/Affine/Utils.h", "include/mlir/Dialect/Affine/Utils.h",
"include/mlir/Dialect/Affine/ViewLikeInterfaceUtils.h", "include/mlir/Dialect/Affine/ViewLikeInterfaceUtils.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineAnalysis", ":AffineAnalysis",
":AffineDialect", ":AffineDialect",
":Analysis", ":Analysis",
":ArithmeticUtils", ":ArithUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":SCFDialect", ":SCFDialect",
":Support", ":Support",
":TransformUtils", ":TransformUtils",
":ViewLikeInterface", ":ViewLikeInterface",
"//llvm:Support", "//llvm:Support",
Show All 26 Linescc_library(
hdrs = ["include/mlir/Dialect/Affine/Passes.h"], hdrs = ["include/mlir/Dialect/Affine/Passes.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineAnalysis", ":AffineAnalysis",
":AffineDialect", ":AffineDialect",
":AffinePassIncGen", ":AffinePassIncGen",
":AffineUtils", ":AffineUtils",
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":ArithmeticUtils", ":ArithUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
":SCFUtils", ":SCFUtils",
":Support", ":Support",
":Transforms", ":Transforms",
Show All 36 Lines
cc_library( cc_library(
name = "ConversionPasses", name = "ConversionPasses",
hdrs = ["include/mlir/Conversion/Passes.h"], hdrs = ["include/mlir/Conversion/Passes.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AMDGPUToROCDL", ":AMDGPUToROCDL",
":AffineToStandard", ":AffineToStandard",
":ArithmeticToLLVM", ":ArithToLLVM",
":ArithmeticToSPIRV", ":ArithToSPIRV",
":ArmNeon2dToIntr", ":ArmNeon2dToIntr",
":AsyncToLLVM", ":AsyncToLLVM",
":BufferizationToMemRef", ":BufferizationToMemRef",
":ComplexToLLVM", ":ComplexToLLVM",
":ComplexToLibm", ":ComplexToLibm",
":ComplexToStandard", ":ComplexToStandard",
":ControlFlowToLLVM", ":ControlFlowToLLVM",
":ControlFlowToSPIRV", ":ControlFlowToSPIRV",
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linescc_library(
name = "AsyncToLLVM", name = "AsyncToLLVM",
srcs = glob([ srcs = glob([
"lib/Conversion/AsyncToLLVM/*.cpp", "lib/Conversion/AsyncToLLVM/*.cpp",
"lib/Conversion/AsyncToLLVM/*.h", "lib/Conversion/AsyncToLLVM/*.h",
]), ]),
hdrs = glob(["include/mlir/Conversion/AsyncToLLVM/*.h"]), hdrs = glob(["include/mlir/Conversion/AsyncToLLVM/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":AsyncDialect", ":AsyncDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":FuncToLLVM", ":FuncToLLVM",
":FuncTransforms", ":FuncTransforms",
":IR", ":IR",
":LLVMCommonConversion", ":LLVMCommonConversion",
":LLVMDialect", ":LLVMDialect",
Show All 10 Lines srcs = glob([
"lib/Conversion/AffineToStandard/*.cpp", "lib/Conversion/AffineToStandard/*.cpp",
"lib/Conversion/AffineToStandard/*.h", "lib/Conversion/AffineToStandard/*.h",
]), ]),
hdrs = glob(["include/mlir/Conversion/AffineToStandard/*.h"]), hdrs = glob(["include/mlir/Conversion/AffineToStandard/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":AffineUtils", ":AffineUtils",
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
":Support", ":Support",
":Transforms", ":Transforms",
Show All 31 Linescc_library(
), ),
hdrs = glob( hdrs = glob(
[ [
"include/mlir/Dialect/SCF/IR/*.h", "include/mlir/Dialect/SCF/IR/*.h",
], ],
), ),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ArithmeticUtils", ":ArithUtils",
":BufferizationDialect", ":BufferizationDialect",
":ControlFlowDialect", ":ControlFlowDialect",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LoopLikeInterface", ":LoopLikeInterface",
":MemRefDialect", ":MemRefDialect",
":ParallelCombiningOpInterface", ":ParallelCombiningOpInterface",
Show All 19 Lines hdrs = glob(
"include/mlir/Dialect/SCF/Utils/*.h", "include/mlir/Dialect/SCF/Utils/*.h",
], ],
), ),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineAnalysis", ":AffineAnalysis",
":AffineDialect", ":AffineDialect",
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":SCFDialect", ":SCFDialect",
":Support", ":Support",
":Transforms", ":Transforms",
"//llvm:Support", "//llvm:Support",
], ],
▲ Show 20 Lines • Show All 139 Lines • ▼ Show 20 Lines
) )
cc_library( cc_library(
name = "ShapeDialect", name = "ShapeDialect",
srcs = glob(["lib/Dialect/Shape/IR/*.cpp"]), srcs = glob(["lib/Dialect/Shape/IR/*.cpp"]),
hdrs = ["include/mlir/Dialect/Shape/IR/Shape.h"], hdrs = ["include/mlir/Dialect/Shape/IR/Shape.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":Dialect", ":Dialect",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
":MLIRShapeCanonicalizationIncGen", ":MLIRShapeCanonicalizationIncGen",
":ShapeOpsIncGen", ":ShapeOpsIncGen",
":SideEffectInterfaces", ":SideEffectInterfaces",
Show All 20 Linescc_library(
name = "ShapeToStandard", name = "ShapeToStandard",
srcs = glob([ srcs = glob([
"lib/Conversion/ShapeToStandard/*.cpp", "lib/Conversion/ShapeToStandard/*.cpp",
"lib/Conversion/ShapeToStandard/*.h", "lib/Conversion/ShapeToStandard/*.h",
]), ]),
hdrs = ["include/mlir/Conversion/ShapeToStandard/ShapeToStandard.h"], hdrs = ["include/mlir/Conversion/ShapeToStandard/ShapeToStandard.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ControlFlowDialect", ":ControlFlowDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
":ShapeDialect", ":ShapeDialect",
Show All 27 Lines srcs = glob([
"lib/Dialect/Shape/Transforms/*.h", "lib/Dialect/Shape/Transforms/*.h",
]), ]),
hdrs = [ hdrs = [
"include/mlir/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.h", "include/mlir/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.h",
"include/mlir/Dialect/Shape/Transforms/Passes.h", "include/mlir/Dialect/Shape/Transforms/Passes.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":BufferizationDialect", ":BufferizationDialect",
":BufferizationTransforms", ":BufferizationTransforms",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
":ShapeDialect", ":ShapeDialect",
":ShapeTransformsPassIncGen", ":ShapeTransformsPassIncGen",
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines srcs = glob(
"lib/Dialect/ControlFlow/IR/*.h", "lib/Dialect/ControlFlow/IR/*.h",
], ],
), ),
hdrs = glob([ hdrs = glob([
"include/mlir/Dialect/ControlFlow/IR/*.h", "include/mlir/Dialect/ControlFlow/IR/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":CommonFolders", ":CommonFolders",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":ControlFlowOpsIncGen", ":ControlFlowOpsIncGen",
":IR", ":IR",
":SideEffectInterfaces", ":SideEffectInterfaces",
":Support", ":Support",
"//llvm:Support", "//llvm:Support",
], ],
Show All 9 Lines srcs = glob(
], ],
), ),
hdrs = glob([ hdrs = glob([
"include/mlir/Dialect/Func/IR/*.h", "include/mlir/Dialect/Func/IR/*.h",
"include/mlir/Dialect/Func/Utils/*.h", "include/mlir/Dialect/Func/Utils/*.h",
]) + ["include/mlir/Transforms/InliningUtils.h"], ]) + ["include/mlir/Transforms/InliningUtils.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":CallOpInterfaces", ":CallOpInterfaces",
":CastOpInterfaces", ":CastOpInterfaces",
":CommonFolders", ":CommonFolders",
":ControlFlowDialect", ":ControlFlowDialect",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":FuncIncGen", ":FuncIncGen",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines srcs = glob(
"lib/Dialect/Vector/IR/*.cpp", "lib/Dialect/Vector/IR/*.cpp",
], ],
), ),
hdrs = glob([ hdrs = glob([
"include/mlir/Dialect/Vector/IR/*.h", "include/mlir/Dialect/Vector/IR/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ArithmeticUtils", ":ArithUtils",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":DialectUtils", ":DialectUtils",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
":MemRefDialect", ":MemRefDialect",
":SideEffectInterfaces", ":SideEffectInterfaces",
":Support", ":Support",
":TensorDialect", ":TensorDialect",
Show All 30 Lines srcs = glob(
], ],
), ),
hdrs = glob([ hdrs = glob([
"include/mlir/Dialect/Vector/Transforms/*.h", "include/mlir/Dialect/Vector/Transforms/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":ArithmeticDialect", ":ArithDialect",
":ArithmeticUtils", ":ArithUtils",
":BufferizationDialect", ":BufferizationDialect",
":BufferizationTransforms", ":BufferizationTransforms",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LinalgDialect", ":LinalgDialect",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
Show All 18 Linescc_library(
), ),
hdrs = glob([ hdrs = glob([
"include/mlir/Dialect/Vector/Utils/*.h", "include/mlir/Dialect/Vector/Utils/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineAnalysis", ":AffineAnalysis",
":AffineDialect", ":AffineDialect",
":ArithmeticDialect", ":ArithDialect",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":Support", ":Support",
":TensorDialect", ":TensorDialect",
":VectorDialect", ":VectorDialect",
"//llvm:Support", "//llvm:Support",
], ],
▲ Show 20 Lines • Show All 384 Lines • ▼ Show 20 Lines srcs = glob(
[ [
"lib/Dialect/GPU/IR/*.cpp", "lib/Dialect/GPU/IR/*.cpp",
"lib/Dialect/GPU/IR/*.h", "lib/Dialect/GPU/IR/*.h",
], ],
), ),
hdrs = glob(["include/mlir/Dialect/GPU/IR/*.h"]), hdrs = glob(["include/mlir/Dialect/GPU/IR/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":DLTIDialect", ":DLTIDialect",
":GPUBaseIncGen", ":GPUBaseIncGen",
":GPUOpsIncGen", ":GPUOpsIncGen",
":IR", ":IR",
":InferIntRangeInterface", ":InferIntRangeInterface",
":InferTypeOpInterface", ":InferTypeOpInterface",
":LLVMDialect", ":LLVMDialect",
":MemRefDialect", ":MemRefDialect",
Show All 40 Lines srcs = glob(
"lib/Dialect/GPU/Transforms/*.cpp", "lib/Dialect/GPU/Transforms/*.cpp",
"lib/Dialect/GPU/Transforms/*.h", "lib/Dialect/GPU/Transforms/*.h",
], ],
), ),
hdrs = glob(["include/mlir/Dialect/GPU/Transforms/*.h"]), hdrs = glob(["include/mlir/Dialect/GPU/Transforms/*.h"]),
defines = if_cuda_available(["MLIR_GPU_TO_CUBIN_PASS_ENABLE"]), defines = if_cuda_available(["MLIR_GPU_TO_CUBIN_PASS_ENABLE"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":AsmParser", ":AsmParser",
":AsyncDialect", ":AsyncDialect",
":ControlFlowDialect", ":ControlFlowDialect",
":DLTIDialect", ":DLTIDialect",
":AffineUtils", ":AffineUtils",
":GPUDialect", ":GPUDialect",
":GPUPassIncGen", ":GPUPassIncGen",
":MemRefDialect", ":MemRefDialect",
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines srcs = glob([
"lib/Conversion/GPUToNVVM/*.cpp", "lib/Conversion/GPUToNVVM/*.cpp",
"lib/Conversion/GPUToNVVM/*.h", "lib/Conversion/GPUToNVVM/*.h",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/GPUToNVVM/*.h", "include/mlir/Conversion/GPUToNVVM/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ArithmeticToLLVM", ":ArithToLLVM",
":ControlFlowDialect", ":ControlFlowDialect",
":ControlFlowToLLVM", ":ControlFlowToLLVM",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":FuncToLLVM", ":FuncToLLVM",
":GPUCommonTransforms", ":GPUCommonTransforms",
":GPUDialect", ":GPUDialect",
":GPUToNVVMGen", ":GPUToNVVMGen",
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Linescc_library(
srcs = [ srcs = [
"include/mlir/Conversion/GPUToROCDL/Runtimes.h", "include/mlir/Conversion/GPUToROCDL/Runtimes.h",
"lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp", "lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp",
], ],
hdrs = ["include/mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h"], hdrs = ["include/mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AMDGPUToROCDL", ":AMDGPUToROCDL",
":ArithmeticToLLVM", ":ArithToLLVM",
":ControlFlowToLLVM", ":ControlFlowToLLVM",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":FuncToLLVM", ":FuncToLLVM",
":GPUCommonTransforms", ":GPUCommonTransforms",
":GPUDialect", ":GPUDialect",
":GPUToROCDLTGen", ":GPUToROCDLTGen",
":GPUTransforms", ":GPUTransforms",
Show All 36 Lines
cc_library( cc_library(
name = "GPUToGPURuntimeTransforms", name = "GPUToGPURuntimeTransforms",
srcs = [ srcs = [
"lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp", "lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp",
], ],
hdrs = ["include/mlir/Conversion/GPUCommon/GPUCommonPass.h"], hdrs = ["include/mlir/Conversion/GPUCommon/GPUCommonPass.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticToLLVM", ":ArithToLLVM",
":AsyncDialect", ":AsyncDialect",
":AsyncToLLVM", ":AsyncToLLVM",
":ControlFlowToLLVM", ":ControlFlowToLLVM",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncToLLVM", ":FuncToLLVM",
":GPUDialect", ":GPUDialect",
":GPUTransforms", ":GPUTransforms",
":IR", ":IR",
Show All 17 Linescc_library(
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/GPUToSPIRV/*.h", "include/mlir/Conversion/GPUToSPIRV/*.h",
]), ]),
includes = [ includes = [
"include", "include",
"lib/Conversions/GPUToSPIRV", "lib/Conversions/GPUToSPIRV",
], ],
deps = [ deps = [
":ArithmeticToSPIRV", ":ArithToSPIRV",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncToSPIRV", ":FuncToSPIRV",
":GPUDialect", ":GPUDialect",
":IR", ":IR",
":MemRefToSPIRV", ":MemRefToSPIRV",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
":SCFToSPIRV", ":SCFToSPIRV",
Show All 31 Linescc_library(
srcs = glob([ srcs = glob([
"lib/Conversion/SPIRVToLLVM/*.cpp", "lib/Conversion/SPIRVToLLVM/*.cpp",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/SPIRVToLLVM/*.h", "include/mlir/Conversion/SPIRVToLLVM/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticToLLVM", ":ArithToLLVM",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":FuncToLLVM", ":FuncToLLVM",
":GPUDialect", ":GPUDialect",
":IR", ":IR",
":LLVMCommonConversion", ":LLVMCommonConversion",
":LLVMDialect", ":LLVMDialect",
":MemRefToLLVM", ":MemRefToLLVM",
▲ Show 20 Lines • Show All 733 Lines • ▼ Show 20 Linescc_library(
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/TensorToLinalg/*.h", "include/mlir/Conversion/TensorToLinalg/*.h",
]), ]),
includes = [ includes = [
"include", "include",
"lib/Conversion/TensorToLinalg", "lib/Conversion/TensorToLinalg",
], ],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LinalgDialect", ":LinalgDialect",
":LinalgTransforms", ":LinalgTransforms",
":Pass", ":Pass",
":Support", ":Support",
":TensorDialect", ":TensorDialect",
Show All 12 Linescc_library(
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/TensorToSPIRV/*.h", "include/mlir/Conversion/TensorToSPIRV/*.h",
]), ]),
includes = [ includes = [
"include", "include",
"lib/Conversion/TensorToSPIRV", "lib/Conversion/TensorToSPIRV",
], ],
deps = [ deps = [
":ArithmeticToSPIRV", ":ArithToSPIRV",
":ControlFlowToSPIRV", ":ControlFlowToSPIRV",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":FuncToSPIRV", ":FuncToSPIRV",
":IR", ":IR",
":MathToSPIRV", ":MathToSPIRV",
":Pass", ":Pass",
":SPIRVCommonConversion", ":SPIRVCommonConversion",
▲ Show 20 Lines • Show All 153 Lines • ▼ Show 20 Linescc_library(
srcs = [ srcs = [
"include/mlir/Transforms/InliningUtils.h", "include/mlir/Transforms/InliningUtils.h",
"lib/Dialect/Tensor/IR/TensorDialect.cpp", "lib/Dialect/Tensor/IR/TensorDialect.cpp",
"lib/Dialect/Tensor/IR/TensorOps.cpp", "lib/Dialect/Tensor/IR/TensorOps.cpp",
], ],
hdrs = ["include/mlir/Dialect/Tensor/IR/Tensor.h"], hdrs = ["include/mlir/Dialect/Tensor/IR/Tensor.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ArithmeticUtils", ":ArithUtils",
":CastOpInterfaces", ":CastOpInterfaces",
":ComplexDialect", ":ComplexDialect",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":DialectUtils", ":DialectUtils",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
":ParallelCombiningOpInterface", ":ParallelCombiningOpInterface",
":SideEffectInterfaces", ":SideEffectInterfaces",
Show All 21 Lines
cc_library( cc_library(
name = "TensorTilingInterfaceImpl", name = "TensorTilingInterfaceImpl",
srcs = ["lib/Dialect/Tensor/IR/TensorTilingInterfaceImpl.cpp"], srcs = ["lib/Dialect/Tensor/IR/TensorTilingInterfaceImpl.cpp"],
hdrs = ["include/mlir/Dialect/Tensor/IR/TensorTilingInterfaceImpl.h"], hdrs = ["include/mlir/Dialect/Tensor/IR/TensorTilingInterfaceImpl.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":ArithmeticUtils", ":ArithUtils",
":IR", ":IR",
":LinalgDialect", ":LinalgDialect",
":SCFDialect", ":SCFDialect",
":TensorDialect", ":TensorDialect",
":TilingInterface", ":TilingInterface",
"//llvm:Support", "//llvm:Support",
], ],
) )
cc_library( cc_library(
name = "TensorUtils", name = "TensorUtils",
srcs = ["lib/Dialect/Tensor/Utils/Utils.cpp"], srcs = ["lib/Dialect/Tensor/Utils/Utils.cpp"],
hdrs = ["include/mlir/Dialect/Tensor/Utils/Utils.h"], hdrs = ["include/mlir/Dialect/Tensor/Utils/Utils.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":ArithmeticDialect", ":ArithDialect",
":TensorDialect", ":TensorDialect",
"//llvm:Support", "//llvm:Support",
], ],
) )
gentbl_cc_library( gentbl_cc_library(
name = "TensorPassIncGen", name = "TensorPassIncGen",
strip_include_prefix = "include", strip_include_prefix = "include",
Show All 24 Lines hdrs = [
"include/mlir/Dialect/Tensor/Transforms/Passes.h", "include/mlir/Dialect/Tensor/Transforms/Passes.h",
"include/mlir/Dialect/Tensor/Transforms/TransformUtils.h", "include/mlir/Dialect/Tensor/Transforms/TransformUtils.h",
"include/mlir/Dialect/Tensor/Transforms/Transforms.h", "include/mlir/Dialect/Tensor/Transforms/Transforms.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":AffineUtils", ":AffineUtils",
":ArithmeticDialect", ":ArithDialect",
":ArithmeticUtils", ":ArithUtils",
":BufferizationDialect", ":BufferizationDialect",
":BufferizationTransforms", ":BufferizationTransforms",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
▲ Show 20 Lines • Show All 310 Lines • ▼ Show 20 Lines
cc_library( cc_library(
name = "SCFToGPU", name = "SCFToGPU",
srcs = glob(["lib/Conversion/SCFToGPU/*.cpp"]), srcs = glob(["lib/Conversion/SCFToGPU/*.cpp"]),
hdrs = glob(["include/mlir/Conversion/SCFToGPU/*.h"]), hdrs = glob(["include/mlir/Conversion/SCFToGPU/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":AffineToStandard", ":AffineToStandard",
":ArithmeticDialect", ":ArithDialect",
":ComplexDialect", ":ComplexDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":GPUDialect", ":GPUDialect",
":GPUTransforms", ":GPUTransforms",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
Show All 12 Lines srcs = glob([
"lib/Conversion/SCFToSPIRV/*.h", "lib/Conversion/SCFToSPIRV/*.h",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/SCFToSPIRV/*.h", "include/mlir/Conversion/SCFToSPIRV/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":ArithmeticToSPIRV", ":ArithToSPIRV",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":FuncToSPIRV", ":FuncToSPIRV",
":IR", ":IR",
":MemRefToSPIRV", ":MemRefToSPIRV",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
":SPIRVConversion", ":SPIRVConversion",
Show All 10 Linescc_library(
srcs = [ srcs = [
"lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp", "lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp",
], ],
hdrs = ["include/mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h"], hdrs = ["include/mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineAnalysis", ":AffineAnalysis",
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LLVMDialect", ":LLVMDialect",
":MemRefDialect", ":MemRefDialect",
":OpenMPDialect", ":OpenMPDialect",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
":Support", ":Support",
":Transforms", ":Transforms",
], ],
) )
cc_library( cc_library(
name = "SCFToControlFlow", name = "SCFToControlFlow",
srcs = [ srcs = [
"lib/Conversion/SCFToControlFlow/SCFToControlFlow.cpp", "lib/Conversion/SCFToControlFlow/SCFToControlFlow.cpp",
], ],
hdrs = ["include/mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"], hdrs = ["include/mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ControlFlowDialect", ":ControlFlowDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LLVMDialect", ":LLVMDialect",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
":Support", ":Support",
Show All 38 Linescc_library(
], ],
hdrs = [ hdrs = [
"include/mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h", "include/mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h",
"include/mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h", "include/mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":Analysis", ":Analysis",
":ArithmeticToLLVM", ":ArithToLLVM",
":ControlFlowToLLVM", ":ControlFlowToLLVM",
":ConversionPassIncGen", ":ConversionPassIncGen",
":DataLayoutInterfaces", ":DataLayoutInterfaces",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":FuncTransforms", ":FuncTransforms",
":IR", ":IR",
":LLVMCommonConversion", ":LLVMCommonConversion",
Show All 16 Lines srcs = [
"lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp", "lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp",
], ],
hdrs = [ hdrs = [
"include/mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h", "include/mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":Analysis", ":Analysis",
":ArithmeticToLLVM", ":ArithToLLVM",
":ControlFlowDialect", ":ControlFlowDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":DataLayoutInterfaces", ":DataLayoutInterfaces",
":DialectUtils", ":DialectUtils",
":IR", ":IR",
":LLVMCommonConversion", ":LLVMCommonConversion",
":LLVMDialect", ":LLVMDialect",
":MathDialect", ":MathDialect",
Show All 30 Lines
cc_library( cc_library(
name = "MemRefToLLVM", name = "MemRefToLLVM",
srcs = glob(["lib/Conversion/MemRefToLLVM/*.cpp"]), srcs = glob(["lib/Conversion/MemRefToLLVM/*.cpp"]),
hdrs = glob(["include/mlir/Conversion/MemRefToLLVM/*.h"]), hdrs = glob(["include/mlir/Conversion/MemRefToLLVM/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":DataLayoutInterfaces", ":DataLayoutInterfaces",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LLVMCommonConversion", ":LLVMCommonConversion",
":LLVMDialect", ":LLVMDialect",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
Show All 26 Lines deps = [
":SPIRVDialect", ":SPIRVDialect",
":Support", ":Support",
":Transforms", ":Transforms",
"//llvm:Support", "//llvm:Support",
], ],
) )
cc_library( cc_library(
name = "ArithmeticToLLVM", name = "ArithToLLVM",
srcs = glob(["lib/Conversion/ArithmeticToLLVM/*.cpp"]), srcs = glob(["lib/Conversion/ArithToLLVM/*.cpp"]),
hdrs = glob(["include/mlir/Conversion/ArithmeticToLLVM/*.h"]), hdrs = glob(["include/mlir/Conversion/ArithToLLVM/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":IR", ":IR",
":LLVMCommonConversion", ":LLVMCommonConversion",
":LLVMDialect", ":LLVMDialect",
":Pass", ":Pass",
":Support", ":Support",
":Transforms", ":Transforms",
], ],
) )
cc_library( cc_library(
name = "ArithmeticToSPIRV", name = "ArithToSPIRV",
srcs = glob(["lib/Conversion/ArithmeticToSPIRV/*.cpp"]), srcs = glob(["lib/Conversion/ArithToSPIRV/*.cpp"]),
hdrs = glob(["include/mlir/Conversion/ArithmeticToSPIRV/*.h"]), hdrs = glob(["include/mlir/Conversion/ArithToSPIRV/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncToSPIRV", ":FuncToSPIRV",
":IR", ":IR",
":Pass", ":Pass",
":SPIRVCommonConversion", ":SPIRVCommonConversion",
":SPIRVConversion", ":SPIRVConversion",
":SPIRVDialect", ":SPIRVDialect",
":Support", ":Support",
Show All 22 Lines
) )
cc_library( cc_library(
name = "MathToFuncs", name = "MathToFuncs",
srcs = glob(["lib/Conversion/MathToFuncs/*.cpp"]), srcs = glob(["lib/Conversion/MathToFuncs/*.cpp"]),
hdrs = glob(["include/mlir/Conversion/MathToFuncs/*.h"]), hdrs = glob(["include/mlir/Conversion/MathToFuncs/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ControlFlowDialect", ":ControlFlowDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LLVMDialect", ":LLVMDialect",
":MathDialect", ":MathDialect",
":Pass", ":Pass",
▲ Show 20 Lines • Show All 186 Lines • ▼ Show 20 Linescc_library(
hdrs = glob( hdrs = glob(
[ [
"include/mlir/Analysis/*.h", "include/mlir/Analysis/*.h",
"include/mlir/Analysis/*/*.h", "include/mlir/Analysis/*/*.h",
], ],
), ),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":CallOpInterfaces", ":CallOpInterfaces",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":DataLayoutInterfaces", ":DataLayoutInterfaces",
":IR", ":IR",
":InferIntRangeInterface", ":InferIntRangeInterface",
":LoopLikeInterface", ":LoopLikeInterface",
":SideEffectInterfaces", ":SideEffectInterfaces",
":Support", ":Support",
▲ Show 20 Lines • Show All 351 Lines • ▼ Show 20 Lines deps = [
":AMDGPUDialect", ":AMDGPUDialect",
":AMDGPUToROCDL", ":AMDGPUToROCDL",
":AMXDialect", ":AMXDialect",
":AMXTransforms", ":AMXTransforms",
":AffineDialect", ":AffineDialect",
":AffinePassIncGen", ":AffinePassIncGen",
":AffineToStandard", ":AffineToStandard",
":AffineTransforms", ":AffineTransforms",
":ArithmeticDialect", ":ArithDialect",
":ArithmeticToLLVM", ":ArithToLLVM",
":ArithmeticToSPIRV", ":ArithToSPIRV",
":ArithmeticTransforms", ":ArithTransforms",
":ArmNeonDialect", ":ArmNeonDialect",
":ArmSVEDialect", ":ArmSVEDialect",
":ArmSVETransforms", ":ArmSVETransforms",
":AsyncDialect", ":AsyncDialect",
":AsyncPassIncGen", ":AsyncPassIncGen",
":AsyncToLLVM", ":AsyncToLLVM",
":AsyncTransforms", ":AsyncTransforms",
":BufferizationDialect", ":BufferizationDialect",
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Lines deps = [
":QuantOps", ":QuantOps",
":SCFToGPU", ":SCFToGPU",
":Support", ":Support",
":Transforms", ":Transforms",
"//llvm:AllTargetsCodeGens", "//llvm:AllTargetsCodeGens",
"//llvm:Support", "//llvm:Support",
"//mlir/test:TestAffine", "//mlir/test:TestAffine",
"//mlir/test:TestAnalysis", "//mlir/test:TestAnalysis",
"//mlir/test:TestArithmetic", "//mlir/test:TestArith",
"//mlir/test:TestDLTI", "//mlir/test:TestDLTI",
"//mlir/test:TestDialect", "//mlir/test:TestDialect",
"//mlir/test:TestFunc", "//mlir/test:TestFunc",
"//mlir/test:TestFuncToLLVM", "//mlir/test:TestFuncToLLVM",
"//mlir/test:TestGPU", "//mlir/test:TestGPU",
"//mlir/test:TestIR", "//mlir/test:TestIR",
"//mlir/test:TestLinalg", "//mlir/test:TestLinalg",
"//mlir/test:TestMath", "//mlir/test:TestMath",
▲ Show 20 Lines • Show All 224 Lines • ▼ Show 20 Lines deps = [
"//llvm:Support", "//llvm:Support",
], ],
) )
cc_binary( cc_binary(
name = "mlir-vulkan-runner", name = "mlir-vulkan-runner",
srcs = ["tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp"], srcs = ["tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ExecutionEngineUtils", ":ExecutionEngineUtils",
":FuncDialect", ":FuncDialect",
":FuncToLLVM", ":FuncToLLVM",
":FuncToSPIRV", ":FuncToSPIRV",
":GPUDialect", ":GPUDialect",
":GPUToSPIRV", ":GPUToSPIRV",
":GPUToVulkanTransforms", ":GPUToVulkanTransforms",
":GPUTransforms", ":GPUTransforms",
Show All 13 Lines deps = [
"//llvm:Support", "//llvm:Support",
], ],
) )
cc_binary( cc_binary(
name = "mlir-spirv-cpu-runner", name = "mlir-spirv-cpu-runner",
srcs = ["tools/mlir-spirv-cpu-runner/mlir-spirv-cpu-runner.cpp"], srcs = ["tools/mlir-spirv-cpu-runner/mlir-spirv-cpu-runner.cpp"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ExecutionEngineUtils", ":ExecutionEngineUtils",
":FuncDialect", ":FuncDialect",
":FuncToLLVM", ":FuncToLLVM",
":GPUDialect", ":GPUDialect",
":GPUToSPIRV", ":GPUToSPIRV",
":GPUTransforms", ":GPUTransforms",
":LLVMDialect", ":LLVMDialect",
":LLVMToLLVMIRTranslation", ":LLVMToLLVMIRTranslation",
▲ Show 20 Lines • Show All 337 Lines • ▼ Show 20 Lines srcs = glob([
"lib/Conversion/OpenACCToSCF/*.cpp", "lib/Conversion/OpenACCToSCF/*.cpp",
"lib/Conversion/OpenACCToSCF/*.h", "lib/Conversion/OpenACCToSCF/*.h",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/OpenACCToSCF/*.h", "include/mlir/Conversion/OpenACCToSCF/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":OpenACCDialect", ":OpenACCDialect",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
":Transforms", ":Transforms",
], ],
Show All 29 Lines srcs = glob([
"lib/Conversion/OpenMPToLLVM/*.cpp", "lib/Conversion/OpenMPToLLVM/*.cpp",
"lib/Conversion/OpenMPToLLVM/*.h", "lib/Conversion/OpenMPToLLVM/*.h",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/OpenMPToLLVM/*.h", "include/mlir/Conversion/OpenMPToLLVM/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticToLLVM", ":ArithToLLVM",
":ControlFlowToLLVM", ":ControlFlowToLLVM",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":FuncToLLVM", ":FuncToLLVM",
":IR", ":IR",
":LLVMCommonConversion", ":LLVMCommonConversion",
":LLVMDialect", ":LLVMDialect",
":MemRefToLLVM", ":MemRefToLLVM",
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Linescc_library(
hdrs = [ hdrs = [
"include/mlir/Dialect/Quant/FakeQuantSupport.h", "include/mlir/Dialect/Quant/FakeQuantSupport.h",
"include/mlir/Dialect/Quant/QuantOps.h", "include/mlir/Dialect/Quant/QuantOps.h",
"include/mlir/Dialect/Quant/QuantTypes.h", "include/mlir/Dialect/Quant/QuantTypes.h",
"include/mlir/Dialect/Quant/UniformSupport.h", "include/mlir/Dialect/Quant/UniformSupport.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
":Pass", ":Pass",
":QuantOpsIncGen", ":QuantOpsIncGen",
":SideEffectInterfaces", ":SideEffectInterfaces",
":TransformUtils", ":TransformUtils",
"//llvm:Support", "//llvm:Support",
▲ Show 20 Lines • Show All 329 Lines • ▼ Show 20 Lines
cc_library( cc_library(
name = "LinalgDialect", name = "LinalgDialect",
srcs = glob(["lib/Dialect/Linalg/IR/*.cpp"]), srcs = glob(["lib/Dialect/Linalg/IR/*.cpp"]),
hdrs = glob(["include/mlir/Dialect/Linalg/IR/*.h"]), hdrs = glob(["include/mlir/Dialect/Linalg/IR/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":ArithmeticDialect", ":ArithDialect",
":ArithmeticUtils", ":ArithUtils",
":AsmParser", ":AsmParser",
":BufferizationDialect", ":BufferizationDialect",
":ComplexDialect", ":ComplexDialect",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":CopyOpInterface", ":CopyOpInterface",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
Show All 23 Lines srcs = [
"lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp", "lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp",
], ],
hdrs = [ hdrs = [
"include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.h", "include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":ArithmeticDialect", ":ArithDialect",
":AsmParser", ":AsmParser",
":ControlFlowDialect", ":ControlFlowDialect",
":GPUDialect", ":GPUDialect",
":IR", ":IR",
":LinalgDialect", ":LinalgDialect",
":LinalgTransformOpsIncGen", ":LinalgTransformOpsIncGen",
":LinalgTransforms", ":LinalgTransforms",
":PDLDialect", ":PDLDialect",
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linescc_library(
hdrs = glob([ hdrs = glob([
"include/mlir/Dialect/Linalg/Utils/*.h", "include/mlir/Dialect/Linalg/Utils/*.h",
]), ]),
deps = [ deps = [
":AffineAnalysis", ":AffineAnalysis",
":AffineDialect", ":AffineDialect",
":AffineUtils", ":AffineUtils",
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":ArithmeticUtils", ":ArithUtils",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LinalgAnalysis", ":LinalgAnalysis",
":LinalgDialect", ":LinalgDialect",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
Show All 15 Lines ] + glob([
"include/mlir/Dialect/Linalg/Transforms/*.h", "include/mlir/Dialect/Linalg/Transforms/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineAnalysis", ":AffineAnalysis",
":AffineDialect", ":AffineDialect",
":AffineUtils", ":AffineUtils",
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":ArithmeticTransforms", ":ArithTransforms",
":ArithmeticUtils", ":ArithUtils",
":BufferizationDialect", ":BufferizationDialect",
":BufferizationTransforms", ":BufferizationTransforms",
":ComplexDialect", ":ComplexDialect",
":ControlFlowDialect", ":ControlFlowDialect",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":FuncTransforms", ":FuncTransforms",
":IR", ":IR",
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Linescc_library(
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/VectorToLLVM/*.h", "include/mlir/Conversion/VectorToLLVM/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AMXDialect", ":AMXDialect",
":AMXTransforms", ":AMXTransforms",
":ArithmeticDialect", ":ArithDialect",
":ArithmeticUtils", ":ArithUtils",
":ArmNeonDialect", ":ArmNeonDialect",
":ArmSVEDialect", ":ArmSVEDialect",
":ArmSVETransforms", ":ArmSVETransforms",
":ConversionPassIncGen", ":ConversionPassIncGen",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LLVMCommonConversion", ":LLVMCommonConversion",
Show All 20 Linescc_library(
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/VectorToGPU/*.h", "include/mlir/Conversion/VectorToGPU/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":FuncToLLVM", ":FuncToLLVM",
":GPUDialect", ":GPUDialect",
":IR", ":IR",
":LLVMDialect", ":LLVMDialect",
":MemRefDialect", ":MemRefDialect",
Show All 18 Linescc_library(
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/VectorToSCF/*.h", "include/mlir/Conversion/VectorToSCF/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":AffineUtils", ":AffineUtils",
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":FuncToLLVM", ":FuncToLLVM",
":IR", ":IR",
":LLVMDialect", ":LLVMDialect",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Linescc_library(
hdrs = glob([ hdrs = glob([
"include/mlir/Dialect/Tosa/IR/*.h", "include/mlir/Dialect/Tosa/IR/*.h",
"include/mlir/Dialect/Tosa/Utils/*.h", "include/mlir/Dialect/Tosa/Utils/*.h",
"include/mlir/Dialect/Tosa/Transforms/*.h", "include/mlir/Dialect/Tosa/Transforms/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":Dialect", ":Dialect",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
":LoopLikeInterface", ":LoopLikeInterface",
":Pass", ":Pass",
":QuantOps", ":QuantOps",
Show All 15 Linescc_library(
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/TosaToArith/*.h", "include/mlir/Conversion/TosaToArith/*.h",
]), ]),
includes = [ includes = [
"include", "include",
"lib/Conversion/TosaToArith", "lib/Conversion/TosaToArith",
], ],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":Pass", ":Pass",
":TosaDialect", ":TosaDialect",
":Transforms", ":Transforms",
], ],
) )
cc_library( cc_library(
name = "TosaToLinalg", name = "TosaToLinalg",
srcs = glob([ srcs = glob([
"lib/Conversion/TosaToLinalg/*.cpp", "lib/Conversion/TosaToLinalg/*.cpp",
"lib/Conversion/TosaToLinalg/*.h", "lib/Conversion/TosaToLinalg/*.h",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/TosaToLinalg/*.h", "include/mlir/Conversion/TosaToLinalg/*.h",
]), ]),
includes = [ includes = [
"include", "include",
"lib/Conversion/TosaToLinalg", "lib/Conversion/TosaToLinalg",
], ],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LinalgDialect", ":LinalgDialect",
":MathDialect", ":MathDialect",
":Pass", ":Pass",
":SCFDialect", ":SCFDialect",
Show All 38 Linescc_library(
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/TosaToTensor/*.h", "include/mlir/Conversion/TosaToTensor/*.h",
]), ]),
includes = [ includes = [
"include", "include",
"lib/Conversion/TosaToTensor", "lib/Conversion/TosaToTensor",
], ],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":Pass", ":Pass",
":TensorDialect", ":TensorDialect",
":TosaDialect", ":TosaDialect",
":Transforms", ":Transforms",
], ],
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 Lines srcs = glob(
[ [
"lib/Dialect/Complex/IR/*.cpp", "lib/Dialect/Complex/IR/*.cpp",
"lib/Dialect/Complex/IR/*.h", "lib/Dialect/Complex/IR/*.h",
], ],
), ),
hdrs = ["include/mlir/Dialect/Complex/IR/Complex.h"], hdrs = ["include/mlir/Dialect/Complex/IR/Complex.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ComplexAttributesIncGen", ":ComplexAttributesIncGen",
":ComplexBaseIncGen", ":ComplexBaseIncGen",
":ComplexOpsIncGen", ":ComplexOpsIncGen",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
":SideEffectInterfaces", ":SideEffectInterfaces",
"//llvm:Support", "//llvm:Support",
], ],
) )
cc_library( cc_library(
name = "ComplexToLLVM", name = "ComplexToLLVM",
srcs = glob([ srcs = glob([
"lib/Conversion/ComplexToLLVM/*.cpp", "lib/Conversion/ComplexToLLVM/*.cpp",
"lib/Conversion/ComplexToLLVM/*.h", "lib/Conversion/ComplexToLLVM/*.h",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/ComplexToLLVM/*.h", "include/mlir/Conversion/ComplexToLLVM/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ComplexDialect", ":ComplexDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LLVMCommonConversion", ":LLVMCommonConversion",
":LLVMDialect", ":LLVMDialect",
":Pass", ":Pass",
":Support", ":Support",
Show All 33 Lines srcs = glob([
"lib/Conversion/ComplexToStandard/*.cpp", "lib/Conversion/ComplexToStandard/*.cpp",
"lib/Conversion/ComplexToStandard/*.h", "lib/Conversion/ComplexToStandard/*.h",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/ComplexToStandard/*.h", "include/mlir/Conversion/ComplexToStandard/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ComplexDialect", ":ComplexDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MathDialect", ":MathDialect",
":Pass", ":Pass",
":Transforms", ":Transforms",
], ],
) )
exports_files([ exports_files([
"include/mlir/Interfaces/CallInterfaces.h", "include/mlir/Interfaces/CallInterfaces.h",
"include/mlir/Interfaces/CastInterfaces.h", "include/mlir/Interfaces/CastInterfaces.h",
"include/mlir/Interfaces/ControlFlowInterfaces.h", "include/mlir/Interfaces/ControlFlowInterfaces.h",
"include/mlir/Transforms/InliningUtils.h", "include/mlir/Transforms/InliningUtils.h",
]) ])
td_library( td_library(
name = "ArithmeticOpsTdFiles", name = "ArithOpsTdFiles",
srcs = [ srcs = [
"include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td", "include/mlir/Dialect/Arith/IR/ArithBase.td",
"include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td", "include/mlir/Dialect/Arith/IR/ArithOps.td",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":BuiltinDialectTdFiles", ":BuiltinDialectTdFiles",
":CastInterfacesTdFiles", ":CastInterfacesTdFiles",
":InferIntRangeInterfaceTdFiles", ":InferIntRangeInterfaceTdFiles",
":InferTypeOpInterfaceTdFiles", ":InferTypeOpInterfaceTdFiles",
":OpBaseTdFiles", ":OpBaseTdFiles",
":SideEffectInterfacesTdFiles", ":SideEffectInterfacesTdFiles",
":VectorInterfacesTdFiles", ":VectorInterfacesTdFiles",
], ],
) )
gentbl_cc_library( gentbl_cc_library(
name = "ArithmeticBaseIncGen", name = "ArithBaseIncGen",
strip_include_prefix = "include", strip_include_prefix = "include",
tbl_outs = [ tbl_outs = [
( (
[ [
"-gen-dialect-decls", "-gen-dialect-decls",
"-dialect=arith", "-dialect=arith",
], ],
"include/mlir/Dialect/Arithmetic/IR/ArithmeticOpsDialect.h.inc", "include/mlir/Dialect/Arith/IR/ArithOpsDialect.h.inc",
), ),
( (
[ [
"-gen-dialect-defs", "-gen-dialect-defs",
"-dialect=arith", "-dialect=arith",
], ],
"include/mlir/Dialect/Arithmetic/IR/ArithmeticOpsDialect.cpp.inc", "include/mlir/Dialect/Arith/IR/ArithOpsDialect.cpp.inc",
), ),
( (
["-gen-enum-decls"], ["-gen-enum-decls"],
"include/mlir/Dialect/Arithmetic/IR/ArithmeticOpsEnums.h.inc", "include/mlir/Dialect/Arith/IR/ArithOpsEnums.h.inc",
), ),
( (
["-gen-enum-defs"], ["-gen-enum-defs"],
"include/mlir/Dialect/Arithmetic/IR/ArithmeticOpsEnums.cpp.inc", "include/mlir/Dialect/Arith/IR/ArithOpsEnums.cpp.inc",
), ),
], ],
tblgen = ":mlir-tblgen", tblgen = ":mlir-tblgen",
td_file = "include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td", td_file = "include/mlir/Dialect/Arith/IR/ArithBase.td",
deps = [":ArithmeticOpsTdFiles"], deps = [":ArithOpsTdFiles"],
) )
gentbl_cc_library( gentbl_cc_library(
name = "ArithmeticOpsIncGen", name = "ArithOpsIncGen",
strip_include_prefix = "include", strip_include_prefix = "include",
tbl_outs = [ tbl_outs = [
( (
["-gen-op-decls"], ["-gen-op-decls"],
"include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.h.inc", "include/mlir/Dialect/Arith/IR/ArithOps.h.inc",
), ),
( (
["-gen-op-defs"], ["-gen-op-defs"],
"include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc", "include/mlir/Dialect/Arith/IR/ArithOps.cpp.inc",
), ),
], ],
tblgen = ":mlir-tblgen", tblgen = ":mlir-tblgen",
td_file = "include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td", td_file = "include/mlir/Dialect/Arith/IR/ArithOps.td",
deps = [ deps = [
":ArithmeticOpsTdFiles", ":ArithOpsTdFiles",
], ],
) )
gentbl_cc_library( gentbl_cc_library(
name = "ArithmeticCanonicalizationIncGen", name = "ArithCanonicalizationIncGen",
strip_include_prefix = "include/mlir/Dialect/Arithmetic/IR", strip_include_prefix = "include/mlir/Dialect/Arith/IR",
tbl_outs = [ tbl_outs = [
( (
["-gen-rewriters"], ["-gen-rewriters"],
"include/mlir/Dialect/Arithmetic/IR/ArithmeticCanonicalization.inc", "include/mlir/Dialect/Arith/IR/ArithCanonicalization.inc",
), ),
], ],
tblgen = ":mlir-tblgen", tblgen = ":mlir-tblgen",
td_file = "lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.td", td_file = "lib/Dialect/Arith/IR/ArithCanonicalization.td",
deps = [ deps = [
":ArithmeticOpsTdFiles", ":ArithOpsTdFiles",
":CastInterfacesTdFiles", ":CastInterfacesTdFiles",
":FuncTdFiles", ":FuncTdFiles",
], ],
) )
cc_library( cc_library(
name = "ArithmeticDialect", name = "ArithDialect",
srcs = glob( srcs = glob(
[ [
"lib/Dialect/Arithmetic/IR/*.cpp", "lib/Dialect/Arith/IR/*.cpp",
"lib/Dialect/Arithmetic/IR/*.h", "lib/Dialect/Arith/IR/*.h",
], ],
), ),
hdrs = [ hdrs = [
"include/mlir/Dialect/Arithmetic/IR/Arithmetic.h", "include/mlir/Dialect/Arith/IR/Arith.h",
"include/mlir/Transforms/InliningUtils.h", "include/mlir/Transforms/InliningUtils.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticBaseIncGen", ":ArithBaseIncGen",
":ArithmeticCanonicalizationIncGen", ":ArithCanonicalizationIncGen",
":ArithmeticOpsIncGen", ":ArithOpsIncGen",
":CommonFolders", ":CommonFolders",
":IR", ":IR",
":InferIntRangeInterface", ":InferIntRangeInterface",
":InferTypeOpInterface", ":InferTypeOpInterface",
":SideEffectInterfaces", ":SideEffectInterfaces",
":VectorInterfaces", ":VectorInterfaces",
"//llvm:Support", "//llvm:Support",
], ],
) )
gentbl_cc_library( gentbl_cc_library(
name = "ArithmeticPassIncGen", name = "ArithPassIncGen",
strip_include_prefix = "include", strip_include_prefix = "include",
tbl_outs = [ tbl_outs = [
( (
[ [
"-gen-pass-decls", "-gen-pass-decls",
"-name=Arithmetic", "-name=Arith",
], ],
"include/mlir/Dialect/Arithmetic/Transforms/Passes.h.inc", "include/mlir/Dialect/Arith/Transforms/Passes.h.inc",
), ),
], ],
tblgen = ":mlir-tblgen", tblgen = ":mlir-tblgen",
td_file = "include/mlir/Dialect/Arithmetic/Transforms/Passes.td", td_file = "include/mlir/Dialect/Arith/Transforms/Passes.td",
deps = [":PassBaseTdFiles"], deps = [":PassBaseTdFiles"],
) )
cc_library( cc_library(
name = "ArithmeticTransforms", name = "ArithTransforms",
srcs = glob([ srcs = glob([
"lib/Dialect/Arithmetic/Transforms/*.cpp", "lib/Dialect/Arith/Transforms/*.cpp",
"lib/Dialect/Arithmetic/Transforms/*.h", "lib/Dialect/Arith/Transforms/*.h",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Dialect/Arithmetic/Transforms/*.h", "include/mlir/Dialect/Arith/Transforms/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":ArithmeticPassIncGen", ":ArithPassIncGen",
":ArithmeticUtils", ":ArithUtils",
":BufferizationDialect", ":BufferizationDialect",
":BufferizationTransforms", ":BufferizationTransforms",
":FuncDialect", ":FuncDialect",
":FuncTransforms", ":FuncTransforms",
":IR", ":IR",
":InferIntRangeInterface", ":InferIntRangeInterface",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
":TransformUtils", ":TransformUtils",
":Transforms", ":Transforms",
":VectorDialect", ":VectorDialect",
"//llvm:Support", "//llvm:Support",
], ],
) )
cc_library( cc_library(
name = "ArithmeticUtils", name = "ArithUtils",
srcs = glob([ srcs = glob([
"lib/Dialect/Arithmetic/Utils/*.cpp", "lib/Dialect/Arith/Utils/*.cpp",
]), ]),
hdrs = ["include/mlir/Dialect/Arithmetic/Utils/Utils.h"], hdrs = ["include/mlir/Dialect/Arith/Utils/Utils.h"],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":IR", ":IR",
"//llvm:Support", "//llvm:Support",
], ],
) )
td_library( td_library(
name = "MathOpsTdFiles", name = "MathOpsTdFiles",
srcs = [ srcs = [
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines srcs = glob(
"lib/Dialect/Math/IR/*.h", "lib/Dialect/Math/IR/*.h",
], ],
), ),
hdrs = [ hdrs = [
"include/mlir/Dialect/Math/IR/Math.h", "include/mlir/Dialect/Math/IR/Math.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":CommonFolders", ":CommonFolders",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
":MathBaseIncGen", ":MathBaseIncGen",
":MathOpsIncGen", ":MathOpsIncGen",
":SideEffectInterfaces", ":SideEffectInterfaces",
":VectorInterfaces", ":VectorInterfaces",
"//llvm:Support", "//llvm:Support",
], ],
) )
cc_library( cc_library(
name = "MathTransforms", name = "MathTransforms",
srcs = glob([ srcs = glob([
"lib/Dialect/Math/Transforms/*.cpp", "lib/Dialect/Math/Transforms/*.cpp",
"lib/Dialect/Math/Transforms/*.h", "lib/Dialect/Math/Transforms/*.h",
]), ]),
hdrs = glob(["include/mlir/Dialect/Math/Transforms/*.h"]), hdrs = glob(["include/mlir/Dialect/Math/Transforms/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MathDialect", ":MathDialect",
":SCFDialect", ":SCFDialect",
":Transforms", ":Transforms",
":VectorDialect", ":VectorDialect",
":VectorUtils", ":VectorUtils",
":X86VectorDialect", ":X86VectorDialect",
"//llvm:Support", "//llvm:Support",
], ],
) )
cc_library( cc_library(
name = "MathToLibm", name = "MathToLibm",
srcs = glob([ srcs = glob([
"lib/Conversion/MathToLibm/*.cpp", "lib/Conversion/MathToLibm/*.cpp",
"lib/Conversion/MathToLibm/*.h", "lib/Conversion/MathToLibm/*.h",
]), ]),
hdrs = glob([ hdrs = glob([
"include/mlir/Conversion/MathToLibm/*.h", "include/mlir/Conversion/MathToLibm/*.h",
]), ]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LLVMDialect", ":LLVMDialect",
":MathDialect", ":MathDialect",
":Pass", ":Pass",
":Support", ":Support",
":Transforms", ":Transforms",
":VectorDialect", ":VectorDialect",
":VectorUtils", ":VectorUtils",
"//llvm:Core", "//llvm:Core",
"//llvm:Support", "//llvm:Support",
], ],
) )
td_library( td_library(
name = "MemRefOpsTdFiles", name = "MemRefOpsTdFiles",
srcs = [ srcs = [
"include/mlir/Dialect/MemRef/IR/MemRefBase.td", "include/mlir/Dialect/MemRef/IR/MemRefBase.td",
"include/mlir/Dialect/MemRef/IR/MemRefOps.td", "include/mlir/Dialect/MemRef/IR/MemRefOps.td",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticOpsTdFiles", ":ArithOpsTdFiles",
":CastInterfacesTdFiles", ":CastInterfacesTdFiles",
":ControlFlowInterfacesTdFiles", ":ControlFlowInterfacesTdFiles",
":CopyOpInterfaceTdFiles", ":CopyOpInterfaceTdFiles",
":OpBaseTdFiles", ":OpBaseTdFiles",
":SideEffectInterfacesTdFiles", ":SideEffectInterfacesTdFiles",
":ViewLikeInterfaceTdFiles", ":ViewLikeInterfaceTdFiles",
], ],
) )
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines srcs = glob(
], ],
), ),
hdrs = [ hdrs = [
"include/mlir/Dialect/MemRef/IR/MemRef.h", "include/mlir/Dialect/MemRef/IR/MemRef.h",
"include/mlir/Dialect/MemRef/Utils/MemRefUtils.h", "include/mlir/Dialect/MemRef/Utils/MemRefUtils.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":ArithmeticUtils", ":ArithUtils",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":CopyOpInterface", ":CopyOpInterface",
":DialectUtils", ":DialectUtils",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
":MemRefBaseIncGen", ":MemRefBaseIncGen",
":MemRefOpsIncGen", ":MemRefOpsIncGen",
":ViewLikeInterface", ":ViewLikeInterface",
Show All 26 Lines srcs = glob(
"lib/Dialect/MemRef/Transforms/*.h", "lib/Dialect/MemRef/Transforms/*.h",
], ],
), ),
hdrs = glob(["include/mlir/Dialect/MemRef/Transforms/*.h"]), hdrs = glob(["include/mlir/Dialect/MemRef/Transforms/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":AffineUtils", ":AffineUtils",
":ArithmeticDialect", ":ArithDialect",
":ArithmeticTransforms", ":ArithTransforms",
":ArithmeticUtils", ":ArithUtils",
":DialectUtils", ":DialectUtils",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
":LoopLikeInterface", ":LoopLikeInterface",
":MemRefDialect", ":MemRefDialect",
":MemRefPassIncGen", ":MemRefPassIncGen",
":Pass", ":Pass",
Show All 38 Lines
cc_library( cc_library(
name = "MemRefTransformOps", name = "MemRefTransformOps",
srcs = glob(["lib/Dialect/MemRef/TransformOps/*.cpp"]), srcs = glob(["lib/Dialect/MemRef/TransformOps/*.cpp"]),
hdrs = glob(["include/mlir/Dialect/MemRef/TransformOps/*.h"]), hdrs = glob(["include/mlir/Dialect/MemRef/TransformOps/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":ArithmeticDialect", ":ArithDialect",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":MemRefTransformOpsIncGen", ":MemRefTransformOpsIncGen",
":MemRefTransforms", ":MemRefTransforms",
":PDLDialect", ":PDLDialect",
":TransformDialect", ":TransformDialect",
"//llvm:Support", "//llvm:Support",
], ],
▲ Show 20 Lines • Show All 273 Lines • ▼ Show 20 Linescc_library(
hdrs = [ hdrs = [
"include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h", "include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h",
"include/mlir/Dialect/Bufferization/IR/Bufferization.h", "include/mlir/Dialect/Bufferization/IR/Bufferization.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AffineDialect", ":AffineDialect",
":AllocationOpInterface", ":AllocationOpInterface",
":ArithmeticDialect", ":ArithDialect",
":BufferizableOpInterfaceIncGen", ":BufferizableOpInterfaceIncGen",
":BufferizationBaseIncGen", ":BufferizationBaseIncGen",
":BufferizationOpsIncGen", ":BufferizationOpsIncGen",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":CopyOpInterface", ":CopyOpInterface",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":InferTypeOpInterface", ":InferTypeOpInterface",
Show All 30 Lines srcs = glob(
"lib/Dialect/Bufferization/Transforms/*.h", "lib/Dialect/Bufferization/Transforms/*.h",
], ],
), ),
hdrs = glob(["include/mlir/Dialect/Bufferization/Transforms/*.h"]), hdrs = glob(["include/mlir/Dialect/Bufferization/Transforms/*.h"]),
includes = ["include"], includes = ["include"],
deps = [ deps = [
":AllocationOpInterface", ":AllocationOpInterface",
":Analysis", ":Analysis",
":ArithmeticDialect", ":ArithDialect",
":BufferizationDialect", ":BufferizationDialect",
":BufferizationPassIncGen", ":BufferizationPassIncGen",
":ControlFlowInterfaces", ":ControlFlowInterfaces",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":LoopLikeInterface", ":LoopLikeInterface",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
Show All 9 Linescc_library(
srcs = [ srcs = [
"lib/Conversion/BufferizationToMemRef/BufferizationToMemRef.cpp", "lib/Conversion/BufferizationToMemRef/BufferizationToMemRef.cpp",
], ],
hdrs = [ hdrs = [
"include/mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h", "include/mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h",
], ],
includes = ["include"], includes = ["include"],
deps = [ deps = [
":ArithmeticDialect", ":ArithDialect",
":BufferizationDialect", ":BufferizationDialect",
":ConversionPassIncGen", ":ConversionPassIncGen",
":FuncDialect", ":FuncDialect",
":IR", ":IR",
":MemRefDialect", ":MemRefDialect",
":Pass", ":Pass",
":Support", ":Support",
":Transforms", ":Transforms",
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

utils/bazel/llvm-project-overlay/mlir/examples/toy/Ch5/BUILD.bazel

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lines deps = [
":ToyCombineIncGen", ":ToyCombineIncGen",
":ToyInterfacesIncGen", ":ToyInterfacesIncGen",
":ToyOpsIncGen", ":ToyOpsIncGen",
"//llvm:Support", "//llvm:Support",
"//mlir:AffineDialect", "//mlir:AffineDialect",
"//mlir:AffineTransforms", "//mlir:AffineTransforms",
"//mlir:AllPassesAndDialects", "//mlir:AllPassesAndDialects",
"//mlir:Analysis", "//mlir:Analysis",
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:CastOpInterfaces", "//mlir:CastOpInterfaces",
"//mlir:FuncDialect", "//mlir:FuncDialect",
"//mlir:IR", "//mlir:IR",
"//mlir:MemRefDialect", "//mlir:MemRefDialect",
"//mlir:Parser", "//mlir:Parser",
"//mlir:Pass", "//mlir:Pass",
"//mlir:SideEffectInterfaces", "//mlir:SideEffectInterfaces",
"//mlir:Support", "//mlir:Support",
"//mlir:TransformUtils", "//mlir:TransformUtils",
"//mlir:Transforms", "//mlir:Transforms",
], ],
) )

utils/bazel/llvm-project-overlay/mlir/examples/toy/Ch6/BUILD.bazel

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines deps = [
":ToyOpsIncGen", ":ToyOpsIncGen",
"//llvm:Core", "//llvm:Core",
"//llvm:Support", "//llvm:Support",
"//mlir:AffineDialect", "//mlir:AffineDialect",
"//mlir:AffineToStandard", "//mlir:AffineToStandard",
"//mlir:AffineTransforms", "//mlir:AffineTransforms",
"//mlir:AllPassesAndDialects", "//mlir:AllPassesAndDialects",
"//mlir:Analysis", "//mlir:Analysis",
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:ArithmeticToLLVM", "//mlir:ArithToLLVM",
"//mlir:CastOpInterfaces", "//mlir:CastOpInterfaces",
"//mlir:ControlFlowToLLVM", "//mlir:ControlFlowToLLVM",
"//mlir:ExecutionEngine", "//mlir:ExecutionEngine",
"//mlir:ExecutionEngineUtils", "//mlir:ExecutionEngineUtils",
"//mlir:FuncDialect", "//mlir:FuncDialect",
"//mlir:FuncToLLVM", "//mlir:FuncToLLVM",
"//mlir:IR", "//mlir:IR",
"//mlir:LLVMCommonConversion", "//mlir:LLVMCommonConversion",
Show All 15 Lines

utils/bazel/llvm-project-overlay/mlir/examples/toy/Ch7/BUILD.bazel

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines deps = [
":ToyOpsIncGen", ":ToyOpsIncGen",
"//llvm:Core", "//llvm:Core",
"//llvm:Support", "//llvm:Support",
"//mlir:AffineDialect", "//mlir:AffineDialect",
"//mlir:AffineToStandard", "//mlir:AffineToStandard",
"//mlir:AffineTransforms", "//mlir:AffineTransforms",
"//mlir:AllPassesAndDialects", "//mlir:AllPassesAndDialects",
"//mlir:Analysis", "//mlir:Analysis",
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:ArithmeticToLLVM", "//mlir:ArithToLLVM",
"//mlir:CastOpInterfaces", "//mlir:CastOpInterfaces",
"//mlir:ControlFlowToLLVM", "//mlir:ControlFlowToLLVM",
"//mlir:ExecutionEngine", "//mlir:ExecutionEngine",
"//mlir:ExecutionEngineUtils", "//mlir:ExecutionEngineUtils",
"//mlir:FuncDialect", "//mlir:FuncDialect",
"//mlir:FuncToLLVM", "//mlir:FuncToLLVM",
"//mlir:IR", "//mlir:IR",
"//mlir:LLVMCommonConversion", "//mlir:LLVMCommonConversion",
Show All 15 Lines

utils/bazel/llvm-project-overlay/mlir/python/BUILD.bazel

Show First 20 Lines • Show All 191 Lines • ▼ Show 20 Lines
) )
filegroup( filegroup(
name = "LinalgOpsPackagePassesPyFiles", name = "LinalgOpsPackagePassesPyFiles",
srcs = glob(["mlir/dialects/linalg/passes/*.py"]), srcs = glob(["mlir/dialects/linalg/passes/*.py"]),
) )
##---------------------------------------------------------------------------## ##---------------------------------------------------------------------------##
# Arithmetic dialect. # Arith dialect.
##---------------------------------------------------------------------------## ##---------------------------------------------------------------------------##
td_library( td_library(
name = "ArithmeticOpsPyTdFiles", name = "ArithOpsPyTdFiles",
srcs = [ srcs = [
"//mlir:include/mlir/Bindings/Python/Attributes.td", "//mlir:include/mlir/Bindings/Python/Attributes.td",
], ],
includes = ["../include"], includes = ["../include"],
deps = [ deps = [
"//mlir:ArithmeticOpsTdFiles", "//mlir:ArithOpsTdFiles",
"//mlir:OpBaseTdFiles", "//mlir:OpBaseTdFiles",
], ],
) )
gentbl_filegroup( gentbl_filegroup(
name = "ArithmeticOpsPyGen", name = "ArithOpsPyGen",
tbl_outs = [ tbl_outs = [
( (
[ [
"-gen-python-op-bindings", "-gen-python-op-bindings",
"-bind-dialect=arith", "-bind-dialect=arith",
], ],
"mlir/dialects/_arith_ops_gen.py", "mlir/dialects/_arith_ops_gen.py",
), ),
], ],
tblgen = "//mlir:mlir-tblgen", tblgen = "//mlir:mlir-tblgen",
td_file = "mlir/dialects/ArithmeticOps.td", td_file = "mlir/dialects/ArithOps.td",
deps = [ deps = [
":ArithmeticOpsPyTdFiles", ":ArithOpsPyTdFiles",
], ],
) )
filegroup( filegroup(
name = "ArithmeticOpsPyFiles", name = "ArithOpsPyFiles",
srcs = [ srcs = [
"mlir/dialects/_arith_ops_ext.py", "mlir/dialects/_arith_ops_ext.py",
"mlir/dialects/arith.py", "mlir/dialects/arith.py",
":ArithmeticOpsPyGen", ":ArithOpsPyGen",
], ],
) )
##---------------------------------------------------------------------------## ##---------------------------------------------------------------------------##
# Bufferization dialect. # Bufferization dialect.
##---------------------------------------------------------------------------## ##---------------------------------------------------------------------------##
td_library( td_library(
▲ Show 20 Lines • Show All 741 Lines • Show Last 20 Lines

utils/bazel/llvm-project-overlay/mlir/test/BUILD.bazel

Show First 20 Lines • Show All 298 Lines • ▼ Show 20 Lines includes = [
"lib/Dialect/Test", "lib/Dialect/Test",
], ],
deps = [ deps = [
":TestAttrDefsIncGen", ":TestAttrDefsIncGen",
":TestInterfacesIncGen", ":TestInterfacesIncGen",
":TestOpsIncGen", ":TestOpsIncGen",
":TestTypeDefsIncGen", ":TestTypeDefsIncGen",
"//llvm:Support", "//llvm:Support",
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:ControlFlowInterfaces", "//mlir:ControlFlowInterfaces",
"//mlir:CopyOpInterface", "//mlir:CopyOpInterface",
"//mlir:DLTIDialect", "//mlir:DLTIDialect",
"//mlir:DataLayoutInterfaces", "//mlir:DataLayoutInterfaces",
"//mlir:DerivedAttributeOpInterface", "//mlir:DerivedAttributeOpInterface",
"//mlir:Dialect", "//mlir:Dialect",
"//mlir:FuncDialect", "//mlir:FuncDialect",
"//mlir:FuncTransforms", "//mlir:FuncTransforms",
Show All 16 Lines
cc_library( cc_library(
name = "TestIR", name = "TestIR",
srcs = glob(["lib/IR/*.cpp"]), srcs = glob(["lib/IR/*.cpp"]),
deps = [ deps = [
":TestDialect", ":TestDialect",
"//llvm:Support", "//llvm:Support",
"//mlir:Analysis", "//mlir:Analysis",
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:FuncDialect", "//mlir:FuncDialect",
"//mlir:IR", "//mlir:IR",
"//mlir:LinalgDialect", "//mlir:LinalgDialect",
"//mlir:Pass", "//mlir:Pass",
"//mlir:Support", "//mlir:Support",
], ],
) )
cc_library( cc_library(
name = "TestTilingInterface", name = "TestTilingInterface",
srcs = glob(["lib/Interfaces/TilingInterface/*.cpp"]), srcs = glob(["lib/Interfaces/TilingInterface/*.cpp"]),
includes = ["lib/Dialect/Test"], includes = ["lib/Dialect/Test"],
deps = [ deps = [
"//llvm:Support", "//llvm:Support",
"//mlir:AffineDialect", "//mlir:AffineDialect",
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:FuncDialect", "//mlir:FuncDialect",
"//mlir:IR", "//mlir:IR",
"//mlir:LinalgDialect", "//mlir:LinalgDialect",
"//mlir:LinalgTransforms", "//mlir:LinalgTransforms",
"//mlir:MemRefDialect", "//mlir:MemRefDialect",
"//mlir:Pass", "//mlir:Pass",
"//mlir:SCFDialect", "//mlir:SCFDialect",
"//mlir:SCFTransforms", "//mlir:SCFTransforms",
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linescc_library(
defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"], defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"],
includes = ["lib/Dialect/Test"], includes = ["lib/Dialect/Test"],
deps = [ deps = [
":TestDialect", ":TestDialect",
"//llvm:Support", "//llvm:Support",
"//mlir:AffineAnalysis", "//mlir:AffineAnalysis",
"//mlir:AffineDialect", "//mlir:AffineDialect",
"//mlir:Analysis", "//mlir:Analysis",
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:FuncDialect", "//mlir:FuncDialect",
"//mlir:IR", "//mlir:IR",
"//mlir:MathDialect", "//mlir:MathDialect",
"//mlir:Pass", "//mlir:Pass",
"//mlir:SCFDialect", "//mlir:SCFDialect",
"//mlir:SPIRVDialect", "//mlir:SPIRVDialect",
"//mlir:Support", "//mlir:Support",
"//mlir:TransformUtils", "//mlir:TransformUtils",
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linescc_library(
name = "TestGPU", name = "TestGPU",
srcs = glob(["lib/Dialect/GPU/*.cpp"]), srcs = glob(["lib/Dialect/GPU/*.cpp"]),
defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"], defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"],
includes = ["lib/Dialect/Test"], includes = ["lib/Dialect/Test"],
deps = [ deps = [
"//llvm:NVPTXCodeGen", "//llvm:NVPTXCodeGen",
"//llvm:Support", "//llvm:Support",
"//mlir:AffineDialect", "//mlir:AffineDialect",
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:FuncDialect", "//mlir:FuncDialect",
"//mlir:GPUDialect", "//mlir:GPUDialect",
"//mlir:GPUTransforms", "//mlir:GPUTransforms",
"//mlir:IR", "//mlir:IR",
"//mlir:MemRefDialect", "//mlir:MemRefDialect",
"//mlir:NVVMToLLVMIRTranslation", "//mlir:NVVMToLLVMIRTranslation",
"//mlir:Pass", "//mlir:Pass",
"//mlir:ROCDLToLLVMIRTranslation", "//mlir:ROCDLToLLVMIRTranslation",
"//mlir:SCFDialect", "//mlir:SCFDialect",
"//mlir:SPIRVDialect", "//mlir:SPIRVDialect",
"//mlir:ToLLVMIRTranslation", "//mlir:ToLLVMIRTranslation",
"//mlir:TransformUtils", "//mlir:TransformUtils",
], ],
) )
cc_library( cc_library(
name = "TestLinalg", name = "TestLinalg",
srcs = glob(["lib/Dialect/Linalg/*.cpp"]), srcs = glob(["lib/Dialect/Linalg/*.cpp"]),
defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"], defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"],
includes = ["lib/Dialect/Test"], includes = ["lib/Dialect/Test"],
deps = [ deps = [
"//llvm:Support", "//llvm:Support",
"//mlir:AffineDialect", "//mlir:AffineDialect",
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:ArithmeticTransforms", "//mlir:ArithTransforms",
"//mlir:BufferizationDialect", "//mlir:BufferizationDialect",
"//mlir:BufferizationTransforms", "//mlir:BufferizationTransforms",
"//mlir:FuncDialect", "//mlir:FuncDialect",
"//mlir:FuncTransforms", "//mlir:FuncTransforms",
"//mlir:GPUDialect", "//mlir:GPUDialect",
"//mlir:IR", "//mlir:IR",
"//mlir:LinalgAnalysis", "//mlir:LinalgAnalysis",
"//mlir:LinalgDialect", "//mlir:LinalgDialect",
Show All 15 Lines
) )
cc_library( cc_library(
name = "TestMath", name = "TestMath",
srcs = glob(["lib/Dialect/Math/*.cpp"]), srcs = glob(["lib/Dialect/Math/*.cpp"]),
defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"], defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"],
includes = ["lib/Dialect/Test"], includes = ["lib/Dialect/Test"],
deps = [ deps = [
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:MathDialect", "//mlir:MathDialect",
"//mlir:MathTransforms", "//mlir:MathTransforms",
"//mlir:Pass", "//mlir:Pass",
"//mlir:SCFDialect", "//mlir:SCFDialect",
"//mlir:TransformUtils", "//mlir:TransformUtils",
"//mlir:VectorDialect", "//mlir:VectorDialect",
"//mlir:X86VectorDialect", "//mlir:X86VectorDialect",
], ],
Show All 40 Lines
cc_library( cc_library(
name = "TestSCF", name = "TestSCF",
srcs = glob(["lib/Dialect/SCF/*.cpp"]), srcs = glob(["lib/Dialect/SCF/*.cpp"]),
defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"], defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"],
includes = ["lib/Dialect/Test"], includes = ["lib/Dialect/Test"],
deps = [ deps = [
"//llvm:Support", "//llvm:Support",
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:FuncDialect", "//mlir:FuncDialect",
"//mlir:IR", "//mlir:IR",
"//mlir:MathDialect", "//mlir:MathDialect",
"//mlir:MemRefDialect", "//mlir:MemRefDialect",
"//mlir:Pass", "//mlir:Pass",
"//mlir:SCFDialect", "//mlir:SCFDialect",
"//mlir:SCFTransforms", "//mlir:SCFTransforms",
"//mlir:SCFUtils", "//mlir:SCFUtils",
"//mlir:TransformUtils", "//mlir:TransformUtils",
], ],
) )
cc_library( cc_library(
name = "TestArithmetic", name = "TestArith",
srcs = glob(["lib/Dialect/Arithmetic/*.cpp"]), srcs = glob(["lib/Dialect/Arith/*.cpp"]),
defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"], defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"],
includes = ["lib/Dialect/Test"], includes = ["lib/Dialect/Test"],
deps = [ deps = [
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:ArithmeticTransforms", "//mlir:ArithTransforms",
"//mlir:FuncDialect", "//mlir:FuncDialect",
"//mlir:LLVMDialect", "//mlir:LLVMDialect",
"//mlir:MathDialect", "//mlir:MathDialect",
"//mlir:Pass", "//mlir:Pass",
"//mlir:Transforms", "//mlir:Transforms",
"//mlir:VectorDialect", "//mlir:VectorDialect",
], ],
) )
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
) )
cc_library( cc_library(
name = "TestTensor", name = "TestTensor",
srcs = glob(["lib/Dialect/Tensor/*.cpp"]), srcs = glob(["lib/Dialect/Tensor/*.cpp"]),
defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"], defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"],
includes = ["lib/Dialect/Test"], includes = ["lib/Dialect/Test"],
deps = [ deps = [
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:LinalgDialect", "//mlir:LinalgDialect",
"//mlir:Pass", "//mlir:Pass",
"//mlir:SCFDialect", "//mlir:SCFDialect",
"//mlir:TensorDialect", "//mlir:TensorDialect",
"//mlir:TensorTransforms", "//mlir:TensorTransforms",
"//mlir:Transforms", "//mlir:Transforms",
], ],
) )
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

utils/bazel/llvm-project-overlay/mlir/unittests/BUILD.bazel

Show First 20 Lines • Show All 309 Lines • ▼ Show 20 Linescc_test(
srcs = glob([ srcs = glob([
"Conversion/*.cpp", "Conversion/*.cpp",
"Conversion/*.h", "Conversion/*.h",
"Conversion/*/*.cpp", "Conversion/*/*.cpp",
"Conversion/*/*.h", "Conversion/*/*.h",
]), ]),
deps = [ deps = [
"//llvm:gtest_main", "//llvm:gtest_main",
"//mlir:ArithmeticDialect", "//mlir:ArithDialect",
"//mlir:PDLToPDLInterp", "//mlir:PDLToPDLInterp",
], ],
) )
cc_test( cc_test(
name = "execution_engine_tests", name = "execution_engine_tests",
size = "small", size = "small",
srcs = glob([ srcs = glob([
Show All 19 Lines
mlir/lib/Dialect/Arithmetic/Transforms/Bufferize.cpp