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
2 lines
2 lines
Tools/
8 lines
Tutorials/
Toy/
2 lines
2 lines
examples/
standalone/
standalone-opt/
2 lines
4 lines
toy/
Ch5/
mlir/
7 lines
Ch6/
mlir/
7 lines
7 lines
Ch7/
mlir/
7 lines
7 lines
include/
mlir/
Conversion/
ArithToLLVM/
ArithmeticToLLVM/
ArithToLLVM.h
ArithmeticToLLVM.h
14 lines
ArithToSPIRV/
32 lines
ArithmeticToLLVM/
ArithmeticToSPIRV/
4 lines
24 lines
Dialect/
Affine/
Analysis/
2 lines
IR/
2 lines
4 lines
2 lines
Arith/
Arithmetic/
2 lines
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
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/
3 lines
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/
433 lines
233 lines
ArithToSPIRV/
ArithmeticToSPIRV/
arith-to-spirv.mlir
arithmetic-to-spirv.mlir
1966 lines
51 lines
ArithmeticToLLVM/
ArithmeticToSPIRV/
Dialect/
Arith/
Arithmetic/
98 lines
1635 lines
18 lines
315 lines
232 lines
714 lines
755 lines
22 lines
61 lines
984 lines
39 lines
88 lines
Arithmetic/
Integration/
Dialect/
Arith/
CPU/
Arithmetic/
CPU/
5 lines
85 lines
215 lines
65 lines
85 lines
84 lines
Arithmetic/
CPU/
lib/
Dialect/
Arith/
Arithmetic/
6 lines
18 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
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 463912

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/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/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 58 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.
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`, `Arithmetic`, `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 294 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`, `Arithmetic`, `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 294 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`, `Arithmetic`, `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 294 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`, `Arithmetic`, `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 Arithmetic 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 Arithmetic 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.
add_subdirectory(IR) add_subdirectory(IR)
add_subdirectory(Transforms) add_subdirectory(Transforms)

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/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.
add_subdirectory(IR) add_subdirectory(IR)
add_subdirectory(Transforms) add_subdirectory(Transforms)
add_subdirectory(Utils) add_subdirectory(Utils)

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.
// RUN: mlir-opt -pass-pipeline="func.func(convert-arith-to-llvm)" %s -split-input-file | FileCheck %s // RUN: mlir-opt -pass-pipeline="func.func(convert-arith-to-llvm)" %s -split-input-file | FileCheck %s
// CHECK-LABEL: @vector_ops // CHECK-LABEL: @vector_ops
func.func @vector_ops(%arg0: vector<4xf32>, %arg1: vector<4xi1>, %arg2: vector<4xi64>, %arg3: vector<4xi64>) -> vector<4xf32> { func.func @vector_ops(%arg0: vector<4xf32>, %arg1: vector<4xi1>, %arg2: vector<4xi64>, %arg3: vector<4xi64>) -> vector<4xf32> {
// CHECK-NEXT: %0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : vector<4xf32> // CHECK-NEXT: %0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : vector<4xf32>
%0 = arith.constant dense<42.> : vector<4xf32> %0 = arith.constant dense<42.> : vector<4xf32>
// CHECK-NEXT: %1 = llvm.fadd %arg0, %0 : vector<4xf32> // CHECK-NEXT: %1 = llvm.fadd %arg0, %0 : vector<4xf32>
%1 = arith.addf %arg0, %0 : vector<4xf32> %1 = arith.addf %arg0, %0 : vector<4xf32>
// CHECK-NEXT: %2 = llvm.sdiv %arg2, %arg2 : vector<4xi64> // CHECK-NEXT: %2 = llvm.sdiv %arg2, %arg2 : vector<4xi64>
%3 = arith.divsi %arg2, %arg2 : vector<4xi64> %3 = arith.divsi %arg2, %arg2 : vector<4xi64>
// CHECK-NEXT: %3 = llvm.udiv %arg2, %arg2 : vector<4xi64> // CHECK-NEXT: %3 = llvm.udiv %arg2, %arg2 : vector<4xi64>
%4 = arith.divui %arg2, %arg2 : vector<4xi64> %4 = arith.divui %arg2, %arg2 : vector<4xi64>
// CHECK-NEXT: %4 = llvm.srem %arg2, %arg2 : vector<4xi64> // CHECK-NEXT: %4 = llvm.srem %arg2, %arg2 : vector<4xi64>
%5 = arith.remsi %arg2, %arg2 : vector<4xi64> %5 = arith.remsi %arg2, %arg2 : vector<4xi64>
// CHECK-NEXT: %5 = llvm.urem %arg2, %arg2 : vector<4xi64> // CHECK-NEXT: %5 = llvm.urem %arg2, %arg2 : vector<4xi64>
%6 = arith.remui %arg2, %arg2 : vector<4xi64> %6 = arith.remui %arg2, %arg2 : vector<4xi64>
// CHECK-NEXT: %6 = llvm.fdiv %arg0, %0 : vector<4xf32> // CHECK-NEXT: %6 = llvm.fdiv %arg0, %0 : vector<4xf32>
%7 = arith.divf %arg0, %0 : vector<4xf32> %7 = arith.divf %arg0, %0 : vector<4xf32>
// CHECK-NEXT: %7 = llvm.frem %arg0, %0 : vector<4xf32> // CHECK-NEXT: %7 = llvm.frem %arg0, %0 : vector<4xf32>
%8 = arith.remf %arg0, %0 : vector<4xf32> %8 = arith.remf %arg0, %0 : vector<4xf32>
// CHECK-NEXT: %8 = llvm.and %arg2, %arg3 : vector<4xi64> // CHECK-NEXT: %8 = llvm.and %arg2, %arg3 : vector<4xi64>
%9 = arith.andi %arg2, %arg3 : vector<4xi64> %9 = arith.andi %arg2, %arg3 : vector<4xi64>
// CHECK-NEXT: %9 = llvm.or %arg2, %arg3 : vector<4xi64> // CHECK-NEXT: %9 = llvm.or %arg2, %arg3 : vector<4xi64>
%10 = arith.ori %arg2, %arg3 : vector<4xi64> %10 = arith.ori %arg2, %arg3 : vector<4xi64>
// CHECK-NEXT: %10 = llvm.xor %arg2, %arg3 : vector<4xi64> // CHECK-NEXT: %10 = llvm.xor %arg2, %arg3 : vector<4xi64>
%11 = arith.xori %arg2, %arg3 : vector<4xi64> %11 = arith.xori %arg2, %arg3 : vector<4xi64>
// CHECK-NEXT: %11 = llvm.shl %arg2, %arg2 : vector<4xi64> // CHECK-NEXT: %11 = llvm.shl %arg2, %arg2 : vector<4xi64>
%12 = arith.shli %arg2, %arg2 : vector<4xi64> %12 = arith.shli %arg2, %arg2 : vector<4xi64>
// CHECK-NEXT: %12 = llvm.ashr %arg2, %arg2 : vector<4xi64> // CHECK-NEXT: %12 = llvm.ashr %arg2, %arg2 : vector<4xi64>
%13 = arith.shrsi %arg2, %arg2 : vector<4xi64> %13 = arith.shrsi %arg2, %arg2 : vector<4xi64>
// CHECK-NEXT: %13 = llvm.lshr %arg2, %arg2 : vector<4xi64> // CHECK-NEXT: %13 = llvm.lshr %arg2, %arg2 : vector<4xi64>
%14 = arith.shrui %arg2, %arg2 : vector<4xi64> %14 = arith.shrui %arg2, %arg2 : vector<4xi64>
return %1 : vector<4xf32> return %1 : vector<4xf32>
} }
// CHECK-LABEL: @ops // CHECK-LABEL: @ops
func.func @ops(f32, f32, i32, i32, f64) -> (f32, i32) { func.func @ops(f32, f32, i32, i32, f64) -> (f32, i32) {
^bb0(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: i32, %arg4: f64): ^bb0(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: i32, %arg4: f64):
// CHECK: = llvm.fsub %arg0, %arg1 : f32 // CHECK: = llvm.fsub %arg0, %arg1 : f32
%0 = arith.subf %arg0, %arg1: f32 %0 = arith.subf %arg0, %arg1: f32
// CHECK: = llvm.sub %arg2, %arg3 : i32 // CHECK: = llvm.sub %arg2, %arg3 : i32
%1 = arith.subi %arg2, %arg3: i32 %1 = arith.subi %arg2, %arg3: i32
// CHECK: = llvm.icmp "slt" %arg2, %1 : i32 // CHECK: = llvm.icmp "slt" %arg2, %1 : i32
%2 = arith.cmpi slt, %arg2, %1 : i32 %2 = arith.cmpi slt, %arg2, %1 : i32
// CHECK: = llvm.sdiv %arg2, %arg3 : i32 // CHECK: = llvm.sdiv %arg2, %arg3 : i32
%3 = arith.divsi %arg2, %arg3 : i32 %3 = arith.divsi %arg2, %arg3 : i32
// CHECK: = llvm.udiv %arg2, %arg3 : i32 // CHECK: = llvm.udiv %arg2, %arg3 : i32
%4 = arith.divui %arg2, %arg3 : i32 %4 = arith.divui %arg2, %arg3 : i32
// CHECK: = llvm.srem %arg2, %arg3 : i32 // CHECK: = llvm.srem %arg2, %arg3 : i32
%5 = arith.remsi %arg2, %arg3 : i32 %5 = arith.remsi %arg2, %arg3 : i32
// CHECK: = llvm.urem %arg2, %arg3 : i32 // CHECK: = llvm.urem %arg2, %arg3 : i32
%6 = arith.remui %arg2, %arg3 : i32 %6 = arith.remui %arg2, %arg3 : i32
// CHECK: = llvm.fdiv %arg0, %arg1 : f32 // CHECK: = llvm.fdiv %arg0, %arg1 : f32
%8 = arith.divf %arg0, %arg1 : f32 %8 = arith.divf %arg0, %arg1 : f32
// CHECK: = llvm.frem %arg0, %arg1 : f32 // CHECK: = llvm.frem %arg0, %arg1 : f32
%9 = arith.remf %arg0, %arg1 : f32 %9 = arith.remf %arg0, %arg1 : f32
// CHECK: = llvm.and %arg2, %arg3 : i32 // CHECK: = llvm.and %arg2, %arg3 : i32
%10 = arith.andi %arg2, %arg3 : i32 %10 = arith.andi %arg2, %arg3 : i32
// CHECK: = llvm.or %arg2, %arg3 : i32 // CHECK: = llvm.or %arg2, %arg3 : i32
%11 = arith.ori %arg2, %arg3 : i32 %11 = arith.ori %arg2, %arg3 : i32
// CHECK: = llvm.xor %arg2, %arg3 : i32 // CHECK: = llvm.xor %arg2, %arg3 : i32
%12 = arith.xori %arg2, %arg3 : i32 %12 = arith.xori %arg2, %arg3 : i32
// CHECK: = llvm.mlir.constant(7.900000e-01 : f64) : f64 // CHECK: = llvm.mlir.constant(7.900000e-01 : f64) : f64
%15 = arith.constant 7.9e-01 : f64 %15 = arith.constant 7.9e-01 : f64
// CHECK: = llvm.shl %arg2, %arg3 : i32 // CHECK: = llvm.shl %arg2, %arg3 : i32
%16 = arith.shli %arg2, %arg3 : i32 %16 = arith.shli %arg2, %arg3 : i32
// CHECK: = llvm.ashr %arg2, %arg3 : i32 // CHECK: = llvm.ashr %arg2, %arg3 : i32
%17 = arith.shrsi %arg2, %arg3 : i32 %17 = arith.shrsi %arg2, %arg3 : i32
// CHECK: = llvm.lshr %arg2, %arg3 : i32 // CHECK: = llvm.lshr %arg2, %arg3 : i32
%18 = arith.shrui %arg2, %arg3 : i32 %18 = arith.shrui %arg2, %arg3 : i32
return %0, %4 : f32, i32 return %0, %4 : f32, i32
} }
// Checking conversion of index types to integers using i1, assuming no target // Checking conversion of index types to integers using i1, assuming no target
// system would have a 1-bit address space. Otherwise, we would have had to // system would have a 1-bit address space. Otherwise, we would have had to
// make this test dependent on the pointer size on the target system. // make this test dependent on the pointer size on the target system.
// CHECK-LABEL: @index_cast // CHECK-LABEL: @index_cast
func.func @index_cast(%arg0: index, %arg1: i1) { func.func @index_cast(%arg0: index, %arg1: i1) {
// CHECK: = llvm.trunc %0 : i{{.*}} to i1 // CHECK: = llvm.trunc %0 : i{{.*}} to i1
%0 = arith.index_cast %arg0: index to i1 %0 = arith.index_cast %arg0: index to i1
// CHECK-NEXT: = llvm.sext %arg1 : i1 to i{{.*}} // CHECK-NEXT: = llvm.sext %arg1 : i1 to i{{.*}}
%1 = arith.index_cast %arg1: i1 to index %1 = arith.index_cast %arg1: i1 to index
return return
} }
// CHECK-LABEL: @vector_index_cast // CHECK-LABEL: @vector_index_cast
func.func @vector_index_cast(%arg0: vector<2xindex>, %arg1: vector<2xi1>) { func.func @vector_index_cast(%arg0: vector<2xindex>, %arg1: vector<2xi1>) {
// CHECK: = llvm.trunc %{{.*}} : vector<2xi{{.*}}> to vector<2xi1> // CHECK: = llvm.trunc %{{.*}} : vector<2xi{{.*}}> to vector<2xi1>
%0 = arith.index_cast %arg0: vector<2xindex> to vector<2xi1> %0 = arith.index_cast %arg0: vector<2xindex> to vector<2xi1>
// CHECK-NEXT: = llvm.sext %{{.*}} : vector<2xi1> to vector<2xi{{.*}}> // CHECK-NEXT: = llvm.sext %{{.*}} : vector<2xi1> to vector<2xi{{.*}}>
%1 = arith.index_cast %arg1: vector<2xi1> to vector<2xindex> %1 = arith.index_cast %arg1: vector<2xi1> to vector<2xindex>
return return
} }
// Checking conversion of signed integer types to floating point. // Checking conversion of signed integer types to floating point.
// CHECK-LABEL: @sitofp // CHECK-LABEL: @sitofp
func.func @sitofp(%arg0 : i32, %arg1 : i64) { func.func @sitofp(%arg0 : i32, %arg1 : i64) {
// CHECK-NEXT: = llvm.sitofp {{.*}} : i32 to f32 // CHECK-NEXT: = llvm.sitofp {{.*}} : i32 to f32
%0 = arith.sitofp %arg0: i32 to f32 %0 = arith.sitofp %arg0: i32 to f32
// CHECK-NEXT: = llvm.sitofp {{.*}} : i32 to f64 // CHECK-NEXT: = llvm.sitofp {{.*}} : i32 to f64
%1 = arith.sitofp %arg0: i32 to f64 %1 = arith.sitofp %arg0: i32 to f64
// CHECK-NEXT: = llvm.sitofp {{.*}} : i64 to f32 // CHECK-NEXT: = llvm.sitofp {{.*}} : i64 to f32
%2 = arith.sitofp %arg1: i64 to f32 %2 = arith.sitofp %arg1: i64 to f32
// CHECK-NEXT: = llvm.sitofp {{.*}} : i64 to f64 // CHECK-NEXT: = llvm.sitofp {{.*}} : i64 to f64
%3 = arith.sitofp %arg1: i64 to f64 %3 = arith.sitofp %arg1: i64 to f64
return return
} }
// Checking conversion of integer vectors to floating point vector types. // Checking conversion of integer vectors to floating point vector types.
// CHECK-LABEL: @sitofp_vector // CHECK-LABEL: @sitofp_vector
func.func @sitofp_vector(%arg0 : vector<2xi16>, %arg1 : vector<2xi32>, %arg2 : vector<2xi64>) { func.func @sitofp_vector(%arg0 : vector<2xi16>, %arg1 : vector<2xi32>, %arg2 : vector<2xi64>) {
// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi16> to vector<2xf32> // CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi16> to vector<2xf32>
%0 = arith.sitofp %arg0: vector<2xi16> to vector<2xf32> %0 = arith.sitofp %arg0: vector<2xi16> to vector<2xf32>
// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi16> to vector<2xf64> // CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi16> to vector<2xf64>
%1 = arith.sitofp %arg0: vector<2xi16> to vector<2xf64> %1 = arith.sitofp %arg0: vector<2xi16> to vector<2xf64>
// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi32> to vector<2xf32> // CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi32> to vector<2xf32>
%2 = arith.sitofp %arg1: vector<2xi32> to vector<2xf32> %2 = arith.sitofp %arg1: vector<2xi32> to vector<2xf32>
// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi32> to vector<2xf64> // CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi32> to vector<2xf64>
%3 = arith.sitofp %arg1: vector<2xi32> to vector<2xf64> %3 = arith.sitofp %arg1: vector<2xi32> to vector<2xf64>
// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi64> to vector<2xf32> // CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi64> to vector<2xf32>
%4 = arith.sitofp %arg2: vector<2xi64> to vector<2xf32> %4 = arith.sitofp %arg2: vector<2xi64> to vector<2xf32>
// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi64> to vector<2xf64> // CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi64> to vector<2xf64>
%5 = arith.sitofp %arg2: vector<2xi64> to vector<2xf64> %5 = arith.sitofp %arg2: vector<2xi64> to vector<2xf64>
return return
} }
// Checking conversion of unsigned integer types to floating point. // Checking conversion of unsigned integer types to floating point.
// CHECK-LABEL: @uitofp // CHECK-LABEL: @uitofp
func.func @uitofp(%arg0 : i32, %arg1 : i64) { func.func @uitofp(%arg0 : i32, %arg1 : i64) {
// CHECK-NEXT: = llvm.uitofp {{.*}} : i32 to f32 // CHECK-NEXT: = llvm.uitofp {{.*}} : i32 to f32
%0 = arith.uitofp %arg0: i32 to f32 %0 = arith.uitofp %arg0: i32 to f32
// CHECK-NEXT: = llvm.uitofp {{.*}} : i32 to f64 // CHECK-NEXT: = llvm.uitofp {{.*}} : i32 to f64
%1 = arith.uitofp %arg0: i32 to f64 %1 = arith.uitofp %arg0: i32 to f64
// CHECK-NEXT: = llvm.uitofp {{.*}} : i64 to f32 // CHECK-NEXT: = llvm.uitofp {{.*}} : i64 to f32
%2 = arith.uitofp %arg1: i64 to f32 %2 = arith.uitofp %arg1: i64 to f32
// CHECK-NEXT: = llvm.uitofp {{.*}} : i64 to f64 // CHECK-NEXT: = llvm.uitofp {{.*}} : i64 to f64
%3 = arith.uitofp %arg1: i64 to f64 %3 = arith.uitofp %arg1: i64 to f64
return return
} }
// Checking conversion of integer types to floating point. // Checking conversion of integer types to floating point.
// CHECK-LABEL: @fpext // CHECK-LABEL: @fpext
func.func @fpext(%arg0 : f16, %arg1 : f32) { func.func @fpext(%arg0 : f16, %arg1 : f32) {
// CHECK-NEXT: = llvm.fpext {{.*}} : f16 to f32 // CHECK-NEXT: = llvm.fpext {{.*}} : f16 to f32
%0 = arith.extf %arg0: f16 to f32 %0 = arith.extf %arg0: f16 to f32
// CHECK-NEXT: = llvm.fpext {{.*}} : f16 to f64 // CHECK-NEXT: = llvm.fpext {{.*}} : f16 to f64
%1 = arith.extf %arg0: f16 to f64 %1 = arith.extf %arg0: f16 to f64
// CHECK-NEXT: = llvm.fpext {{.*}} : f32 to f64 // CHECK-NEXT: = llvm.fpext {{.*}} : f32 to f64
%2 = arith.extf %arg1: f32 to f64 %2 = arith.extf %arg1: f32 to f64
return return
} }
// Checking conversion of integer types to floating point. // Checking conversion of integer types to floating point.
// CHECK-LABEL: @fpext // CHECK-LABEL: @fpext
func.func @fpext_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>) { func.func @fpext_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>) {
// CHECK-NEXT: = llvm.fpext {{.*}} : vector<2xf16> to vector<2xf32> // CHECK-NEXT: = llvm.fpext {{.*}} : vector<2xf16> to vector<2xf32>
%0 = arith.extf %arg0: vector<2xf16> to vector<2xf32> %0 = arith.extf %arg0: vector<2xf16> to vector<2xf32>
// CHECK-NEXT: = llvm.fpext {{.*}} : vector<2xf16> to vector<2xf64> // CHECK-NEXT: = llvm.fpext {{.*}} : vector<2xf16> to vector<2xf64>
%1 = arith.extf %arg0: vector<2xf16> to vector<2xf64> %1 = arith.extf %arg0: vector<2xf16> to vector<2xf64>
// CHECK-NEXT: = llvm.fpext {{.*}} : vector<2xf32> to vector<2xf64> // CHECK-NEXT: = llvm.fpext {{.*}} : vector<2xf32> to vector<2xf64>
%2 = arith.extf %arg1: vector<2xf32> to vector<2xf64> %2 = arith.extf %arg1: vector<2xf32> to vector<2xf64>
return return
} }
// Checking conversion of floating point to integer types. // Checking conversion of floating point to integer types.
// CHECK-LABEL: @fptosi // CHECK-LABEL: @fptosi
func.func @fptosi(%arg0 : f32, %arg1 : f64) { func.func @fptosi(%arg0 : f32, %arg1 : f64) {
// CHECK-NEXT: = llvm.fptosi {{.*}} : f32 to i32 // CHECK-NEXT: = llvm.fptosi {{.*}} : f32 to i32
%0 = arith.fptosi %arg0: f32 to i32 %0 = arith.fptosi %arg0: f32 to i32
// CHECK-NEXT: = llvm.fptosi {{.*}} : f32 to i64 // CHECK-NEXT: = llvm.fptosi {{.*}} : f32 to i64
%1 = arith.fptosi %arg0: f32 to i64 %1 = arith.fptosi %arg0: f32 to i64
// CHECK-NEXT: = llvm.fptosi {{.*}} : f64 to i32 // CHECK-NEXT: = llvm.fptosi {{.*}} : f64 to i32
%2 = arith.fptosi %arg1: f64 to i32 %2 = arith.fptosi %arg1: f64 to i32
// CHECK-NEXT: = llvm.fptosi {{.*}} : f64 to i64 // CHECK-NEXT: = llvm.fptosi {{.*}} : f64 to i64
%3 = arith.fptosi %arg1: f64 to i64 %3 = arith.fptosi %arg1: f64 to i64
return return
} }
// Checking conversion of floating point vectors to integer vector types. // Checking conversion of floating point vectors to integer vector types.
// CHECK-LABEL: @fptosi_vector // CHECK-LABEL: @fptosi_vector
func.func @fptosi_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>, %arg2 : vector<2xf64>) { func.func @fptosi_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>, %arg2 : vector<2xf64>) {
// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf16> to vector<2xi32> // CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf16> to vector<2xi32>
%0 = arith.fptosi %arg0: vector<2xf16> to vector<2xi32> %0 = arith.fptosi %arg0: vector<2xf16> to vector<2xi32>
// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf16> to vector<2xi64> // CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf16> to vector<2xi64>
%1 = arith.fptosi %arg0: vector<2xf16> to vector<2xi64> %1 = arith.fptosi %arg0: vector<2xf16> to vector<2xi64>
// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf32> to vector<2xi32> // CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf32> to vector<2xi32>
%2 = arith.fptosi %arg1: vector<2xf32> to vector<2xi32> %2 = arith.fptosi %arg1: vector<2xf32> to vector<2xi32>
// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf32> to vector<2xi64> // CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf32> to vector<2xi64>
%3 = arith.fptosi %arg1: vector<2xf32> to vector<2xi64> %3 = arith.fptosi %arg1: vector<2xf32> to vector<2xi64>
// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf64> to vector<2xi32> // CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf64> to vector<2xi32>
%4 = arith.fptosi %arg2: vector<2xf64> to vector<2xi32> %4 = arith.fptosi %arg2: vector<2xf64> to vector<2xi32>
// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf64> to vector<2xi64> // CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf64> to vector<2xi64>
%5 = arith.fptosi %arg2: vector<2xf64> to vector<2xi64> %5 = arith.fptosi %arg2: vector<2xf64> to vector<2xi64>
return return
} }
// Checking conversion of floating point to integer types. // Checking conversion of floating point to integer types.
// CHECK-LABEL: @fptoui // CHECK-LABEL: @fptoui
func.func @fptoui(%arg0 : f32, %arg1 : f64) { func.func @fptoui(%arg0 : f32, %arg1 : f64) {
// CHECK-NEXT: = llvm.fptoui {{.*}} : f32 to i32 // CHECK-NEXT: = llvm.fptoui {{.*}} : f32 to i32
%0 = arith.fptoui %arg0: f32 to i32 %0 = arith.fptoui %arg0: f32 to i32
// CHECK-NEXT: = llvm.fptoui {{.*}} : f32 to i64 // CHECK-NEXT: = llvm.fptoui {{.*}} : f32 to i64
%1 = arith.fptoui %arg0: f32 to i64 %1 = arith.fptoui %arg0: f32 to i64
// CHECK-NEXT: = llvm.fptoui {{.*}} : f64 to i32 // CHECK-NEXT: = llvm.fptoui {{.*}} : f64 to i32
%2 = arith.fptoui %arg1: f64 to i32 %2 = arith.fptoui %arg1: f64 to i32
// CHECK-NEXT: = llvm.fptoui {{.*}} : f64 to i64 // CHECK-NEXT: = llvm.fptoui {{.*}} : f64 to i64
%3 = arith.fptoui %arg1: f64 to i64 %3 = arith.fptoui %arg1: f64 to i64
return return
} }
// Checking conversion of floating point vectors to integer vector types. // Checking conversion of floating point vectors to integer vector types.
// CHECK-LABEL: @fptoui_vector // CHECK-LABEL: @fptoui_vector
func.func @fptoui_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>, %arg2 : vector<2xf64>) { func.func @fptoui_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>, %arg2 : vector<2xf64>) {
// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf16> to vector<2xi32> // CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf16> to vector<2xi32>
%0 = arith.fptoui %arg0: vector<2xf16> to vector<2xi32> %0 = arith.fptoui %arg0: vector<2xf16> to vector<2xi32>
// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf16> to vector<2xi64> // CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf16> to vector<2xi64>
%1 = arith.fptoui %arg0: vector<2xf16> to vector<2xi64> %1 = arith.fptoui %arg0: vector<2xf16> to vector<2xi64>
// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf32> to vector<2xi32> // CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf32> to vector<2xi32>
%2 = arith.fptoui %arg1: vector<2xf32> to vector<2xi32> %2 = arith.fptoui %arg1: vector<2xf32> to vector<2xi32>
// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf32> to vector<2xi64> // CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf32> to vector<2xi64>
%3 = arith.fptoui %arg1: vector<2xf32> to vector<2xi64> %3 = arith.fptoui %arg1: vector<2xf32> to vector<2xi64>
// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf64> to vector<2xi32> // CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf64> to vector<2xi32>
%4 = arith.fptoui %arg2: vector<2xf64> to vector<2xi32> %4 = arith.fptoui %arg2: vector<2xf64> to vector<2xi32>
// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf64> to vector<2xi64> // CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf64> to vector<2xi64>
%5 = arith.fptoui %arg2: vector<2xf64> to vector<2xi64> %5 = arith.fptoui %arg2: vector<2xf64> to vector<2xi64>
return return
} }
// Checking conversion of integer vectors to floating point vector types. // Checking conversion of integer vectors to floating point vector types.
// CHECK-LABEL: @uitofp_vector // CHECK-LABEL: @uitofp_vector
func.func @uitofp_vector(%arg0 : vector<2xi16>, %arg1 : vector<2xi32>, %arg2 : vector<2xi64>) { func.func @uitofp_vector(%arg0 : vector<2xi16>, %arg1 : vector<2xi32>, %arg2 : vector<2xi64>) {
// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi16> to vector<2xf32> // CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi16> to vector<2xf32>
%0 = arith.uitofp %arg0: vector<2xi16> to vector<2xf32> %0 = arith.uitofp %arg0: vector<2xi16> to vector<2xf32>
// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi16> to vector<2xf64> // CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi16> to vector<2xf64>
%1 = arith.uitofp %arg0: vector<2xi16> to vector<2xf64> %1 = arith.uitofp %arg0: vector<2xi16> to vector<2xf64>
// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi32> to vector<2xf32> // CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi32> to vector<2xf32>
%2 = arith.uitofp %arg1: vector<2xi32> to vector<2xf32> %2 = arith.uitofp %arg1: vector<2xi32> to vector<2xf32>
// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi32> to vector<2xf64> // CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi32> to vector<2xf64>
%3 = arith.uitofp %arg1: vector<2xi32> to vector<2xf64> %3 = arith.uitofp %arg1: vector<2xi32> to vector<2xf64>
// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi64> to vector<2xf32> // CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi64> to vector<2xf32>
%4 = arith.uitofp %arg2: vector<2xi64> to vector<2xf32> %4 = arith.uitofp %arg2: vector<2xi64> to vector<2xf32>
// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi64> to vector<2xf64> // CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi64> to vector<2xf64>
%5 = arith.uitofp %arg2: vector<2xi64> to vector<2xf64> %5 = arith.uitofp %arg2: vector<2xi64> to vector<2xf64>
return return
} }
// Checking conversion of integer types to floating point. // Checking conversion of integer types to floating point.
// CHECK-LABEL: @fptrunc // CHECK-LABEL: @fptrunc
func.func @fptrunc(%arg0 : f32, %arg1 : f64) { func.func @fptrunc(%arg0 : f32, %arg1 : f64) {
// CHECK-NEXT: = llvm.fptrunc {{.*}} : f32 to f16 // CHECK-NEXT: = llvm.fptrunc {{.*}} : f32 to f16
%0 = arith.truncf %arg0: f32 to f16 %0 = arith.truncf %arg0: f32 to f16
// CHECK-NEXT: = llvm.fptrunc {{.*}} : f64 to f16 // CHECK-NEXT: = llvm.fptrunc {{.*}} : f64 to f16
%1 = arith.truncf %arg1: f64 to f16 %1 = arith.truncf %arg1: f64 to f16
// CHECK-NEXT: = llvm.fptrunc {{.*}} : f64 to f32 // CHECK-NEXT: = llvm.fptrunc {{.*}} : f64 to f32
%2 = arith.truncf %arg1: f64 to f32 %2 = arith.truncf %arg1: f64 to f32
return return
} }
// Checking conversion of integer types to floating point. // Checking conversion of integer types to floating point.
// CHECK-LABEL: @fptrunc // CHECK-LABEL: @fptrunc
func.func @fptrunc_vector(%arg0 : vector<2xf32>, %arg1 : vector<2xf64>) { func.func @fptrunc_vector(%arg0 : vector<2xf32>, %arg1 : vector<2xf64>) {
// CHECK-NEXT: = llvm.fptrunc {{.*}} : vector<2xf32> to vector<2xf16> // CHECK-NEXT: = llvm.fptrunc {{.*}} : vector<2xf32> to vector<2xf16>
%0 = arith.truncf %arg0: vector<2xf32> to vector<2xf16> %0 = arith.truncf %arg0: vector<2xf32> to vector<2xf16>
// CHECK-NEXT: = llvm.fptrunc {{.*}} : vector<2xf64> to vector<2xf16> // CHECK-NEXT: = llvm.fptrunc {{.*}} : vector<2xf64> to vector<2xf16>
%1 = arith.truncf %arg1: vector<2xf64> to vector<2xf16> %1 = arith.truncf %arg1: vector<2xf64> to vector<2xf16>
// CHECK-NEXT: = llvm.fptrunc {{.*}} : vector<2xf64> to vector<2xf32> // CHECK-NEXT: = llvm.fptrunc {{.*}} : vector<2xf64> to vector<2xf32>
%2 = arith.truncf %arg1: vector<2xf64> to vector<2xf32> %2 = arith.truncf %arg1: vector<2xf64> to vector<2xf32>
return return
} }
// Check sign and zero extension and truncation of integers. // Check sign and zero extension and truncation of integers.
// CHECK-LABEL: @integer_extension_and_truncation // CHECK-LABEL: @integer_extension_and_truncation
func.func @integer_extension_and_truncation(%arg0 : i3) { func.func @integer_extension_and_truncation(%arg0 : i3) {
// CHECK-NEXT: = llvm.sext %arg0 : i3 to i6 // CHECK-NEXT: = llvm.sext %arg0 : i3 to i6
%0 = arith.extsi %arg0 : i3 to i6 %0 = arith.extsi %arg0 : i3 to i6
// CHECK-NEXT: = llvm.zext %arg0 : i3 to i6 // CHECK-NEXT: = llvm.zext %arg0 : i3 to i6
%1 = arith.extui %arg0 : i3 to i6 %1 = arith.extui %arg0 : i3 to i6
// CHECK-NEXT: = llvm.trunc %arg0 : i3 to i2 // CHECK-NEXT: = llvm.trunc %arg0 : i3 to i2
%2 = arith.trunci %arg0 : i3 to i2 %2 = arith.trunci %arg0 : i3 to i2
return return
} }
// CHECK-LABEL: func @fcmp(%arg0: f32, %arg1: f32) { // CHECK-LABEL: func @fcmp(%arg0: f32, %arg1: f32) {
func.func @fcmp(f32, f32) -> () { func.func @fcmp(f32, f32) -> () {
^bb0(%arg0: f32, %arg1: f32): ^bb0(%arg0: f32, %arg1: f32):
// CHECK: llvm.fcmp "oeq" %arg0, %arg1 : f32 // CHECK: llvm.fcmp "oeq" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "ogt" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "ogt" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "oge" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "oge" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "olt" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "olt" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "ole" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "ole" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "one" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "one" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "ord" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "ord" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "ueq" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "ueq" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "ugt" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "ugt" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "uge" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "uge" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "ult" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "ult" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "ule" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "ule" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "une" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "une" %arg0, %arg1 : f32
// CHECK-NEXT: llvm.fcmp "uno" %arg0, %arg1 : f32 // CHECK-NEXT: llvm.fcmp "uno" %arg0, %arg1 : f32
// CHECK-NEXT: return // CHECK-NEXT: return
%1 = arith.cmpf oeq, %arg0, %arg1 : f32 %1 = arith.cmpf oeq, %arg0, %arg1 : f32
%2 = arith.cmpf ogt, %arg0, %arg1 : f32 %2 = arith.cmpf ogt, %arg0, %arg1 : f32
%3 = arith.cmpf oge, %arg0, %arg1 : f32 %3 = arith.cmpf oge, %arg0, %arg1 : f32
%4 = arith.cmpf olt, %arg0, %arg1 : f32 %4 = arith.cmpf olt, %arg0, %arg1 : f32
%5 = arith.cmpf ole, %arg0, %arg1 : f32 %5 = arith.cmpf ole, %arg0, %arg1 : f32
%6 = arith.cmpf one, %arg0, %arg1 : f32 %6 = arith.cmpf one, %arg0, %arg1 : f32
%7 = arith.cmpf ord, %arg0, %arg1 : f32 %7 = arith.cmpf ord, %arg0, %arg1 : f32
%8 = arith.cmpf ueq, %arg0, %arg1 : f32 %8 = arith.cmpf ueq, %arg0, %arg1 : f32
%9 = arith.cmpf ugt, %arg0, %arg1 : f32 %9 = arith.cmpf ugt, %arg0, %arg1 : f32
%10 = arith.cmpf uge, %arg0, %arg1 : f32 %10 = arith.cmpf uge, %arg0, %arg1 : f32
%11 = arith.cmpf ult, %arg0, %arg1 : f32 %11 = arith.cmpf ult, %arg0, %arg1 : f32
%12 = arith.cmpf ule, %arg0, %arg1 : f32 %12 = arith.cmpf ule, %arg0, %arg1 : f32
%13 = arith.cmpf une, %arg0, %arg1 : f32 %13 = arith.cmpf une, %arg0, %arg1 : f32
%14 = arith.cmpf uno, %arg0, %arg1 : f32 %14 = arith.cmpf uno, %arg0, %arg1 : f32
return return
} }
// ----- // -----
// CHECK-LABEL: @index_vector // CHECK-LABEL: @index_vector
func.func @index_vector(%arg0: vector<4xindex>) { func.func @index_vector(%arg0: vector<4xindex>) {
// CHECK: %[[CST:.*]] = llvm.mlir.constant(dense<[0, 1, 2, 3]> : vector<4xindex>) : vector<4xi64> // CHECK: %[[CST:.*]] = llvm.mlir.constant(dense<[0, 1, 2, 3]> : vector<4xindex>) : vector<4xi64>
%0 = arith.constant dense<[0, 1, 2, 3]> : vector<4xindex> %0 = arith.constant dense<[0, 1, 2, 3]> : vector<4xindex>
// CHECK: %[[V:.*]] = llvm.add %{{.*}}, %[[CST]] : vector<4xi64> // CHECK: %[[V:.*]] = llvm.add %{{.*}}, %[[CST]] : vector<4xi64>
%1 = arith.addi %arg0, %0 : vector<4xindex> %1 = arith.addi %arg0, %0 : vector<4xindex>
func.return func.return
} }
// ----- // -----
// CHECK-LABEL: @bitcast_1d // CHECK-LABEL: @bitcast_1d
func.func @bitcast_1d(%arg0: vector<2xf32>) { func.func @bitcast_1d(%arg0: vector<2xf32>) {
// CHECK: llvm.bitcast %{{.*}} : vector<2xf32> to vector<2xi32> // CHECK: llvm.bitcast %{{.*}} : vector<2xf32> to vector<2xi32>
arith.bitcast %arg0 : vector<2xf32> to vector<2xi32> arith.bitcast %arg0 : vector<2xf32> to vector<2xi32>
return return
} }
// ----- // -----
// CHECK-LABEL: @addui_carry_scalar // CHECK-LABEL: @addui_carry_scalar
// CHECK-SAME: ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> (i32, i1) // CHECK-SAME: ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> (i32, i1)
func.func @addui_carry_scalar(%arg0: i32, %arg1: i32) -> (i32, i1) { func.func @addui_carry_scalar(%arg0: i32, %arg1: i32) -> (i32, i1) {
// CHECK-NEXT: [[RES:%.+]] = "llvm.intr.uadd.with.overflow"([[ARG0]], [[ARG1]]) : (i32, i32) -> !llvm.struct<(i32, i1)> // CHECK-NEXT: [[RES:%.+]] = "llvm.intr.uadd.with.overflow"([[ARG0]], [[ARG1]]) : (i32, i32) -> !llvm.struct<(i32, i1)>
// CHECK-NEXT: [[SUM:%.+]] = llvm.extractvalue [[RES]][0] : !llvm.struct<(i32, i1)> // CHECK-NEXT: [[SUM:%.+]] = llvm.extractvalue [[RES]][0] : !llvm.struct<(i32, i1)>
// CHECK-NEXT: [[CARRY:%.+]] = llvm.extractvalue [[RES]][1] : !llvm.struct<(i32, i1)> // CHECK-NEXT: [[CARRY:%.+]] = llvm.extractvalue [[RES]][1] : !llvm.struct<(i32, i1)>
%sum, %carry = arith.addui_carry %arg0, %arg1 : i32, i1 %sum, %carry = arith.addui_carry %arg0, %arg1 : i32, i1
// CHECK-NEXT: return [[SUM]], [[CARRY]] : i32, i1 // CHECK-NEXT: return [[SUM]], [[CARRY]] : i32, i1
return %sum, %carry : i32, i1 return %sum, %carry : i32, i1
} }
// CHECK-LABEL: @addui_carry_vector1d // CHECK-LABEL: @addui_carry_vector1d
// CHECK-SAME: ([[ARG0:%.+]]: vector<3xi16>, [[ARG1:%.+]]: vector<3xi16>) -> (vector<3xi16>, vector<3xi1>) // CHECK-SAME: ([[ARG0:%.+]]: vector<3xi16>, [[ARG1:%.+]]: vector<3xi16>) -> (vector<3xi16>, vector<3xi1>)
func.func @addui_carry_vector1d(%arg0: vector<3xi16>, %arg1: vector<3xi16>) -> (vector<3xi16>, vector<3xi1>) { func.func @addui_carry_vector1d(%arg0: vector<3xi16>, %arg1: vector<3xi16>) -> (vector<3xi16>, vector<3xi1>) {
// CHECK-NEXT: [[RES:%.+]] = "llvm.intr.uadd.with.overflow"([[ARG0]], [[ARG1]]) : (vector<3xi16>, vector<3xi16>) -> !llvm.struct<(vector<3xi16>, vector<3xi1>)> // CHECK-NEXT: [[RES:%.+]] = "llvm.intr.uadd.with.overflow"([[ARG0]], [[ARG1]]) : (vector<3xi16>, vector<3xi16>) -> !llvm.struct<(vector<3xi16>, vector<3xi1>)>
// CHECK-NEXT: [[SUM:%.+]] = llvm.extractvalue [[RES]][0] : !llvm.struct<(vector<3xi16>, vector<3xi1>)> // CHECK-NEXT: [[SUM:%.+]] = llvm.extractvalue [[RES]][0] : !llvm.struct<(vector<3xi16>, vector<3xi1>)>
// CHECK-NEXT: [[CARRY:%.+]] = llvm.extractvalue [[RES]][1] : !llvm.struct<(vector<3xi16>, vector<3xi1>)> // CHECK-NEXT: [[CARRY:%.+]] = llvm.extractvalue [[RES]][1] : !llvm.struct<(vector<3xi16>, vector<3xi1>)>
%sum, %carry = arith.addui_carry %arg0, %arg1 : vector<3xi16>, vector<3xi1> %sum, %carry = arith.addui_carry %arg0, %arg1 : vector<3xi16>, vector<3xi1>
// CHECK-NEXT: return [[SUM]], [[CARRY]] : vector<3xi16>, vector<3xi1> // CHECK-NEXT: return [[SUM]], [[CARRY]] : vector<3xi16>, vector<3xi1>
return %sum, %carry : vector<3xi16>, vector<3xi1> return %sum, %carry : vector<3xi16>, vector<3xi1>
} }
// ----- // -----
// CHECK-LABEL: func @cmpf_2dvector( // CHECK-LABEL: func @cmpf_2dvector(
func.func @cmpf_2dvector(%arg0 : vector<4x3xf32>, %arg1 : vector<4x3xf32>) { func.func @cmpf_2dvector(%arg0 : vector<4x3xf32>, %arg1 : vector<4x3xf32>) {
// CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast // CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast
// CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast // CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast
// CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.array<4 x vector<3xf32>> // CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.array<4 x vector<3xf32>>
// CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.array<4 x vector<3xf32>> // CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.array<4 x vector<3xf32>>
// CHECK: %[[CMP:.*]] = llvm.fcmp "olt" %[[EXTRACT1]], %[[EXTRACT2]] : vector<3xf32> // CHECK: %[[CMP:.*]] = llvm.fcmp "olt" %[[EXTRACT1]], %[[EXTRACT2]] : vector<3xf32>
// CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[CMP]], %2[0] : !llvm.array<4 x vector<3xi1>> // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[CMP]], %2[0] : !llvm.array<4 x vector<3xi1>>
%0 = arith.cmpf olt, %arg0, %arg1 : vector<4x3xf32> %0 = arith.cmpf olt, %arg0, %arg1 : vector<4x3xf32>
func.return func.return
} }
// ----- // -----
// CHECK-LABEL: func @cmpi_0dvector( // CHECK-LABEL: func @cmpi_0dvector(
func.func @cmpi_0dvector(%arg0 : vector<i32>, %arg1 : vector<i32>) { func.func @cmpi_0dvector(%arg0 : vector<i32>, %arg1 : vector<i32>) {
// CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast // CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast
// CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast // CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast
// CHECK: %[[CMP:.*]] = llvm.icmp "ult" %[[ARG0]], %[[ARG1]] : vector<1xi32> // CHECK: %[[CMP:.*]] = llvm.icmp "ult" %[[ARG0]], %[[ARG1]] : vector<1xi32>
%0 = arith.cmpi ult, %arg0, %arg1 : vector<i32> %0 = arith.cmpi ult, %arg0, %arg1 : vector<i32>
func.return func.return
} }
// ----- // -----
// CHECK-LABEL: func @cmpi_2dvector( // CHECK-LABEL: func @cmpi_2dvector(
func.func @cmpi_2dvector(%arg0 : vector<4x3xi32>, %arg1 : vector<4x3xi32>) { func.func @cmpi_2dvector(%arg0 : vector<4x3xi32>, %arg1 : vector<4x3xi32>) {
// CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast // CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast
// CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast // CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast
// CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.array<4 x vector<3xi32>> // CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.array<4 x vector<3xi32>>
// CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.array<4 x vector<3xi32>> // CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.array<4 x vector<3xi32>>
// CHECK: %[[CMP:.*]] = llvm.icmp "ult" %[[EXTRACT1]], %[[EXTRACT2]] : vector<3xi32> // CHECK: %[[CMP:.*]] = llvm.icmp "ult" %[[EXTRACT1]], %[[EXTRACT2]] : vector<3xi32>
// CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[CMP]], %2[0] : !llvm.array<4 x vector<3xi1>> // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[CMP]], %2[0] : !llvm.array<4 x vector<3xi1>>
%0 = arith.cmpi ult, %arg0, %arg1 : vector<4x3xi32> %0 = arith.cmpi ult, %arg0, %arg1 : vector<4x3xi32>
func.return func.return
} }
// ----- // -----
// CHECK-LABEL: @select // CHECK-LABEL: @select
func.func @select(%arg0 : i1, %arg1 : i32, %arg2 : i32) -> i32 { func.func @select(%arg0 : i1, %arg1 : i32, %arg2 : i32) -> i32 {
// CHECK: = llvm.select %arg0, %arg1, %arg2 : i1, i32 // CHECK: = llvm.select %arg0, %arg1, %arg2 : i1, i32
%0 = arith.select %arg0, %arg1, %arg2 : i32 %0 = arith.select %arg0, %arg1, %arg2 : i32
return %0 : i32 return %0 : i32
} }
// ----- // -----
// CHECK-LABEL: @minmaxi // CHECK-LABEL: @minmaxi
func.func @minmaxi(%arg0 : i32, %arg1 : i32) -> i32 { func.func @minmaxi(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: = "llvm.intr.smin"(%arg0, %arg1) : (i32, i32) -> i32 // CHECK: = "llvm.intr.smin"(%arg0, %arg1) : (i32, i32) -> i32
%0 = arith.minsi %arg0, %arg1 : i32 %0 = arith.minsi %arg0, %arg1 : i32
// CHECK: = "llvm.intr.smax"(%arg0, %arg1) : (i32, i32) -> i32 // CHECK: = "llvm.intr.smax"(%arg0, %arg1) : (i32, i32) -> i32
%1 = arith.maxsi %arg0, %arg1 : i32 %1 = arith.maxsi %arg0, %arg1 : i32
// CHECK: = "llvm.intr.umin"(%arg0, %arg1) : (i32, i32) -> i32 // CHECK: = "llvm.intr.umin"(%arg0, %arg1) : (i32, i32) -> i32
%2 = arith.minui %arg0, %arg1 : i32 %2 = arith.minui %arg0, %arg1 : i32
// CHECK: = "llvm.intr.umax"(%arg0, %arg1) : (i32, i32) -> i32 // CHECK: = "llvm.intr.umax"(%arg0, %arg1) : (i32, i32) -> i32
%3 = arith.maxui %arg0, %arg1 : i32 %3 = arith.maxui %arg0, %arg1 : i32
return %0 : i32 return %0 : i32
} }
// CHECK-LABEL: @minmaxf // CHECK-LABEL: @minmaxf
func.func @minmaxf(%arg0 : f32, %arg1 : f32) -> f32 { func.func @minmaxf(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK: = "llvm.intr.minnum"(%arg0, %arg1) : (f32, f32) -> f32 // CHECK: = "llvm.intr.minnum"(%arg0, %arg1) : (f32, f32) -> f32
%0 = arith.minf %arg0, %arg1 : f32 %0 = arith.minf %arg0, %arg1 : f32
// CHECK: = "llvm.intr.maxnum"(%arg0, %arg1) : (f32, f32) -> f32 // CHECK: = "llvm.intr.maxnum"(%arg0, %arg1) : (f32, f32) -> f32
%1 = arith.maxf %arg0, %arg1 : f32 %1 = arith.maxf %arg0, %arg1 : f32
return %0 : f32 return %0 : f32
} }

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.
// RUN: mlir-opt -pass-pipeline="func.func(convert-arith-to-llvm)" %s -split-input-file | FileCheck %s // RUN: mlir-opt -pass-pipeline="func.func(convert-arith-to-llvm)" %s -split-input-file | FileCheck %s
// CHECK-LABEL: @vec_bin // CHECK-LABEL: @vec_bin
func.func @vec_bin(%arg0: vector<2x2x2xf32>) -> vector<2x2x2xf32> { func.func @vec_bin(%arg0: vector<2x2x2xf32>) -> vector<2x2x2xf32> {
// CHECK: llvm.mlir.undef : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK: llvm.mlir.undef : !llvm.array<2 x array<2 x vector<2xf32>>>
// This block appears 2x2 times // This block appears 2x2 times
// CHECK-NEXT: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK-NEXT: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<2 x array<2 x vector<2xf32>>>
// CHECK-NEXT: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK-NEXT: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<2 x array<2 x vector<2xf32>>>
// CHECK-NEXT: llvm.fadd %{{.*}} : vector<2xf32> // CHECK-NEXT: llvm.fadd %{{.*}} : vector<2xf32>
// CHECK-NEXT: llvm.insertvalue %{{.*}}[0, 0] : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK-NEXT: llvm.insertvalue %{{.*}}[0, 0] : !llvm.array<2 x array<2 x vector<2xf32>>>
// We check the proper indexing of extract/insert in the remaining 3 positions. // We check the proper indexing of extract/insert in the remaining 3 positions.
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<2 x array<2 x vector<2xf32>>>
// CHECK: llvm.insertvalue %{{.*}}[0, 1] : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK: llvm.insertvalue %{{.*}}[0, 1] : !llvm.array<2 x array<2 x vector<2xf32>>>
// CHECK: llvm.extractvalue %{{.*}}[1, 0] : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK: llvm.extractvalue %{{.*}}[1, 0] : !llvm.array<2 x array<2 x vector<2xf32>>>
// CHECK: llvm.insertvalue %{{.*}}[1, 0] : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK: llvm.insertvalue %{{.*}}[1, 0] : !llvm.array<2 x array<2 x vector<2xf32>>>
// CHECK: llvm.extractvalue %{{.*}}[1, 1] : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK: llvm.extractvalue %{{.*}}[1, 1] : !llvm.array<2 x array<2 x vector<2xf32>>>
// CHECK: llvm.insertvalue %{{.*}}[1, 1] : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK: llvm.insertvalue %{{.*}}[1, 1] : !llvm.array<2 x array<2 x vector<2xf32>>>
%0 = arith.addf %arg0, %arg0 : vector<2x2x2xf32> %0 = arith.addf %arg0, %arg0 : vector<2x2x2xf32>
return %0 : vector<2x2x2xf32> return %0 : vector<2x2x2xf32>
} }
// CHECK-LABEL: @sexti // CHECK-LABEL: @sexti
func.func @sexti_vector(%arg0 : vector<1x2x3xi32>, %arg1 : vector<1x2x3xi64>) { func.func @sexti_vector(%arg0 : vector<1x2x3xi32>, %arg1 : vector<1x2x3xi64>) {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.sext %{{.*}} : vector<3xi32> to vector<3xi64> // CHECK: llvm.sext %{{.*}} : vector<3xi32> to vector<3xi64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.sext %{{.*}} : vector<3xi32> to vector<3xi64> // CHECK: llvm.sext %{{.*}} : vector<3xi32> to vector<3xi64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>>
%0 = arith.extsi %arg0: vector<1x2x3xi32> to vector<1x2x3xi64> %0 = arith.extsi %arg0: vector<1x2x3xi32> to vector<1x2x3xi64>
return return
} }
// CHECK-LABEL: @zexti // CHECK-LABEL: @zexti
func.func @zexti_vector(%arg0 : vector<1x2x3xi32>, %arg1 : vector<1x2x3xi64>) { func.func @zexti_vector(%arg0 : vector<1x2x3xi32>, %arg1 : vector<1x2x3xi64>) {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.zext %{{.*}} : vector<3xi32> to vector<3xi64> // CHECK: llvm.zext %{{.*}} : vector<3xi32> to vector<3xi64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.zext %{{.*}} : vector<3xi32> to vector<3xi64> // CHECK: llvm.zext %{{.*}} : vector<3xi32> to vector<3xi64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>>
%0 = arith.extui %arg0: vector<1x2x3xi32> to vector<1x2x3xi64> %0 = arith.extui %arg0: vector<1x2x3xi32> to vector<1x2x3xi64>
return return
} }
// CHECK-LABEL: @sitofp // CHECK-LABEL: @sitofp
func.func @sitofp_vector(%arg0 : vector<1x2x3xi32>) -> vector<1x2x3xf32> { func.func @sitofp_vector(%arg0 : vector<1x2x3xi32>) -> vector<1x2x3xf32> {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xf32>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xf32>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.sitofp %{{.*}} : vector<3xi32> to vector<3xf32> // CHECK: llvm.sitofp %{{.*}} : vector<3xi32> to vector<3xf32>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf32>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf32>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.sitofp %{{.*}} : vector<3xi32> to vector<3xf32> // CHECK: llvm.sitofp %{{.*}} : vector<3xi32> to vector<3xf32>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf32>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf32>>>
%0 = arith.sitofp %arg0: vector<1x2x3xi32> to vector<1x2x3xf32> %0 = arith.sitofp %arg0: vector<1x2x3xi32> to vector<1x2x3xf32>
return %0 : vector<1x2x3xf32> return %0 : vector<1x2x3xf32>
} }
// CHECK-LABEL: @uitofp // CHECK-LABEL: @uitofp
func.func @uitofp_vector(%arg0 : vector<1x2x3xi32>) -> vector<1x2x3xf32> { func.func @uitofp_vector(%arg0 : vector<1x2x3xi32>) -> vector<1x2x3xf32> {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xf32>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xf32>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.uitofp %{{.*}} : vector<3xi32> to vector<3xf32> // CHECK: llvm.uitofp %{{.*}} : vector<3xi32> to vector<3xf32>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf32>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf32>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.uitofp %{{.*}} : vector<3xi32> to vector<3xf32> // CHECK: llvm.uitofp %{{.*}} : vector<3xi32> to vector<3xf32>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf32>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf32>>>
%0 = arith.uitofp %arg0: vector<1x2x3xi32> to vector<1x2x3xf32> %0 = arith.uitofp %arg0: vector<1x2x3xi32> to vector<1x2x3xf32>
return %0 : vector<1x2x3xf32> return %0 : vector<1x2x3xf32>
} }
// CHECK-LABEL: @fptosi // CHECK-LABEL: @fptosi
func.func @fptosi_vector(%arg0 : vector<1x2x3xf32>) -> vector<1x2x3xi32> { func.func @fptosi_vector(%arg0 : vector<1x2x3xf32>) -> vector<1x2x3xi32> {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf32>>>
// CHECK: llvm.fptosi %{{.*}} : vector<3xf32> to vector<3xi32> // CHECK: llvm.fptosi %{{.*}} : vector<3xf32> to vector<3xi32>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf32>>>
// CHECK: llvm.fptosi %{{.*}} : vector<3xf32> to vector<3xi32> // CHECK: llvm.fptosi %{{.*}} : vector<3xf32> to vector<3xi32>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>>
%0 = arith.fptosi %arg0: vector<1x2x3xf32> to vector<1x2x3xi32> %0 = arith.fptosi %arg0: vector<1x2x3xf32> to vector<1x2x3xi32>
return %0 : vector<1x2x3xi32> return %0 : vector<1x2x3xi32>
} }
// CHECK-LABEL: @fptoui // CHECK-LABEL: @fptoui
func.func @fptoui_vector(%arg0 : vector<1x2x3xf32>) -> vector<1x2x3xi32> { func.func @fptoui_vector(%arg0 : vector<1x2x3xf32>) -> vector<1x2x3xi32> {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf32>>>
// CHECK: llvm.fptoui %{{.*}} : vector<3xf32> to vector<3xi32> // CHECK: llvm.fptoui %{{.*}} : vector<3xf32> to vector<3xi32>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi32>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf32>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf32>>>
// CHECK: llvm.fptoui %{{.*}} : vector<3xf32> to vector<3xi32> // CHECK: llvm.fptoui %{{.*}} : vector<3xf32> to vector<3xi32>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi32>>>
%0 = arith.fptoui %arg0: vector<1x2x3xf32> to vector<1x2x3xi32> %0 = arith.fptoui %arg0: vector<1x2x3xf32> to vector<1x2x3xi32>
return %0 : vector<1x2x3xi32> return %0 : vector<1x2x3xi32>
} }
// CHECK-LABEL: @fpext // CHECK-LABEL: @fpext
func.func @fpext_vector(%arg0 : vector<1x2x3xf16>) -> vector<1x2x3xf64> { func.func @fpext_vector(%arg0 : vector<1x2x3xf16>) -> vector<1x2x3xf64> {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xf64>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xf64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf16>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf16>>>
// CHECK: llvm.fpext %{{.*}} : vector<3xf16> to vector<3xf64> // CHECK: llvm.fpext %{{.*}} : vector<3xf16> to vector<3xf64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf16>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf16>>>
// CHECK: llvm.fpext %{{.*}} : vector<3xf16> to vector<3xf64> // CHECK: llvm.fpext %{{.*}} : vector<3xf16> to vector<3xf64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf64>>>
%0 = arith.extf %arg0: vector<1x2x3xf16> to vector<1x2x3xf64> %0 = arith.extf %arg0: vector<1x2x3xf16> to vector<1x2x3xf64>
return %0 : vector<1x2x3xf64> return %0 : vector<1x2x3xf64>
} }
// CHECK-LABEL: @fptrunc // CHECK-LABEL: @fptrunc
func.func @fptrunc_vector(%arg0 : vector<1x2x3xf64>) -> vector<1x2x3xf16> { func.func @fptrunc_vector(%arg0 : vector<1x2x3xf64>) -> vector<1x2x3xf16> {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xf16>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xf16>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf64>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf64>>>
// CHECK: llvm.fptrunc %{{.*}} : vector<3xf64> to vector<3xf16> // CHECK: llvm.fptrunc %{{.*}} : vector<3xf64> to vector<3xf16>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf16>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xf16>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf64>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf64>>>
// CHECK: llvm.fptrunc %{{.*}} : vector<3xf64> to vector<3xf16> // CHECK: llvm.fptrunc %{{.*}} : vector<3xf64> to vector<3xf16>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf16>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xf16>>>
%0 = arith.truncf %arg0: vector<1x2x3xf64> to vector<1x2x3xf16> %0 = arith.truncf %arg0: vector<1x2x3xf64> to vector<1x2x3xf16>
return %0 : vector<1x2x3xf16> return %0 : vector<1x2x3xf16>
} }
// CHECK-LABEL: @trunci // CHECK-LABEL: @trunci
func.func @trunci_vector(%arg0 : vector<1x2x3xi64>) -> vector<1x2x3xi16> { func.func @trunci_vector(%arg0 : vector<1x2x3xi64>) -> vector<1x2x3xi16> {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi16>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi16>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.trunc %{{.*}} : vector<3xi64> to vector<3xi16> // CHECK: llvm.trunc %{{.*}} : vector<3xi64> to vector<3xi16>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi16>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi16>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.trunc %{{.*}} : vector<3xi64> to vector<3xi16> // CHECK: llvm.trunc %{{.*}} : vector<3xi64> to vector<3xi16>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi16>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi16>>>
%0 = arith.trunci %arg0: vector<1x2x3xi64> to vector<1x2x3xi16> %0 = arith.trunci %arg0: vector<1x2x3xi64> to vector<1x2x3xi16>
return %0 : vector<1x2x3xi16> return %0 : vector<1x2x3xi16>
} }
// CHECK-LABEL: @shl // CHECK-LABEL: @shl
func.func @shl_vector(%arg0 : vector<1x2x3xi64>) -> vector<1x2x3xi64> { func.func @shl_vector(%arg0 : vector<1x2x3xi64>) -> vector<1x2x3xi64> {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.shl %{{.*}}, %{{.*}} : vector<3xi64> // CHECK: llvm.shl %{{.*}}, %{{.*}} : vector<3xi64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.shl %{{.*}}, %{{.*}} : vector<3xi64> // CHECK: llvm.shl %{{.*}}, %{{.*}} : vector<3xi64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>>
%c1 = arith.constant dense<1> : vector<1x2x3xi64> %c1 = arith.constant dense<1> : vector<1x2x3xi64>
%0 = arith.shli %arg0, %c1 : vector<1x2x3xi64> %0 = arith.shli %arg0, %c1 : vector<1x2x3xi64>
return %0 : vector<1x2x3xi64> return %0 : vector<1x2x3xi64>
} }
// CHECK-LABEL: @shrs // CHECK-LABEL: @shrs
func.func @shrs_vector(%arg0 : vector<1x2x3xi64>) -> vector<1x2x3xi64> { func.func @shrs_vector(%arg0 : vector<1x2x3xi64>) -> vector<1x2x3xi64> {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.ashr %{{.*}}, %{{.*}} : vector<3xi64> // CHECK: llvm.ashr %{{.*}}, %{{.*}} : vector<3xi64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.ashr %{{.*}}, %{{.*}} : vector<3xi64> // CHECK: llvm.ashr %{{.*}}, %{{.*}} : vector<3xi64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>>
%c1 = arith.constant dense<1> : vector<1x2x3xi64> %c1 = arith.constant dense<1> : vector<1x2x3xi64>
%0 = arith.shrsi %arg0, %c1 : vector<1x2x3xi64> %0 = arith.shrsi %arg0, %c1 : vector<1x2x3xi64>
return %0 : vector<1x2x3xi64> return %0 : vector<1x2x3xi64>
} }
// CHECK-LABEL: @shru // CHECK-LABEL: @shru
func.func @shru_vector(%arg0 : vector<1x2x3xi64>) -> vector<1x2x3xi64> { func.func @shru_vector(%arg0 : vector<1x2x3xi64>) -> vector<1x2x3xi64> {
// CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.mlir.undef : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.lshr %{{.*}}, %{{.*}} : vector<3xi64> // CHECK: llvm.lshr %{{.*}}, %{{.*}} : vector<3xi64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>>
// CHECK: llvm.lshr %{{.*}}, %{{.*}} : vector<3xi64> // CHECK: llvm.lshr %{{.*}}, %{{.*}} : vector<3xi64>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>>
%c1 = arith.constant dense<1> : vector<1x2x3xi64> %c1 = arith.constant dense<1> : vector<1x2x3xi64>
%0 = arith.shrui %arg0, %c1 : vector<1x2x3xi64> %0 = arith.shrui %arg0, %c1 : vector<1x2x3xi64>
return %0 : vector<1x2x3xi64> return %0 : vector<1x2x3xi64>
} }
// ----- // -----
// CHECK-LABEL: @bitcast_2d // CHECK-LABEL: @bitcast_2d
func.func @bitcast_2d(%arg0: vector<2x4xf32>) { func.func @bitcast_2d(%arg0: vector<2x4xf32>) {
// CHECK: llvm.mlir.undef // CHECK: llvm.mlir.undef
// CHECK: llvm.extractvalue %{{.*}}[0] // CHECK: llvm.extractvalue %{{.*}}[0]
// CHECK: llvm.bitcast %{{.*}} : vector<4xf32> to vector<4xi32> // CHECK: llvm.bitcast %{{.*}} : vector<4xf32> to vector<4xi32>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0] // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0]
// CHECK: llvm.extractvalue %{{.*}}[1] // CHECK: llvm.extractvalue %{{.*}}[1]
// CHECK: llvm.bitcast %{{.*}} : vector<4xf32> to vector<4xi32> // CHECK: llvm.bitcast %{{.*}} : vector<4xf32> to vector<4xi32>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1]
arith.bitcast %arg0 : vector<2x4xf32> to vector<2x4xi32> arith.bitcast %arg0 : vector<2x4xf32> to vector<2x4xi32>
return return
} }
// ----- // -----
// CHECK-LABEL: func @select_2d( // CHECK-LABEL: func @select_2d(
func.func @select_2d(%arg0 : vector<4x3xi1>, %arg1 : vector<4x3xi32>, %arg2 : vector<4x3xi32>) { func.func @select_2d(%arg0 : vector<4x3xi1>, %arg1 : vector<4x3xi32>, %arg2 : vector<4x3xi32>) {
// CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast %arg0 // CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast %arg0
// CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %arg1 // CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %arg1
// CHECK: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %arg2 // CHECK: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %arg2
// CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.array<4 x vector<3xi1>> // CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.array<4 x vector<3xi1>>
// CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.array<4 x vector<3xi32>> // CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.array<4 x vector<3xi32>>
// CHECK: %[[EXTRACT3:.*]] = llvm.extractvalue %[[ARG2]][0] : !llvm.array<4 x vector<3xi32>> // CHECK: %[[EXTRACT3:.*]] = llvm.extractvalue %[[ARG2]][0] : !llvm.array<4 x vector<3xi32>>
// CHECK: %[[SELECT:.*]] = llvm.select %[[EXTRACT1]], %[[EXTRACT2]], %[[EXTRACT3]] : vector<3xi1>, vector<3xi32> // CHECK: %[[SELECT:.*]] = llvm.select %[[EXTRACT1]], %[[EXTRACT2]], %[[EXTRACT3]] : vector<3xi1>, vector<3xi32>
// CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[SELECT]], %{{.*}}[0] : !llvm.array<4 x vector<3xi32>> // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[SELECT]], %{{.*}}[0] : !llvm.array<4 x vector<3xi32>>
%0 = arith.select %arg0, %arg1, %arg2 : vector<4x3xi1>, vector<4x3xi32> %0 = arith.select %arg0, %arg1, %arg2 : vector<4x3xi1>, vector<4x3xi32>
func.return func.return
} }
// CHECK-LABEL: func @index_cast_2d( // CHECK-LABEL: func @index_cast_2d(
// CHECK-SAME: %[[ARG0:.*]]: vector<1x2x3xi1>) // CHECK-SAME: %[[ARG0:.*]]: vector<1x2x3xi1>)
func.func @index_cast_2d(%arg0: vector<1x2x3xi1>) { func.func @index_cast_2d(%arg0: vector<1x2x3xi1>) {
// CHECK: %[[SRC:.*]] = builtin.unrealized_conversion_cast %[[ARG0]] // CHECK: %[[SRC:.*]] = builtin.unrealized_conversion_cast %[[ARG0]]
// CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[SRC]][0, 0] : !llvm.array<1 x array<2 x vector<3xi1>>> // CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[SRC]][0, 0] : !llvm.array<1 x array<2 x vector<3xi1>>>
// CHECK: %[[SEXT1:.*]] = llvm.sext %[[EXTRACT1]] : vector<3xi1> to vector<3xi{{.*}}> // CHECK: %[[SEXT1:.*]] = llvm.sext %[[EXTRACT1]] : vector<3xi1> to vector<3xi{{.*}}>
// CHECK: %[[INSERT1:.*]] = llvm.insertvalue %[[SEXT1]], %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi{{.*}}>>> // CHECK: %[[INSERT1:.*]] = llvm.insertvalue %[[SEXT1]], %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi{{.*}}>>>
// CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[SRC]][0, 1] : !llvm.array<1 x array<2 x vector<3xi1>>> // CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[SRC]][0, 1] : !llvm.array<1 x array<2 x vector<3xi1>>>
// CHECK: %[[SEXT2:.*]] = llvm.sext %[[EXTRACT2]] : vector<3xi1> to vector<3xi{{.*}}> // CHECK: %[[SEXT2:.*]] = llvm.sext %[[EXTRACT2]] : vector<3xi1> to vector<3xi{{.*}}>
// CHECK: %[[INSERT2:.*]] = llvm.insertvalue %[[SEXT2]], %[[INSERT1]][0, 1] : !llvm.array<1 x array<2 x vector<3xi{{.*}}>>> // CHECK: %[[INSERT2:.*]] = llvm.insertvalue %[[SEXT2]], %[[INSERT1]][0, 1] : !llvm.array<1 x array<2 x vector<3xi{{.*}}>>>
%0 = arith.index_cast %arg0: vector<1x2x3xi1> to vector<1x2x3xindex> %0 = arith.index_cast %arg0: vector<1x2x3xi1> to vector<1x2x3xindex>
// CHECK: %[[EXTRACT3:.*]] = llvm.extractvalue %[[INSERT2]][0, 0] : !llvm.array<1 x array<2 x vector<3xi{{.*}}>>> // CHECK: %[[EXTRACT3:.*]] = llvm.extractvalue %[[INSERT2]][0, 0] : !llvm.array<1 x array<2 x vector<3xi{{.*}}>>>
// CHECK: %[[TRUNC1:.*]] = llvm.trunc %[[EXTRACT3]] : vector<3xi{{.*}}> to vector<3xi1> // CHECK: %[[TRUNC1:.*]] = llvm.trunc %[[EXTRACT3]] : vector<3xi{{.*}}> to vector<3xi1>
// CHECK: %[[INSERT3:.*]] = llvm.insertvalue %[[TRUNC1]], %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi1>>> // CHECK: %[[INSERT3:.*]] = llvm.insertvalue %[[TRUNC1]], %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi1>>>
// CHECK: %[[EXTRACT4:.*]] = llvm.extractvalue %[[INSERT2]][0, 1] : !llvm.array<1 x array<2 x vector<3xi{{.*}}>>> // CHECK: %[[EXTRACT4:.*]] = llvm.extractvalue %[[INSERT2]][0, 1] : !llvm.array<1 x array<2 x vector<3xi{{.*}}>>>
// CHECK: %[[TRUNC2:.*]] = llvm.trunc %[[EXTRACT4]] : vector<3xi{{.*}}> to vector<3xi1> // CHECK: %[[TRUNC2:.*]] = llvm.trunc %[[EXTRACT4]] : vector<3xi{{.*}}> to vector<3xi1>
// CHECK: %[[INSERT4:.*]] = llvm.insertvalue %[[TRUNC2]], %[[INSERT3]][0, 1] : !llvm.array<1 x array<2 x vector<3xi1>>> // CHECK: %[[INSERT4:.*]] = llvm.insertvalue %[[TRUNC2]], %[[INSERT3]][0, 1] : !llvm.array<1 x array<2 x vector<3xi1>>>
%1 = arith.index_cast %0: vector<1x2x3xindex> to vector<1x2x3xi1> %1 = arith.index_cast %0: vector<1x2x3xindex> to vector<1x2x3xi1>
return return
} }

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

  • This file was moved from mlir/test/Conversion/ArithmeticToSPIRV/arithmetic-to-spirv.mlir.
// RUN: mlir-opt -split-input-file -convert-arith-to-spirv -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -split-input-file -convert-arith-to-spirv -verify-diagnostics %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// arithmetic ops // arithmetic ops
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env< spirv.target_env = #spirv.target_env<
#spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64, Shader], []>, #spirv.resource_limits<>> #spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64, Shader], []>, #spirv.resource_limits<>>
} { } {
// Check integer operation conversions. // Check integer operation conversions.
// CHECK-LABEL: @int32_scalar // CHECK-LABEL: @int32_scalar
func.func @int32_scalar(%lhs: i32, %rhs: i32) { func.func @int32_scalar(%lhs: i32, %rhs: i32) {
// CHECK: spirv.IAdd %{{.*}}, %{{.*}}: i32 // CHECK: spirv.IAdd %{{.*}}, %{{.*}}: i32
%0 = arith.addi %lhs, %rhs: i32 %0 = arith.addi %lhs, %rhs: i32
// CHECK: spirv.ISub %{{.*}}, %{{.*}}: i32 // CHECK: spirv.ISub %{{.*}}, %{{.*}}: i32
%1 = arith.subi %lhs, %rhs: i32 %1 = arith.subi %lhs, %rhs: i32
// CHECK: spirv.IMul %{{.*}}, %{{.*}}: i32 // CHECK: spirv.IMul %{{.*}}, %{{.*}}: i32
%2 = arith.muli %lhs, %rhs: i32 %2 = arith.muli %lhs, %rhs: i32
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: i32 // CHECK: spirv.SDiv %{{.*}}, %{{.*}}: i32
%3 = arith.divsi %lhs, %rhs: i32 %3 = arith.divsi %lhs, %rhs: i32
// CHECK: spirv.UDiv %{{.*}}, %{{.*}}: i32 // CHECK: spirv.UDiv %{{.*}}, %{{.*}}: i32
%4 = arith.divui %lhs, %rhs: i32 %4 = arith.divui %lhs, %rhs: i32
// CHECK: spirv.UMod %{{.*}}, %{{.*}}: i32 // CHECK: spirv.UMod %{{.*}}, %{{.*}}: i32
%5 = arith.remui %lhs, %rhs: i32 %5 = arith.remui %lhs, %rhs: i32
return return
} }
// CHECK-LABEL: @int32_scalar_srem // CHECK-LABEL: @int32_scalar_srem
// CHECK-SAME: (%[[LHS:.+]]: i32, %[[RHS:.+]]: i32) // CHECK-SAME: (%[[LHS:.+]]: i32, %[[RHS:.+]]: i32)
func.func @int32_scalar_srem(%lhs: i32, %rhs: i32) { func.func @int32_scalar_srem(%lhs: i32, %rhs: i32) {
// CHECK: %[[LABS:.+]] = spirv.GL.SAbs %[[LHS]] : i32 // CHECK: %[[LABS:.+]] = spirv.GL.SAbs %[[LHS]] : i32
// CHECK: %[[RABS:.+]] = spirv.GL.SAbs %[[RHS]] : i32 // CHECK: %[[RABS:.+]] = spirv.GL.SAbs %[[RHS]] : i32
// CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : i32 // CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : i32
// CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : i32 // CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : i32
// CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : i32 // CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : i32
// CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : i1, i32 // CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : i1, i32
%0 = arith.remsi %lhs, %rhs: i32 %0 = arith.remsi %lhs, %rhs: i32
return return
} }
// CHECK-LABEL: @index_scalar // CHECK-LABEL: @index_scalar
func.func @index_scalar(%lhs: index, %rhs: index) { func.func @index_scalar(%lhs: index, %rhs: index) {
// CHECK: spirv.IAdd %{{.*}}, %{{.*}}: i32 // CHECK: spirv.IAdd %{{.*}}, %{{.*}}: i32
%0 = arith.addi %lhs, %rhs: index %0 = arith.addi %lhs, %rhs: index
// CHECK: spirv.ISub %{{.*}}, %{{.*}}: i32 // CHECK: spirv.ISub %{{.*}}, %{{.*}}: i32
%1 = arith.subi %lhs, %rhs: index %1 = arith.subi %lhs, %rhs: index
// CHECK: spirv.IMul %{{.*}}, %{{.*}}: i32 // CHECK: spirv.IMul %{{.*}}, %{{.*}}: i32
%2 = arith.muli %lhs, %rhs: index %2 = arith.muli %lhs, %rhs: index
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: i32 // CHECK: spirv.SDiv %{{.*}}, %{{.*}}: i32
%3 = arith.divsi %lhs, %rhs: index %3 = arith.divsi %lhs, %rhs: index
// CHECK: spirv.UDiv %{{.*}}, %{{.*}}: i32 // CHECK: spirv.UDiv %{{.*}}, %{{.*}}: i32
%4 = arith.divui %lhs, %rhs: index %4 = arith.divui %lhs, %rhs: index
// CHECK: spirv.UMod %{{.*}}, %{{.*}}: i32 // CHECK: spirv.UMod %{{.*}}, %{{.*}}: i32
%5 = arith.remui %lhs, %rhs: index %5 = arith.remui %lhs, %rhs: index
return return
} }
// CHECK-LABEL: @index_scalar_srem // CHECK-LABEL: @index_scalar_srem
// CHECK-SAME: (%[[A:.+]]: index, %[[B:.+]]: index) // CHECK-SAME: (%[[A:.+]]: index, %[[B:.+]]: index)
func.func @index_scalar_srem(%lhs: index, %rhs: index) { func.func @index_scalar_srem(%lhs: index, %rhs: index) {
// CHECK: %[[LHS:.+]] = builtin.unrealized_conversion_cast %[[A]] : index to i32 // CHECK: %[[LHS:.+]] = builtin.unrealized_conversion_cast %[[A]] : index to i32
// CHECK: %[[RHS:.+]] = builtin.unrealized_conversion_cast %[[B]] : index to i32 // CHECK: %[[RHS:.+]] = builtin.unrealized_conversion_cast %[[B]] : index to i32
// CHECK: %[[LABS:.+]] = spirv.GL.SAbs %[[LHS]] : i32 // CHECK: %[[LABS:.+]] = spirv.GL.SAbs %[[LHS]] : i32
// CHECK: %[[RABS:.+]] = spirv.GL.SAbs %[[RHS]] : i32 // CHECK: %[[RABS:.+]] = spirv.GL.SAbs %[[RHS]] : i32
// CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : i32 // CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : i32
// CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : i32 // CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : i32
// CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : i32 // CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : i32
// CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : i1, i32 // CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : i1, i32
%0 = arith.remsi %lhs, %rhs: index %0 = arith.remsi %lhs, %rhs: index
return return
} }
// Check integer add-with-carry conversions. // Check integer add-with-carry conversions.
// CHECK-LABEL: @int32_scalar_addui_carry // CHECK-LABEL: @int32_scalar_addui_carry
// CHECK-SAME: (%[[LHS:.+]]: i32, %[[RHS:.+]]: i32) // CHECK-SAME: (%[[LHS:.+]]: i32, %[[RHS:.+]]: i32)
func.func @int32_scalar_addui_carry(%lhs: i32, %rhs: i32) -> (i32, i1) { func.func @int32_scalar_addui_carry(%lhs: i32, %rhs: i32) -> (i32, i1) {
// CHECK-NEXT: %[[IAC:.+]] = spirv.IAddCarry %[[LHS]], %[[RHS]] : !spirv.struct<(i32, i32)> // CHECK-NEXT: %[[IAC:.+]] = spirv.IAddCarry %[[LHS]], %[[RHS]] : !spirv.struct<(i32, i32)>
// CHECK-DAG: %[[SUM:.+]] = spirv.CompositeExtract %[[IAC]][0 : i32] : !spirv.struct<(i32, i32)> // CHECK-DAG: %[[SUM:.+]] = spirv.CompositeExtract %[[IAC]][0 : i32] : !spirv.struct<(i32, i32)>
// CHECK-DAG: %[[C0:.+]] = spirv.CompositeExtract %[[IAC]][1 : i32] : !spirv.struct<(i32, i32)> // CHECK-DAG: %[[C0:.+]] = spirv.CompositeExtract %[[IAC]][1 : i32] : !spirv.struct<(i32, i32)>
// CHECK-DAG: %[[ONE:.+]] = spirv.Constant 1 : i32 // CHECK-DAG: %[[ONE:.+]] = spirv.Constant 1 : i32
// CHECK-NEXT: %[[C1:.+]] = spirv.IEqual %[[C0]], %[[ONE]] : i32 // CHECK-NEXT: %[[C1:.+]] = spirv.IEqual %[[C0]], %[[ONE]] : i32
// CHECK-NEXT: return %[[SUM]], %[[C1]] : i32, i1 // CHECK-NEXT: return %[[SUM]], %[[C1]] : i32, i1
%sum, %carry = arith.addui_carry %lhs, %rhs: i32, i1 %sum, %carry = arith.addui_carry %lhs, %rhs: i32, i1
return %sum, %carry : i32, i1 return %sum, %carry : i32, i1
} }
// CHECK-LABEL: @int32_vector_addui_carry // CHECK-LABEL: @int32_vector_addui_carry
// CHECK-SAME: (%[[LHS:.+]]: vector<4xi32>, %[[RHS:.+]]: vector<4xi32>) // CHECK-SAME: (%[[LHS:.+]]: vector<4xi32>, %[[RHS:.+]]: vector<4xi32>)
func.func @int32_vector_addui_carry(%lhs: vector<4xi32>, %rhs: vector<4xi32>) -> (vector<4xi32>, vector<4xi1>) { func.func @int32_vector_addui_carry(%lhs: vector<4xi32>, %rhs: vector<4xi32>) -> (vector<4xi32>, vector<4xi1>) {
// CHECK-NEXT: %[[IAC:.+]] = spirv.IAddCarry %[[LHS]], %[[RHS]] : !spirv.struct<(vector<4xi32>, vector<4xi32>)> // CHECK-NEXT: %[[IAC:.+]] = spirv.IAddCarry %[[LHS]], %[[RHS]] : !spirv.struct<(vector<4xi32>, vector<4xi32>)>
// CHECK-DAG: %[[SUM:.+]] = spirv.CompositeExtract %[[IAC]][0 : i32] : !spirv.struct<(vector<4xi32>, vector<4xi32>)> // CHECK-DAG: %[[SUM:.+]] = spirv.CompositeExtract %[[IAC]][0 : i32] : !spirv.struct<(vector<4xi32>, vector<4xi32>)>
// CHECK-DAG: %[[C0:.+]] = spirv.CompositeExtract %[[IAC]][1 : i32] : !spirv.struct<(vector<4xi32>, vector<4xi32>)> // CHECK-DAG: %[[C0:.+]] = spirv.CompositeExtract %[[IAC]][1 : i32] : !spirv.struct<(vector<4xi32>, vector<4xi32>)>
// CHECK-DAG: %[[ONE:.+]] = spirv.Constant dense<1> : vector<4xi32> // CHECK-DAG: %[[ONE:.+]] = spirv.Constant dense<1> : vector<4xi32>
// CHECK-NEXT: %[[C1:.+]] = spirv.IEqual %[[C0]], %[[ONE]] : vector<4xi32> // CHECK-NEXT: %[[C1:.+]] = spirv.IEqual %[[C0]], %[[ONE]] : vector<4xi32>
// CHECK-NEXT: return %[[SUM]], %[[C1]] : vector<4xi32>, vector<4xi1> // CHECK-NEXT: return %[[SUM]], %[[C1]] : vector<4xi32>, vector<4xi1>
%sum, %carry = arith.addui_carry %lhs, %rhs: vector<4xi32>, vector<4xi1> %sum, %carry = arith.addui_carry %lhs, %rhs: vector<4xi32>, vector<4xi1>
return %sum, %carry : vector<4xi32>, vector<4xi1> return %sum, %carry : vector<4xi32>, vector<4xi1>
} }
// Check float unary operation conversions. // Check float unary operation conversions.
// CHECK-LABEL: @float32_unary_scalar // CHECK-LABEL: @float32_unary_scalar
func.func @float32_unary_scalar(%arg0: f32) { func.func @float32_unary_scalar(%arg0: f32) {
// CHECK: spirv.FNegate %{{.*}}: f32 // CHECK: spirv.FNegate %{{.*}}: f32
%0 = arith.negf %arg0 : f32 %0 = arith.negf %arg0 : f32
return return
} }
// Check float binary operation conversions. // Check float binary operation conversions.
// CHECK-LABEL: @float32_binary_scalar // CHECK-LABEL: @float32_binary_scalar
func.func @float32_binary_scalar(%lhs: f32, %rhs: f32) { func.func @float32_binary_scalar(%lhs: f32, %rhs: f32) {
// CHECK: spirv.FAdd %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FAdd %{{.*}}, %{{.*}}: f32
%0 = arith.addf %lhs, %rhs: f32 %0 = arith.addf %lhs, %rhs: f32
// CHECK: spirv.FSub %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FSub %{{.*}}, %{{.*}}: f32
%1 = arith.subf %lhs, %rhs: f32 %1 = arith.subf %lhs, %rhs: f32
// CHECK: spirv.FMul %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FMul %{{.*}}, %{{.*}}: f32
%2 = arith.mulf %lhs, %rhs: f32 %2 = arith.mulf %lhs, %rhs: f32
// CHECK: spirv.FDiv %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FDiv %{{.*}}, %{{.*}}: f32
%3 = arith.divf %lhs, %rhs: f32 %3 = arith.divf %lhs, %rhs: f32
// CHECK: spirv.FRem %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FRem %{{.*}}, %{{.*}}: f32
%4 = arith.remf %lhs, %rhs: f32 %4 = arith.remf %lhs, %rhs: f32
return return
} }
// Check int vector types. // Check int vector types.
// CHECK-LABEL: @int_vector234 // CHECK-LABEL: @int_vector234
func.func @int_vector234(%arg0: vector<2xi8>, %arg1: vector<4xi64>) { func.func @int_vector234(%arg0: vector<2xi8>, %arg1: vector<4xi64>) {
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<2xi8> // CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<2xi8>
%0 = arith.divsi %arg0, %arg0: vector<2xi8> %0 = arith.divsi %arg0, %arg0: vector<2xi8>
// CHECK: spirv.UDiv %{{.*}}, %{{.*}}: vector<4xi64> // CHECK: spirv.UDiv %{{.*}}, %{{.*}}: vector<4xi64>
%1 = arith.divui %arg1, %arg1: vector<4xi64> %1 = arith.divui %arg1, %arg1: vector<4xi64>
return return
} }
// CHECK-LABEL: @vector_srem // CHECK-LABEL: @vector_srem
// CHECK-SAME: (%[[LHS:.+]]: vector<3xi16>, %[[RHS:.+]]: vector<3xi16>) // CHECK-SAME: (%[[LHS:.+]]: vector<3xi16>, %[[RHS:.+]]: vector<3xi16>)
func.func @vector_srem(%arg0: vector<3xi16>, %arg1: vector<3xi16>) { func.func @vector_srem(%arg0: vector<3xi16>, %arg1: vector<3xi16>) {
// CHECK: %[[LABS:.+]] = spirv.GL.SAbs %[[LHS]] : vector<3xi16> // CHECK: %[[LABS:.+]] = spirv.GL.SAbs %[[LHS]] : vector<3xi16>
// CHECK: %[[RABS:.+]] = spirv.GL.SAbs %[[RHS]] : vector<3xi16> // CHECK: %[[RABS:.+]] = spirv.GL.SAbs %[[RHS]] : vector<3xi16>
// CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : vector<3xi16> // CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : vector<3xi16>
// CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : vector<3xi16> // CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : vector<3xi16>
// CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : vector<3xi16> // CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : vector<3xi16>
// CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : vector<3xi1>, vector<3xi16> // CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : vector<3xi1>, vector<3xi16>
%0 = arith.remsi %arg0, %arg1: vector<3xi16> %0 = arith.remsi %arg0, %arg1: vector<3xi16>
return return
} }
// Check float vector types. // Check float vector types.
// CHECK-LABEL: @float_vector234 // CHECK-LABEL: @float_vector234
func.func @float_vector234(%arg0: vector<2xf16>, %arg1: vector<3xf64>) { func.func @float_vector234(%arg0: vector<2xf16>, %arg1: vector<3xf64>) {
// CHECK: spirv.FAdd %{{.*}}, %{{.*}}: vector<2xf16> // CHECK: spirv.FAdd %{{.*}}, %{{.*}}: vector<2xf16>
%0 = arith.addf %arg0, %arg0: vector<2xf16> %0 = arith.addf %arg0, %arg0: vector<2xf16>
// CHECK: spirv.FMul %{{.*}}, %{{.*}}: vector<3xf64> // CHECK: spirv.FMul %{{.*}}, %{{.*}}: vector<3xf64>
%1 = arith.mulf %arg1, %arg1: vector<3xf64> %1 = arith.mulf %arg1, %arg1: vector<3xf64>
return return
} }
// CHECK-LABEL: @one_elem_vector // CHECK-LABEL: @one_elem_vector
func.func @one_elem_vector(%arg0: vector<1xi32>) { func.func @one_elem_vector(%arg0: vector<1xi32>) {
// CHECK: spirv.IAdd %{{.+}}, %{{.+}}: i32 // CHECK: spirv.IAdd %{{.+}}, %{{.+}}: i32
%0 = arith.addi %arg0, %arg0: vector<1xi32> %0 = arith.addi %arg0, %arg0: vector<1xi32>
return return
} }
// CHECK-LABEL: @unsupported_5elem_vector // CHECK-LABEL: @unsupported_5elem_vector
func.func @unsupported_5elem_vector(%arg0: vector<5xi32>) { func.func @unsupported_5elem_vector(%arg0: vector<5xi32>) {
// CHECK: arith.subi // CHECK: arith.subi
%1 = arith.subi %arg0, %arg0: vector<5xi32> %1 = arith.subi %arg0, %arg0: vector<5xi32>
return return
} }
// CHECK-LABEL: @unsupported_2x2elem_vector // CHECK-LABEL: @unsupported_2x2elem_vector
func.func @unsupported_2x2elem_vector(%arg0: vector<2x2xi32>) { func.func @unsupported_2x2elem_vector(%arg0: vector<2x2xi32>) {
// CHECK: arith.muli // CHECK: arith.muli
%2 = arith.muli %arg0, %arg0: vector<2x2xi32> %2 = arith.muli %arg0, %arg0: vector<2x2xi32>
return return
} }
} // end module } // end module
// ----- // -----
// Check that types are converted to 32-bit when no special capabilities. // Check that types are converted to 32-bit when no special capabilities.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @int_vector23 // CHECK-LABEL: @int_vector23
func.func @int_vector23(%arg0: vector<2xi8>, %arg1: vector<3xi16>) { func.func @int_vector23(%arg0: vector<2xi8>, %arg1: vector<3xi16>) {
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<2xi32> // CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<2xi32>
%0 = arith.divsi %arg0, %arg0: vector<2xi8> %0 = arith.divsi %arg0, %arg0: vector<2xi8>
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<3xi32> // CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<3xi32>
%1 = arith.divsi %arg1, %arg1: vector<3xi16> %1 = arith.divsi %arg1, %arg1: vector<3xi16>
return return
} }
// CHECK-LABEL: @float_scalar // CHECK-LABEL: @float_scalar
func.func @float_scalar(%arg0: f16, %arg1: f64) { func.func @float_scalar(%arg0: f16, %arg1: f64) {
// CHECK: spirv.FAdd %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FAdd %{{.*}}, %{{.*}}: f32
%0 = arith.addf %arg0, %arg0: f16 %0 = arith.addf %arg0, %arg0: f16
// CHECK: spirv.FMul %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FMul %{{.*}}, %{{.*}}: f32
%1 = arith.mulf %arg1, %arg1: f64 %1 = arith.mulf %arg1, %arg1: f64
return return
} }
} // end module } // end module
// ----- // -----
// Check that types are converted to 32-bit when no special capabilities that // Check that types are converted to 32-bit when no special capabilities that
// are not supported. // are not supported.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
func.func @int_vector4_invalid(%arg0: vector<4xi64>) { func.func @int_vector4_invalid(%arg0: vector<4xi64>) {
// expected-error @+1 {{bitwidth emulation is not implemented yet on unsigned op}} // expected-error @+1 {{bitwidth emulation is not implemented yet on unsigned op}}
%0 = arith.divui %arg0, %arg0: vector<4xi64> %0 = arith.divui %arg0, %arg0: vector<4xi64>
return return
} }
} // end module } // end module
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// std bit ops // std bit ops
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @bitwise_scalar // CHECK-LABEL: @bitwise_scalar
func.func @bitwise_scalar(%arg0 : i32, %arg1 : i32) { func.func @bitwise_scalar(%arg0 : i32, %arg1 : i32) {
// CHECK: spirv.BitwiseAnd // CHECK: spirv.BitwiseAnd
%0 = arith.andi %arg0, %arg1 : i32 %0 = arith.andi %arg0, %arg1 : i32
// CHECK: spirv.BitwiseOr // CHECK: spirv.BitwiseOr
%1 = arith.ori %arg0, %arg1 : i32 %1 = arith.ori %arg0, %arg1 : i32
// CHECK: spirv.BitwiseXor // CHECK: spirv.BitwiseXor
%2 = arith.xori %arg0, %arg1 : i32 %2 = arith.xori %arg0, %arg1 : i32
return return
} }
// CHECK-LABEL: @bitwise_vector // CHECK-LABEL: @bitwise_vector
func.func @bitwise_vector(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) { func.func @bitwise_vector(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) {
// CHECK: spirv.BitwiseAnd // CHECK: spirv.BitwiseAnd
%0 = arith.andi %arg0, %arg1 : vector<4xi32> %0 = arith.andi %arg0, %arg1 : vector<4xi32>
// CHECK: spirv.BitwiseOr // CHECK: spirv.BitwiseOr
%1 = arith.ori %arg0, %arg1 : vector<4xi32> %1 = arith.ori %arg0, %arg1 : vector<4xi32>
// CHECK: spirv.BitwiseXor // CHECK: spirv.BitwiseXor
%2 = arith.xori %arg0, %arg1 : vector<4xi32> %2 = arith.xori %arg0, %arg1 : vector<4xi32>
return return
} }
// CHECK-LABEL: @logical_scalar // CHECK-LABEL: @logical_scalar
func.func @logical_scalar(%arg0 : i1, %arg1 : i1) { func.func @logical_scalar(%arg0 : i1, %arg1 : i1) {
// CHECK: spirv.LogicalAnd // CHECK: spirv.LogicalAnd
%0 = arith.andi %arg0, %arg1 : i1 %0 = arith.andi %arg0, %arg1 : i1
// CHECK: spirv.LogicalOr // CHECK: spirv.LogicalOr
%1 = arith.ori %arg0, %arg1 : i1 %1 = arith.ori %arg0, %arg1 : i1
// CHECK: spirv.LogicalNotEqual // CHECK: spirv.LogicalNotEqual
%2 = arith.xori %arg0, %arg1 : i1 %2 = arith.xori %arg0, %arg1 : i1
return return
} }
// CHECK-LABEL: @logical_vector // CHECK-LABEL: @logical_vector
func.func @logical_vector(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>) { func.func @logical_vector(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>) {
// CHECK: spirv.LogicalAnd // CHECK: spirv.LogicalAnd
%0 = arith.andi %arg0, %arg1 : vector<4xi1> %0 = arith.andi %arg0, %arg1 : vector<4xi1>
// CHECK: spirv.LogicalOr // CHECK: spirv.LogicalOr
%1 = arith.ori %arg0, %arg1 : vector<4xi1> %1 = arith.ori %arg0, %arg1 : vector<4xi1>
// CHECK: spirv.LogicalNotEqual // CHECK: spirv.LogicalNotEqual
%2 = arith.xori %arg0, %arg1 : vector<4xi1> %2 = arith.xori %arg0, %arg1 : vector<4xi1>
return return
} }
// CHECK-LABEL: @shift_scalar // CHECK-LABEL: @shift_scalar
func.func @shift_scalar(%arg0 : i32, %arg1 : i32) { func.func @shift_scalar(%arg0 : i32, %arg1 : i32) {
// CHECK: spirv.ShiftLeftLogical // CHECK: spirv.ShiftLeftLogical
%0 = arith.shli %arg0, %arg1 : i32 %0 = arith.shli %arg0, %arg1 : i32
// CHECK: spirv.ShiftRightArithmetic // CHECK: spirv.ShiftRightArithmetic
%1 = arith.shrsi %arg0, %arg1 : i32 %1 = arith.shrsi %arg0, %arg1 : i32
// CHECK: spirv.ShiftRightLogical // CHECK: spirv.ShiftRightLogical
%2 = arith.shrui %arg0, %arg1 : i32 %2 = arith.shrui %arg0, %arg1 : i32
return return
} }
// CHECK-LABEL: @shift_vector // CHECK-LABEL: @shift_vector
func.func @shift_vector(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) { func.func @shift_vector(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) {
// CHECK: spirv.ShiftLeftLogical // CHECK: spirv.ShiftLeftLogical
%0 = arith.shli %arg0, %arg1 : vector<4xi32> %0 = arith.shli %arg0, %arg1 : vector<4xi32>
// CHECK: spirv.ShiftRightArithmetic // CHECK: spirv.ShiftRightArithmetic
%1 = arith.shrsi %arg0, %arg1 : vector<4xi32> %1 = arith.shrsi %arg0, %arg1 : vector<4xi32>
// CHECK: spirv.ShiftRightLogical // CHECK: spirv.ShiftRightLogical
%2 = arith.shrui %arg0, %arg1 : vector<4xi32> %2 = arith.shrui %arg0, %arg1 : vector<4xi32>
return return
} }
} // end module } // end module
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// arith.cmpf // arith.cmpf
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @cmpf // CHECK-LABEL: @cmpf
func.func @cmpf(%arg0 : f32, %arg1 : f32) { func.func @cmpf(%arg0 : f32, %arg1 : f32) {
// CHECK: spirv.FOrdEqual // CHECK: spirv.FOrdEqual
%1 = arith.cmpf oeq, %arg0, %arg1 : f32 %1 = arith.cmpf oeq, %arg0, %arg1 : f32
// CHECK: spirv.FOrdGreaterThan // CHECK: spirv.FOrdGreaterThan
%2 = arith.cmpf ogt, %arg0, %arg1 : f32 %2 = arith.cmpf ogt, %arg0, %arg1 : f32
// CHECK: spirv.FOrdGreaterThanEqual // CHECK: spirv.FOrdGreaterThanEqual
%3 = arith.cmpf oge, %arg0, %arg1 : f32 %3 = arith.cmpf oge, %arg0, %arg1 : f32
// CHECK: spirv.FOrdLessThan // CHECK: spirv.FOrdLessThan
%4 = arith.cmpf olt, %arg0, %arg1 : f32 %4 = arith.cmpf olt, %arg0, %arg1 : f32
// CHECK: spirv.FOrdLessThanEqual // CHECK: spirv.FOrdLessThanEqual
%5 = arith.cmpf ole, %arg0, %arg1 : f32 %5 = arith.cmpf ole, %arg0, %arg1 : f32
// CHECK: spirv.FOrdNotEqual // CHECK: spirv.FOrdNotEqual
%6 = arith.cmpf one, %arg0, %arg1 : f32 %6 = arith.cmpf one, %arg0, %arg1 : f32
// CHECK: spirv.FUnordEqual // CHECK: spirv.FUnordEqual
%7 = arith.cmpf ueq, %arg0, %arg1 : f32 %7 = arith.cmpf ueq, %arg0, %arg1 : f32
// CHECK: spirv.FUnordGreaterThan // CHECK: spirv.FUnordGreaterThan
%8 = arith.cmpf ugt, %arg0, %arg1 : f32 %8 = arith.cmpf ugt, %arg0, %arg1 : f32
// CHECK: spirv.FUnordGreaterThanEqual // CHECK: spirv.FUnordGreaterThanEqual
%9 = arith.cmpf uge, %arg0, %arg1 : f32 %9 = arith.cmpf uge, %arg0, %arg1 : f32
// CHECK: spirv.FUnordLessThan // CHECK: spirv.FUnordLessThan
%10 = arith.cmpf ult, %arg0, %arg1 : f32 %10 = arith.cmpf ult, %arg0, %arg1 : f32
// CHECK: FUnordLessThanEqual // CHECK: FUnordLessThanEqual
%11 = arith.cmpf ule, %arg0, %arg1 : f32 %11 = arith.cmpf ule, %arg0, %arg1 : f32
// CHECK: spirv.FUnordNotEqual // CHECK: spirv.FUnordNotEqual
%12 = arith.cmpf une, %arg0, %arg1 : f32 %12 = arith.cmpf une, %arg0, %arg1 : f32
return return
} }
} // end module } // end module
// ----- // -----
// With Kernel capability, we can convert NaN check to spirv.Ordered/spirv.Unordered. // With Kernel capability, we can convert NaN check to spirv.Ordered/spirv.Unordered.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Kernel], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Kernel], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @cmpf // CHECK-LABEL: @cmpf
func.func @cmpf(%arg0 : f32, %arg1 : f32) { func.func @cmpf(%arg0 : f32, %arg1 : f32) {
// CHECK: spirv.Ordered // CHECK: spirv.Ordered
%0 = arith.cmpf ord, %arg0, %arg1 : f32 %0 = arith.cmpf ord, %arg0, %arg1 : f32
// CHECK: spirv.Unordered // CHECK: spirv.Unordered
%1 = arith.cmpf uno, %arg0, %arg1 : f32 %1 = arith.cmpf uno, %arg0, %arg1 : f32
return return
} }
} // end module } // end module
// ----- // -----
// Without Kernel capability, we need to convert NaN check to spirv.IsNan. // Without Kernel capability, we need to convert NaN check to spirv.IsNan.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @cmpf // CHECK-LABEL: @cmpf
// CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32 // CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32
func.func @cmpf(%arg0 : f32, %arg1 : f32) { func.func @cmpf(%arg0 : f32, %arg1 : f32) {
// CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32 // CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32
// CHECK-NEXT: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32 // CHECK-NEXT: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32
// CHECK-NEXT: %[[OR:.+]] = spirv.LogicalOr %[[LHS_NAN]], %[[RHS_NAN]] : i1 // CHECK-NEXT: %[[OR:.+]] = spirv.LogicalOr %[[LHS_NAN]], %[[RHS_NAN]] : i1
// CHECK-NEXT: %{{.+}} = spirv.LogicalNot %[[OR]] : i1 // CHECK-NEXT: %{{.+}} = spirv.LogicalNot %[[OR]] : i1
%0 = arith.cmpf ord, %arg0, %arg1 : f32 %0 = arith.cmpf ord, %arg0, %arg1 : f32
// CHECK-NEXT: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32 // CHECK-NEXT: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32
// CHECK-NEXT: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32 // CHECK-NEXT: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32
// CHECK-NEXT: %{{.+}} = spirv.LogicalOr %[[LHS_NAN]], %[[RHS_NAN]] : i1 // CHECK-NEXT: %{{.+}} = spirv.LogicalOr %[[LHS_NAN]], %[[RHS_NAN]] : i1
%1 = arith.cmpf uno, %arg0, %arg1 : f32 %1 = arith.cmpf uno, %arg0, %arg1 : f32
return return
} }
} // end module } // end module
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// arith.cmpi // arith.cmpi
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @cmpi // CHECK-LABEL: @cmpi
func.func @cmpi(%arg0 : i32, %arg1 : i32) { func.func @cmpi(%arg0 : i32, %arg1 : i32) {
// CHECK: spirv.IEqual // CHECK: spirv.IEqual
%0 = arith.cmpi eq, %arg0, %arg1 : i32 %0 = arith.cmpi eq, %arg0, %arg1 : i32
// CHECK: spirv.INotEqual // CHECK: spirv.INotEqual
%1 = arith.cmpi ne, %arg0, %arg1 : i32 %1 = arith.cmpi ne, %arg0, %arg1 : i32
// CHECK: spirv.SLessThan // CHECK: spirv.SLessThan
%2 = arith.cmpi slt, %arg0, %arg1 : i32 %2 = arith.cmpi slt, %arg0, %arg1 : i32
// CHECK: spirv.SLessThanEqual // CHECK: spirv.SLessThanEqual
%3 = arith.cmpi sle, %arg0, %arg1 : i32 %3 = arith.cmpi sle, %arg0, %arg1 : i32
// CHECK: spirv.SGreaterThan // CHECK: spirv.SGreaterThan
%4 = arith.cmpi sgt, %arg0, %arg1 : i32 %4 = arith.cmpi sgt, %arg0, %arg1 : i32
// CHECK: spirv.SGreaterThanEqual // CHECK: spirv.SGreaterThanEqual
%5 = arith.cmpi sge, %arg0, %arg1 : i32 %5 = arith.cmpi sge, %arg0, %arg1 : i32
// CHECK: spirv.ULessThan // CHECK: spirv.ULessThan
%6 = arith.cmpi ult, %arg0, %arg1 : i32 %6 = arith.cmpi ult, %arg0, %arg1 : i32
// CHECK: spirv.ULessThanEqual // CHECK: spirv.ULessThanEqual
%7 = arith.cmpi ule, %arg0, %arg1 : i32 %7 = arith.cmpi ule, %arg0, %arg1 : i32
// CHECK: spirv.UGreaterThan // CHECK: spirv.UGreaterThan
%8 = arith.cmpi ugt, %arg0, %arg1 : i32 %8 = arith.cmpi ugt, %arg0, %arg1 : i32
// CHECK: spirv.UGreaterThanEqual // CHECK: spirv.UGreaterThanEqual
%9 = arith.cmpi uge, %arg0, %arg1 : i32 %9 = arith.cmpi uge, %arg0, %arg1 : i32
return return
} }
// CHECK-LABEL: @vec1cmpi // CHECK-LABEL: @vec1cmpi
func.func @vec1cmpi(%arg0 : vector<1xi32>, %arg1 : vector<1xi32>) { func.func @vec1cmpi(%arg0 : vector<1xi32>, %arg1 : vector<1xi32>) {
// CHECK: spirv.ULessThan // CHECK: spirv.ULessThan
%0 = arith.cmpi ult, %arg0, %arg1 : vector<1xi32> %0 = arith.cmpi ult, %arg0, %arg1 : vector<1xi32>
// CHECK: spirv.SGreaterThan // CHECK: spirv.SGreaterThan
%1 = arith.cmpi sgt, %arg0, %arg1 : vector<1xi32> %1 = arith.cmpi sgt, %arg0, %arg1 : vector<1xi32>
return return
} }
// CHECK-LABEL: @boolcmpi_equality // CHECK-LABEL: @boolcmpi_equality
func.func @boolcmpi_equality(%arg0 : i1, %arg1 : i1) { func.func @boolcmpi_equality(%arg0 : i1, %arg1 : i1) {
// CHECK: spirv.LogicalEqual // CHECK: spirv.LogicalEqual
%0 = arith.cmpi eq, %arg0, %arg1 : i1 %0 = arith.cmpi eq, %arg0, %arg1 : i1
// CHECK: spirv.LogicalNotEqual // CHECK: spirv.LogicalNotEqual
%1 = arith.cmpi ne, %arg0, %arg1 : i1 %1 = arith.cmpi ne, %arg0, %arg1 : i1
return return
} }
// CHECK-LABEL: @boolcmpi_unsigned // CHECK-LABEL: @boolcmpi_unsigned
func.func @boolcmpi_unsigned(%arg0 : i1, %arg1 : i1) { func.func @boolcmpi_unsigned(%arg0 : i1, %arg1 : i1) {
// CHECK-COUNT-2: spirv.Select // CHECK-COUNT-2: spirv.Select
// CHECK: spirv.UGreaterThanEqual // CHECK: spirv.UGreaterThanEqual
%0 = arith.cmpi uge, %arg0, %arg1 : i1 %0 = arith.cmpi uge, %arg0, %arg1 : i1
// CHECK-COUNT-2: spirv.Select // CHECK-COUNT-2: spirv.Select
// CHECK: spirv.ULessThan // CHECK: spirv.ULessThan
%1 = arith.cmpi ult, %arg0, %arg1 : i1 %1 = arith.cmpi ult, %arg0, %arg1 : i1
return return
} }
// CHECK-LABEL: @vec1boolcmpi_equality // CHECK-LABEL: @vec1boolcmpi_equality
func.func @vec1boolcmpi_equality(%arg0 : vector<1xi1>, %arg1 : vector<1xi1>) { func.func @vec1boolcmpi_equality(%arg0 : vector<1xi1>, %arg1 : vector<1xi1>) {
// CHECK: spirv.LogicalEqual // CHECK: spirv.LogicalEqual
%0 = arith.cmpi eq, %arg0, %arg1 : vector<1xi1> %0 = arith.cmpi eq, %arg0, %arg1 : vector<1xi1>
// CHECK: spirv.LogicalNotEqual // CHECK: spirv.LogicalNotEqual
%1 = arith.cmpi ne, %arg0, %arg1 : vector<1xi1> %1 = arith.cmpi ne, %arg0, %arg1 : vector<1xi1>
return return
} }
// CHECK-LABEL: @vec1boolcmpi_unsigned // CHECK-LABEL: @vec1boolcmpi_unsigned
func.func @vec1boolcmpi_unsigned(%arg0 : vector<1xi1>, %arg1 : vector<1xi1>) { func.func @vec1boolcmpi_unsigned(%arg0 : vector<1xi1>, %arg1 : vector<1xi1>) {
// CHECK-COUNT-2: spirv.Select // CHECK-COUNT-2: spirv.Select
// CHECK: spirv.UGreaterThanEqual // CHECK: spirv.UGreaterThanEqual
%0 = arith.cmpi uge, %arg0, %arg1 : vector<1xi1> %0 = arith.cmpi uge, %arg0, %arg1 : vector<1xi1>
// CHECK-COUNT-2: spirv.Select // CHECK-COUNT-2: spirv.Select
// CHECK: spirv.ULessThan // CHECK: spirv.ULessThan
%1 = arith.cmpi ult, %arg0, %arg1 : vector<1xi1> %1 = arith.cmpi ult, %arg0, %arg1 : vector<1xi1>
return return
} }
// CHECK-LABEL: @vecboolcmpi_equality // CHECK-LABEL: @vecboolcmpi_equality
func.func @vecboolcmpi_equality(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>) { func.func @vecboolcmpi_equality(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>) {
// CHECK: spirv.LogicalEqual // CHECK: spirv.LogicalEqual
%0 = arith.cmpi eq, %arg0, %arg1 : vector<4xi1> %0 = arith.cmpi eq, %arg0, %arg1 : vector<4xi1>
// CHECK: spirv.LogicalNotEqual // CHECK: spirv.LogicalNotEqual
%1 = arith.cmpi ne, %arg0, %arg1 : vector<4xi1> %1 = arith.cmpi ne, %arg0, %arg1 : vector<4xi1>
return return
} }
// CHECK-LABEL: @vecboolcmpi_unsigned // CHECK-LABEL: @vecboolcmpi_unsigned
func.func @vecboolcmpi_unsigned(%arg0 : vector<3xi1>, %arg1 : vector<3xi1>) { func.func @vecboolcmpi_unsigned(%arg0 : vector<3xi1>, %arg1 : vector<3xi1>) {
// CHECK-COUNT-2: spirv.Select // CHECK-COUNT-2: spirv.Select
// CHECK: spirv.UGreaterThanEqual // CHECK: spirv.UGreaterThanEqual
%0 = arith.cmpi uge, %arg0, %arg1 : vector<3xi1> %0 = arith.cmpi uge, %arg0, %arg1 : vector<3xi1>
// CHECK-COUNT-2: spirv.Select // CHECK-COUNT-2: spirv.Select
// CHECK: spirv.ULessThan // CHECK: spirv.ULessThan
%1 = arith.cmpi ult, %arg0, %arg1 : vector<3xi1> %1 = arith.cmpi ult, %arg0, %arg1 : vector<3xi1>
return return
} }
} // end module } // end module
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// arith.constant // arith.constant
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env< spirv.target_env = #spirv.target_env<
#spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, #spirv.resource_limits<>> #spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @constant // CHECK-LABEL: @constant
func.func @constant() { func.func @constant() {
// CHECK: spirv.Constant true // CHECK: spirv.Constant true
%0 = arith.constant true %0 = arith.constant true
// CHECK: spirv.Constant 42 : i32 // CHECK: spirv.Constant 42 : i32
%1 = arith.constant 42 : i32 %1 = arith.constant 42 : i32
// CHECK: spirv.Constant 5.000000e-01 : f32 // CHECK: spirv.Constant 5.000000e-01 : f32
%2 = arith.constant 0.5 : f32 %2 = arith.constant 0.5 : f32
// CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32> // CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32>
%3 = arith.constant dense<[2, 3]> : vector<2xi32> %3 = arith.constant dense<[2, 3]> : vector<2xi32>
// CHECK: spirv.Constant 1 : i32 // CHECK: spirv.Constant 1 : i32
%4 = arith.constant 1 : index %4 = arith.constant 1 : index
// CHECK: spirv.Constant dense<1> : tensor<6xi32> : !spirv.array<6 x i32> // CHECK: spirv.Constant dense<1> : tensor<6xi32> : !spirv.array<6 x i32>
%5 = arith.constant dense<1> : tensor<2x3xi32> %5 = arith.constant dense<1> : tensor<2x3xi32>
// CHECK: spirv.Constant dense<1.000000e+00> : tensor<6xf32> : !spirv.array<6 x f32> // CHECK: spirv.Constant dense<1.000000e+00> : tensor<6xf32> : !spirv.array<6 x f32>
%6 = arith.constant dense<1.0> : tensor<2x3xf32> %6 = arith.constant dense<1.0> : tensor<2x3xf32>
// CHECK: spirv.Constant dense<{{\[}}1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf32> : !spirv.array<6 x f32> // CHECK: spirv.Constant dense<{{\[}}1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf32> : !spirv.array<6 x f32>
%7 = arith.constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32> %7 = arith.constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32>
// CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32> // CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32>
%8 = arith.constant dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32> %8 = arith.constant dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32>
// CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32> // CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32>
%9 = arith.constant dense<[[1, 2], [3, 4], [5, 6]]> : tensor<3x2xi32> %9 = arith.constant dense<[[1, 2], [3, 4], [5, 6]]> : tensor<3x2xi32>
// CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32> // CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32>
%10 = arith.constant dense<[1, 2, 3, 4, 5, 6]> : tensor<6xi32> %10 = arith.constant dense<[1, 2, 3, 4, 5, 6]> : tensor<6xi32>
return return
} }
// CHECK-LABEL: @constant_16bit // CHECK-LABEL: @constant_16bit
func.func @constant_16bit() { func.func @constant_16bit() {
// CHECK: spirv.Constant 4 : i16 // CHECK: spirv.Constant 4 : i16
%0 = arith.constant 4 : i16 %0 = arith.constant 4 : i16
// CHECK: spirv.Constant 5.000000e+00 : f16 // CHECK: spirv.Constant 5.000000e+00 : f16
%1 = arith.constant 5.0 : f16 %1 = arith.constant 5.0 : f16
// CHECK: spirv.Constant dense<[2, 3]> : vector<2xi16> // CHECK: spirv.Constant dense<[2, 3]> : vector<2xi16>
%2 = arith.constant dense<[2, 3]> : vector<2xi16> %2 = arith.constant dense<[2, 3]> : vector<2xi16>
// CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf16> : !spirv.array<5 x f16> // CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf16> : !spirv.array<5 x f16>
%3 = arith.constant dense<4.0> : tensor<5xf16> %3 = arith.constant dense<4.0> : tensor<5xf16>
return return
} }
// CHECK-LABEL: @constant_64bit // CHECK-LABEL: @constant_64bit
func.func @constant_64bit() { func.func @constant_64bit() {
// CHECK: spirv.Constant 4 : i64 // CHECK: spirv.Constant 4 : i64
%0 = arith.constant 4 : i64 %0 = arith.constant 4 : i64
// CHECK: spirv.Constant 5.000000e+00 : f64 // CHECK: spirv.Constant 5.000000e+00 : f64
%1 = arith.constant 5.0 : f64 %1 = arith.constant 5.0 : f64
// CHECK: spirv.Constant dense<[2, 3]> : vector<2xi64> // CHECK: spirv.Constant dense<[2, 3]> : vector<2xi64>
%2 = arith.constant dense<[2, 3]> : vector<2xi64> %2 = arith.constant dense<[2, 3]> : vector<2xi64>
// CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf64> : !spirv.array<5 x f64> // CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf64> : !spirv.array<5 x f64>
%3 = arith.constant dense<4.0> : tensor<5xf64> %3 = arith.constant dense<4.0> : tensor<5xf64>
return return
} }
// CHECK-LABEL: @constant_size1 // CHECK-LABEL: @constant_size1
func.func @constant_size1() { func.func @constant_size1() {
// CHECK: spirv.Constant true // CHECK: spirv.Constant true
%0 = arith.constant dense<true> : tensor<1xi1> %0 = arith.constant dense<true> : tensor<1xi1>
// CHECK: spirv.Constant 4 : i64 // CHECK: spirv.Constant 4 : i64
%1 = arith.constant dense<4> : vector<1xi64> %1 = arith.constant dense<4> : vector<1xi64>
// CHECK: spirv.Constant 5.000000e+00 : f64 // CHECK: spirv.Constant 5.000000e+00 : f64
%2 = arith.constant dense<5.0> : tensor<1xf64> %2 = arith.constant dense<5.0> : tensor<1xf64>
return return
} }
} // end module } // end module
// ----- // -----
// Check that constants are converted to 32-bit when no special capability. // Check that constants are converted to 32-bit when no special capability.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @constant_16bit // CHECK-LABEL: @constant_16bit
func.func @constant_16bit() { func.func @constant_16bit() {
// CHECK: spirv.Constant 4 : i32 // CHECK: spirv.Constant 4 : i32
%0 = arith.constant 4 : i16 %0 = arith.constant 4 : i16
// CHECK: spirv.Constant 5.000000e+00 : f32 // CHECK: spirv.Constant 5.000000e+00 : f32
%1 = arith.constant 5.0 : f16 %1 = arith.constant 5.0 : f16
// CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32> // CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32>
%2 = arith.constant dense<[2, 3]> : vector<2xi16> %2 = arith.constant dense<[2, 3]> : vector<2xi16>
// CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf32> : !spirv.array<5 x f32> // CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf32> : !spirv.array<5 x f32>
%3 = arith.constant dense<4.0> : tensor<5xf16> %3 = arith.constant dense<4.0> : tensor<5xf16>
// CHECK: spirv.Constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spirv.array<4 x f32> // CHECK: spirv.Constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spirv.array<4 x f32>
%4 = arith.constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16> %4 = arith.constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16>
return return
} }
// CHECK-LABEL: @constant_64bit // CHECK-LABEL: @constant_64bit
func.func @constant_64bit() { func.func @constant_64bit() {
// CHECK: spirv.Constant 4 : i32 // CHECK: spirv.Constant 4 : i32
%0 = arith.constant 4 : i64 %0 = arith.constant 4 : i64
// CHECK: spirv.Constant 5.000000e+00 : f32 // CHECK: spirv.Constant 5.000000e+00 : f32
%1 = arith.constant 5.0 : f64 %1 = arith.constant 5.0 : f64
// CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32> // CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32>
%2 = arith.constant dense<[2, 3]> : vector<2xi64> %2 = arith.constant dense<[2, 3]> : vector<2xi64>
// CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf32> : !spirv.array<5 x f32> // CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf32> : !spirv.array<5 x f32>
%3 = arith.constant dense<4.0> : tensor<5xf64> %3 = arith.constant dense<4.0> : tensor<5xf64>
// CHECK: spirv.Constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spirv.array<4 x f32> // CHECK: spirv.Constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spirv.array<4 x f32>
%4 = arith.constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16> %4 = arith.constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16>
return return
} }
// CHECK-LABEL: @constant_size1 // CHECK-LABEL: @constant_size1
func.func @constant_size1() { func.func @constant_size1() {
// CHECK: spirv.Constant 4 : i32 // CHECK: spirv.Constant 4 : i32
%0 = arith.constant dense<4> : vector<1xi64> %0 = arith.constant dense<4> : vector<1xi64>
// CHECK: spirv.Constant 5.000000e+00 : f32 // CHECK: spirv.Constant 5.000000e+00 : f32
%1 = arith.constant dense<5.0> : tensor<1xf64> %1 = arith.constant dense<5.0> : tensor<1xf64>
return return
} }
// CHECK-LABEL: @corner_cases // CHECK-LABEL: @corner_cases
func.func @corner_cases() { func.func @corner_cases() {
// CHECK: %{{.*}} = spirv.Constant -1 : i32 // CHECK: %{{.*}} = spirv.Constant -1 : i32
%0 = arith.constant 4294967295 : i64 // 2^32 - 1 %0 = arith.constant 4294967295 : i64 // 2^32 - 1
// CHECK: %{{.*}} = spirv.Constant 2147483647 : i32 // CHECK: %{{.*}} = spirv.Constant 2147483647 : i32
%1 = arith.constant 2147483647 : i64 // 2^31 - 1 %1 = arith.constant 2147483647 : i64 // 2^31 - 1
// CHECK: %{{.*}} = spirv.Constant -2147483648 : i32 // CHECK: %{{.*}} = spirv.Constant -2147483648 : i32
%2 = arith.constant 2147483648 : i64 // 2^31 %2 = arith.constant 2147483648 : i64 // 2^31
// CHECK: %{{.*}} = spirv.Constant -2147483648 : i32 // CHECK: %{{.*}} = spirv.Constant -2147483648 : i32
%3 = arith.constant -2147483648 : i64 // -2^31 %3 = arith.constant -2147483648 : i64 // -2^31
// CHECK: %{{.*}} = spirv.Constant -1 : i32 // CHECK: %{{.*}} = spirv.Constant -1 : i32
%5 = arith.constant -1 : i64 %5 = arith.constant -1 : i64
// CHECK: %{{.*}} = spirv.Constant -2 : i32 // CHECK: %{{.*}} = spirv.Constant -2 : i32
%6 = arith.constant -2 : i64 %6 = arith.constant -2 : i64
// CHECK: %{{.*}} = spirv.Constant -1 : i32 // CHECK: %{{.*}} = spirv.Constant -1 : i32
%7 = arith.constant -1 : index %7 = arith.constant -1 : index
// CHECK: %{{.*}} = spirv.Constant -2 : i32 // CHECK: %{{.*}} = spirv.Constant -2 : i32
%8 = arith.constant -2 : index %8 = arith.constant -2 : index
// CHECK: spirv.Constant false // CHECK: spirv.Constant false
%9 = arith.constant false %9 = arith.constant false
// CHECK: spirv.Constant true // CHECK: spirv.Constant true
%10 = arith.constant true %10 = arith.constant true
return return
} }
// CHECK-LABEL: @unsupported_cases // CHECK-LABEL: @unsupported_cases
func.func @unsupported_cases() { func.func @unsupported_cases() {
// CHECK: %{{.*}} = arith.constant 4294967296 : i64 // CHECK: %{{.*}} = arith.constant 4294967296 : i64
%0 = arith.constant 4294967296 : i64 // 2^32 %0 = arith.constant 4294967296 : i64 // 2^32
// CHECK: %{{.*}} = arith.constant -2147483649 : i64 // CHECK: %{{.*}} = arith.constant -2147483649 : i64
%1 = arith.constant -2147483649 : i64 // -2^31 - 1 %1 = arith.constant -2147483649 : i64 // -2^31 - 1
// CHECK: %{{.*}} = arith.constant 1.0000000000000002 : f64 // CHECK: %{{.*}} = arith.constant 1.0000000000000002 : f64
%2 = arith.constant 0x3FF0000000000001 : f64 // smallest number > 1 %2 = arith.constant 0x3FF0000000000001 : f64 // smallest number > 1
return return
} }
} // end module } // end module
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// std cast ops // std cast ops
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env< spirv.target_env = #spirv.target_env<
#spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, #spirv.resource_limits<>> #spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: index_cast1 // CHECK-LABEL: index_cast1
func.func @index_cast1(%arg0: i16) { func.func @index_cast1(%arg0: i16) {
// CHECK: spirv.SConvert %{{.+}} : i16 to i32 // CHECK: spirv.SConvert %{{.+}} : i16 to i32
%0 = arith.index_cast %arg0 : i16 to index %0 = arith.index_cast %arg0 : i16 to index
return return
} }
// CHECK-LABEL: index_cast2 // CHECK-LABEL: index_cast2
func.func @index_cast2(%arg0: index) { func.func @index_cast2(%arg0: index) {
// CHECK: spirv.SConvert %{{.+}} : i32 to i16 // CHECK: spirv.SConvert %{{.+}} : i32 to i16
%0 = arith.index_cast %arg0 : index to i16 %0 = arith.index_cast %arg0 : index to i16
return return
} }
// CHECK-LABEL: index_cast3 // CHECK-LABEL: index_cast3
func.func @index_cast3(%arg0: i32) { func.func @index_cast3(%arg0: i32) {
// CHECK-NOT: spirv.SConvert // CHECK-NOT: spirv.SConvert
%0 = arith.index_cast %arg0 : i32 to index %0 = arith.index_cast %arg0 : i32 to index
return return
} }
// CHECK-LABEL: index_cast4 // CHECK-LABEL: index_cast4
func.func @index_cast4(%arg0: index) { func.func @index_cast4(%arg0: index) {
// CHECK-NOT: spirv.SConvert // CHECK-NOT: spirv.SConvert
%0 = arith.index_cast %arg0 : index to i32 %0 = arith.index_cast %arg0 : index to i32
return return
} }
// CHECK-LABEL: @bit_cast // CHECK-LABEL: @bit_cast
func.func @bit_cast(%arg0: vector<2xf32>, %arg1: i64) { func.func @bit_cast(%arg0: vector<2xf32>, %arg1: i64) {
// CHECK: spirv.Bitcast %{{.+}} : vector<2xf32> to vector<2xi32> // CHECK: spirv.Bitcast %{{.+}} : vector<2xf32> to vector<2xi32>
%0 = arith.bitcast %arg0 : vector<2xf32> to vector<2xi32> %0 = arith.bitcast %arg0 : vector<2xf32> to vector<2xi32>
// CHECK: spirv.Bitcast %{{.+}} : i64 to f64 // CHECK: spirv.Bitcast %{{.+}} : i64 to f64
%1 = arith.bitcast %arg1 : i64 to f64 %1 = arith.bitcast %arg1 : i64 to f64
return return
} }
// CHECK-LABEL: @fpext1 // CHECK-LABEL: @fpext1
func.func @fpext1(%arg0: f16) -> f64 { func.func @fpext1(%arg0: f16) -> f64 {
// CHECK: spirv.FConvert %{{.*}} : f16 to f64 // CHECK: spirv.FConvert %{{.*}} : f16 to f64
%0 = arith.extf %arg0 : f16 to f64 %0 = arith.extf %arg0 : f16 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: @fpext2 // CHECK-LABEL: @fpext2
func.func @fpext2(%arg0 : f32) -> f64 { func.func @fpext2(%arg0 : f32) -> f64 {
// CHECK: spirv.FConvert %{{.*}} : f32 to f64 // CHECK: spirv.FConvert %{{.*}} : f32 to f64
%0 = arith.extf %arg0 : f32 to f64 %0 = arith.extf %arg0 : f32 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: @fptrunc1 // CHECK-LABEL: @fptrunc1
func.func @fptrunc1(%arg0 : f64) -> f16 { func.func @fptrunc1(%arg0 : f64) -> f16 {
// CHECK: spirv.FConvert %{{.*}} : f64 to f16 // CHECK: spirv.FConvert %{{.*}} : f64 to f16
%0 = arith.truncf %arg0 : f64 to f16 %0 = arith.truncf %arg0 : f64 to f16
return %0 : f16 return %0 : f16
} }
// CHECK-LABEL: @fptrunc2 // CHECK-LABEL: @fptrunc2
func.func @fptrunc2(%arg0: f32) -> f16 { func.func @fptrunc2(%arg0: f32) -> f16 {
// CHECK: spirv.FConvert %{{.*}} : f32 to f16 // CHECK: spirv.FConvert %{{.*}} : f32 to f16
%0 = arith.truncf %arg0 : f32 to f16 %0 = arith.truncf %arg0 : f32 to f16
return %0 : f16 return %0 : f16
} }
// CHECK-LABEL: @sitofp1 // CHECK-LABEL: @sitofp1
func.func @sitofp1(%arg0 : i32) -> f32 { func.func @sitofp1(%arg0 : i32) -> f32 {
// CHECK: spirv.ConvertSToF %{{.*}} : i32 to f32 // CHECK: spirv.ConvertSToF %{{.*}} : i32 to f32
%0 = arith.sitofp %arg0 : i32 to f32 %0 = arith.sitofp %arg0 : i32 to f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: @sitofp2 // CHECK-LABEL: @sitofp2
func.func @sitofp2(%arg0 : i64) -> f64 { func.func @sitofp2(%arg0 : i64) -> f64 {
// CHECK: spirv.ConvertSToF %{{.*}} : i64 to f64 // CHECK: spirv.ConvertSToF %{{.*}} : i64 to f64
%0 = arith.sitofp %arg0 : i64 to f64 %0 = arith.sitofp %arg0 : i64 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: @uitofp_i16_f32 // CHECK-LABEL: @uitofp_i16_f32
func.func @uitofp_i16_f32(%arg0: i16) -> f32 { func.func @uitofp_i16_f32(%arg0: i16) -> f32 {
// CHECK: spirv.ConvertUToF %{{.*}} : i16 to f32 // CHECK: spirv.ConvertUToF %{{.*}} : i16 to f32
%0 = arith.uitofp %arg0 : i16 to f32 %0 = arith.uitofp %arg0 : i16 to f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: @uitofp_i32_f32 // CHECK-LABEL: @uitofp_i32_f32
func.func @uitofp_i32_f32(%arg0 : i32) -> f32 { func.func @uitofp_i32_f32(%arg0 : i32) -> f32 {
// CHECK: spirv.ConvertUToF %{{.*}} : i32 to f32 // CHECK: spirv.ConvertUToF %{{.*}} : i32 to f32
%0 = arith.uitofp %arg0 : i32 to f32 %0 = arith.uitofp %arg0 : i32 to f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: @uitofp_i1_f32 // CHECK-LABEL: @uitofp_i1_f32
func.func @uitofp_i1_f32(%arg0 : i1) -> f32 { func.func @uitofp_i1_f32(%arg0 : i1) -> f32 {
// CHECK: %[[ZERO:.+]] = spirv.Constant 0.000000e+00 : f32 // CHECK: %[[ZERO:.+]] = spirv.Constant 0.000000e+00 : f32
// CHECK: %[[ONE:.+]] = spirv.Constant 1.000000e+00 : f32 // CHECK: %[[ONE:.+]] = spirv.Constant 1.000000e+00 : f32
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f32 // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f32
%0 = arith.uitofp %arg0 : i1 to f32 %0 = arith.uitofp %arg0 : i1 to f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: @uitofp_i1_f64 // CHECK-LABEL: @uitofp_i1_f64
func.func @uitofp_i1_f64(%arg0 : i1) -> f64 { func.func @uitofp_i1_f64(%arg0 : i1) -> f64 {
// CHECK: %[[ZERO:.+]] = spirv.Constant 0.000000e+00 : f64 // CHECK: %[[ZERO:.+]] = spirv.Constant 0.000000e+00 : f64
// CHECK: %[[ONE:.+]] = spirv.Constant 1.000000e+00 : f64 // CHECK: %[[ONE:.+]] = spirv.Constant 1.000000e+00 : f64
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f64 // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f64
%0 = arith.uitofp %arg0 : i1 to f64 %0 = arith.uitofp %arg0 : i1 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: @uitofp_vec_i1_f32 // CHECK-LABEL: @uitofp_vec_i1_f32
func.func @uitofp_vec_i1_f32(%arg0 : vector<4xi1>) -> vector<4xf32> { func.func @uitofp_vec_i1_f32(%arg0 : vector<4xi1>) -> vector<4xf32> {
// CHECK: %[[ZERO:.+]] = spirv.Constant dense<0.000000e+00> : vector<4xf32> // CHECK: %[[ZERO:.+]] = spirv.Constant dense<0.000000e+00> : vector<4xf32>
// CHECK: %[[ONE:.+]] = spirv.Constant dense<1.000000e+00> : vector<4xf32> // CHECK: %[[ONE:.+]] = spirv.Constant dense<1.000000e+00> : vector<4xf32>
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf32> // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf32>
%0 = arith.uitofp %arg0 : vector<4xi1> to vector<4xf32> %0 = arith.uitofp %arg0 : vector<4xi1> to vector<4xf32>
return %0 : vector<4xf32> return %0 : vector<4xf32>
} }
// CHECK-LABEL: @uitofp_vec_i1_f64 // CHECK-LABEL: @uitofp_vec_i1_f64
spirv.func @uitofp_vec_i1_f64(%arg0: vector<4xi1>) -> vector<4xf64> "None" { spirv.func @uitofp_vec_i1_f64(%arg0: vector<4xi1>) -> vector<4xf64> "None" {
// CHECK: %[[ZERO:.+]] = spirv.Constant dense<0.000000e+00> : vector<4xf64> // CHECK: %[[ZERO:.+]] = spirv.Constant dense<0.000000e+00> : vector<4xf64>
// CHECK: %[[ONE:.+]] = spirv.Constant dense<1.000000e+00> : vector<4xf64> // CHECK: %[[ONE:.+]] = spirv.Constant dense<1.000000e+00> : vector<4xf64>
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf64> // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf64>
%0 = spirv.Constant dense<0.000000e+00> : vector<4xf64> %0 = spirv.Constant dense<0.000000e+00> : vector<4xf64>
%1 = spirv.Constant dense<1.000000e+00> : vector<4xf64> %1 = spirv.Constant dense<1.000000e+00> : vector<4xf64>
%2 = spirv.Select %arg0, %1, %0 : vector<4xi1>, vector<4xf64> %2 = spirv.Select %arg0, %1, %0 : vector<4xi1>, vector<4xf64>
spirv.ReturnValue %2 : vector<4xf64> spirv.ReturnValue %2 : vector<4xf64>
} }
// CHECK-LABEL: @sexti1 // CHECK-LABEL: @sexti1
func.func @sexti1(%arg0: i16) -> i64 { func.func @sexti1(%arg0: i16) -> i64 {
// CHECK: spirv.SConvert %{{.*}} : i16 to i64 // CHECK: spirv.SConvert %{{.*}} : i16 to i64
%0 = arith.extsi %arg0 : i16 to i64 %0 = arith.extsi %arg0 : i16 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: @sexti2 // CHECK-LABEL: @sexti2
func.func @sexti2(%arg0 : i32) -> i64 { func.func @sexti2(%arg0 : i32) -> i64 {
// CHECK: spirv.SConvert %{{.*}} : i32 to i64 // CHECK: spirv.SConvert %{{.*}} : i32 to i64
%0 = arith.extsi %arg0 : i32 to i64 %0 = arith.extsi %arg0 : i32 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: @zexti1 // CHECK-LABEL: @zexti1
func.func @zexti1(%arg0: i16) -> i64 { func.func @zexti1(%arg0: i16) -> i64 {
// CHECK: spirv.UConvert %{{.*}} : i16 to i64 // CHECK: spirv.UConvert %{{.*}} : i16 to i64
%0 = arith.extui %arg0 : i16 to i64 %0 = arith.extui %arg0 : i16 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: @zexti2 // CHECK-LABEL: @zexti2
func.func @zexti2(%arg0 : i32) -> i64 { func.func @zexti2(%arg0 : i32) -> i64 {
// CHECK: spirv.UConvert %{{.*}} : i32 to i64 // CHECK: spirv.UConvert %{{.*}} : i32 to i64
%0 = arith.extui %arg0 : i32 to i64 %0 = arith.extui %arg0 : i32 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: @zexti3 // CHECK-LABEL: @zexti3
func.func @zexti3(%arg0 : i1) -> i32 { func.func @zexti3(%arg0 : i1) -> i32 {
// CHECK: %[[ZERO:.+]] = spirv.Constant 0 : i32 // CHECK: %[[ZERO:.+]] = spirv.Constant 0 : i32
// CHECK: %[[ONE:.+]] = spirv.Constant 1 : i32 // CHECK: %[[ONE:.+]] = spirv.Constant 1 : i32
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, i32 // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, i32
%0 = arith.extui %arg0 : i1 to i32 %0 = arith.extui %arg0 : i1 to i32
return %0 : i32 return %0 : i32
} }
// CHECK-LABEL: @zexti4 // CHECK-LABEL: @zexti4
func.func @zexti4(%arg0 : vector<4xi1>) -> vector<4xi32> { func.func @zexti4(%arg0 : vector<4xi1>) -> vector<4xi32> {
// CHECK: %[[ZERO:.+]] = spirv.Constant dense<0> : vector<4xi32> // CHECK: %[[ZERO:.+]] = spirv.Constant dense<0> : vector<4xi32>
// CHECK: %[[ONE:.+]] = spirv.Constant dense<1> : vector<4xi32> // CHECK: %[[ONE:.+]] = spirv.Constant dense<1> : vector<4xi32>
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi32> // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi32>
%0 = arith.extui %arg0 : vector<4xi1> to vector<4xi32> %0 = arith.extui %arg0 : vector<4xi1> to vector<4xi32>
return %0 : vector<4xi32> return %0 : vector<4xi32>
} }
// CHECK-LABEL: @zexti5 // CHECK-LABEL: @zexti5
func.func @zexti5(%arg0 : vector<4xi1>) -> vector<4xi64> { func.func @zexti5(%arg0 : vector<4xi1>) -> vector<4xi64> {
// CHECK: %[[ZERO:.+]] = spirv.Constant dense<0> : vector<4xi64> // CHECK: %[[ZERO:.+]] = spirv.Constant dense<0> : vector<4xi64>
// CHECK: %[[ONE:.+]] = spirv.Constant dense<1> : vector<4xi64> // CHECK: %[[ONE:.+]] = spirv.Constant dense<1> : vector<4xi64>
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi64> // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi64>
%0 = arith.extui %arg0 : vector<4xi1> to vector<4xi64> %0 = arith.extui %arg0 : vector<4xi1> to vector<4xi64>
return %0 : vector<4xi64> return %0 : vector<4xi64>
} }
// CHECK-LABEL: @trunci1 // CHECK-LABEL: @trunci1
func.func @trunci1(%arg0 : i64) -> i16 { func.func @trunci1(%arg0 : i64) -> i16 {
// CHECK: spirv.SConvert %{{.*}} : i64 to i16 // CHECK: spirv.SConvert %{{.*}} : i64 to i16
%0 = arith.trunci %arg0 : i64 to i16 %0 = arith.trunci %arg0 : i64 to i16
return %0 : i16 return %0 : i16
} }
// CHECK-LABEL: @trunci2 // CHECK-LABEL: @trunci2
func.func @trunci2(%arg0: i32) -> i16 { func.func @trunci2(%arg0: i32) -> i16 {
// CHECK: spirv.SConvert %{{.*}} : i32 to i16 // CHECK: spirv.SConvert %{{.*}} : i32 to i16
%0 = arith.trunci %arg0 : i32 to i16 %0 = arith.trunci %arg0 : i32 to i16
return %0 : i16 return %0 : i16
} }
// CHECK-LABEL: @trunc_to_i1 // CHECK-LABEL: @trunc_to_i1
func.func @trunc_to_i1(%arg0: i32) -> i1 { func.func @trunc_to_i1(%arg0: i32) -> i1 {
// CHECK: %[[MASK:.*]] = spirv.Constant 1 : i32 // CHECK: %[[MASK:.*]] = spirv.Constant 1 : i32
// CHECK: %[[MASKED_SRC:.*]] = spirv.BitwiseAnd %{{.*}}, %[[MASK]] : i32 // CHECK: %[[MASKED_SRC:.*]] = spirv.BitwiseAnd %{{.*}}, %[[MASK]] : i32
// CHECK: %[[IS_ONE:.*]] = spirv.IEqual %[[MASKED_SRC]], %[[MASK]] : i32 // CHECK: %[[IS_ONE:.*]] = spirv.IEqual %[[MASKED_SRC]], %[[MASK]] : i32
// CHECK-DAG: %[[TRUE:.*]] = spirv.Constant true // CHECK-DAG: %[[TRUE:.*]] = spirv.Constant true
// CHECK-DAG: %[[FALSE:.*]] = spirv.Constant false // CHECK-DAG: %[[FALSE:.*]] = spirv.Constant false
// CHECK: spirv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : i1, i1 // CHECK: spirv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : i1, i1
%0 = arith.trunci %arg0 : i32 to i1 %0 = arith.trunci %arg0 : i32 to i1
return %0 : i1 return %0 : i1
} }
// CHECK-LABEL: @trunc_to_veci1 // CHECK-LABEL: @trunc_to_veci1
func.func @trunc_to_veci1(%arg0: vector<4xi32>) -> vector<4xi1> { func.func @trunc_to_veci1(%arg0: vector<4xi32>) -> vector<4xi1> {
// CHECK: %[[MASK:.*]] = spirv.Constant dense<1> : vector<4xi32> // CHECK: %[[MASK:.*]] = spirv.Constant dense<1> : vector<4xi32>
// CHECK: %[[MASKED_SRC:.*]] = spirv.BitwiseAnd %{{.*}}, %[[MASK]] : vector<4xi32> // CHECK: %[[MASKED_SRC:.*]] = spirv.BitwiseAnd %{{.*}}, %[[MASK]] : vector<4xi32>
// CHECK: %[[IS_ONE:.*]] = spirv.IEqual %[[MASKED_SRC]], %[[MASK]] : vector<4xi32> // CHECK: %[[IS_ONE:.*]] = spirv.IEqual %[[MASKED_SRC]], %[[MASK]] : vector<4xi32>
// CHECK-DAG: %[[TRUE:.*]] = spirv.Constant dense<true> : vector<4xi1> // CHECK-DAG: %[[TRUE:.*]] = spirv.Constant dense<true> : vector<4xi1>
// CHECK-DAG: %[[FALSE:.*]] = spirv.Constant dense<false> : vector<4xi1> // CHECK-DAG: %[[FALSE:.*]] = spirv.Constant dense<false> : vector<4xi1>
// CHECK: spirv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : vector<4xi1>, vector<4xi1> // CHECK: spirv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : vector<4xi1>, vector<4xi1>
%0 = arith.trunci %arg0 : vector<4xi32> to vector<4xi1> %0 = arith.trunci %arg0 : vector<4xi32> to vector<4xi1>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// CHECK-LABEL: @fptosi1 // CHECK-LABEL: @fptosi1
func.func @fptosi1(%arg0 : f32) -> i32 { func.func @fptosi1(%arg0 : f32) -> i32 {
// CHECK: spirv.ConvertFToS %{{.*}} : f32 to i32 // CHECK: spirv.ConvertFToS %{{.*}} : f32 to i32
%0 = arith.fptosi %arg0 : f32 to i32 %0 = arith.fptosi %arg0 : f32 to i32
return %0 : i32 return %0 : i32
} }
// CHECK-LABEL: @fptosi2 // CHECK-LABEL: @fptosi2
func.func @fptosi2(%arg0 : f16) -> i16 { func.func @fptosi2(%arg0 : f16) -> i16 {
// CHECK: spirv.ConvertFToS %{{.*}} : f16 to i16 // CHECK: spirv.ConvertFToS %{{.*}} : f16 to i16
%0 = arith.fptosi %arg0 : f16 to i16 %0 = arith.fptosi %arg0 : f16 to i16
return %0 : i16 return %0 : i16
} }
} // end module } // end module
// ----- // -----
// Checks that cast types will be adjusted when missing special capabilities for // Checks that cast types will be adjusted when missing special capabilities for
// certain non-32-bit scalar types. // certain non-32-bit scalar types.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Float64], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Float64], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @fpext1 // CHECK-LABEL: @fpext1
// CHECK-SAME: %[[A:.*]]: f16 // CHECK-SAME: %[[A:.*]]: f16
func.func @fpext1(%arg0: f16) -> f64 { func.func @fpext1(%arg0: f16) -> f64 {
// CHECK: %[[ARG:.+]] = builtin.unrealized_conversion_cast %[[A]] : f16 to f32 // CHECK: %[[ARG:.+]] = builtin.unrealized_conversion_cast %[[A]] : f16 to f32
// CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f64 // CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f64
%0 = arith.extf %arg0 : f16 to f64 %0 = arith.extf %arg0 : f16 to f64
return %0: f64 return %0: f64
} }
// CHECK-LABEL: @fpext2 // CHECK-LABEL: @fpext2
// CHECK-SAME: %[[ARG:.*]]: f32 // CHECK-SAME: %[[ARG:.*]]: f32
func.func @fpext2(%arg0 : f32) -> f64 { func.func @fpext2(%arg0 : f32) -> f64 {
// CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f64 // CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f64
%0 = arith.extf %arg0 : f32 to f64 %0 = arith.extf %arg0 : f32 to f64
return %0: f64 return %0: f64
} }
} // end module } // end module
// ----- // -----
// Checks that cast types will be adjusted when missing special capabilities for // Checks that cast types will be adjusted when missing special capabilities for
// certain non-32-bit scalar types. // certain non-32-bit scalar types.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Float16], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Float16], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @fptrunc1 // CHECK-LABEL: @fptrunc1
// CHECK-SAME: %[[A:.*]]: f64 // CHECK-SAME: %[[A:.*]]: f64
func.func @fptrunc1(%arg0 : f64) -> f16 { func.func @fptrunc1(%arg0 : f64) -> f16 {
// CHECK: %[[ARG:.+]] = builtin.unrealized_conversion_cast %[[A]] : f64 to f32 // CHECK: %[[ARG:.+]] = builtin.unrealized_conversion_cast %[[A]] : f64 to f32
// CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f16 // CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f16
%0 = arith.truncf %arg0 : f64 to f16 %0 = arith.truncf %arg0 : f64 to f16
return %0: f16 return %0: f16
} }
// CHECK-LABEL: @fptrunc2 // CHECK-LABEL: @fptrunc2
// CHECK-SAME: %[[ARG:.*]]: f32 // CHECK-SAME: %[[ARG:.*]]: f32
func.func @fptrunc2(%arg0: f32) -> f16 { func.func @fptrunc2(%arg0: f32) -> f16 {
// CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f16 // CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f16
%0 = arith.truncf %arg0 : f32 to f16 %0 = arith.truncf %arg0 : f32 to f16
return %0: f16 return %0: f16
} }
// CHECK-LABEL: @sitofp // CHECK-LABEL: @sitofp
func.func @sitofp(%arg0 : i64) -> f64 { func.func @sitofp(%arg0 : i64) -> f64 {
// CHECK: spirv.ConvertSToF %{{.*}} : i32 to f32 // CHECK: spirv.ConvertSToF %{{.*}} : i32 to f32
%0 = arith.sitofp %arg0 : i64 to f64 %0 = arith.sitofp %arg0 : i64 to f64
return %0: f64 return %0: f64
} }
} // end module } // end module
// ----- // -----
// Check various lowerings for OpenCL. // Check various lowerings for OpenCL.
module attributes { module attributes {
spirv.target_env = #spirv.target_env< spirv.target_env = #spirv.target_env<
#spirv.vce<v1.0, [Int16, Kernel], []>, #spirv.resource_limits<>> #spirv.vce<v1.0, [Int16, Kernel], []>, #spirv.resource_limits<>>
} { } {
// Check integer operation conversions. // Check integer operation conversions.
// CHECK-LABEL: @int32_scalar // CHECK-LABEL: @int32_scalar
func.func @int32_scalar(%lhs: i32, %rhs: i32) { func.func @int32_scalar(%lhs: i32, %rhs: i32) {
// CHECK: spirv.IAdd %{{.*}}, %{{.*}}: i32 // CHECK: spirv.IAdd %{{.*}}, %{{.*}}: i32
%0 = arith.addi %lhs, %rhs: i32 %0 = arith.addi %lhs, %rhs: i32
// CHECK: spirv.ISub %{{.*}}, %{{.*}}: i32 // CHECK: spirv.ISub %{{.*}}, %{{.*}}: i32
%1 = arith.subi %lhs, %rhs: i32 %1 = arith.subi %lhs, %rhs: i32
// CHECK: spirv.IMul %{{.*}}, %{{.*}}: i32 // CHECK: spirv.IMul %{{.*}}, %{{.*}}: i32
%2 = arith.muli %lhs, %rhs: i32 %2 = arith.muli %lhs, %rhs: i32
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: i32 // CHECK: spirv.SDiv %{{.*}}, %{{.*}}: i32
%3 = arith.divsi %lhs, %rhs: i32 %3 = arith.divsi %lhs, %rhs: i32
// CHECK: spirv.UDiv %{{.*}}, %{{.*}}: i32 // CHECK: spirv.UDiv %{{.*}}, %{{.*}}: i32
%4 = arith.divui %lhs, %rhs: i32 %4 = arith.divui %lhs, %rhs: i32
// CHECK: spirv.UMod %{{.*}}, %{{.*}}: i32 // CHECK: spirv.UMod %{{.*}}, %{{.*}}: i32
%5 = arith.remui %lhs, %rhs: i32 %5 = arith.remui %lhs, %rhs: i32
// CHECK: spirv.CL.s_max %{{.*}}, %{{.*}}: i32 // CHECK: spirv.CL.s_max %{{.*}}, %{{.*}}: i32
%6 = arith.maxsi %lhs, %rhs : i32 %6 = arith.maxsi %lhs, %rhs : i32
// CHECK: spirv.CL.u_max %{{.*}}, %{{.*}}: i32 // CHECK: spirv.CL.u_max %{{.*}}, %{{.*}}: i32
%7 = arith.maxui %lhs, %rhs : i32 %7 = arith.maxui %lhs, %rhs : i32
// CHECK: spirv.CL.s_min %{{.*}}, %{{.*}}: i32 // CHECK: spirv.CL.s_min %{{.*}}, %{{.*}}: i32
%8 = arith.minsi %lhs, %rhs : i32 %8 = arith.minsi %lhs, %rhs : i32
// CHECK: spirv.CL.u_min %{{.*}}, %{{.*}}: i32 // CHECK: spirv.CL.u_min %{{.*}}, %{{.*}}: i32
%9 = arith.minui %lhs, %rhs : i32 %9 = arith.minui %lhs, %rhs : i32
return return
} }
// Check float binary operation conversions. // Check float binary operation conversions.
// CHECK-LABEL: @float32_binary_scalar // CHECK-LABEL: @float32_binary_scalar
func.func @float32_binary_scalar(%lhs: f32, %rhs: f32) { func.func @float32_binary_scalar(%lhs: f32, %rhs: f32) {
// CHECK: spirv.FAdd %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FAdd %{{.*}}, %{{.*}}: f32
%0 = arith.addf %lhs, %rhs: f32 %0 = arith.addf %lhs, %rhs: f32
// CHECK: spirv.FSub %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FSub %{{.*}}, %{{.*}}: f32
%1 = arith.subf %lhs, %rhs: f32 %1 = arith.subf %lhs, %rhs: f32
// CHECK: spirv.FMul %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FMul %{{.*}}, %{{.*}}: f32
%2 = arith.mulf %lhs, %rhs: f32 %2 = arith.mulf %lhs, %rhs: f32
// CHECK: spirv.FDiv %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FDiv %{{.*}}, %{{.*}}: f32
%3 = arith.divf %lhs, %rhs: f32 %3 = arith.divf %lhs, %rhs: f32
// CHECK: spirv.FRem %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FRem %{{.*}}, %{{.*}}: f32
%4 = arith.remf %lhs, %rhs: f32 %4 = arith.remf %lhs, %rhs: f32
return return
} }
// CHECK-LABEL: @float32_minf_scalar // CHECK-LABEL: @float32_minf_scalar
// CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32 // CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32
func.func @float32_minf_scalar(%arg0 : f32, %arg1 : f32) -> f32 { func.func @float32_minf_scalar(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK: %[[MIN:.+]] = spirv.CL.fmin %arg0, %arg1 : f32 // CHECK: %[[MIN:.+]] = spirv.CL.fmin %arg0, %arg1 : f32
// CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32 // CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32
// CHECK: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32 // CHECK: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32
// CHECK: %[[SELECT1:.+]] = spirv.Select %[[LHS_NAN]], %[[LHS]], %[[MIN]] // CHECK: %[[SELECT1:.+]] = spirv.Select %[[LHS_NAN]], %[[LHS]], %[[MIN]]
// CHECK: %[[SELECT2:.+]] = spirv.Select %[[RHS_NAN]], %[[RHS]], %[[SELECT1]] // CHECK: %[[SELECT2:.+]] = spirv.Select %[[RHS_NAN]], %[[RHS]], %[[SELECT1]]
%0 = arith.minf %arg0, %arg1 : f32 %0 = arith.minf %arg0, %arg1 : f32
// CHECK: return %[[SELECT2]] // CHECK: return %[[SELECT2]]
return %0: f32 return %0: f32
} }
// CHECK-LABEL: @float32_maxf_scalar // CHECK-LABEL: @float32_maxf_scalar
// CHECK-SAME: %[[LHS:.+]]: vector<2xf32>, %[[RHS:.+]]: vector<2xf32> // CHECK-SAME: %[[LHS:.+]]: vector<2xf32>, %[[RHS:.+]]: vector<2xf32>
func.func @float32_maxf_scalar(%arg0 : vector<2xf32>, %arg1 : vector<2xf32>) -> vector<2xf32> { func.func @float32_maxf_scalar(%arg0 : vector<2xf32>, %arg1 : vector<2xf32>) -> vector<2xf32> {
// CHECK: %[[MAX:.+]] = spirv.CL.fmax %arg0, %arg1 : vector<2xf32> // CHECK: %[[MAX:.+]] = spirv.CL.fmax %arg0, %arg1 : vector<2xf32>
// CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : vector<2xf32> // CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : vector<2xf32>
// CHECK: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : vector<2xf32> // CHECK: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : vector<2xf32>
// CHECK: %[[SELECT1:.+]] = spirv.Select %[[LHS_NAN]], %[[LHS]], %[[MAX]] // CHECK: %[[SELECT1:.+]] = spirv.Select %[[LHS_NAN]], %[[LHS]], %[[MAX]]
// CHECK: %[[SELECT2:.+]] = spirv.Select %[[RHS_NAN]], %[[RHS]], %[[SELECT1]] // CHECK: %[[SELECT2:.+]] = spirv.Select %[[RHS_NAN]], %[[RHS]], %[[SELECT1]]
%0 = arith.maxf %arg0, %arg1 : vector<2xf32> %0 = arith.maxf %arg0, %arg1 : vector<2xf32>
// CHECK: return %[[SELECT2]] // CHECK: return %[[SELECT2]]
return %0: vector<2xf32> return %0: vector<2xf32>
} }
// CHECK-LABEL: @scalar_srem // CHECK-LABEL: @scalar_srem
// CHECK-SAME: (%[[LHS:.+]]: i32, %[[RHS:.+]]: i32) // CHECK-SAME: (%[[LHS:.+]]: i32, %[[RHS:.+]]: i32)
func.func @scalar_srem(%lhs: i32, %rhs: i32) { func.func @scalar_srem(%lhs: i32, %rhs: i32) {
// CHECK: %[[LABS:.+]] = spirv.CL.s_abs %[[LHS]] : i32 // CHECK: %[[LABS:.+]] = spirv.CL.s_abs %[[LHS]] : i32
// CHECK: %[[RABS:.+]] = spirv.CL.s_abs %[[RHS]] : i32 // CHECK: %[[RABS:.+]] = spirv.CL.s_abs %[[RHS]] : i32
// CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : i32 // CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : i32
// CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : i32 // CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : i32
// CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : i32 // CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : i32
// CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : i1, i32 // CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : i1, i32
%0 = arith.remsi %lhs, %rhs: i32 %0 = arith.remsi %lhs, %rhs: i32
return return
} }
// CHECK-LABEL: @vector_srem // CHECK-LABEL: @vector_srem
// CHECK-SAME: (%[[LHS:.+]]: vector<3xi16>, %[[RHS:.+]]: vector<3xi16>) // CHECK-SAME: (%[[LHS:.+]]: vector<3xi16>, %[[RHS:.+]]: vector<3xi16>)
func.func @vector_srem(%arg0: vector<3xi16>, %arg1: vector<3xi16>) { func.func @vector_srem(%arg0: vector<3xi16>, %arg1: vector<3xi16>) {
// CHECK: %[[LABS:.+]] = spirv.CL.s_abs %[[LHS]] : vector<3xi16> // CHECK: %[[LABS:.+]] = spirv.CL.s_abs %[[LHS]] : vector<3xi16>
// CHECK: %[[RABS:.+]] = spirv.CL.s_abs %[[RHS]] : vector<3xi16> // CHECK: %[[RABS:.+]] = spirv.CL.s_abs %[[RHS]] : vector<3xi16>
// CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : vector<3xi16> // CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : vector<3xi16>
// CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : vector<3xi16> // CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : vector<3xi16>
// CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : vector<3xi16> // CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : vector<3xi16>
// CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : vector<3xi1>, vector<3xi16> // CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : vector<3xi1>, vector<3xi16>
%0 = arith.remsi %arg0, %arg1: vector<3xi16> %0 = arith.remsi %arg0, %arg1: vector<3xi16>
return return
} }
} // end module } // end module
// ----- // -----
module attributes { module attributes {
spirv.target_env = #spirv.target_env< spirv.target_env = #spirv.target_env<
#spirv.vce<v1.0, [Shader, Int8, Int16, Int64, Float16, Float64], #spirv.vce<v1.0, [Shader, Int8, Int16, Int64, Float16, Float64],
[SPV_KHR_storage_buffer_storage_class]>, #spirv.resource_limits<>> [SPV_KHR_storage_buffer_storage_class]>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @select // CHECK-LABEL: @select
func.func @select(%arg0 : i32, %arg1 : i32) { func.func @select(%arg0 : i32, %arg1 : i32) {
%0 = arith.cmpi sle, %arg0, %arg1 : i32 %0 = arith.cmpi sle, %arg0, %arg1 : i32
// CHECK: spirv.Select // CHECK: spirv.Select
%1 = arith.select %0, %arg0, %arg1 : i32 %1 = arith.select %0, %arg0, %arg1 : i32
return return
} }
} // end module } // end module
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// arith.select // arith.select
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env< spirv.target_env = #spirv.target_env<
#spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64, Shader], []>, #spirv.resource_limits<>> #spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64, Shader], []>, #spirv.resource_limits<>>
} { } {
// Check integer operation conversions. // Check integer operation conversions.
// CHECK-LABEL: @int32_scalar // CHECK-LABEL: @int32_scalar
func.func @int32_scalar(%lhs: i32, %rhs: i32) { func.func @int32_scalar(%lhs: i32, %rhs: i32) {
// CHECK: spirv.IAdd %{{.*}}, %{{.*}}: i32 // CHECK: spirv.IAdd %{{.*}}, %{{.*}}: i32
%0 = arith.addi %lhs, %rhs: i32 %0 = arith.addi %lhs, %rhs: i32
// CHECK: spirv.ISub %{{.*}}, %{{.*}}: i32 // CHECK: spirv.ISub %{{.*}}, %{{.*}}: i32
%1 = arith.subi %lhs, %rhs: i32 %1 = arith.subi %lhs, %rhs: i32
// CHECK: spirv.IMul %{{.*}}, %{{.*}}: i32 // CHECK: spirv.IMul %{{.*}}, %{{.*}}: i32
%2 = arith.muli %lhs, %rhs: i32 %2 = arith.muli %lhs, %rhs: i32
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: i32 // CHECK: spirv.SDiv %{{.*}}, %{{.*}}: i32
%3 = arith.divsi %lhs, %rhs: i32 %3 = arith.divsi %lhs, %rhs: i32
// CHECK: spirv.UDiv %{{.*}}, %{{.*}}: i32 // CHECK: spirv.UDiv %{{.*}}, %{{.*}}: i32
%4 = arith.divui %lhs, %rhs: i32 %4 = arith.divui %lhs, %rhs: i32
// CHECK: spirv.UMod %{{.*}}, %{{.*}}: i32 // CHECK: spirv.UMod %{{.*}}, %{{.*}}: i32
%5 = arith.remui %lhs, %rhs: i32 %5 = arith.remui %lhs, %rhs: i32
// CHECK: spirv.GL.SMax %{{.*}}, %{{.*}}: i32 // CHECK: spirv.GL.SMax %{{.*}}, %{{.*}}: i32
%6 = arith.maxsi %lhs, %rhs : i32 %6 = arith.maxsi %lhs, %rhs : i32
// CHECK: spirv.GL.UMax %{{.*}}, %{{.*}}: i32 // CHECK: spirv.GL.UMax %{{.*}}, %{{.*}}: i32
%7 = arith.maxui %lhs, %rhs : i32 %7 = arith.maxui %lhs, %rhs : i32
// CHECK: spirv.GL.SMin %{{.*}}, %{{.*}}: i32 // CHECK: spirv.GL.SMin %{{.*}}, %{{.*}}: i32
%8 = arith.minsi %lhs, %rhs : i32 %8 = arith.minsi %lhs, %rhs : i32
// CHECK: spirv.GL.UMin %{{.*}}, %{{.*}}: i32 // CHECK: spirv.GL.UMin %{{.*}}, %{{.*}}: i32
%9 = arith.minui %lhs, %rhs : i32 %9 = arith.minui %lhs, %rhs : i32
return return
} }
// CHECK-LABEL: @scalar_srem // CHECK-LABEL: @scalar_srem
// CHECK-SAME: (%[[LHS:.+]]: i32, %[[RHS:.+]]: i32) // CHECK-SAME: (%[[LHS:.+]]: i32, %[[RHS:.+]]: i32)
func.func @scalar_srem(%lhs: i32, %rhs: i32) { func.func @scalar_srem(%lhs: i32, %rhs: i32) {
// CHECK: %[[LABS:.+]] = spirv.GL.SAbs %[[LHS]] : i32 // CHECK: %[[LABS:.+]] = spirv.GL.SAbs %[[LHS]] : i32
// CHECK: %[[RABS:.+]] = spirv.GL.SAbs %[[RHS]] : i32 // CHECK: %[[RABS:.+]] = spirv.GL.SAbs %[[RHS]] : i32
// CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : i32 // CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : i32
// CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : i32 // CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : i32
// CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : i32 // CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : i32
// CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : i1, i32 // CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : i1, i32
%0 = arith.remsi %lhs, %rhs: i32 %0 = arith.remsi %lhs, %rhs: i32
return return
} }
// Check float unary operation conversions. // Check float unary operation conversions.
// CHECK-LABEL: @float32_unary_scalar // CHECK-LABEL: @float32_unary_scalar
func.func @float32_unary_scalar(%arg0: f32) { func.func @float32_unary_scalar(%arg0: f32) {
// CHECK: spirv.FNegate %{{.*}}: f32 // CHECK: spirv.FNegate %{{.*}}: f32
%5 = arith.negf %arg0 : f32 %5 = arith.negf %arg0 : f32
return return
} }
// Check float binary operation conversions. // Check float binary operation conversions.
// CHECK-LABEL: @float32_binary_scalar // CHECK-LABEL: @float32_binary_scalar
func.func @float32_binary_scalar(%lhs: f32, %rhs: f32) { func.func @float32_binary_scalar(%lhs: f32, %rhs: f32) {
// CHECK: spirv.FAdd %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FAdd %{{.*}}, %{{.*}}: f32
%0 = arith.addf %lhs, %rhs: f32 %0 = arith.addf %lhs, %rhs: f32
// CHECK: spirv.FSub %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FSub %{{.*}}, %{{.*}}: f32
%1 = arith.subf %lhs, %rhs: f32 %1 = arith.subf %lhs, %rhs: f32
// CHECK: spirv.FMul %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FMul %{{.*}}, %{{.*}}: f32
%2 = arith.mulf %lhs, %rhs: f32 %2 = arith.mulf %lhs, %rhs: f32
// CHECK: spirv.FDiv %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FDiv %{{.*}}, %{{.*}}: f32
%3 = arith.divf %lhs, %rhs: f32 %3 = arith.divf %lhs, %rhs: f32
// CHECK: spirv.FRem %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FRem %{{.*}}, %{{.*}}: f32
%4 = arith.remf %lhs, %rhs: f32 %4 = arith.remf %lhs, %rhs: f32
return return
} }
// CHECK-LABEL: @float32_minf_scalar // CHECK-LABEL: @float32_minf_scalar
// CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32 // CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32
func.func @float32_minf_scalar(%arg0 : f32, %arg1 : f32) -> f32 { func.func @float32_minf_scalar(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK: %[[MIN:.+]] = spirv.GL.FMin %arg0, %arg1 : f32 // CHECK: %[[MIN:.+]] = spirv.GL.FMin %arg0, %arg1 : f32
// CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32 // CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32
// CHECK: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32 // CHECK: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32
// CHECK: %[[SELECT1:.+]] = spirv.Select %[[LHS_NAN]], %[[LHS]], %[[MIN]] // CHECK: %[[SELECT1:.+]] = spirv.Select %[[LHS_NAN]], %[[LHS]], %[[MIN]]
// CHECK: %[[SELECT2:.+]] = spirv.Select %[[RHS_NAN]], %[[RHS]], %[[SELECT1]] // CHECK: %[[SELECT2:.+]] = spirv.Select %[[RHS_NAN]], %[[RHS]], %[[SELECT1]]
%0 = arith.minf %arg0, %arg1 : f32 %0 = arith.minf %arg0, %arg1 : f32
// CHECK: return %[[SELECT2]] // CHECK: return %[[SELECT2]]
return %0: f32 return %0: f32
} }
// CHECK-LABEL: @float32_maxf_scalar // CHECK-LABEL: @float32_maxf_scalar
// CHECK-SAME: %[[LHS:.+]]: vector<2xf32>, %[[RHS:.+]]: vector<2xf32> // CHECK-SAME: %[[LHS:.+]]: vector<2xf32>, %[[RHS:.+]]: vector<2xf32>
func.func @float32_maxf_scalar(%arg0 : vector<2xf32>, %arg1 : vector<2xf32>) -> vector<2xf32> { func.func @float32_maxf_scalar(%arg0 : vector<2xf32>, %arg1 : vector<2xf32>) -> vector<2xf32> {
// CHECK: %[[MAX:.+]] = spirv.GL.FMax %arg0, %arg1 : vector<2xf32> // CHECK: %[[MAX:.+]] = spirv.GL.FMax %arg0, %arg1 : vector<2xf32>
// CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : vector<2xf32> // CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : vector<2xf32>
// CHECK: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : vector<2xf32> // CHECK: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : vector<2xf32>
// CHECK: %[[SELECT1:.+]] = spirv.Select %[[LHS_NAN]], %[[LHS]], %[[MAX]] // CHECK: %[[SELECT1:.+]] = spirv.Select %[[LHS_NAN]], %[[LHS]], %[[MAX]]
// CHECK: %[[SELECT2:.+]] = spirv.Select %[[RHS_NAN]], %[[RHS]], %[[SELECT1]] // CHECK: %[[SELECT2:.+]] = spirv.Select %[[RHS_NAN]], %[[RHS]], %[[SELECT1]]
%0 = arith.maxf %arg0, %arg1 : vector<2xf32> %0 = arith.maxf %arg0, %arg1 : vector<2xf32>
// CHECK: return %[[SELECT2]] // CHECK: return %[[SELECT2]]
return %0: vector<2xf32> return %0: vector<2xf32>
} }
// Check int vector types. // Check int vector types.
// CHECK-LABEL: @int_vector234 // CHECK-LABEL: @int_vector234
func.func @int_vector234(%arg0: vector<2xi8>, %arg1: vector<4xi64>) { func.func @int_vector234(%arg0: vector<2xi8>, %arg1: vector<4xi64>) {
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<2xi8> // CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<2xi8>
%0 = arith.divsi %arg0, %arg0: vector<2xi8> %0 = arith.divsi %arg0, %arg0: vector<2xi8>
// CHECK: spirv.UDiv %{{.*}}, %{{.*}}: vector<4xi64> // CHECK: spirv.UDiv %{{.*}}, %{{.*}}: vector<4xi64>
%1 = arith.divui %arg1, %arg1: vector<4xi64> %1 = arith.divui %arg1, %arg1: vector<4xi64>
return return
} }
// CHECK-LABEL: @vector_srem // CHECK-LABEL: @vector_srem
// CHECK-SAME: (%[[LHS:.+]]: vector<3xi16>, %[[RHS:.+]]: vector<3xi16>) // CHECK-SAME: (%[[LHS:.+]]: vector<3xi16>, %[[RHS:.+]]: vector<3xi16>)
func.func @vector_srem(%arg0: vector<3xi16>, %arg1: vector<3xi16>) { func.func @vector_srem(%arg0: vector<3xi16>, %arg1: vector<3xi16>) {
// CHECK: %[[LABS:.+]] = spirv.GL.SAbs %[[LHS]] : vector<3xi16> // CHECK: %[[LABS:.+]] = spirv.GL.SAbs %[[LHS]] : vector<3xi16>
// CHECK: %[[RABS:.+]] = spirv.GL.SAbs %[[RHS]] : vector<3xi16> // CHECK: %[[RABS:.+]] = spirv.GL.SAbs %[[RHS]] : vector<3xi16>
// CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : vector<3xi16> // CHECK: %[[ABS:.+]] = spirv.UMod %[[LABS]], %[[RABS]] : vector<3xi16>
// CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : vector<3xi16> // CHECK: %[[POS:.+]] = spirv.IEqual %[[LHS]], %[[LABS]] : vector<3xi16>
// CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : vector<3xi16> // CHECK: %[[NEG:.+]] = spirv.SNegate %[[ABS]] : vector<3xi16>
// CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : vector<3xi1>, vector<3xi16> // CHECK: %{{.+}} = spirv.Select %[[POS]], %[[ABS]], %[[NEG]] : vector<3xi1>, vector<3xi16>
%0 = arith.remsi %arg0, %arg1: vector<3xi16> %0 = arith.remsi %arg0, %arg1: vector<3xi16>
return return
} }
// Check float vector types. // Check float vector types.
// CHECK-LABEL: @float_vector234 // CHECK-LABEL: @float_vector234
func.func @float_vector234(%arg0: vector<2xf16>, %arg1: vector<3xf64>) { func.func @float_vector234(%arg0: vector<2xf16>, %arg1: vector<3xf64>) {
// CHECK: spirv.FAdd %{{.*}}, %{{.*}}: vector<2xf16> // CHECK: spirv.FAdd %{{.*}}, %{{.*}}: vector<2xf16>
%0 = arith.addf %arg0, %arg0: vector<2xf16> %0 = arith.addf %arg0, %arg0: vector<2xf16>
// CHECK: spirv.FMul %{{.*}}, %{{.*}}: vector<3xf64> // CHECK: spirv.FMul %{{.*}}, %{{.*}}: vector<3xf64>
%1 = arith.mulf %arg1, %arg1: vector<3xf64> %1 = arith.mulf %arg1, %arg1: vector<3xf64>
return return
} }
// CHECK-LABEL: @one_elem_vector // CHECK-LABEL: @one_elem_vector
func.func @one_elem_vector(%arg0: vector<1xi32>) { func.func @one_elem_vector(%arg0: vector<1xi32>) {
// CHECK: spirv.IAdd %{{.+}}, %{{.+}}: i32 // CHECK: spirv.IAdd %{{.+}}, %{{.+}}: i32
%0 = arith.addi %arg0, %arg0: vector<1xi32> %0 = arith.addi %arg0, %arg0: vector<1xi32>
return return
} }
// CHECK-LABEL: @unsupported_5elem_vector // CHECK-LABEL: @unsupported_5elem_vector
func.func @unsupported_5elem_vector(%arg0: vector<5xi32>) { func.func @unsupported_5elem_vector(%arg0: vector<5xi32>) {
// CHECK: subi // CHECK: subi
%1 = arith.subi %arg0, %arg0: vector<5xi32> %1 = arith.subi %arg0, %arg0: vector<5xi32>
return return
} }
// CHECK-LABEL: @unsupported_2x2elem_vector // CHECK-LABEL: @unsupported_2x2elem_vector
func.func @unsupported_2x2elem_vector(%arg0: vector<2x2xi32>) { func.func @unsupported_2x2elem_vector(%arg0: vector<2x2xi32>) {
// CHECK: muli // CHECK: muli
%2 = arith.muli %arg0, %arg0: vector<2x2xi32> %2 = arith.muli %arg0, %arg0: vector<2x2xi32>
return return
} }
} // end module } // end module
// ----- // -----
// Check that types are converted to 32-bit when no special capabilities. // Check that types are converted to 32-bit when no special capabilities.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @int_vector23 // CHECK-LABEL: @int_vector23
func.func @int_vector23(%arg0: vector<2xi8>, %arg1: vector<3xi16>) { func.func @int_vector23(%arg0: vector<2xi8>, %arg1: vector<3xi16>) {
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<2xi32> // CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<2xi32>
%0 = arith.divsi %arg0, %arg0: vector<2xi8> %0 = arith.divsi %arg0, %arg0: vector<2xi8>
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<3xi32> // CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<3xi32>
%1 = arith.divsi %arg1, %arg1: vector<3xi16> %1 = arith.divsi %arg1, %arg1: vector<3xi16>
return return
} }
// CHECK-LABEL: @float_scalar // CHECK-LABEL: @float_scalar
func.func @float_scalar(%arg0: f16, %arg1: f64) { func.func @float_scalar(%arg0: f16, %arg1: f64) {
// CHECK: spirv.FAdd %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FAdd %{{.*}}, %{{.*}}: f32
%0 = arith.addf %arg0, %arg0: f16 %0 = arith.addf %arg0, %arg0: f16
// CHECK: spirv.FMul %{{.*}}, %{{.*}}: f32 // CHECK: spirv.FMul %{{.*}}, %{{.*}}: f32
%1 = arith.mulf %arg1, %arg1: f64 %1 = arith.mulf %arg1, %arg1: f64
return return
} }
} // end module } // end module
// ----- // -----
// Check that types are converted to 32-bit when no special capabilities that // Check that types are converted to 32-bit when no special capabilities that
// are not supported. // are not supported.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
func.func @int_vector4_invalid(%arg0: vector<4xi64>) { func.func @int_vector4_invalid(%arg0: vector<4xi64>) {
// expected-error@+1 {{bitwidth emulation is not implemented yet on unsigned op}} // expected-error@+1 {{bitwidth emulation is not implemented yet on unsigned op}}
%0 = arith.divui %arg0, %arg0: vector<4xi64> %0 = arith.divui %arg0, %arg0: vector<4xi64>
return return
} }
} // end module } // end module
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// std bit ops // std bit ops
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @bitwise_scalar // CHECK-LABEL: @bitwise_scalar
func.func @bitwise_scalar(%arg0 : i32, %arg1 : i32) { func.func @bitwise_scalar(%arg0 : i32, %arg1 : i32) {
// CHECK: spirv.BitwiseAnd // CHECK: spirv.BitwiseAnd
%0 = arith.andi %arg0, %arg1 : i32 %0 = arith.andi %arg0, %arg1 : i32
// CHECK: spirv.BitwiseOr // CHECK: spirv.BitwiseOr
%1 = arith.ori %arg0, %arg1 : i32 %1 = arith.ori %arg0, %arg1 : i32
// CHECK: spirv.BitwiseXor // CHECK: spirv.BitwiseXor
%2 = arith.xori %arg0, %arg1 : i32 %2 = arith.xori %arg0, %arg1 : i32
return return
} }
// CHECK-LABEL: @bitwise_vector // CHECK-LABEL: @bitwise_vector
func.func @bitwise_vector(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) { func.func @bitwise_vector(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) {
// CHECK: spirv.BitwiseAnd // CHECK: spirv.BitwiseAnd
%0 = arith.andi %arg0, %arg1 : vector<4xi32> %0 = arith.andi %arg0, %arg1 : vector<4xi32>
// CHECK: spirv.BitwiseOr // CHECK: spirv.BitwiseOr
%1 = arith.ori %arg0, %arg1 : vector<4xi32> %1 = arith.ori %arg0, %arg1 : vector<4xi32>
// CHECK: spirv.BitwiseXor // CHECK: spirv.BitwiseXor
%2 = arith.xori %arg0, %arg1 : vector<4xi32> %2 = arith.xori %arg0, %arg1 : vector<4xi32>
return return
} }
// CHECK-LABEL: @logical_scalar // CHECK-LABEL: @logical_scalar
func.func @logical_scalar(%arg0 : i1, %arg1 : i1) { func.func @logical_scalar(%arg0 : i1, %arg1 : i1) {
// CHECK: spirv.LogicalAnd // CHECK: spirv.LogicalAnd
%0 = arith.andi %arg0, %arg1 : i1 %0 = arith.andi %arg0, %arg1 : i1
// CHECK: spirv.LogicalOr // CHECK: spirv.LogicalOr
%1 = arith.ori %arg0, %arg1 : i1 %1 = arith.ori %arg0, %arg1 : i1
// CHECK: spirv.LogicalNotEqual // CHECK: spirv.LogicalNotEqual
%2 = arith.xori %arg0, %arg1 : i1 %2 = arith.xori %arg0, %arg1 : i1
return return
} }
// CHECK-LABEL: @logical_vector // CHECK-LABEL: @logical_vector
func.func @logical_vector(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>) { func.func @logical_vector(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>) {
// CHECK: spirv.LogicalAnd // CHECK: spirv.LogicalAnd
%0 = arith.andi %arg0, %arg1 : vector<4xi1> %0 = arith.andi %arg0, %arg1 : vector<4xi1>
// CHECK: spirv.LogicalOr // CHECK: spirv.LogicalOr
%1 = arith.ori %arg0, %arg1 : vector<4xi1> %1 = arith.ori %arg0, %arg1 : vector<4xi1>
// CHECK: spirv.LogicalNotEqual // CHECK: spirv.LogicalNotEqual
%2 = arith.xori %arg0, %arg1 : vector<4xi1> %2 = arith.xori %arg0, %arg1 : vector<4xi1>
return return
} }
// CHECK-LABEL: @shift_scalar // CHECK-LABEL: @shift_scalar
func.func @shift_scalar(%arg0 : i32, %arg1 : i32) { func.func @shift_scalar(%arg0 : i32, %arg1 : i32) {
// CHECK: spirv.ShiftLeftLogical // CHECK: spirv.ShiftLeftLogical
%0 = arith.shli %arg0, %arg1 : i32 %0 = arith.shli %arg0, %arg1 : i32
// CHECK: spirv.ShiftRightArithmetic // CHECK: spirv.ShiftRightArithmetic
%1 = arith.shrsi %arg0, %arg1 : i32 %1 = arith.shrsi %arg0, %arg1 : i32
// CHECK: spirv.ShiftRightLogical // CHECK: spirv.ShiftRightLogical
%2 = arith.shrui %arg0, %arg1 : i32 %2 = arith.shrui %arg0, %arg1 : i32
return return
} }
// CHECK-LABEL: @shift_vector // CHECK-LABEL: @shift_vector
func.func @shift_vector(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) { func.func @shift_vector(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) {
// CHECK: spirv.ShiftLeftLogical // CHECK: spirv.ShiftLeftLogical
%0 = arith.shli %arg0, %arg1 : vector<4xi32> %0 = arith.shli %arg0, %arg1 : vector<4xi32>
// CHECK: spirv.ShiftRightArithmetic // CHECK: spirv.ShiftRightArithmetic
%1 = arith.shrsi %arg0, %arg1 : vector<4xi32> %1 = arith.shrsi %arg0, %arg1 : vector<4xi32>
// CHECK: spirv.ShiftRightLogical // CHECK: spirv.ShiftRightLogical
%2 = arith.shrui %arg0, %arg1 : vector<4xi32> %2 = arith.shrui %arg0, %arg1 : vector<4xi32>
return return
} }
} // end module } // end module
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// arith.cmpf // arith.cmpf
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @cmpf // CHECK-LABEL: @cmpf
func.func @cmpf(%arg0 : f32, %arg1 : f32) { func.func @cmpf(%arg0 : f32, %arg1 : f32) {
// CHECK: spirv.FOrdEqual // CHECK: spirv.FOrdEqual
%1 = arith.cmpf oeq, %arg0, %arg1 : f32 %1 = arith.cmpf oeq, %arg0, %arg1 : f32
// CHECK: spirv.FOrdGreaterThan // CHECK: spirv.FOrdGreaterThan
%2 = arith.cmpf ogt, %arg0, %arg1 : f32 %2 = arith.cmpf ogt, %arg0, %arg1 : f32
// CHECK: spirv.FOrdGreaterThanEqual // CHECK: spirv.FOrdGreaterThanEqual
%3 = arith.cmpf oge, %arg0, %arg1 : f32 %3 = arith.cmpf oge, %arg0, %arg1 : f32
// CHECK: spirv.FOrdLessThan // CHECK: spirv.FOrdLessThan
%4 = arith.cmpf olt, %arg0, %arg1 : f32 %4 = arith.cmpf olt, %arg0, %arg1 : f32
// CHECK: spirv.FOrdLessThanEqual // CHECK: spirv.FOrdLessThanEqual
%5 = arith.cmpf ole, %arg0, %arg1 : f32 %5 = arith.cmpf ole, %arg0, %arg1 : f32
// CHECK: spirv.FOrdNotEqual // CHECK: spirv.FOrdNotEqual
%6 = arith.cmpf one, %arg0, %arg1 : f32 %6 = arith.cmpf one, %arg0, %arg1 : f32
// CHECK: spirv.FUnordEqual // CHECK: spirv.FUnordEqual
%7 = arith.cmpf ueq, %arg0, %arg1 : f32 %7 = arith.cmpf ueq, %arg0, %arg1 : f32
// CHECK: spirv.FUnordGreaterThan // CHECK: spirv.FUnordGreaterThan
%8 = arith.cmpf ugt, %arg0, %arg1 : f32 %8 = arith.cmpf ugt, %arg0, %arg1 : f32
// CHECK: spirv.FUnordGreaterThanEqual // CHECK: spirv.FUnordGreaterThanEqual
%9 = arith.cmpf uge, %arg0, %arg1 : f32 %9 = arith.cmpf uge, %arg0, %arg1 : f32
// CHECK: spirv.FUnordLessThan // CHECK: spirv.FUnordLessThan
%10 = arith.cmpf ult, %arg0, %arg1 : f32 %10 = arith.cmpf ult, %arg0, %arg1 : f32
// CHECK: FUnordLessThanEqual // CHECK: FUnordLessThanEqual
%11 = arith.cmpf ule, %arg0, %arg1 : f32 %11 = arith.cmpf ule, %arg0, %arg1 : f32
// CHECK: spirv.FUnordNotEqual // CHECK: spirv.FUnordNotEqual
%12 = arith.cmpf une, %arg0, %arg1 : f32 %12 = arith.cmpf une, %arg0, %arg1 : f32
return return
} }
// CHECK-LABEL: @vec1cmpf // CHECK-LABEL: @vec1cmpf
func.func @vec1cmpf(%arg0 : vector<1xf32>, %arg1 : vector<1xf32>) { func.func @vec1cmpf(%arg0 : vector<1xf32>, %arg1 : vector<1xf32>) {
// CHECK: spirv.FOrdGreaterThan // CHECK: spirv.FOrdGreaterThan
%0 = arith.cmpf ogt, %arg0, %arg1 : vector<1xf32> %0 = arith.cmpf ogt, %arg0, %arg1 : vector<1xf32>
// CHECK: spirv.FUnordLessThan // CHECK: spirv.FUnordLessThan
%1 = arith.cmpf ult, %arg0, %arg1 : vector<1xf32> %1 = arith.cmpf ult, %arg0, %arg1 : vector<1xf32>
return return
} }
} // end module } // end module
// ----- // -----
// With Kernel capability, we can convert NaN check to spirv.Ordered/spirv.Unordered. // With Kernel capability, we can convert NaN check to spirv.Ordered/spirv.Unordered.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Kernel], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Kernel], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @cmpf // CHECK-LABEL: @cmpf
func.func @cmpf(%arg0 : f32, %arg1 : f32) { func.func @cmpf(%arg0 : f32, %arg1 : f32) {
// CHECK: spirv.Ordered // CHECK: spirv.Ordered
%0 = arith.cmpf ord, %arg0, %arg1 : f32 %0 = arith.cmpf ord, %arg0, %arg1 : f32
// CHECK: spirv.Unordered // CHECK: spirv.Unordered
%1 = arith.cmpf uno, %arg0, %arg1 : f32 %1 = arith.cmpf uno, %arg0, %arg1 : f32
return return
} }
} // end module } // end module
// ----- // -----
// Without Kernel capability, we need to convert NaN check to spirv.IsNan. // Without Kernel capability, we need to convert NaN check to spirv.IsNan.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @cmpf // CHECK-LABEL: @cmpf
// CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32 // CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32
func.func @cmpf(%arg0 : f32, %arg1 : f32) { func.func @cmpf(%arg0 : f32, %arg1 : f32) {
// CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32 // CHECK: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32
// CHECK-NEXT: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32 // CHECK-NEXT: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32
// CHECK-NEXT: %[[OR:.+]] = spirv.LogicalOr %[[LHS_NAN]], %[[RHS_NAN]] : i1 // CHECK-NEXT: %[[OR:.+]] = spirv.LogicalOr %[[LHS_NAN]], %[[RHS_NAN]] : i1
// CHECK-NEXT: %{{.+}} = spirv.LogicalNot %[[OR]] : i1 // CHECK-NEXT: %{{.+}} = spirv.LogicalNot %[[OR]] : i1
%0 = arith.cmpf ord, %arg0, %arg1 : f32 %0 = arith.cmpf ord, %arg0, %arg1 : f32
// CHECK-NEXT: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32 // CHECK-NEXT: %[[LHS_NAN:.+]] = spirv.IsNan %[[LHS]] : f32
// CHECK-NEXT: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32 // CHECK-NEXT: %[[RHS_NAN:.+]] = spirv.IsNan %[[RHS]] : f32
// CHECK-NEXT: %{{.+}} = spirv.LogicalOr %[[LHS_NAN]], %[[RHS_NAN]] : i1 // CHECK-NEXT: %{{.+}} = spirv.LogicalOr %[[LHS_NAN]], %[[RHS_NAN]] : i1
%1 = arith.cmpf uno, %arg0, %arg1 : f32 %1 = arith.cmpf uno, %arg0, %arg1 : f32
return return
} }
} // end module } // end module
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// arith.cmpi // arith.cmpi
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @cmpi // CHECK-LABEL: @cmpi
func.func @cmpi(%arg0 : i32, %arg1 : i32) { func.func @cmpi(%arg0 : i32, %arg1 : i32) {
// CHECK: spirv.IEqual // CHECK: spirv.IEqual
%0 = arith.cmpi eq, %arg0, %arg1 : i32 %0 = arith.cmpi eq, %arg0, %arg1 : i32
// CHECK: spirv.INotEqual // CHECK: spirv.INotEqual
%1 = arith.cmpi ne, %arg0, %arg1 : i32 %1 = arith.cmpi ne, %arg0, %arg1 : i32
// CHECK: spirv.SLessThan // CHECK: spirv.SLessThan
%2 = arith.cmpi slt, %arg0, %arg1 : i32 %2 = arith.cmpi slt, %arg0, %arg1 : i32
// CHECK: spirv.SLessThanEqual // CHECK: spirv.SLessThanEqual
%3 = arith.cmpi sle, %arg0, %arg1 : i32 %3 = arith.cmpi sle, %arg0, %arg1 : i32
// CHECK: spirv.SGreaterThan // CHECK: spirv.SGreaterThan
%4 = arith.cmpi sgt, %arg0, %arg1 : i32 %4 = arith.cmpi sgt, %arg0, %arg1 : i32
// CHECK: spirv.SGreaterThanEqual // CHECK: spirv.SGreaterThanEqual
%5 = arith.cmpi sge, %arg0, %arg1 : i32 %5 = arith.cmpi sge, %arg0, %arg1 : i32
// CHECK: spirv.ULessThan // CHECK: spirv.ULessThan
%6 = arith.cmpi ult, %arg0, %arg1 : i32 %6 = arith.cmpi ult, %arg0, %arg1 : i32
// CHECK: spirv.ULessThanEqual // CHECK: spirv.ULessThanEqual
%7 = arith.cmpi ule, %arg0, %arg1 : i32 %7 = arith.cmpi ule, %arg0, %arg1 : i32
// CHECK: spirv.UGreaterThan // CHECK: spirv.UGreaterThan
%8 = arith.cmpi ugt, %arg0, %arg1 : i32 %8 = arith.cmpi ugt, %arg0, %arg1 : i32
// CHECK: spirv.UGreaterThanEqual // CHECK: spirv.UGreaterThanEqual
%9 = arith.cmpi uge, %arg0, %arg1 : i32 %9 = arith.cmpi uge, %arg0, %arg1 : i32
return return
} }
// CHECK-LABEL: @boolcmpi // CHECK-LABEL: @boolcmpi
func.func @boolcmpi(%arg0 : i1, %arg1 : i1) { func.func @boolcmpi(%arg0 : i1, %arg1 : i1) {
// CHECK: spirv.LogicalEqual // CHECK: spirv.LogicalEqual
%0 = arith.cmpi eq, %arg0, %arg1 : i1 %0 = arith.cmpi eq, %arg0, %arg1 : i1
// CHECK: spirv.LogicalNotEqual // CHECK: spirv.LogicalNotEqual
%1 = arith.cmpi ne, %arg0, %arg1 : i1 %1 = arith.cmpi ne, %arg0, %arg1 : i1
return return
} }
// CHECK-LABEL: @vecboolcmpi // CHECK-LABEL: @vecboolcmpi
func.func @vecboolcmpi(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>) { func.func @vecboolcmpi(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>) {
// CHECK: spirv.LogicalEqual // CHECK: spirv.LogicalEqual
%0 = arith.cmpi eq, %arg0, %arg1 : vector<4xi1> %0 = arith.cmpi eq, %arg0, %arg1 : vector<4xi1>
// CHECK: spirv.LogicalNotEqual // CHECK: spirv.LogicalNotEqual
%1 = arith.cmpi ne, %arg0, %arg1 : vector<4xi1> %1 = arith.cmpi ne, %arg0, %arg1 : vector<4xi1>
return return
} }
} // end module } // end module
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// arith.constant // arith.constant
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env< spirv.target_env = #spirv.target_env<
#spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, #spirv.resource_limits<>> #spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @constant // CHECK-LABEL: @constant
func.func @constant() { func.func @constant() {
// CHECK: spirv.Constant true // CHECK: spirv.Constant true
%0 = arith.constant true %0 = arith.constant true
// CHECK: spirv.Constant 42 : i32 // CHECK: spirv.Constant 42 : i32
%1 = arith.constant 42 : i32 %1 = arith.constant 42 : i32
// CHECK: spirv.Constant 5.000000e-01 : f32 // CHECK: spirv.Constant 5.000000e-01 : f32
%2 = arith.constant 0.5 : f32 %2 = arith.constant 0.5 : f32
// CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32> // CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32>
%3 = arith.constant dense<[2, 3]> : vector<2xi32> %3 = arith.constant dense<[2, 3]> : vector<2xi32>
// CHECK: spirv.Constant 1 : i32 // CHECK: spirv.Constant 1 : i32
%4 = arith.constant 1 : index %4 = arith.constant 1 : index
// CHECK: spirv.Constant dense<1> : tensor<6xi32> : !spirv.array<6 x i32> // CHECK: spirv.Constant dense<1> : tensor<6xi32> : !spirv.array<6 x i32>
%5 = arith.constant dense<1> : tensor<2x3xi32> %5 = arith.constant dense<1> : tensor<2x3xi32>
// CHECK: spirv.Constant dense<1.000000e+00> : tensor<6xf32> : !spirv.array<6 x f32> // CHECK: spirv.Constant dense<1.000000e+00> : tensor<6xf32> : !spirv.array<6 x f32>
%6 = arith.constant dense<1.0> : tensor<2x3xf32> %6 = arith.constant dense<1.0> : tensor<2x3xf32>
// CHECK: spirv.Constant dense<{{\[}}1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf32> : !spirv.array<6 x f32> // CHECK: spirv.Constant dense<{{\[}}1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf32> : !spirv.array<6 x f32>
%7 = arith.constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32> %7 = arith.constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32>
// CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32> // CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32>
%8 = arith.constant dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32> %8 = arith.constant dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32>
// CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32> // CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32>
%9 = arith.constant dense<[[1, 2], [3, 4], [5, 6]]> : tensor<3x2xi32> %9 = arith.constant dense<[[1, 2], [3, 4], [5, 6]]> : tensor<3x2xi32>
// CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32> // CHECK: spirv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spirv.array<6 x i32>
%10 = arith.constant dense<[1, 2, 3, 4, 5, 6]> : tensor<6xi32> %10 = arith.constant dense<[1, 2, 3, 4, 5, 6]> : tensor<6xi32>
return return
} }
// CHECK-LABEL: @constant_16bit // CHECK-LABEL: @constant_16bit
func.func @constant_16bit() { func.func @constant_16bit() {
// CHECK: spirv.Constant 4 : i16 // CHECK: spirv.Constant 4 : i16
%0 = arith.constant 4 : i16 %0 = arith.constant 4 : i16
// CHECK: spirv.Constant 5.000000e+00 : f16 // CHECK: spirv.Constant 5.000000e+00 : f16
%1 = arith.constant 5.0 : f16 %1 = arith.constant 5.0 : f16
// CHECK: spirv.Constant dense<[2, 3]> : vector<2xi16> // CHECK: spirv.Constant dense<[2, 3]> : vector<2xi16>
%2 = arith.constant dense<[2, 3]> : vector<2xi16> %2 = arith.constant dense<[2, 3]> : vector<2xi16>
// CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf16> : !spirv.array<5 x f16> // CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf16> : !spirv.array<5 x f16>
%3 = arith.constant dense<4.0> : tensor<5xf16> %3 = arith.constant dense<4.0> : tensor<5xf16>
return return
} }
// CHECK-LABEL: @constant_64bit // CHECK-LABEL: @constant_64bit
func.func @constant_64bit() { func.func @constant_64bit() {
// CHECK: spirv.Constant 4 : i64 // CHECK: spirv.Constant 4 : i64
%0 = arith.constant 4 : i64 %0 = arith.constant 4 : i64
// CHECK: spirv.Constant 5.000000e+00 : f64 // CHECK: spirv.Constant 5.000000e+00 : f64
%1 = arith.constant 5.0 : f64 %1 = arith.constant 5.0 : f64
// CHECK: spirv.Constant dense<[2, 3]> : vector<2xi64> // CHECK: spirv.Constant dense<[2, 3]> : vector<2xi64>
%2 = arith.constant dense<[2, 3]> : vector<2xi64> %2 = arith.constant dense<[2, 3]> : vector<2xi64>
// CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf64> : !spirv.array<5 x f64> // CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf64> : !spirv.array<5 x f64>
%3 = arith.constant dense<4.0> : tensor<5xf64> %3 = arith.constant dense<4.0> : tensor<5xf64>
return return
} }
} // end module } // end module
// ----- // -----
// Check that constants are converted to 32-bit when no special capability. // Check that constants are converted to 32-bit when no special capability.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @constant_16bit // CHECK-LABEL: @constant_16bit
func.func @constant_16bit() { func.func @constant_16bit() {
// CHECK: spirv.Constant 4 : i32 // CHECK: spirv.Constant 4 : i32
%0 = arith.constant 4 : i16 %0 = arith.constant 4 : i16
// CHECK: spirv.Constant 5.000000e+00 : f32 // CHECK: spirv.Constant 5.000000e+00 : f32
%1 = arith.constant 5.0 : f16 %1 = arith.constant 5.0 : f16
// CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32> // CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32>
%2 = arith.constant dense<[2, 3]> : vector<2xi16> %2 = arith.constant dense<[2, 3]> : vector<2xi16>
// CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf32> : !spirv.array<5 x f32> // CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf32> : !spirv.array<5 x f32>
%3 = arith.constant dense<4.0> : tensor<5xf16> %3 = arith.constant dense<4.0> : tensor<5xf16>
// CHECK: spirv.Constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spirv.array<4 x f32> // CHECK: spirv.Constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spirv.array<4 x f32>
%4 = arith.constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16> %4 = arith.constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16>
return return
} }
// CHECK-LABEL: @constant_64bit // CHECK-LABEL: @constant_64bit
func.func @constant_64bit() { func.func @constant_64bit() {
// CHECK: spirv.Constant 4 : i32 // CHECK: spirv.Constant 4 : i32
%0 = arith.constant 4 : i64 %0 = arith.constant 4 : i64
// CHECK: spirv.Constant 5.000000e+00 : f32 // CHECK: spirv.Constant 5.000000e+00 : f32
%1 = arith.constant 5.0 : f64 %1 = arith.constant 5.0 : f64
// CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32> // CHECK: spirv.Constant dense<[2, 3]> : vector<2xi32>
%2 = arith.constant dense<[2, 3]> : vector<2xi64> %2 = arith.constant dense<[2, 3]> : vector<2xi64>
// CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf32> : !spirv.array<5 x f32> // CHECK: spirv.Constant dense<4.000000e+00> : tensor<5xf32> : !spirv.array<5 x f32>
%3 = arith.constant dense<4.0> : tensor<5xf64> %3 = arith.constant dense<4.0> : tensor<5xf64>
// CHECK: spirv.Constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spirv.array<4 x f32> // CHECK: spirv.Constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spirv.array<4 x f32>
%4 = arith.constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16> %4 = arith.constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16>
return return
} }
// CHECK-LABEL: @corner_cases // CHECK-LABEL: @corner_cases
func.func @corner_cases() { func.func @corner_cases() {
// CHECK: %{{.*}} = spirv.Constant -1 : i32 // CHECK: %{{.*}} = spirv.Constant -1 : i32
%0 = arith.constant 4294967295 : i64 // 2^32 - 1 %0 = arith.constant 4294967295 : i64 // 2^32 - 1
// CHECK: %{{.*}} = spirv.Constant 2147483647 : i32 // CHECK: %{{.*}} = spirv.Constant 2147483647 : i32
%1 = arith.constant 2147483647 : i64 // 2^31 - 1 %1 = arith.constant 2147483647 : i64 // 2^31 - 1
// CHECK: %{{.*}} = spirv.Constant -2147483648 : i32 // CHECK: %{{.*}} = spirv.Constant -2147483648 : i32
%2 = arith.constant 2147483648 : i64 // 2^31 %2 = arith.constant 2147483648 : i64 // 2^31
// CHECK: %{{.*}} = spirv.Constant -2147483648 : i32 // CHECK: %{{.*}} = spirv.Constant -2147483648 : i32
%3 = arith.constant -2147483648 : i64 // -2^31 %3 = arith.constant -2147483648 : i64 // -2^31
// CHECK: %{{.*}} = spirv.Constant -1 : i32 // CHECK: %{{.*}} = spirv.Constant -1 : i32
%5 = arith.constant -1 : i64 %5 = arith.constant -1 : i64
// CHECK: %{{.*}} = spirv.Constant -2 : i32 // CHECK: %{{.*}} = spirv.Constant -2 : i32
%6 = arith.constant -2 : i64 %6 = arith.constant -2 : i64
// CHECK: %{{.*}} = spirv.Constant -1 : i32 // CHECK: %{{.*}} = spirv.Constant -1 : i32
%7 = arith.constant -1 : index %7 = arith.constant -1 : index
// CHECK: %{{.*}} = spirv.Constant -2 : i32 // CHECK: %{{.*}} = spirv.Constant -2 : i32
%8 = arith.constant -2 : index %8 = arith.constant -2 : index
// CHECK: spirv.Constant false // CHECK: spirv.Constant false
%9 = arith.constant false %9 = arith.constant false
// CHECK: spirv.Constant true // CHECK: spirv.Constant true
%10 = arith.constant true %10 = arith.constant true
return return
} }
// CHECK-LABEL: @unsupported_cases // CHECK-LABEL: @unsupported_cases
func.func @unsupported_cases() { func.func @unsupported_cases() {
// CHECK: %{{.*}} = arith.constant 4294967296 : i64 // CHECK: %{{.*}} = arith.constant 4294967296 : i64
%0 = arith.constant 4294967296 : i64 // 2^32 %0 = arith.constant 4294967296 : i64 // 2^32
// CHECK: %{{.*}} = arith.constant -2147483649 : i64 // CHECK: %{{.*}} = arith.constant -2147483649 : i64
%1 = arith.constant -2147483649 : i64 // -2^31 - 1 %1 = arith.constant -2147483649 : i64 // -2^31 - 1
// CHECK: %{{.*}} = arith.constant 1.0000000000000002 : f64 // CHECK: %{{.*}} = arith.constant 1.0000000000000002 : f64
%2 = arith.constant 0x3FF0000000000001 : f64 // smallest number > 1 %2 = arith.constant 0x3FF0000000000001 : f64 // smallest number > 1
return return
} }
} // end module } // end module
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// std cast ops // std cast ops
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
module attributes { module attributes {
spirv.target_env = #spirv.target_env< spirv.target_env = #spirv.target_env<
#spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, #spirv.resource_limits<>> #spirv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: index_cast1 // CHECK-LABEL: index_cast1
func.func @index_cast1(%arg0: i16) { func.func @index_cast1(%arg0: i16) {
// CHECK: spirv.SConvert %{{.+}} : i16 to i32 // CHECK: spirv.SConvert %{{.+}} : i16 to i32
%0 = arith.index_cast %arg0 : i16 to index %0 = arith.index_cast %arg0 : i16 to index
return return
} }
// CHECK-LABEL: index_cast2 // CHECK-LABEL: index_cast2
func.func @index_cast2(%arg0: index) { func.func @index_cast2(%arg0: index) {
// CHECK: spirv.SConvert %{{.+}} : i32 to i16 // CHECK: spirv.SConvert %{{.+}} : i32 to i16
%0 = arith.index_cast %arg0 : index to i16 %0 = arith.index_cast %arg0 : index to i16
return return
} }
// CHECK-LABEL: index_cast3 // CHECK-LABEL: index_cast3
func.func @index_cast3(%arg0: i32) { func.func @index_cast3(%arg0: i32) {
// CHECK-NOT: spirv.SConvert // CHECK-NOT: spirv.SConvert
%0 = arith.index_cast %arg0 : i32 to index %0 = arith.index_cast %arg0 : i32 to index
return return
} }
// CHECK-LABEL: index_cast4 // CHECK-LABEL: index_cast4
func.func @index_cast4(%arg0: index) { func.func @index_cast4(%arg0: index) {
// CHECK-NOT: spirv.SConvert // CHECK-NOT: spirv.SConvert
%0 = arith.index_cast %arg0 : index to i32 %0 = arith.index_cast %arg0 : index to i32
return return
} }
// CHECK-LABEL: @fpext1 // CHECK-LABEL: @fpext1
func.func @fpext1(%arg0: f16) -> f64 { func.func @fpext1(%arg0: f16) -> f64 {
// CHECK: spirv.FConvert %{{.*}} : f16 to f64 // CHECK: spirv.FConvert %{{.*}} : f16 to f64
%0 = arith.extf %arg0 : f16 to f64 %0 = arith.extf %arg0 : f16 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: @fpext2 // CHECK-LABEL: @fpext2
func.func @fpext2(%arg0 : f32) -> f64 { func.func @fpext2(%arg0 : f32) -> f64 {
// CHECK: spirv.FConvert %{{.*}} : f32 to f64 // CHECK: spirv.FConvert %{{.*}} : f32 to f64
%0 = arith.extf %arg0 : f32 to f64 %0 = arith.extf %arg0 : f32 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: @fptrunc1 // CHECK-LABEL: @fptrunc1
func.func @fptrunc1(%arg0 : f64) -> f16 { func.func @fptrunc1(%arg0 : f64) -> f16 {
// CHECK: spirv.FConvert %{{.*}} : f64 to f16 // CHECK: spirv.FConvert %{{.*}} : f64 to f16
%0 = arith.truncf %arg0 : f64 to f16 %0 = arith.truncf %arg0 : f64 to f16
return %0 : f16 return %0 : f16
} }
// CHECK-LABEL: @fptrunc2 // CHECK-LABEL: @fptrunc2
func.func @fptrunc2(%arg0: f32) -> f16 { func.func @fptrunc2(%arg0: f32) -> f16 {
// CHECK: spirv.FConvert %{{.*}} : f32 to f16 // CHECK: spirv.FConvert %{{.*}} : f32 to f16
%0 = arith.truncf %arg0 : f32 to f16 %0 = arith.truncf %arg0 : f32 to f16
return %0 : f16 return %0 : f16
} }
// CHECK-LABEL: @sitofp1 // CHECK-LABEL: @sitofp1
func.func @sitofp1(%arg0 : i32) -> f32 { func.func @sitofp1(%arg0 : i32) -> f32 {
// CHECK: spirv.ConvertSToF %{{.*}} : i32 to f32 // CHECK: spirv.ConvertSToF %{{.*}} : i32 to f32
%0 = arith.sitofp %arg0 : i32 to f32 %0 = arith.sitofp %arg0 : i32 to f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: @sitofp2 // CHECK-LABEL: @sitofp2
func.func @sitofp2(%arg0 : i64) -> f64 { func.func @sitofp2(%arg0 : i64) -> f64 {
// CHECK: spirv.ConvertSToF %{{.*}} : i64 to f64 // CHECK: spirv.ConvertSToF %{{.*}} : i64 to f64
%0 = arith.sitofp %arg0 : i64 to f64 %0 = arith.sitofp %arg0 : i64 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: @uitofp_i16_f32 // CHECK-LABEL: @uitofp_i16_f32
func.func @uitofp_i16_f32(%arg0: i16) -> f32 { func.func @uitofp_i16_f32(%arg0: i16) -> f32 {
// CHECK: spirv.ConvertUToF %{{.*}} : i16 to f32 // CHECK: spirv.ConvertUToF %{{.*}} : i16 to f32
%0 = arith.uitofp %arg0 : i16 to f32 %0 = arith.uitofp %arg0 : i16 to f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: @uitofp_i32_f32 // CHECK-LABEL: @uitofp_i32_f32
func.func @uitofp_i32_f32(%arg0 : i32) -> f32 { func.func @uitofp_i32_f32(%arg0 : i32) -> f32 {
// CHECK: spirv.ConvertUToF %{{.*}} : i32 to f32 // CHECK: spirv.ConvertUToF %{{.*}} : i32 to f32
%0 = arith.uitofp %arg0 : i32 to f32 %0 = arith.uitofp %arg0 : i32 to f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: @uitofp_i1_f32 // CHECK-LABEL: @uitofp_i1_f32
func.func @uitofp_i1_f32(%arg0 : i1) -> f32 { func.func @uitofp_i1_f32(%arg0 : i1) -> f32 {
// CHECK: %[[ZERO:.+]] = spirv.Constant 0.000000e+00 : f32 // CHECK: %[[ZERO:.+]] = spirv.Constant 0.000000e+00 : f32
// CHECK: %[[ONE:.+]] = spirv.Constant 1.000000e+00 : f32 // CHECK: %[[ONE:.+]] = spirv.Constant 1.000000e+00 : f32
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f32 // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f32
%0 = arith.uitofp %arg0 : i1 to f32 %0 = arith.uitofp %arg0 : i1 to f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: @uitofp_i1_f64 // CHECK-LABEL: @uitofp_i1_f64
func.func @uitofp_i1_f64(%arg0 : i1) -> f64 { func.func @uitofp_i1_f64(%arg0 : i1) -> f64 {
// CHECK: %[[ZERO:.+]] = spirv.Constant 0.000000e+00 : f64 // CHECK: %[[ZERO:.+]] = spirv.Constant 0.000000e+00 : f64
// CHECK: %[[ONE:.+]] = spirv.Constant 1.000000e+00 : f64 // CHECK: %[[ONE:.+]] = spirv.Constant 1.000000e+00 : f64
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f64 // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f64
%0 = arith.uitofp %arg0 : i1 to f64 %0 = arith.uitofp %arg0 : i1 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: @uitofp_vec_i1_f32 // CHECK-LABEL: @uitofp_vec_i1_f32
func.func @uitofp_vec_i1_f32(%arg0 : vector<4xi1>) -> vector<4xf32> { func.func @uitofp_vec_i1_f32(%arg0 : vector<4xi1>) -> vector<4xf32> {
// CHECK: %[[ZERO:.+]] = spirv.Constant dense<0.000000e+00> : vector<4xf32> // CHECK: %[[ZERO:.+]] = spirv.Constant dense<0.000000e+00> : vector<4xf32>
// CHECK: %[[ONE:.+]] = spirv.Constant dense<1.000000e+00> : vector<4xf32> // CHECK: %[[ONE:.+]] = spirv.Constant dense<1.000000e+00> : vector<4xf32>
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf32> // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf32>
%0 = arith.uitofp %arg0 : vector<4xi1> to vector<4xf32> %0 = arith.uitofp %arg0 : vector<4xi1> to vector<4xf32>
return %0 : vector<4xf32> return %0 : vector<4xf32>
} }
// CHECK-LABEL: @uitofp_vec_i1_f64 // CHECK-LABEL: @uitofp_vec_i1_f64
spirv.func @uitofp_vec_i1_f64(%arg0: vector<4xi1>) -> vector<4xf64> "None" { spirv.func @uitofp_vec_i1_f64(%arg0: vector<4xi1>) -> vector<4xf64> "None" {
// CHECK: %[[ZERO:.+]] = spirv.Constant dense<0.000000e+00> : vector<4xf64> // CHECK: %[[ZERO:.+]] = spirv.Constant dense<0.000000e+00> : vector<4xf64>
// CHECK: %[[ONE:.+]] = spirv.Constant dense<1.000000e+00> : vector<4xf64> // CHECK: %[[ONE:.+]] = spirv.Constant dense<1.000000e+00> : vector<4xf64>
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf64> // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf64>
%0 = spirv.Constant dense<0.000000e+00> : vector<4xf64> %0 = spirv.Constant dense<0.000000e+00> : vector<4xf64>
%1 = spirv.Constant dense<1.000000e+00> : vector<4xf64> %1 = spirv.Constant dense<1.000000e+00> : vector<4xf64>
%2 = spirv.Select %arg0, %1, %0 : vector<4xi1>, vector<4xf64> %2 = spirv.Select %arg0, %1, %0 : vector<4xi1>, vector<4xf64>
spirv.ReturnValue %2 : vector<4xf64> spirv.ReturnValue %2 : vector<4xf64>
} }
// CHECK-LABEL: @sexti1 // CHECK-LABEL: @sexti1
func.func @sexti1(%arg0: i16) -> i64 { func.func @sexti1(%arg0: i16) -> i64 {
// CHECK: spirv.SConvert %{{.*}} : i16 to i64 // CHECK: spirv.SConvert %{{.*}} : i16 to i64
%0 = arith.extsi %arg0 : i16 to i64 %0 = arith.extsi %arg0 : i16 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: @sexti2 // CHECK-LABEL: @sexti2
func.func @sexti2(%arg0 : i32) -> i64 { func.func @sexti2(%arg0 : i32) -> i64 {
// CHECK: spirv.SConvert %{{.*}} : i32 to i64 // CHECK: spirv.SConvert %{{.*}} : i32 to i64
%0 = arith.extsi %arg0 : i32 to i64 %0 = arith.extsi %arg0 : i32 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: @zexti1 // CHECK-LABEL: @zexti1
func.func @zexti1(%arg0: i16) -> i64 { func.func @zexti1(%arg0: i16) -> i64 {
// CHECK: spirv.UConvert %{{.*}} : i16 to i64 // CHECK: spirv.UConvert %{{.*}} : i16 to i64
%0 = arith.extui %arg0 : i16 to i64 %0 = arith.extui %arg0 : i16 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: @zexti2 // CHECK-LABEL: @zexti2
func.func @zexti2(%arg0 : i32) -> i64 { func.func @zexti2(%arg0 : i32) -> i64 {
// CHECK: spirv.UConvert %{{.*}} : i32 to i64 // CHECK: spirv.UConvert %{{.*}} : i32 to i64
%0 = arith.extui %arg0 : i32 to i64 %0 = arith.extui %arg0 : i32 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: @zexti3 // CHECK-LABEL: @zexti3
func.func @zexti3(%arg0 : i1) -> i32 { func.func @zexti3(%arg0 : i1) -> i32 {
// CHECK: %[[ZERO:.+]] = spirv.Constant 0 : i32 // CHECK: %[[ZERO:.+]] = spirv.Constant 0 : i32
// CHECK: %[[ONE:.+]] = spirv.Constant 1 : i32 // CHECK: %[[ONE:.+]] = spirv.Constant 1 : i32
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, i32 // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, i32
%0 = arith.extui %arg0 : i1 to i32 %0 = arith.extui %arg0 : i1 to i32
return %0 : i32 return %0 : i32
} }
// CHECK-LABEL: @zexti4 // CHECK-LABEL: @zexti4
func.func @zexti4(%arg0 : vector<4xi1>) -> vector<4xi32> { func.func @zexti4(%arg0 : vector<4xi1>) -> vector<4xi32> {
// CHECK: %[[ZERO:.+]] = spirv.Constant dense<0> : vector<4xi32> // CHECK: %[[ZERO:.+]] = spirv.Constant dense<0> : vector<4xi32>
// CHECK: %[[ONE:.+]] = spirv.Constant dense<1> : vector<4xi32> // CHECK: %[[ONE:.+]] = spirv.Constant dense<1> : vector<4xi32>
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi32> // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi32>
%0 = arith.extui %arg0 : vector<4xi1> to vector<4xi32> %0 = arith.extui %arg0 : vector<4xi1> to vector<4xi32>
return %0 : vector<4xi32> return %0 : vector<4xi32>
} }
// CHECK-LABEL: @zexti5 // CHECK-LABEL: @zexti5
func.func @zexti5(%arg0 : vector<4xi1>) -> vector<4xi64> { func.func @zexti5(%arg0 : vector<4xi1>) -> vector<4xi64> {
// CHECK: %[[ZERO:.+]] = spirv.Constant dense<0> : vector<4xi64> // CHECK: %[[ZERO:.+]] = spirv.Constant dense<0> : vector<4xi64>
// CHECK: %[[ONE:.+]] = spirv.Constant dense<1> : vector<4xi64> // CHECK: %[[ONE:.+]] = spirv.Constant dense<1> : vector<4xi64>
// CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi64> // CHECK: spirv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi64>
%0 = arith.extui %arg0 : vector<4xi1> to vector<4xi64> %0 = arith.extui %arg0 : vector<4xi1> to vector<4xi64>
return %0 : vector<4xi64> return %0 : vector<4xi64>
} }
// CHECK-LABEL: @trunci1 // CHECK-LABEL: @trunci1
func.func @trunci1(%arg0 : i64) -> i16 { func.func @trunci1(%arg0 : i64) -> i16 {
// CHECK: spirv.SConvert %{{.*}} : i64 to i16 // CHECK: spirv.SConvert %{{.*}} : i64 to i16
%0 = arith.trunci %arg0 : i64 to i16 %0 = arith.trunci %arg0 : i64 to i16
return %0 : i16 return %0 : i16
} }
// CHECK-LABEL: @trunci2 // CHECK-LABEL: @trunci2
func.func @trunci2(%arg0: i32) -> i16 { func.func @trunci2(%arg0: i32) -> i16 {
// CHECK: spirv.SConvert %{{.*}} : i32 to i16 // CHECK: spirv.SConvert %{{.*}} : i32 to i16
%0 = arith.trunci %arg0 : i32 to i16 %0 = arith.trunci %arg0 : i32 to i16
return %0 : i16 return %0 : i16
} }
// CHECK-LABEL: @trunc_to_i1 // CHECK-LABEL: @trunc_to_i1
func.func @trunc_to_i1(%arg0: i32) -> i1 { func.func @trunc_to_i1(%arg0: i32) -> i1 {
// CHECK: %[[MASK:.*]] = spirv.Constant 1 : i32 // CHECK: %[[MASK:.*]] = spirv.Constant 1 : i32
// CHECK: %[[MASKED_SRC:.*]] = spirv.BitwiseAnd %{{.*}}, %[[MASK]] : i32 // CHECK: %[[MASKED_SRC:.*]] = spirv.BitwiseAnd %{{.*}}, %[[MASK]] : i32
// CHECK: %[[IS_ONE:.*]] = spirv.IEqual %[[MASKED_SRC]], %[[MASK]] : i32 // CHECK: %[[IS_ONE:.*]] = spirv.IEqual %[[MASKED_SRC]], %[[MASK]] : i32
// CHECK-DAG: %[[TRUE:.*]] = spirv.Constant true // CHECK-DAG: %[[TRUE:.*]] = spirv.Constant true
// CHECK-DAG: %[[FALSE:.*]] = spirv.Constant false // CHECK-DAG: %[[FALSE:.*]] = spirv.Constant false
// CHECK: spirv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : i1, i1 // CHECK: spirv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : i1, i1
%0 = arith.trunci %arg0 : i32 to i1 %0 = arith.trunci %arg0 : i32 to i1
return %0 : i1 return %0 : i1
} }
// CHECK-LABEL: @trunc_to_veci1 // CHECK-LABEL: @trunc_to_veci1
func.func @trunc_to_veci1(%arg0: vector<4xi32>) -> vector<4xi1> { func.func @trunc_to_veci1(%arg0: vector<4xi32>) -> vector<4xi1> {
// CHECK: %[[MASK:.*]] = spirv.Constant dense<1> : vector<4xi32> // CHECK: %[[MASK:.*]] = spirv.Constant dense<1> : vector<4xi32>
// CHECK: %[[MASKED_SRC:.*]] = spirv.BitwiseAnd %{{.*}}, %[[MASK]] : vector<4xi32> // CHECK: %[[MASKED_SRC:.*]] = spirv.BitwiseAnd %{{.*}}, %[[MASK]] : vector<4xi32>
// CHECK: %[[IS_ONE:.*]] = spirv.IEqual %[[MASKED_SRC]], %[[MASK]] : vector<4xi32> // CHECK: %[[IS_ONE:.*]] = spirv.IEqual %[[MASKED_SRC]], %[[MASK]] : vector<4xi32>
// CHECK-DAG: %[[TRUE:.*]] = spirv.Constant dense<true> : vector<4xi1> // CHECK-DAG: %[[TRUE:.*]] = spirv.Constant dense<true> : vector<4xi1>
// CHECK-DAG: %[[FALSE:.*]] = spirv.Constant dense<false> : vector<4xi1> // CHECK-DAG: %[[FALSE:.*]] = spirv.Constant dense<false> : vector<4xi1>
// CHECK: spirv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : vector<4xi1>, vector<4xi1> // CHECK: spirv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : vector<4xi1>, vector<4xi1>
%0 = arith.trunci %arg0 : vector<4xi32> to vector<4xi1> %0 = arith.trunci %arg0 : vector<4xi32> to vector<4xi1>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// CHECK-LABEL: @fptosi1 // CHECK-LABEL: @fptosi1
func.func @fptosi1(%arg0 : f32) -> i32 { func.func @fptosi1(%arg0 : f32) -> i32 {
// CHECK: spirv.ConvertFToS %{{.*}} : f32 to i32 // CHECK: spirv.ConvertFToS %{{.*}} : f32 to i32
%0 = arith.fptosi %arg0 : f32 to i32 %0 = arith.fptosi %arg0 : f32 to i32
return %0 : i32 return %0 : i32
} }
// CHECK-LABEL: @fptosi2 // CHECK-LABEL: @fptosi2
func.func @fptosi2(%arg0 : f16) -> i16 { func.func @fptosi2(%arg0 : f16) -> i16 {
// CHECK: spirv.ConvertFToS %{{.*}} : f16 to i16 // CHECK: spirv.ConvertFToS %{{.*}} : f16 to i16
%0 = arith.fptosi %arg0 : f16 to i16 %0 = arith.fptosi %arg0 : f16 to i16
return %0 : i16 return %0 : i16
} }
} // end module } // end module
// ----- // -----
// Checks that cast types will be adjusted when missing special capabilities for // Checks that cast types will be adjusted when missing special capabilities for
// certain non-32-bit scalar types. // certain non-32-bit scalar types.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Float64], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Float64], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @fpext1 // CHECK-LABEL: @fpext1
// CHECK-SAME: %[[A:.*]]: f16 // CHECK-SAME: %[[A:.*]]: f16
func.func @fpext1(%arg0: f16) -> f64 { func.func @fpext1(%arg0: f16) -> f64 {
// CHECK: %[[ARG:.+]] = builtin.unrealized_conversion_cast %[[A]] : f16 to f32 // CHECK: %[[ARG:.+]] = builtin.unrealized_conversion_cast %[[A]] : f16 to f32
// CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f64 // CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f64
%0 = arith.extf %arg0 : f16 to f64 %0 = arith.extf %arg0 : f16 to f64
return %0: f64 return %0: f64
} }
// CHECK-LABEL: @fpext2 // CHECK-LABEL: @fpext2
// CHECK-SAME: %[[ARG:.*]]: f32 // CHECK-SAME: %[[ARG:.*]]: f32
func.func @fpext2(%arg0 : f32) -> f64 { func.func @fpext2(%arg0 : f32) -> f64 {
// CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f64 // CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f64
%0 = arith.extf %arg0 : f32 to f64 %0 = arith.extf %arg0 : f32 to f64
return %0: f64 return %0: f64
} }
} // end module } // end module
// ----- // -----
// Checks that cast types will be adjusted when missing special capabilities for // Checks that cast types will be adjusted when missing special capabilities for
// certain non-32-bit scalar types. // certain non-32-bit scalar types.
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Float16], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Float16], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @fptrunc1 // CHECK-LABEL: @fptrunc1
// CHECK-SAME: %[[A:.*]]: f64 // CHECK-SAME: %[[A:.*]]: f64
func.func @fptrunc1(%arg0 : f64) -> f16 { func.func @fptrunc1(%arg0 : f64) -> f16 {
// CHECK: %[[ARG:.+]] = builtin.unrealized_conversion_cast %[[A]] : f64 to f32 // CHECK: %[[ARG:.+]] = builtin.unrealized_conversion_cast %[[A]] : f64 to f32
// CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f16 // CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f16
%0 = arith.truncf %arg0 : f64 to f16 %0 = arith.truncf %arg0 : f64 to f16
return %0: f16 return %0: f16
} }
// CHECK-LABEL: @fptrunc2 // CHECK-LABEL: @fptrunc2
// CHECK-SAME: %[[ARG:.*]]: f32 // CHECK-SAME: %[[ARG:.*]]: f32
func.func @fptrunc2(%arg0: f32) -> f16 { func.func @fptrunc2(%arg0: f32) -> f16 {
// CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f16 // CHECK-NEXT: spirv.FConvert %[[ARG]] : f32 to f16
%0 = arith.truncf %arg0 : f32 to f16 %0 = arith.truncf %arg0 : f32 to f16
return %0: f16 return %0: f16
} }
// CHECK-LABEL: @sitofp // CHECK-LABEL: @sitofp
func.func @sitofp(%arg0 : i64) -> f64 { func.func @sitofp(%arg0 : i64) -> f64 {
// CHECK: spirv.ConvertSToF %{{.*}} : i32 to f32 // CHECK: spirv.ConvertSToF %{{.*}} : i32 to f32
%0 = arith.sitofp %arg0 : i64 to f64 %0 = arith.sitofp %arg0 : i64 to f64
return %0: f64 return %0: f64
} }
} // end module } // end module
// ----- // -----

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

  • This file was moved from mlir/test/Conversion/ArithmeticToSPIRV/fast-math.mlir.
// RUN: mlir-opt -split-input-file -convert-arith-to-spirv=enable-fast-math -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -split-input-file -convert-arith-to-spirv=enable-fast-math -verify-diagnostics %s | FileCheck %s
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @cmpf_ordered // CHECK-LABEL: @cmpf_ordered
// CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32 // CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32
func.func @cmpf_ordered(%arg0 : f32, %arg1 : f32) -> i1 { func.func @cmpf_ordered(%arg0 : f32, %arg1 : f32) -> i1 {
// CHECK: %[[T:.+]] = spirv.Constant true // CHECK: %[[T:.+]] = spirv.Constant true
%0 = arith.cmpf ord, %arg0, %arg1 : f32 %0 = arith.cmpf ord, %arg0, %arg1 : f32
// CHECK: return %[[T]] // CHECK: return %[[T]]
return %0: i1 return %0: i1
} }
// CHECK-LABEL: @cmpf_unordered // CHECK-LABEL: @cmpf_unordered
// CHECK-SAME: %[[LHS:.+]]: vector<4xf32>, %[[RHS:.+]]: vector<4xf32> // CHECK-SAME: %[[LHS:.+]]: vector<4xf32>, %[[RHS:.+]]: vector<4xf32>
func.func @cmpf_unordered(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) -> vector<4xi1> { func.func @cmpf_unordered(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) -> vector<4xi1> {
// CHECK: %[[F:.+]] = spirv.Constant dense<false> // CHECK: %[[F:.+]] = spirv.Constant dense<false>
%0 = arith.cmpf uno, %arg0, %arg1 : vector<4xf32> %0 = arith.cmpf uno, %arg0, %arg1 : vector<4xf32>
// CHECK: return %[[F]] // CHECK: return %[[F]]
return %0: vector<4xi1> return %0: vector<4xi1>
} }
} // end module } // end module
// ----- // -----
module attributes { module attributes {
spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Shader], []>, #spirv.resource_limits<>> spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Shader], []>, #spirv.resource_limits<>>
} { } {
// CHECK-LABEL: @minf // CHECK-LABEL: @minf
// CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32 // CHECK-SAME: %[[LHS:.+]]: f32, %[[RHS:.+]]: f32
func.func @minf(%arg0 : f32, %arg1 : f32) -> f32 { func.func @minf(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK: %[[F:.+]] = spirv.GL.FMin %[[LHS]], %[[RHS]] // CHECK: %[[F:.+]] = spirv.GL.FMin %[[LHS]], %[[RHS]]
%0 = arith.minf %arg0, %arg1 : f32 %0 = arith.minf %arg0, %arg1 : f32
// CHECK: return %[[F]] // CHECK: return %[[F]]
return %0: f32 return %0: f32
} }
// CHECK-LABEL: @maxf // CHECK-LABEL: @maxf
// CHECK-SAME: %[[LHS:.+]]: vector<4xf32>, %[[RHS:.+]]: vector<4xf32> // CHECK-SAME: %[[LHS:.+]]: vector<4xf32>, %[[RHS:.+]]: vector<4xf32>
func.func @maxf(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) -> vector<4xf32> { func.func @maxf(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) -> vector<4xf32> {
// CHECK: %[[F:.+]] = spirv.GL.FMax %[[LHS]], %[[RHS]] // CHECK: %[[F:.+]] = spirv.GL.FMax %[[LHS]], %[[RHS]]
%0 = arith.maxf %arg0, %arg1 : vector<4xf32> %0 = arith.maxf %arg0, %arg1 : vector<4xf32>
// CHECK: return %[[F]] // CHECK: return %[[F]]
return %0: vector<4xf32> return %0: vector<4xf32>
} }
} // end module } // end module

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.
// RUN: mlir-opt %s -arith-bufferize -split-input-file | FileCheck %s // RUN: mlir-opt %s -arith-bufferize -split-input-file | FileCheck %s
// RUN: mlir-opt %s -arith-bufferize=alignment=64 -split-input-file | FileCheck --check-prefix=ALIGNED %s // RUN: mlir-opt %s -arith-bufferize=alignment=64 -split-input-file | FileCheck --check-prefix=ALIGNED %s
// CHECK-LABEL: func @index_cast( // CHECK-LABEL: func @index_cast(
// CHECK-SAME: %[[TENSOR:.*]]: tensor<i32>, %[[SCALAR:.*]]: i32 // CHECK-SAME: %[[TENSOR:.*]]: tensor<i32>, %[[SCALAR:.*]]: i32
func.func @index_cast(%tensor: tensor<i32>, %scalar: i32) -> (tensor<index>, index) { func.func @index_cast(%tensor: tensor<i32>, %scalar: i32) -> (tensor<index>, index) {
%index_tensor = arith.index_cast %tensor : tensor<i32> to tensor<index> %index_tensor = arith.index_cast %tensor : tensor<i32> to tensor<index>
%index_scalar = arith.index_cast %scalar : i32 to index %index_scalar = arith.index_cast %scalar : i32 to index
return %index_tensor, %index_scalar : tensor<index>, index return %index_tensor, %index_scalar : tensor<index>, index
} }
// CHECK: %[[MEMREF:.*]] = bufferization.to_memref %[[TENSOR]] : memref<i32> // CHECK: %[[MEMREF:.*]] = bufferization.to_memref %[[TENSOR]] : memref<i32>
// CHECK-NEXT: %[[INDEX_MEMREF:.*]] = arith.index_cast %[[MEMREF]] // CHECK-NEXT: %[[INDEX_MEMREF:.*]] = arith.index_cast %[[MEMREF]]
// CHECK-SAME: memref<i32> to memref<index> // CHECK-SAME: memref<i32> to memref<index>
// CHECK-NEXT: %[[INDEX_TENSOR:.*]] = bufferization.to_tensor %[[INDEX_MEMREF]] // CHECK-NEXT: %[[INDEX_TENSOR:.*]] = bufferization.to_tensor %[[INDEX_MEMREF]]
// CHECK: return %[[INDEX_TENSOR]] // CHECK: return %[[INDEX_TENSOR]]
// ----- // -----
// CHECK-LABEL: module { // CHECK-LABEL: module {
// We check the debug name too since we put some effort into making that readable. // We check the debug name too since we put some effort into making that readable.
// The name isn't load-bearing though. // The name isn't load-bearing though.
// CHECK: memref.global "private" constant @__constant_3x4xf32 : memref<3x4xf32> = dense<7.000000e+00> // CHECK: memref.global "private" constant @__constant_3x4xf32 : memref<3x4xf32> = dense<7.000000e+00>
// CHECK-NOT: alignment // CHECK-NOT: alignment
// ALIGNED: memref.global "private" constant @__constant_3x4xf32 : memref<3x4xf32> = dense<7.000000e+00> // ALIGNED: memref.global "private" constant @__constant_3x4xf32 : memref<3x4xf32> = dense<7.000000e+00>
// ALIGNED-SAME: {alignment = 64 : i64} // ALIGNED-SAME: {alignment = 64 : i64}
// CHECK: @basic // CHECK: @basic
func.func @basic() -> tensor<3x4xf32> { func.func @basic() -> tensor<3x4xf32> {
// CHECK: %[[MEMREF:.*]] = memref.get_global @__constant_3x4xf32 : memref<3x4xf32> // CHECK: %[[MEMREF:.*]] = memref.get_global @__constant_3x4xf32 : memref<3x4xf32>
// CHECK: %[[TENSOR:.*]] = bufferization.to_tensor %[[MEMREF]] // CHECK: %[[TENSOR:.*]] = bufferization.to_tensor %[[MEMREF]]
%0 = arith.constant dense<7.0> : tensor<3x4xf32> %0 = arith.constant dense<7.0> : tensor<3x4xf32>
// CHECK: return %[[TENSOR]] // CHECK: return %[[TENSOR]]
return %0 : tensor<3x4xf32> return %0 : tensor<3x4xf32>
} }
// CHECK: } // CHECK: }
// ----- // -----
// CHECK-LABEL: module { // CHECK-LABEL: module {
// Only one global is created. // Only one global is created.
// CHECK: memref.global // CHECK: memref.global
// CHECK-NOT: memref.global // CHECK-NOT: memref.global
func.func @duplicate_constants() -> (tensor<3x4xf32>, tensor<3x4xf32>) { func.func @duplicate_constants() -> (tensor<3x4xf32>, tensor<3x4xf32>) {
%0 = arith.constant dense<7.0> : tensor<3x4xf32> %0 = arith.constant dense<7.0> : tensor<3x4xf32>
%1 = arith.constant dense<7.0> : tensor<3x4xf32> %1 = arith.constant dense<7.0> : tensor<3x4xf32>
return %0, %1 : tensor<3x4xf32>, tensor<3x4xf32> return %0, %1 : tensor<3x4xf32>, tensor<3x4xf32>
} }
// CHECK: } // CHECK: }
// ----- // -----
// CHECK-LABEL: module { // CHECK-LABEL: module {
// Two globals are created. // Two globals are created.
// CHECK: memref.global // CHECK: memref.global
// CHECK: memref.global // CHECK: memref.global
// CHECK-NOT: memref.global // CHECK-NOT: memref.global
func.func @multiple_constants() -> (tensor<3x4xf32>, tensor<3x4xf32>) { func.func @multiple_constants() -> (tensor<3x4xf32>, tensor<3x4xf32>) {
%0 = arith.constant dense<7.0> : tensor<3x4xf32> %0 = arith.constant dense<7.0> : tensor<3x4xf32>
%1 = arith.constant dense<8.0> : tensor<3x4xf32> %1 = arith.constant dense<8.0> : tensor<3x4xf32>
return %0, %1 : tensor<3x4xf32>, tensor<3x4xf32> return %0, %1 : tensor<3x4xf32>, tensor<3x4xf32>
} }
// CHECK: } // CHECK: }
// ----- // -----
// CHECK-LABEL: module { // CHECK-LABEL: module {
// We don't convert non-tensor globals. // We don't convert non-tensor globals.
// CHECK-NOT: memref.global // CHECK-NOT: memref.global
func.func @non_tensor() { func.func @non_tensor() {
%0 = arith.constant 7 : i32 %0 = arith.constant 7 : i32
return return
} }
// CHECK: } // CHECK: }
// ----- // -----
// CHECK-LABEL: func @select( // CHECK-LABEL: func @select(
// CHECK-SAME: %[[PRED:.*]]: i1, // CHECK-SAME: %[[PRED:.*]]: i1,
// CHECK-SAME: %[[TRUE_VAL:.*]]: tensor<f32>, // CHECK-SAME: %[[TRUE_VAL:.*]]: tensor<f32>,
// CHECK-SAME: %[[FALSE_VAL:.*]]: tensor<f32>) -> tensor<f32> { // CHECK-SAME: %[[FALSE_VAL:.*]]: tensor<f32>) -> tensor<f32> {
// CHECK-DAG: %[[TRUE_VAL_MEMREF:.*]] = bufferization.to_memref %[[TRUE_VAL]] : memref<f32> // CHECK-DAG: %[[TRUE_VAL_MEMREF:.*]] = bufferization.to_memref %[[TRUE_VAL]] : memref<f32>
// CHECK-DAG: %[[FALSE_VAL_MEMREF:.*]] = bufferization.to_memref %[[FALSE_VAL]] : memref<f32> // CHECK-DAG: %[[FALSE_VAL_MEMREF:.*]] = bufferization.to_memref %[[FALSE_VAL]] : memref<f32>
// CHECK: %[[RET_MEMREF:.*]] = arith.select %[[PRED]], %[[TRUE_VAL_MEMREF]], %[[FALSE_VAL_MEMREF]] : memref<f32> // CHECK: %[[RET_MEMREF:.*]] = arith.select %[[PRED]], %[[TRUE_VAL_MEMREF]], %[[FALSE_VAL_MEMREF]] : memref<f32>
// CHECK: %[[RET:.*]] = bufferization.to_tensor %[[RET_MEMREF]] : memref<f32> // CHECK: %[[RET:.*]] = bufferization.to_tensor %[[RET_MEMREF]] : memref<f32>
// CHECK: return %[[RET]] : tensor<f32> // CHECK: return %[[RET]] : tensor<f32>
func.func @select(%arg0: i1, %arg1: tensor<f32>, %arg2: tensor<f32>) -> tensor<f32> { func.func @select(%arg0: i1, %arg1: tensor<f32>, %arg2: tensor<f32>) -> tensor<f32> {
%0 = arith.select %arg0, %arg1, %arg2 : tensor<f32> %0 = arith.select %arg0, %arg1, %arg2 : tensor<f32>
return %0 : tensor<f32> return %0 : tensor<f32>
} }

mlir/test/Dialect/Arith/canonicalize.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/canonicalize.mlir.
// RUN: mlir-opt %s -canonicalize --split-input-file | FileCheck %s // RUN: mlir-opt %s -canonicalize --split-input-file | FileCheck %s
// CHECK-LABEL: @select_same_val // CHECK-LABEL: @select_same_val
// CHECK: return %arg1 // CHECK: return %arg1
func.func @select_same_val(%arg0: i1, %arg1: i64) -> i64 { func.func @select_same_val(%arg0: i1, %arg1: i64) -> i64 {
%0 = arith.select %arg0, %arg1, %arg1 : i64 %0 = arith.select %arg0, %arg1, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: @select_cmp_eq_select // CHECK-LABEL: @select_cmp_eq_select
// CHECK: return %arg1 // CHECK: return %arg1
func.func @select_cmp_eq_select(%arg0: i64, %arg1: i64) -> i64 { func.func @select_cmp_eq_select(%arg0: i64, %arg1: i64) -> i64 {
%0 = arith.cmpi eq, %arg0, %arg1 : i64 %0 = arith.cmpi eq, %arg0, %arg1 : i64
%1 = arith.select %0, %arg0, %arg1 : i64 %1 = arith.select %0, %arg0, %arg1 : i64
return %1 : i64 return %1 : i64
} }
// CHECK-LABEL: @select_cmp_ne_select // CHECK-LABEL: @select_cmp_ne_select
// CHECK: return %arg0 // CHECK: return %arg0
func.func @select_cmp_ne_select(%arg0: i64, %arg1: i64) -> i64 { func.func @select_cmp_ne_select(%arg0: i64, %arg1: i64) -> i64 {
%0 = arith.cmpi ne, %arg0, %arg1 : i64 %0 = arith.cmpi ne, %arg0, %arg1 : i64
%1 = arith.select %0, %arg0, %arg1 : i64 %1 = arith.select %0, %arg0, %arg1 : i64
return %1 : i64 return %1 : i64
} }
// CHECK-LABEL: @select_extui // CHECK-LABEL: @select_extui
// CHECK: %[[res:.+]] = arith.extui %arg0 : i1 to i64 // CHECK: %[[res:.+]] = arith.extui %arg0 : i1 to i64
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @select_extui(%arg0: i1) -> i64 { func.func @select_extui(%arg0: i1) -> i64 {
%c0_i64 = arith.constant 0 : i64 %c0_i64 = arith.constant 0 : i64
%c1_i64 = arith.constant 1 : i64 %c1_i64 = arith.constant 1 : i64
%res = arith.select %arg0, %c1_i64, %c0_i64 : i64 %res = arith.select %arg0, %c1_i64, %c0_i64 : i64
return %res : i64 return %res : i64
} }
// CHECK-LABEL: @select_extui2 // CHECK-LABEL: @select_extui2
// CHECK-DAG: %true = arith.constant true // CHECK-DAG: %true = arith.constant true
// CHECK-DAG: %[[xor:.+]] = arith.xori %arg0, %true : i1 // CHECK-DAG: %[[xor:.+]] = arith.xori %arg0, %true : i1
// CHECK-DAG: %[[res:.+]] = arith.extui %[[xor]] : i1 to i64 // CHECK-DAG: %[[res:.+]] = arith.extui %[[xor]] : i1 to i64
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @select_extui2(%arg0: i1) -> i64 { func.func @select_extui2(%arg0: i1) -> i64 {
%c0_i64 = arith.constant 0 : i64 %c0_i64 = arith.constant 0 : i64
%c1_i64 = arith.constant 1 : i64 %c1_i64 = arith.constant 1 : i64
%res = arith.select %arg0, %c0_i64, %c1_i64 : i64 %res = arith.select %arg0, %c0_i64, %c1_i64 : i64
return %res : i64 return %res : i64
} }
// CHECK-LABEL: @select_extui_i1 // CHECK-LABEL: @select_extui_i1
// CHECK-NEXT: return %arg0 // CHECK-NEXT: return %arg0
func.func @select_extui_i1(%arg0: i1) -> i1 { func.func @select_extui_i1(%arg0: i1) -> i1 {
%c0_i1 = arith.constant false %c0_i1 = arith.constant false
%c1_i1 = arith.constant true %c1_i1 = arith.constant true
%res = arith.select %arg0, %c1_i1, %c0_i1 : i1 %res = arith.select %arg0, %c1_i1, %c0_i1 : i1
return %res : i1 return %res : i1
} }
// CHECK-LABEL: @selToNot // CHECK-LABEL: @selToNot
// CHECK: %[[trueval:.+]] = arith.constant true // CHECK: %[[trueval:.+]] = arith.constant true
// CHECK: %[[res:.+]] = arith.xori %arg0, %[[trueval]] : i1 // CHECK: %[[res:.+]] = arith.xori %arg0, %[[trueval]] : i1
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @selToNot(%arg0: i1) -> i1 { func.func @selToNot(%arg0: i1) -> i1 {
%true = arith.constant true %true = arith.constant true
%false = arith.constant false %false = arith.constant false
%res = arith.select %arg0, %false, %true : i1 %res = arith.select %arg0, %false, %true : i1
return %res : i1 return %res : i1
} }
// CHECK-LABEL: @selToArith // CHECK-LABEL: @selToArith
// CHECK-NEXT: %[[trueval:.+]] = arith.constant true // CHECK-NEXT: %[[trueval:.+]] = arith.constant true
// CHECK-NEXT: %[[notcmp:.+]] = arith.xori %arg0, %[[trueval]] : i1 // CHECK-NEXT: %[[notcmp:.+]] = arith.xori %arg0, %[[trueval]] : i1
// CHECK-NEXT: %[[condtrue:.+]] = arith.andi %arg0, %arg1 : i1 // CHECK-NEXT: %[[condtrue:.+]] = arith.andi %arg0, %arg1 : i1
// CHECK-NEXT: %[[condfalse:.+]] = arith.andi %[[notcmp]], %arg2 : i1 // CHECK-NEXT: %[[condfalse:.+]] = arith.andi %[[notcmp]], %arg2 : i1
// CHECK-NEXT: %[[res:.+]] = arith.ori %[[condtrue]], %[[condfalse]] : i1 // CHECK-NEXT: %[[res:.+]] = arith.ori %[[condtrue]], %[[condfalse]] : i1
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @selToArith(%arg0: i1, %arg1 : i1, %arg2 : i1) -> i1 { func.func @selToArith(%arg0: i1, %arg1 : i1, %arg2 : i1) -> i1 {
%res = arith.select %arg0, %arg1, %arg2 : i1 %res = arith.select %arg0, %arg1, %arg2 : i1
return %res : i1 return %res : i1
} }
// Test case: Folding of comparisons with equal operands. // Test case: Folding of comparisons with equal operands.
// CHECK-LABEL: @cmpi_equal_operands // CHECK-LABEL: @cmpi_equal_operands
// CHECK-DAG: %[[T:.*]] = arith.constant true // CHECK-DAG: %[[T:.*]] = arith.constant true
// CHECK-DAG: %[[F:.*]] = arith.constant false // CHECK-DAG: %[[F:.*]] = arith.constant false
// CHECK: return %[[T]], %[[T]], %[[T]], %[[T]], %[[T]], // CHECK: return %[[T]], %[[T]], %[[T]], %[[T]], %[[T]],
// CHECK-SAME: %[[F]], %[[F]], %[[F]], %[[F]], %[[F]] // CHECK-SAME: %[[F]], %[[F]], %[[F]], %[[F]], %[[F]]
func.func @cmpi_equal_operands(%arg0: i64) func.func @cmpi_equal_operands(%arg0: i64)
-> (i1, i1, i1, i1, i1, i1, i1, i1, i1, i1) { -> (i1, i1, i1, i1, i1, i1, i1, i1, i1, i1) {
%0 = arith.cmpi eq, %arg0, %arg0 : i64 %0 = arith.cmpi eq, %arg0, %arg0 : i64
%1 = arith.cmpi sle, %arg0, %arg0 : i64 %1 = arith.cmpi sle, %arg0, %arg0 : i64
%2 = arith.cmpi sge, %arg0, %arg0 : i64 %2 = arith.cmpi sge, %arg0, %arg0 : i64
%3 = arith.cmpi ule, %arg0, %arg0 : i64 %3 = arith.cmpi ule, %arg0, %arg0 : i64
%4 = arith.cmpi uge, %arg0, %arg0 : i64 %4 = arith.cmpi uge, %arg0, %arg0 : i64
%5 = arith.cmpi ne, %arg0, %arg0 : i64 %5 = arith.cmpi ne, %arg0, %arg0 : i64
%6 = arith.cmpi slt, %arg0, %arg0 : i64 %6 = arith.cmpi slt, %arg0, %arg0 : i64
%7 = arith.cmpi sgt, %arg0, %arg0 : i64 %7 = arith.cmpi sgt, %arg0, %arg0 : i64
%8 = arith.cmpi ult, %arg0, %arg0 : i64 %8 = arith.cmpi ult, %arg0, %arg0 : i64
%9 = arith.cmpi ugt, %arg0, %arg0 : i64 %9 = arith.cmpi ugt, %arg0, %arg0 : i64
return %0, %1, %2, %3, %4, %5, %6, %7, %8, %9 return %0, %1, %2, %3, %4, %5, %6, %7, %8, %9
: i1, i1, i1, i1, i1, i1, i1, i1, i1, i1 : i1, i1, i1, i1, i1, i1, i1, i1, i1, i1
} }
// Test case: Folding of comparisons with equal vector operands. // Test case: Folding of comparisons with equal vector operands.
// CHECK-LABEL: @cmpi_equal_vector_operands // CHECK-LABEL: @cmpi_equal_vector_operands
// CHECK-DAG: %[[T:.*]] = arith.constant dense<true> // CHECK-DAG: %[[T:.*]] = arith.constant dense<true>
// CHECK-DAG: %[[F:.*]] = arith.constant dense<false> // CHECK-DAG: %[[F:.*]] = arith.constant dense<false>
// CHECK: return %[[T]], %[[T]], %[[T]], %[[T]], %[[T]], // CHECK: return %[[T]], %[[T]], %[[T]], %[[T]], %[[T]],
// CHECK-SAME: %[[F]], %[[F]], %[[F]], %[[F]], %[[F]] // CHECK-SAME: %[[F]], %[[F]], %[[F]], %[[F]], %[[F]]
func.func @cmpi_equal_vector_operands(%arg0: vector<1x8xi64>) func.func @cmpi_equal_vector_operands(%arg0: vector<1x8xi64>)
-> (vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, -> (vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>,
vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>,
vector<1x8xi1>, vector<1x8xi1>) { vector<1x8xi1>, vector<1x8xi1>) {
%0 = arith.cmpi eq, %arg0, %arg0 : vector<1x8xi64> %0 = arith.cmpi eq, %arg0, %arg0 : vector<1x8xi64>
%1 = arith.cmpi sle, %arg0, %arg0 : vector<1x8xi64> %1 = arith.cmpi sle, %arg0, %arg0 : vector<1x8xi64>
%2 = arith.cmpi sge, %arg0, %arg0 : vector<1x8xi64> %2 = arith.cmpi sge, %arg0, %arg0 : vector<1x8xi64>
%3 = arith.cmpi ule, %arg0, %arg0 : vector<1x8xi64> %3 = arith.cmpi ule, %arg0, %arg0 : vector<1x8xi64>
%4 = arith.cmpi uge, %arg0, %arg0 : vector<1x8xi64> %4 = arith.cmpi uge, %arg0, %arg0 : vector<1x8xi64>
%5 = arith.cmpi ne, %arg0, %arg0 : vector<1x8xi64> %5 = arith.cmpi ne, %arg0, %arg0 : vector<1x8xi64>
%6 = arith.cmpi slt, %arg0, %arg0 : vector<1x8xi64> %6 = arith.cmpi slt, %arg0, %arg0 : vector<1x8xi64>
%7 = arith.cmpi sgt, %arg0, %arg0 : vector<1x8xi64> %7 = arith.cmpi sgt, %arg0, %arg0 : vector<1x8xi64>
%8 = arith.cmpi ult, %arg0, %arg0 : vector<1x8xi64> %8 = arith.cmpi ult, %arg0, %arg0 : vector<1x8xi64>
%9 = arith.cmpi ugt, %arg0, %arg0 : vector<1x8xi64> %9 = arith.cmpi ugt, %arg0, %arg0 : vector<1x8xi64>
return %0, %1, %2, %3, %4, %5, %6, %7, %8, %9 return %0, %1, %2, %3, %4, %5, %6, %7, %8, %9
: vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, : vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>,
vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>,
vector<1x8xi1>, vector<1x8xi1> vector<1x8xi1>, vector<1x8xi1>
} }
// ----- // -----
// Test case: Move constant to the right side. // Test case: Move constant to the right side.
// CHECK-LABEL: @cmpi_const_right( // CHECK-LABEL: @cmpi_const_right(
// CHECK-SAME: %[[ARG:.*]]: // CHECK-SAME: %[[ARG:.*]]:
// CHECK: %[[C:.*]] = arith.constant 1 : i64 // CHECK: %[[C:.*]] = arith.constant 1 : i64
// CHECK: %[[R0:.*]] = arith.cmpi eq, %[[ARG]], %[[C]] : i64 // CHECK: %[[R0:.*]] = arith.cmpi eq, %[[ARG]], %[[C]] : i64
// CHECK: %[[R1:.*]] = arith.cmpi sge, %[[ARG]], %[[C]] : i64 // CHECK: %[[R1:.*]] = arith.cmpi sge, %[[ARG]], %[[C]] : i64
// CHECK: %[[R2:.*]] = arith.cmpi sle, %[[ARG]], %[[C]] : i64 // CHECK: %[[R2:.*]] = arith.cmpi sle, %[[ARG]], %[[C]] : i64
// CHECK: %[[R3:.*]] = arith.cmpi uge, %[[ARG]], %[[C]] : i64 // CHECK: %[[R3:.*]] = arith.cmpi uge, %[[ARG]], %[[C]] : i64
// CHECK: %[[R4:.*]] = arith.cmpi ule, %[[ARG]], %[[C]] : i64 // CHECK: %[[R4:.*]] = arith.cmpi ule, %[[ARG]], %[[C]] : i64
// CHECK: %[[R5:.*]] = arith.cmpi ne, %[[ARG]], %[[C]] : i64 // CHECK: %[[R5:.*]] = arith.cmpi ne, %[[ARG]], %[[C]] : i64
// CHECK: %[[R6:.*]] = arith.cmpi sgt, %[[ARG]], %[[C]] : i64 // CHECK: %[[R6:.*]] = arith.cmpi sgt, %[[ARG]], %[[C]] : i64
// CHECK: %[[R7:.*]] = arith.cmpi slt, %[[ARG]], %[[C]] : i64 // CHECK: %[[R7:.*]] = arith.cmpi slt, %[[ARG]], %[[C]] : i64
// CHECK: %[[R8:.*]] = arith.cmpi ugt, %[[ARG]], %[[C]] : i64 // CHECK: %[[R8:.*]] = arith.cmpi ugt, %[[ARG]], %[[C]] : i64
// CHECK: %[[R9:.*]] = arith.cmpi ult, %[[ARG]], %[[C]] : i64 // CHECK: %[[R9:.*]] = arith.cmpi ult, %[[ARG]], %[[C]] : i64
// CHECK: return %[[R0]], %[[R1]], %[[R2]], %[[R3]], %[[R4]], // CHECK: return %[[R0]], %[[R1]], %[[R2]], %[[R3]], %[[R4]],
// CHECK-SAME: %[[R5]], %[[R6]], %[[R7]], %[[R8]], %[[R9]] // CHECK-SAME: %[[R5]], %[[R6]], %[[R7]], %[[R8]], %[[R9]]
func.func @cmpi_const_right(%arg0: i64) func.func @cmpi_const_right(%arg0: i64)
-> (i1, i1, i1, i1, i1, i1, i1, i1, i1, i1) { -> (i1, i1, i1, i1, i1, i1, i1, i1, i1, i1) {
%c1 = arith.constant 1 : i64 %c1 = arith.constant 1 : i64
%0 = arith.cmpi eq, %c1, %arg0 : i64 %0 = arith.cmpi eq, %c1, %arg0 : i64
%1 = arith.cmpi sle, %c1, %arg0 : i64 %1 = arith.cmpi sle, %c1, %arg0 : i64
%2 = arith.cmpi sge, %c1, %arg0 : i64 %2 = arith.cmpi sge, %c1, %arg0 : i64
%3 = arith.cmpi ule, %c1, %arg0 : i64 %3 = arith.cmpi ule, %c1, %arg0 : i64
%4 = arith.cmpi uge, %c1, %arg0 : i64 %4 = arith.cmpi uge, %c1, %arg0 : i64
%5 = arith.cmpi ne, %c1, %arg0 : i64 %5 = arith.cmpi ne, %c1, %arg0 : i64
%6 = arith.cmpi slt, %c1, %arg0 : i64 %6 = arith.cmpi slt, %c1, %arg0 : i64
%7 = arith.cmpi sgt, %c1, %arg0 : i64 %7 = arith.cmpi sgt, %c1, %arg0 : i64
%8 = arith.cmpi ult, %c1, %arg0 : i64 %8 = arith.cmpi ult, %c1, %arg0 : i64
%9 = arith.cmpi ugt, %c1, %arg0 : i64 %9 = arith.cmpi ugt, %c1, %arg0 : i64
return %0, %1, %2, %3, %4, %5, %6, %7, %8, %9 return %0, %1, %2, %3, %4, %5, %6, %7, %8, %9
: i1, i1, i1, i1, i1, i1, i1, i1, i1, i1 : i1, i1, i1, i1, i1, i1, i1, i1, i1, i1
} }
// ----- // -----
// CHECK-LABEL: @cmpOfExtSI // CHECK-LABEL: @cmpOfExtSI
// CHECK-NEXT: return %arg0 // CHECK-NEXT: return %arg0
func.func @cmpOfExtSI(%arg0: i1) -> i1 { func.func @cmpOfExtSI(%arg0: i1) -> i1 {
%ext = arith.extsi %arg0 : i1 to i64 %ext = arith.extsi %arg0 : i1 to i64
%c0 = arith.constant 0 : i64 %c0 = arith.constant 0 : i64
%res = arith.cmpi ne, %ext, %c0 : i64 %res = arith.cmpi ne, %ext, %c0 : i64
return %res : i1 return %res : i1
} }
// CHECK-LABEL: @cmpOfExtUI // CHECK-LABEL: @cmpOfExtUI
// CHECK-NEXT: return %arg0 // CHECK-NEXT: return %arg0
func.func @cmpOfExtUI(%arg0: i1) -> i1 { func.func @cmpOfExtUI(%arg0: i1) -> i1 {
%ext = arith.extui %arg0 : i1 to i64 %ext = arith.extui %arg0 : i1 to i64
%c0 = arith.constant 0 : i64 %c0 = arith.constant 0 : i64
%res = arith.cmpi ne, %ext, %c0 : i64 %res = arith.cmpi ne, %ext, %c0 : i64
return %res : i1 return %res : i1
} }
// ----- // -----
// CHECK-LABEL: @extSIOfExtUI // CHECK-LABEL: @extSIOfExtUI
// CHECK: %[[res:.+]] = arith.extui %arg0 : i1 to i64 // CHECK: %[[res:.+]] = arith.extui %arg0 : i1 to i64
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @extSIOfExtUI(%arg0: i1) -> i64 { func.func @extSIOfExtUI(%arg0: i1) -> i64 {
%ext1 = arith.extui %arg0 : i1 to i8 %ext1 = arith.extui %arg0 : i1 to i8
%ext2 = arith.extsi %ext1 : i8 to i64 %ext2 = arith.extsi %ext1 : i8 to i64
return %ext2 : i64 return %ext2 : i64
} }
// CHECK-LABEL: @extUIOfExtUI // CHECK-LABEL: @extUIOfExtUI
// CHECK: %[[res:.+]] = arith.extui %arg0 : i1 to i64 // CHECK: %[[res:.+]] = arith.extui %arg0 : i1 to i64
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @extUIOfExtUI(%arg0: i1) -> i64 { func.func @extUIOfExtUI(%arg0: i1) -> i64 {
%ext1 = arith.extui %arg0 : i1 to i8 %ext1 = arith.extui %arg0 : i1 to i8
%ext2 = arith.extui %ext1 : i8 to i64 %ext2 = arith.extui %ext1 : i8 to i64
return %ext2 : i64 return %ext2 : i64
} }
// CHECK-LABEL: @extSIOfExtSI // CHECK-LABEL: @extSIOfExtSI
// CHECK: %[[res:.+]] = arith.extsi %arg0 : i1 to i64 // CHECK: %[[res:.+]] = arith.extsi %arg0 : i1 to i64
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @extSIOfExtSI(%arg0: i1) -> i64 { func.func @extSIOfExtSI(%arg0: i1) -> i64 {
%ext1 = arith.extsi %arg0 : i1 to i8 %ext1 = arith.extsi %arg0 : i1 to i8
%ext2 = arith.extsi %ext1 : i8 to i64 %ext2 = arith.extsi %ext1 : i8 to i64
return %ext2 : i64 return %ext2 : i64
} }
// ----- // -----
// CHECK-LABEL: @cmpIExtSINE // CHECK-LABEL: @cmpIExtSINE
// CHECK: %[[comb:.+]] = arith.cmpi ne, %arg0, %arg1 : i8 // CHECK: %[[comb:.+]] = arith.cmpi ne, %arg0, %arg1 : i8
// CHECK: return %[[comb]] // CHECK: return %[[comb]]
func.func @cmpIExtSINE(%arg0: i8, %arg1: i8) -> i1 { func.func @cmpIExtSINE(%arg0: i8, %arg1: i8) -> i1 {
%ext0 = arith.extsi %arg0 : i8 to i64 %ext0 = arith.extsi %arg0 : i8 to i64
%ext1 = arith.extsi %arg1 : i8 to i64 %ext1 = arith.extsi %arg1 : i8 to i64
%res = arith.cmpi ne, %ext0, %ext1 : i64 %res = arith.cmpi ne, %ext0, %ext1 : i64
return %res : i1 return %res : i1
} }
// CHECK-LABEL: @cmpIExtSIEQ // CHECK-LABEL: @cmpIExtSIEQ
// CHECK: %[[comb:.+]] = arith.cmpi eq, %arg0, %arg1 : i8 // CHECK: %[[comb:.+]] = arith.cmpi eq, %arg0, %arg1 : i8
// CHECK: return %[[comb]] // CHECK: return %[[comb]]
func.func @cmpIExtSIEQ(%arg0: i8, %arg1: i8) -> i1 { func.func @cmpIExtSIEQ(%arg0: i8, %arg1: i8) -> i1 {
%ext0 = arith.extsi %arg0 : i8 to i64 %ext0 = arith.extsi %arg0 : i8 to i64
%ext1 = arith.extsi %arg1 : i8 to i64 %ext1 = arith.extsi %arg1 : i8 to i64
%res = arith.cmpi eq, %ext0, %ext1 : i64 %res = arith.cmpi eq, %ext0, %ext1 : i64
return %res : i1 return %res : i1
} }
// CHECK-LABEL: @cmpIExtUINE // CHECK-LABEL: @cmpIExtUINE
// CHECK: %[[comb:.+]] = arith.cmpi ne, %arg0, %arg1 : i8 // CHECK: %[[comb:.+]] = arith.cmpi ne, %arg0, %arg1 : i8
// CHECK: return %[[comb]] // CHECK: return %[[comb]]
func.func @cmpIExtUINE(%arg0: i8, %arg1: i8) -> i1 { func.func @cmpIExtUINE(%arg0: i8, %arg1: i8) -> i1 {
%ext0 = arith.extui %arg0 : i8 to i64 %ext0 = arith.extui %arg0 : i8 to i64
%ext1 = arith.extui %arg1 : i8 to i64 %ext1 = arith.extui %arg1 : i8 to i64
%res = arith.cmpi ne, %ext0, %ext1 : i64 %res = arith.cmpi ne, %ext0, %ext1 : i64
return %res : i1 return %res : i1
} }
// CHECK-LABEL: @cmpIExtUIEQ // CHECK-LABEL: @cmpIExtUIEQ
// CHECK: %[[comb:.+]] = arith.cmpi eq, %arg0, %arg1 : i8 // CHECK: %[[comb:.+]] = arith.cmpi eq, %arg0, %arg1 : i8
// CHECK: return %[[comb]] // CHECK: return %[[comb]]
func.func @cmpIExtUIEQ(%arg0: i8, %arg1: i8) -> i1 { func.func @cmpIExtUIEQ(%arg0: i8, %arg1: i8) -> i1 {
%ext0 = arith.extui %arg0 : i8 to i64 %ext0 = arith.extui %arg0 : i8 to i64
%ext1 = arith.extui %arg1 : i8 to i64 %ext1 = arith.extui %arg1 : i8 to i64
%res = arith.cmpi eq, %ext0, %ext1 : i64 %res = arith.cmpi eq, %ext0, %ext1 : i64
return %res : i1 return %res : i1
} }
// ----- // -----
// CHECK-LABEL: @andOfExtSI // CHECK-LABEL: @andOfExtSI
// CHECK: %[[comb:.+]] = arith.andi %arg0, %arg1 : i8 // CHECK: %[[comb:.+]] = arith.andi %arg0, %arg1 : i8
// CHECK: %[[ext:.+]] = arith.extsi %[[comb]] : i8 to i64 // CHECK: %[[ext:.+]] = arith.extsi %[[comb]] : i8 to i64
// CHECK: return %[[ext]] // CHECK: return %[[ext]]
func.func @andOfExtSI(%arg0: i8, %arg1: i8) -> i64 { func.func @andOfExtSI(%arg0: i8, %arg1: i8) -> i64 {
%ext0 = arith.extsi %arg0 : i8 to i64 %ext0 = arith.extsi %arg0 : i8 to i64
%ext1 = arith.extsi %arg1 : i8 to i64 %ext1 = arith.extsi %arg1 : i8 to i64
%res = arith.andi %ext0, %ext1 : i64 %res = arith.andi %ext0, %ext1 : i64
return %res : i64 return %res : i64
} }
// CHECK-LABEL: @andOfExtUI // CHECK-LABEL: @andOfExtUI
// CHECK: %[[comb:.+]] = arith.andi %arg0, %arg1 : i8 // CHECK: %[[comb:.+]] = arith.andi %arg0, %arg1 : i8
// CHECK: %[[ext:.+]] = arith.extui %[[comb]] : i8 to i64 // CHECK: %[[ext:.+]] = arith.extui %[[comb]] : i8 to i64
// CHECK: return %[[ext]] // CHECK: return %[[ext]]
func.func @andOfExtUI(%arg0: i8, %arg1: i8) -> i64 { func.func @andOfExtUI(%arg0: i8, %arg1: i8) -> i64 {
%ext0 = arith.extui %arg0 : i8 to i64 %ext0 = arith.extui %arg0 : i8 to i64
%ext1 = arith.extui %arg1 : i8 to i64 %ext1 = arith.extui %arg1 : i8 to i64
%res = arith.andi %ext0, %ext1 : i64 %res = arith.andi %ext0, %ext1 : i64
return %res : i64 return %res : i64
} }
// CHECK-LABEL: @orOfExtSI // CHECK-LABEL: @orOfExtSI
// CHECK: %[[comb:.+]] = arith.ori %arg0, %arg1 : i8 // CHECK: %[[comb:.+]] = arith.ori %arg0, %arg1 : i8
// CHECK: %[[ext:.+]] = arith.extsi %[[comb]] : i8 to i64 // CHECK: %[[ext:.+]] = arith.extsi %[[comb]] : i8 to i64
// CHECK: return %[[ext]] // CHECK: return %[[ext]]
func.func @orOfExtSI(%arg0: i8, %arg1: i8) -> i64 { func.func @orOfExtSI(%arg0: i8, %arg1: i8) -> i64 {
%ext0 = arith.extsi %arg0 : i8 to i64 %ext0 = arith.extsi %arg0 : i8 to i64
%ext1 = arith.extsi %arg1 : i8 to i64 %ext1 = arith.extsi %arg1 : i8 to i64
%res = arith.ori %ext0, %ext1 : i64 %res = arith.ori %ext0, %ext1 : i64
return %res : i64 return %res : i64
} }
// CHECK-LABEL: @orOfExtUI // CHECK-LABEL: @orOfExtUI
// CHECK: %[[comb:.+]] = arith.ori %arg0, %arg1 : i8 // CHECK: %[[comb:.+]] = arith.ori %arg0, %arg1 : i8
// CHECK: %[[ext:.+]] = arith.extui %[[comb]] : i8 to i64 // CHECK: %[[ext:.+]] = arith.extui %[[comb]] : i8 to i64
// CHECK: return %[[ext]] // CHECK: return %[[ext]]
func.func @orOfExtUI(%arg0: i8, %arg1: i8) -> i64 { func.func @orOfExtUI(%arg0: i8, %arg1: i8) -> i64 {
%ext0 = arith.extui %arg0 : i8 to i64 %ext0 = arith.extui %arg0 : i8 to i64
%ext1 = arith.extui %arg1 : i8 to i64 %ext1 = arith.extui %arg1 : i8 to i64
%res = arith.ori %ext0, %ext1 : i64 %res = arith.ori %ext0, %ext1 : i64
return %res : i64 return %res : i64
} }
// ----- // -----
// CHECK-LABEL: @indexCastOfSignExtend // CHECK-LABEL: @indexCastOfSignExtend
// CHECK: %[[res:.+]] = arith.index_cast %arg0 : i8 to index // CHECK: %[[res:.+]] = arith.index_cast %arg0 : i8 to index
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @indexCastOfSignExtend(%arg0: i8) -> index { func.func @indexCastOfSignExtend(%arg0: i8) -> index {
%ext = arith.extsi %arg0 : i8 to i16 %ext = arith.extsi %arg0 : i8 to i16
%idx = arith.index_cast %ext : i16 to index %idx = arith.index_cast %ext : i16 to index
return %idx : index return %idx : index
} }
// CHECK-LABEL: @signExtendConstant // CHECK-LABEL: @signExtendConstant
// CHECK: %[[cres:.+]] = arith.constant -2 : i16 // CHECK: %[[cres:.+]] = arith.constant -2 : i16
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @signExtendConstant() -> i16 { func.func @signExtendConstant() -> i16 {
%c-2 = arith.constant -2 : i8 %c-2 = arith.constant -2 : i8
%ext = arith.extsi %c-2 : i8 to i16 %ext = arith.extsi %c-2 : i8 to i16
return %ext : i16 return %ext : i16
} }
// CHECK-LABEL: @signExtendConstantSplat // CHECK-LABEL: @signExtendConstantSplat
// CHECK: %[[cres:.+]] = arith.constant dense<-2> : vector<4xi16> // CHECK: %[[cres:.+]] = arith.constant dense<-2> : vector<4xi16>
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @signExtendConstantSplat() -> vector<4xi16> { func.func @signExtendConstantSplat() -> vector<4xi16> {
%c-2 = arith.constant -2 : i8 %c-2 = arith.constant -2 : i8
%splat = vector.splat %c-2 : vector<4xi8> %splat = vector.splat %c-2 : vector<4xi8>
%ext = arith.extsi %splat : vector<4xi8> to vector<4xi16> %ext = arith.extsi %splat : vector<4xi8> to vector<4xi16>
return %ext : vector<4xi16> return %ext : vector<4xi16>
} }
// CHECK-LABEL: @signExtendConstantVector // CHECK-LABEL: @signExtendConstantVector
// CHECK: %[[cres:.+]] = arith.constant dense<[1, 3, 5, 7]> : vector<4xi16> // CHECK: %[[cres:.+]] = arith.constant dense<[1, 3, 5, 7]> : vector<4xi16>
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @signExtendConstantVector() -> vector<4xi16> { func.func @signExtendConstantVector() -> vector<4xi16> {
%vector = arith.constant dense<[1, 3, 5, 7]> : vector<4xi8> %vector = arith.constant dense<[1, 3, 5, 7]> : vector<4xi8>
%ext = arith.extsi %vector : vector<4xi8> to vector<4xi16> %ext = arith.extsi %vector : vector<4xi8> to vector<4xi16>
return %ext : vector<4xi16> return %ext : vector<4xi16>
} }
// CHECK-LABEL: @unsignedExtendConstant // CHECK-LABEL: @unsignedExtendConstant
// CHECK: %[[cres:.+]] = arith.constant 2 : i16 // CHECK: %[[cres:.+]] = arith.constant 2 : i16
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @unsignedExtendConstant() -> i16 { func.func @unsignedExtendConstant() -> i16 {
%c2 = arith.constant 2 : i8 %c2 = arith.constant 2 : i8
%ext = arith.extui %c2 : i8 to i16 %ext = arith.extui %c2 : i8 to i16
return %ext : i16 return %ext : i16
} }
// CHECK-LABEL: @unsignedExtendConstantSplat // CHECK-LABEL: @unsignedExtendConstantSplat
// CHECK: %[[cres:.+]] = arith.constant dense<2> : vector<4xi16> // CHECK: %[[cres:.+]] = arith.constant dense<2> : vector<4xi16>
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @unsignedExtendConstantSplat() -> vector<4xi16> { func.func @unsignedExtendConstantSplat() -> vector<4xi16> {
%c2 = arith.constant 2 : i8 %c2 = arith.constant 2 : i8
%splat = vector.splat %c2 : vector<4xi8> %splat = vector.splat %c2 : vector<4xi8>
%ext = arith.extui %splat : vector<4xi8> to vector<4xi16> %ext = arith.extui %splat : vector<4xi8> to vector<4xi16>
return %ext : vector<4xi16> return %ext : vector<4xi16>
} }
// CHECK-LABEL: @unsignedExtendConstantVector // CHECK-LABEL: @unsignedExtendConstantVector
// CHECK: %[[cres:.+]] = arith.constant dense<[1, 3, 5, 7]> : vector<4xi16> // CHECK: %[[cres:.+]] = arith.constant dense<[1, 3, 5, 7]> : vector<4xi16>
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @unsignedExtendConstantVector() -> vector<4xi16> { func.func @unsignedExtendConstantVector() -> vector<4xi16> {
%vector = arith.constant dense<[1, 3, 5, 7]> : vector<4xi8> %vector = arith.constant dense<[1, 3, 5, 7]> : vector<4xi8>
%ext = arith.extui %vector : vector<4xi8> to vector<4xi16> %ext = arith.extui %vector : vector<4xi8> to vector<4xi16>
return %ext : vector<4xi16> return %ext : vector<4xi16>
} }
// CHECK-LABEL: @truncConstant // CHECK-LABEL: @truncConstant
// CHECK: %[[cres:.+]] = arith.constant -2 : i16 // CHECK: %[[cres:.+]] = arith.constant -2 : i16
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @truncConstant(%arg0: i8) -> i16 { func.func @truncConstant(%arg0: i8) -> i16 {
%c-2 = arith.constant -2 : i32 %c-2 = arith.constant -2 : i32
%tr = arith.trunci %c-2 : i32 to i16 %tr = arith.trunci %c-2 : i32 to i16
return %tr : i16 return %tr : i16
} }
// CHECK-LABEL: @truncConstantSplat // CHECK-LABEL: @truncConstantSplat
// CHECK: %[[cres:.+]] = arith.constant dense<-2> : vector<4xi8> // CHECK: %[[cres:.+]] = arith.constant dense<-2> : vector<4xi8>
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @truncConstantSplat() -> vector<4xi8> { func.func @truncConstantSplat() -> vector<4xi8> {
%c-2 = arith.constant -2 : i16 %c-2 = arith.constant -2 : i16
%splat = vector.splat %c-2 : vector<4xi16> %splat = vector.splat %c-2 : vector<4xi16>
%trunc = arith.trunci %splat : vector<4xi16> to vector<4xi8> %trunc = arith.trunci %splat : vector<4xi16> to vector<4xi8>
return %trunc : vector<4xi8> return %trunc : vector<4xi8>
} }
// CHECK-LABEL: @truncConstantVector // CHECK-LABEL: @truncConstantVector
// CHECK: %[[cres:.+]] = arith.constant dense<[1, 3, 5, 7]> : vector<4xi8> // CHECK: %[[cres:.+]] = arith.constant dense<[1, 3, 5, 7]> : vector<4xi8>
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @truncConstantVector() -> vector<4xi8> { func.func @truncConstantVector() -> vector<4xi8> {
%vector = arith.constant dense<[1, 3, 5, 7]> : vector<4xi16> %vector = arith.constant dense<[1, 3, 5, 7]> : vector<4xi16>
%trunc = arith.trunci %vector : vector<4xi16> to vector<4xi8> %trunc = arith.trunci %vector : vector<4xi16> to vector<4xi8>
return %trunc : vector<4xi8> return %trunc : vector<4xi8>
} }
// CHECK-LABEL: @truncTrunc // CHECK-LABEL: @truncTrunc
// CHECK: %[[cres:.+]] = arith.trunci %arg0 : i64 to i8 // CHECK: %[[cres:.+]] = arith.trunci %arg0 : i64 to i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @truncTrunc(%arg0: i64) -> i8 { func.func @truncTrunc(%arg0: i64) -> i8 {
%tr1 = arith.trunci %arg0 : i64 to i32 %tr1 = arith.trunci %arg0 : i64 to i32
%tr2 = arith.trunci %tr1 : i32 to i8 %tr2 = arith.trunci %tr1 : i32 to i8
return %tr2 : i8 return %tr2 : i8
} }
// CHECK-LABEL: @truncFPConstant // CHECK-LABEL: @truncFPConstant
// CHECK: %[[cres:.+]] = arith.constant 1.000000e+00 : bf16 // CHECK: %[[cres:.+]] = arith.constant 1.000000e+00 : bf16
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @truncFPConstant() -> bf16 { func.func @truncFPConstant() -> bf16 {
%cst = arith.constant 1.000000e+00 : f32 %cst = arith.constant 1.000000e+00 : f32
%0 = arith.truncf %cst : f32 to bf16 %0 = arith.truncf %cst : f32 to bf16
return %0 : bf16 return %0 : bf16
} }
// Test that cases with rounding are NOT propagated // Test that cases with rounding are NOT propagated
// CHECK-LABEL: @truncFPConstantRounding // CHECK-LABEL: @truncFPConstantRounding
// CHECK: arith.constant 1.444000e+25 : f32 // CHECK: arith.constant 1.444000e+25 : f32
// CHECK: truncf // CHECK: truncf
func.func @truncFPConstantRounding() -> bf16 { func.func @truncFPConstantRounding() -> bf16 {
%cst = arith.constant 1.444000e+25 : f32 %cst = arith.constant 1.444000e+25 : f32
%0 = arith.truncf %cst : f32 to bf16 %0 = arith.truncf %cst : f32 to bf16
return %0 : bf16 return %0 : bf16
} }
// CHECK-LABEL: @tripleAddAdd // CHECK-LABEL: @tripleAddAdd
// CHECK: %[[cres:.+]] = arith.constant 59 : index // CHECK: %[[cres:.+]] = arith.constant 59 : index
// CHECK: %[[add:.+]] = arith.addi %arg0, %[[cres]] : index // CHECK: %[[add:.+]] = arith.addi %arg0, %[[cres]] : index
// CHECK: return %[[add]] // CHECK: return %[[add]]
func.func @tripleAddAdd(%arg0: index) -> index { func.func @tripleAddAdd(%arg0: index) -> index {
%c17 = arith.constant 17 : index %c17 = arith.constant 17 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
%add1 = arith.addi %c17, %arg0 : index %add1 = arith.addi %c17, %arg0 : index
%add2 = arith.addi %c42, %add1 : index %add2 = arith.addi %c42, %add1 : index
return %add2 : index return %add2 : index
} }
// CHECK-LABEL: @tripleAddSub0 // CHECK-LABEL: @tripleAddSub0
// CHECK: %[[cres:.+]] = arith.constant 59 : index // CHECK: %[[cres:.+]] = arith.constant 59 : index
// CHECK: %[[add:.+]] = arith.subi %[[cres]], %arg0 : index // CHECK: %[[add:.+]] = arith.subi %[[cres]], %arg0 : index
// CHECK: return %[[add]] // CHECK: return %[[add]]
func.func @tripleAddSub0(%arg0: index) -> index { func.func @tripleAddSub0(%arg0: index) -> index {
%c17 = arith.constant 17 : index %c17 = arith.constant 17 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
%add1 = arith.subi %c17, %arg0 : index %add1 = arith.subi %c17, %arg0 : index
%add2 = arith.addi %c42, %add1 : index %add2 = arith.addi %c42, %add1 : index
return %add2 : index return %add2 : index
} }
// CHECK-LABEL: @tripleAddSub1 // CHECK-LABEL: @tripleAddSub1
// CHECK: %[[cres:.+]] = arith.constant 25 : index // CHECK: %[[cres:.+]] = arith.constant 25 : index
// CHECK: %[[add:.+]] = arith.addi %arg0, %[[cres]] : index // CHECK: %[[add:.+]] = arith.addi %arg0, %[[cres]] : index
// CHECK: return %[[add]] // CHECK: return %[[add]]
func.func @tripleAddSub1(%arg0: index) -> index { func.func @tripleAddSub1(%arg0: index) -> index {
%c17 = arith.constant 17 : index %c17 = arith.constant 17 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
%add1 = arith.subi %arg0, %c17 : index %add1 = arith.subi %arg0, %c17 : index
%add2 = arith.addi %c42, %add1 : index %add2 = arith.addi %c42, %add1 : index
return %add2 : index return %add2 : index
} }
// CHECK-LABEL: @tripleSubAdd0 // CHECK-LABEL: @tripleSubAdd0
// CHECK: %[[cres:.+]] = arith.constant 25 : index // CHECK: %[[cres:.+]] = arith.constant 25 : index
// CHECK: %[[add:.+]] = arith.subi %[[cres]], %arg0 : index // CHECK: %[[add:.+]] = arith.subi %[[cres]], %arg0 : index
// CHECK: return %[[add]] // CHECK: return %[[add]]
func.func @tripleSubAdd0(%arg0: index) -> index { func.func @tripleSubAdd0(%arg0: index) -> index {
%c17 = arith.constant 17 : index %c17 = arith.constant 17 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
%add1 = arith.addi %c17, %arg0 : index %add1 = arith.addi %c17, %arg0 : index
%add2 = arith.subi %c42, %add1 : index %add2 = arith.subi %c42, %add1 : index
return %add2 : index return %add2 : index
} }
// CHECK-LABEL: @tripleSubAdd1 // CHECK-LABEL: @tripleSubAdd1
// CHECK: %[[cres:.+]] = arith.constant -25 : index // CHECK: %[[cres:.+]] = arith.constant -25 : index
// CHECK: %[[add:.+]] = arith.addi %arg0, %[[cres]] : index // CHECK: %[[add:.+]] = arith.addi %arg0, %[[cres]] : index
// CHECK: return %[[add]] // CHECK: return %[[add]]
func.func @tripleSubAdd1(%arg0: index) -> index { func.func @tripleSubAdd1(%arg0: index) -> index {
%c17 = arith.constant 17 : index %c17 = arith.constant 17 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
%add1 = arith.addi %c17, %arg0 : index %add1 = arith.addi %c17, %arg0 : index
%add2 = arith.subi %add1, %c42 : index %add2 = arith.subi %add1, %c42 : index
return %add2 : index return %add2 : index
} }
// CHECK-LABEL: @subSub0 // CHECK-LABEL: @subSub0
// CHECK: %[[c0:.+]] = arith.constant 0 : index // CHECK: %[[c0:.+]] = arith.constant 0 : index
// CHECK: %[[add:.+]] = arith.subi %[[c0]], %arg1 : index // CHECK: %[[add:.+]] = arith.subi %[[c0]], %arg1 : index
// CHECK: return %[[add]] // CHECK: return %[[add]]
func.func @subSub0(%arg0: index, %arg1: index) -> index { func.func @subSub0(%arg0: index, %arg1: index) -> index {
%sub1 = arith.subi %arg0, %arg1 : index %sub1 = arith.subi %arg0, %arg1 : index
%sub2 = arith.subi %sub1, %arg0 : index %sub2 = arith.subi %sub1, %arg0 : index
return %sub2 : index return %sub2 : index
} }
// CHECK-LABEL: @tripleSubSub0 // CHECK-LABEL: @tripleSubSub0
// CHECK: %[[cres:.+]] = arith.constant 25 : index // CHECK: %[[cres:.+]] = arith.constant 25 : index
// CHECK: %[[add:.+]] = arith.addi %arg0, %[[cres]] : index // CHECK: %[[add:.+]] = arith.addi %arg0, %[[cres]] : index
// CHECK: return %[[add]] // CHECK: return %[[add]]
func.func @tripleSubSub0(%arg0: index) -> index { func.func @tripleSubSub0(%arg0: index) -> index {
%c17 = arith.constant 17 : index %c17 = arith.constant 17 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
%add1 = arith.subi %c17, %arg0 : index %add1 = arith.subi %c17, %arg0 : index
%add2 = arith.subi %c42, %add1 : index %add2 = arith.subi %c42, %add1 : index
return %add2 : index return %add2 : index
} }
// CHECK-LABEL: @tripleSubSub1 // CHECK-LABEL: @tripleSubSub1
// CHECK: %[[cres:.+]] = arith.constant -25 : index // CHECK: %[[cres:.+]] = arith.constant -25 : index
// CHECK: %[[add:.+]] = arith.subi %[[cres]], %arg0 : index // CHECK: %[[add:.+]] = arith.subi %[[cres]], %arg0 : index
// CHECK: return %[[add]] // CHECK: return %[[add]]
func.func @tripleSubSub1(%arg0: index) -> index { func.func @tripleSubSub1(%arg0: index) -> index {
%c17 = arith.constant 17 : index %c17 = arith.constant 17 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
%add1 = arith.subi %c17, %arg0 : index %add1 = arith.subi %c17, %arg0 : index
%add2 = arith.subi %add1, %c42 : index %add2 = arith.subi %add1, %c42 : index
return %add2 : index return %add2 : index
} }
// CHECK-LABEL: @tripleSubSub2 // CHECK-LABEL: @tripleSubSub2
// CHECK: %[[cres:.+]] = arith.constant 59 : index // CHECK: %[[cres:.+]] = arith.constant 59 : index
// CHECK: %[[add:.+]] = arith.subi %[[cres]], %arg0 : index // CHECK: %[[add:.+]] = arith.subi %[[cres]], %arg0 : index
// CHECK: return %[[add]] // CHECK: return %[[add]]
func.func @tripleSubSub2(%arg0: index) -> index { func.func @tripleSubSub2(%arg0: index) -> index {
%c17 = arith.constant 17 : index %c17 = arith.constant 17 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
%add1 = arith.subi %arg0, %c17 : index %add1 = arith.subi %arg0, %c17 : index
%add2 = arith.subi %c42, %add1 : index %add2 = arith.subi %c42, %add1 : index
return %add2 : index return %add2 : index
} }
// CHECK-LABEL: @tripleSubSub3 // CHECK-LABEL: @tripleSubSub3
// CHECK: %[[cres:.+]] = arith.constant 59 : index // CHECK: %[[cres:.+]] = arith.constant 59 : index
// CHECK: %[[add:.+]] = arith.subi %arg0, %[[cres]] : index // CHECK: %[[add:.+]] = arith.subi %arg0, %[[cres]] : index
// CHECK: return %[[add]] // CHECK: return %[[add]]
func.func @tripleSubSub3(%arg0: index) -> index { func.func @tripleSubSub3(%arg0: index) -> index {
%c17 = arith.constant 17 : index %c17 = arith.constant 17 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
%add1 = arith.subi %arg0, %c17 : index %add1 = arith.subi %arg0, %c17 : index
%add2 = arith.subi %add1, %c42 : index %add2 = arith.subi %add1, %c42 : index
return %add2 : index return %add2 : index
} }
// CHECK-LABEL: @subAdd1 // CHECK-LABEL: @subAdd1
// CHECK-NEXT: return %arg0 // CHECK-NEXT: return %arg0
func.func @subAdd1(%arg0: index, %arg1 : index) -> index { func.func @subAdd1(%arg0: index, %arg1 : index) -> index {
%add = arith.addi %arg0, %arg1 : index %add = arith.addi %arg0, %arg1 : index
%sub = arith.subi %add, %arg1 : index %sub = arith.subi %add, %arg1 : index
return %sub : index return %sub : index
} }
// CHECK-LABEL: @subAdd2 // CHECK-LABEL: @subAdd2
// CHECK-NEXT: return %arg1 // CHECK-NEXT: return %arg1
func.func @subAdd2(%arg0: index, %arg1 : index) -> index { func.func @subAdd2(%arg0: index, %arg1 : index) -> index {
%add = arith.addi %arg0, %arg1 : index %add = arith.addi %arg0, %arg1 : index
%sub = arith.subi %add, %arg0 : index %sub = arith.subi %add, %arg0 : index
return %sub : index return %sub : index
} }
// CHECK-LABEL: @doubleAddSub1 // CHECK-LABEL: @doubleAddSub1
// CHECK-NEXT: return %arg0 // CHECK-NEXT: return %arg0
func.func @doubleAddSub1(%arg0: index, %arg1 : index) -> index { func.func @doubleAddSub1(%arg0: index, %arg1 : index) -> index {
%sub = arith.subi %arg0, %arg1 : index %sub = arith.subi %arg0, %arg1 : index
%add = arith.addi %sub, %arg1 : index %add = arith.addi %sub, %arg1 : index
return %add : index return %add : index
} }
// CHECK-LABEL: @doubleAddSub2 // CHECK-LABEL: @doubleAddSub2
// CHECK-NEXT: return %arg0 // CHECK-NEXT: return %arg0
func.func @doubleAddSub2(%arg0: index, %arg1 : index) -> index { func.func @doubleAddSub2(%arg0: index, %arg1 : index) -> index {
%sub = arith.subi %arg0, %arg1 : index %sub = arith.subi %arg0, %arg1 : index
%add = arith.addi %arg1, %sub : index %add = arith.addi %arg1, %sub : index
return %add : index return %add : index
} }
// CHECK-LABEL: @addiCarryZeroRhs // CHECK-LABEL: @addiCarryZeroRhs
// CHECK-NEXT: %[[false:.+]] = arith.constant false // CHECK-NEXT: %[[false:.+]] = arith.constant false
// CHECK-NEXT: return %arg0, %[[false]] // CHECK-NEXT: return %arg0, %[[false]]
func.func @addiCarryZeroRhs(%arg0: i32) -> (i32, i1) { func.func @addiCarryZeroRhs(%arg0: i32) -> (i32, i1) {
%zero = arith.constant 0 : i32 %zero = arith.constant 0 : i32
%sum, %carry = arith.addui_carry %arg0, %zero: i32, i1 %sum, %carry = arith.addui_carry %arg0, %zero: i32, i1
return %sum, %carry : i32, i1 return %sum, %carry : i32, i1
} }
// CHECK-LABEL: @addiCarryZeroRhsSplat // CHECK-LABEL: @addiCarryZeroRhsSplat
// CHECK-NEXT: %[[false:.+]] = arith.constant dense<false> : vector<4xi1> // CHECK-NEXT: %[[false:.+]] = arith.constant dense<false> : vector<4xi1>
// CHECK-NEXT: return %arg0, %[[false]] // CHECK-NEXT: return %arg0, %[[false]]
func.func @addiCarryZeroRhsSplat(%arg0: vector<4xi32>) -> (vector<4xi32>, vector<4xi1>) { func.func @addiCarryZeroRhsSplat(%arg0: vector<4xi32>) -> (vector<4xi32>, vector<4xi1>) {
%zero = arith.constant dense<0> : vector<4xi32> %zero = arith.constant dense<0> : vector<4xi32>
%sum, %carry = arith.addui_carry %arg0, %zero: vector<4xi32>, vector<4xi1> %sum, %carry = arith.addui_carry %arg0, %zero: vector<4xi32>, vector<4xi1>
return %sum, %carry : vector<4xi32>, vector<4xi1> return %sum, %carry : vector<4xi32>, vector<4xi1>
} }
// CHECK-LABEL: @addiCarryZeroLhs // CHECK-LABEL: @addiCarryZeroLhs
// CHECK-NEXT: %[[false:.+]] = arith.constant false // CHECK-NEXT: %[[false:.+]] = arith.constant false
// CHECK-NEXT: return %arg0, %[[false]] // CHECK-NEXT: return %arg0, %[[false]]
func.func @addiCarryZeroLhs(%arg0: i32) -> (i32, i1) { func.func @addiCarryZeroLhs(%arg0: i32) -> (i32, i1) {
%zero = arith.constant 0 : i32 %zero = arith.constant 0 : i32
%sum, %carry = arith.addui_carry %zero, %arg0: i32, i1 %sum, %carry = arith.addui_carry %zero, %arg0: i32, i1
return %sum, %carry : i32, i1 return %sum, %carry : i32, i1
} }
// CHECK-LABEL: @addiCarryConstants // CHECK-LABEL: @addiCarryConstants
// CHECK-DAG: %[[false:.+]] = arith.constant false // CHECK-DAG: %[[false:.+]] = arith.constant false
// CHECK-DAG: %[[c50:.+]] = arith.constant 50 : i32 // CHECK-DAG: %[[c50:.+]] = arith.constant 50 : i32
// CHECK-NEXT: return %[[c50]], %[[false]] // CHECK-NEXT: return %[[c50]], %[[false]]
func.func @addiCarryConstants() -> (i32, i1) { func.func @addiCarryConstants() -> (i32, i1) {
%c13 = arith.constant 13 : i32 %c13 = arith.constant 13 : i32
%c37 = arith.constant 37 : i32 %c37 = arith.constant 37 : i32
%sum, %carry = arith.addui_carry %c13, %c37: i32, i1 %sum, %carry = arith.addui_carry %c13, %c37: i32, i1
return %sum, %carry : i32, i1 return %sum, %carry : i32, i1
} }
// CHECK-LABEL: @addiCarryConstantsOverflow1 // CHECK-LABEL: @addiCarryConstantsOverflow1
// CHECK-DAG: %[[true:.+]] = arith.constant true // CHECK-DAG: %[[true:.+]] = arith.constant true
// CHECK-DAG: %[[c0:.+]] = arith.constant 0 : i32 // CHECK-DAG: %[[c0:.+]] = arith.constant 0 : i32
// CHECK-NEXT: return %[[c0]], %[[true]] // CHECK-NEXT: return %[[c0]], %[[true]]
func.func @addiCarryConstantsOverflow1() -> (i32, i1) { func.func @addiCarryConstantsOverflow1() -> (i32, i1) {
%max = arith.constant 4294967295 : i32 %max = arith.constant 4294967295 : i32
%c1 = arith.constant 1 : i32 %c1 = arith.constant 1 : i32
%sum, %carry = arith.addui_carry %max, %c1: i32, i1 %sum, %carry = arith.addui_carry %max, %c1: i32, i1
return %sum, %carry : i32, i1 return %sum, %carry : i32, i1
} }
// CHECK-LABEL: @addiCarryConstantsOverflow2 // CHECK-LABEL: @addiCarryConstantsOverflow2
// CHECK-DAG: %[[true:.+]] = arith.constant true // CHECK-DAG: %[[true:.+]] = arith.constant true
// CHECK-DAG: %[[c_2:.+]] = arith.constant -2 : i32 // CHECK-DAG: %[[c_2:.+]] = arith.constant -2 : i32
// CHECK-NEXT: return %[[c_2]], %[[true]] // CHECK-NEXT: return %[[c_2]], %[[true]]
func.func @addiCarryConstantsOverflow2() -> (i32, i1) { func.func @addiCarryConstantsOverflow2() -> (i32, i1) {
%max = arith.constant 4294967295 : i32 %max = arith.constant 4294967295 : i32
%sum, %carry = arith.addui_carry %max, %max: i32, i1 %sum, %carry = arith.addui_carry %max, %max: i32, i1
return %sum, %carry : i32, i1 return %sum, %carry : i32, i1
} }
// CHECK-LABEL: @addiCarryConstantsOverflowVector // CHECK-LABEL: @addiCarryConstantsOverflowVector
// CHECK-DAG: %[[sum:.+]] = arith.constant dense<[1, 6, 2, 14]> : vector<4xi32> // CHECK-DAG: %[[sum:.+]] = arith.constant dense<[1, 6, 2, 14]> : vector<4xi32>
// CHECK-DAG: %[[carry:.+]] = arith.constant dense<[false, false, true, false]> : vector<4xi1> // CHECK-DAG: %[[carry:.+]] = arith.constant dense<[false, false, true, false]> : vector<4xi1>
// CHECK-NEXT: return %[[sum]], %[[carry]] // CHECK-NEXT: return %[[sum]], %[[carry]]
func.func @addiCarryConstantsOverflowVector() -> (vector<4xi32>, vector<4xi1>) { func.func @addiCarryConstantsOverflowVector() -> (vector<4xi32>, vector<4xi1>) {
%v1 = arith.constant dense<[1, 3, 3, 7]> : vector<4xi32> %v1 = arith.constant dense<[1, 3, 3, 7]> : vector<4xi32>
%v2 = arith.constant dense<[0, 3, 4294967295, 7]> : vector<4xi32> %v2 = arith.constant dense<[0, 3, 4294967295, 7]> : vector<4xi32>
%sum, %carry = arith.addui_carry %v1, %v2 : vector<4xi32>, vector<4xi1> %sum, %carry = arith.addui_carry %v1, %v2 : vector<4xi32>, vector<4xi1>
return %sum, %carry : vector<4xi32>, vector<4xi1> return %sum, %carry : vector<4xi32>, vector<4xi1>
} }
// CHECK-LABEL: @addiCarryConstantsSplatVector // CHECK-LABEL: @addiCarryConstantsSplatVector
// CHECK-DAG: %[[sum:.+]] = arith.constant dense<3> : vector<4xi32> // CHECK-DAG: %[[sum:.+]] = arith.constant dense<3> : vector<4xi32>
// CHECK-DAG: %[[carry:.+]] = arith.constant dense<false> : vector<4xi1> // CHECK-DAG: %[[carry:.+]] = arith.constant dense<false> : vector<4xi1>
// CHECK-NEXT: return %[[sum]], %[[carry]] // CHECK-NEXT: return %[[sum]], %[[carry]]
func.func @addiCarryConstantsSplatVector() -> (vector<4xi32>, vector<4xi1>) { func.func @addiCarryConstantsSplatVector() -> (vector<4xi32>, vector<4xi1>) {
%v1 = arith.constant dense<1> : vector<4xi32> %v1 = arith.constant dense<1> : vector<4xi32>
%v2 = arith.constant dense<2> : vector<4xi32> %v2 = arith.constant dense<2> : vector<4xi32>
%sum, %carry = arith.addui_carry %v1, %v2 : vector<4xi32>, vector<4xi1> %sum, %carry = arith.addui_carry %v1, %v2 : vector<4xi32>, vector<4xi1>
return %sum, %carry : vector<4xi32>, vector<4xi1> return %sum, %carry : vector<4xi32>, vector<4xi1>
} }
// CHECK-LABEL: @notCmpEQ // CHECK-LABEL: @notCmpEQ
// CHECK: %[[cres:.+]] = arith.cmpi ne, %arg0, %arg1 : i8 // CHECK: %[[cres:.+]] = arith.cmpi ne, %arg0, %arg1 : i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @notCmpEQ(%arg0: i8, %arg1: i8) -> i1 { func.func @notCmpEQ(%arg0: i8, %arg1: i8) -> i1 {
%true = arith.constant true %true = arith.constant true
%cmp = arith.cmpi "eq", %arg0, %arg1 : i8 %cmp = arith.cmpi "eq", %arg0, %arg1 : i8
%ncmp = arith.xori %cmp, %true : i1 %ncmp = arith.xori %cmp, %true : i1
return %ncmp : i1 return %ncmp : i1
} }
// CHECK-LABEL: @notCmpEQ2 // CHECK-LABEL: @notCmpEQ2
// CHECK: %[[cres:.+]] = arith.cmpi ne, %arg0, %arg1 : i8 // CHECK: %[[cres:.+]] = arith.cmpi ne, %arg0, %arg1 : i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @notCmpEQ2(%arg0: i8, %arg1: i8) -> i1 { func.func @notCmpEQ2(%arg0: i8, %arg1: i8) -> i1 {
%true = arith.constant true %true = arith.constant true
%cmp = arith.cmpi "eq", %arg0, %arg1 : i8 %cmp = arith.cmpi "eq", %arg0, %arg1 : i8
%ncmp = arith.xori %true, %cmp : i1 %ncmp = arith.xori %true, %cmp : i1
return %ncmp : i1 return %ncmp : i1
} }
// CHECK-LABEL: @notCmpNE // CHECK-LABEL: @notCmpNE
// CHECK: %[[cres:.+]] = arith.cmpi eq, %arg0, %arg1 : i8 // CHECK: %[[cres:.+]] = arith.cmpi eq, %arg0, %arg1 : i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @notCmpNE(%arg0: i8, %arg1: i8) -> i1 { func.func @notCmpNE(%arg0: i8, %arg1: i8) -> i1 {
%true = arith.constant true %true = arith.constant true
%cmp = arith.cmpi "ne", %arg0, %arg1 : i8 %cmp = arith.cmpi "ne", %arg0, %arg1 : i8
%ncmp = arith.xori %cmp, %true : i1 %ncmp = arith.xori %cmp, %true : i1
return %ncmp : i1 return %ncmp : i1
} }
// CHECK-LABEL: @notCmpSLT // CHECK-LABEL: @notCmpSLT
// CHECK: %[[cres:.+]] = arith.cmpi sge, %arg0, %arg1 : i8 // CHECK: %[[cres:.+]] = arith.cmpi sge, %arg0, %arg1 : i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @notCmpSLT(%arg0: i8, %arg1: i8) -> i1 { func.func @notCmpSLT(%arg0: i8, %arg1: i8) -> i1 {
%true = arith.constant true %true = arith.constant true
%cmp = arith.cmpi "slt", %arg0, %arg1 : i8 %cmp = arith.cmpi "slt", %arg0, %arg1 : i8
%ncmp = arith.xori %cmp, %true : i1 %ncmp = arith.xori %cmp, %true : i1
return %ncmp : i1 return %ncmp : i1
} }
// CHECK-LABEL: @notCmpSLE // CHECK-LABEL: @notCmpSLE
// CHECK: %[[cres:.+]] = arith.cmpi sgt, %arg0, %arg1 : i8 // CHECK: %[[cres:.+]] = arith.cmpi sgt, %arg0, %arg1 : i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @notCmpSLE(%arg0: i8, %arg1: i8) -> i1 { func.func @notCmpSLE(%arg0: i8, %arg1: i8) -> i1 {
%true = arith.constant true %true = arith.constant true
%cmp = arith.cmpi "sle", %arg0, %arg1 : i8 %cmp = arith.cmpi "sle", %arg0, %arg1 : i8
%ncmp = arith.xori %cmp, %true : i1 %ncmp = arith.xori %cmp, %true : i1
return %ncmp : i1 return %ncmp : i1
} }
// CHECK-LABEL: @notCmpSGT // CHECK-LABEL: @notCmpSGT
// CHECK: %[[cres:.+]] = arith.cmpi sle, %arg0, %arg1 : i8 // CHECK: %[[cres:.+]] = arith.cmpi sle, %arg0, %arg1 : i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @notCmpSGT(%arg0: i8, %arg1: i8) -> i1 { func.func @notCmpSGT(%arg0: i8, %arg1: i8) -> i1 {
%true = arith.constant true %true = arith.constant true
%cmp = arith.cmpi "sgt", %arg0, %arg1 : i8 %cmp = arith.cmpi "sgt", %arg0, %arg1 : i8
%ncmp = arith.xori %cmp, %true : i1 %ncmp = arith.xori %cmp, %true : i1
return %ncmp : i1 return %ncmp : i1
} }
// CHECK-LABEL: @notCmpSGE // CHECK-LABEL: @notCmpSGE
// CHECK: %[[cres:.+]] = arith.cmpi slt, %arg0, %arg1 : i8 // CHECK: %[[cres:.+]] = arith.cmpi slt, %arg0, %arg1 : i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @notCmpSGE(%arg0: i8, %arg1: i8) -> i1 { func.func @notCmpSGE(%arg0: i8, %arg1: i8) -> i1 {
%true = arith.constant true %true = arith.constant true
%cmp = arith.cmpi "sge", %arg0, %arg1 : i8 %cmp = arith.cmpi "sge", %arg0, %arg1 : i8
%ncmp = arith.xori %cmp, %true : i1 %ncmp = arith.xori %cmp, %true : i1
return %ncmp : i1 return %ncmp : i1
} }
// CHECK-LABEL: @notCmpULT // CHECK-LABEL: @notCmpULT
// CHECK: %[[cres:.+]] = arith.cmpi uge, %arg0, %arg1 : i8 // CHECK: %[[cres:.+]] = arith.cmpi uge, %arg0, %arg1 : i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @notCmpULT(%arg0: i8, %arg1: i8) -> i1 { func.func @notCmpULT(%arg0: i8, %arg1: i8) -> i1 {
%true = arith.constant true %true = arith.constant true
%cmp = arith.cmpi "ult", %arg0, %arg1 : i8 %cmp = arith.cmpi "ult", %arg0, %arg1 : i8
%ncmp = arith.xori %cmp, %true : i1 %ncmp = arith.xori %cmp, %true : i1
return %ncmp : i1 return %ncmp : i1
} }
// CHECK-LABEL: @notCmpULE // CHECK-LABEL: @notCmpULE
// CHECK: %[[cres:.+]] = arith.cmpi ugt, %arg0, %arg1 : i8 // CHECK: %[[cres:.+]] = arith.cmpi ugt, %arg0, %arg1 : i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @notCmpULE(%arg0: i8, %arg1: i8) -> i1 { func.func @notCmpULE(%arg0: i8, %arg1: i8) -> i1 {
%true = arith.constant true %true = arith.constant true
%cmp = arith.cmpi "ule", %arg0, %arg1 : i8 %cmp = arith.cmpi "ule", %arg0, %arg1 : i8
%ncmp = arith.xori %cmp, %true : i1 %ncmp = arith.xori %cmp, %true : i1
return %ncmp : i1 return %ncmp : i1
} }
// CHECK-LABEL: @notCmpUGT // CHECK-LABEL: @notCmpUGT
// CHECK: %[[cres:.+]] = arith.cmpi ule, %arg0, %arg1 : i8 // CHECK: %[[cres:.+]] = arith.cmpi ule, %arg0, %arg1 : i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @notCmpUGT(%arg0: i8, %arg1: i8) -> i1 { func.func @notCmpUGT(%arg0: i8, %arg1: i8) -> i1 {
%true = arith.constant true %true = arith.constant true
%cmp = arith.cmpi "ugt", %arg0, %arg1 : i8 %cmp = arith.cmpi "ugt", %arg0, %arg1 : i8
%ncmp = arith.xori %cmp, %true : i1 %ncmp = arith.xori %cmp, %true : i1
return %ncmp : i1 return %ncmp : i1
} }
// CHECK-LABEL: @notCmpUGE // CHECK-LABEL: @notCmpUGE
// CHECK: %[[cres:.+]] = arith.cmpi ult, %arg0, %arg1 : i8 // CHECK: %[[cres:.+]] = arith.cmpi ult, %arg0, %arg1 : i8
// CHECK: return %[[cres]] // CHECK: return %[[cres]]
func.func @notCmpUGE(%arg0: i8, %arg1: i8) -> i1 { func.func @notCmpUGE(%arg0: i8, %arg1: i8) -> i1 {
%true = arith.constant true %true = arith.constant true
%cmp = arith.cmpi "uge", %arg0, %arg1 : i8 %cmp = arith.cmpi "uge", %arg0, %arg1 : i8
%ncmp = arith.xori %cmp, %true : i1 %ncmp = arith.xori %cmp, %true : i1
return %ncmp : i1 return %ncmp : i1
} }
// ----- // -----
// CHECK-LABEL: @xorxor( // CHECK-LABEL: @xorxor(
// CHECK-NOT: xori // CHECK-NOT: xori
// CHECK: return %arg0 // CHECK: return %arg0
func.func @xorxor(%cmp : i1) -> i1 { func.func @xorxor(%cmp : i1) -> i1 {
%true = arith.constant true %true = arith.constant true
%ncmp = arith.xori %cmp, %true : i1 %ncmp = arith.xori %cmp, %true : i1
%nncmp = arith.xori %ncmp, %true : i1 %nncmp = arith.xori %ncmp, %true : i1
return %nncmp : i1 return %nncmp : i1
} }
// ----- // -----
// CHECK-LABEL: @bitcastSameType( // CHECK-LABEL: @bitcastSameType(
// CHECK-SAME: %[[ARG:[a-zA-Z0-9_]*]] // CHECK-SAME: %[[ARG:[a-zA-Z0-9_]*]]
func.func @bitcastSameType(%arg : f32) -> f32 { func.func @bitcastSameType(%arg : f32) -> f32 {
// CHECK: return %[[ARG]] // CHECK: return %[[ARG]]
%res = arith.bitcast %arg : f32 to f32 %res = arith.bitcast %arg : f32 to f32
return %res : f32 return %res : f32
} }
// ----- // -----
// CHECK-LABEL: @bitcastConstantFPtoI( // CHECK-LABEL: @bitcastConstantFPtoI(
func.func @bitcastConstantFPtoI() -> i32 { func.func @bitcastConstantFPtoI() -> i32 {
// CHECK: %[[C0:.+]] = arith.constant 0 : i32 // CHECK: %[[C0:.+]] = arith.constant 0 : i32
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant 0.0 : f32 %c0 = arith.constant 0.0 : f32
%res = arith.bitcast %c0 : f32 to i32 %res = arith.bitcast %c0 : f32 to i32
return %res : i32 return %res : i32
} }
// ----- // -----
// CHECK-LABEL: @bitcastConstantItoFP( // CHECK-LABEL: @bitcastConstantItoFP(
func.func @bitcastConstantItoFP() -> f32 { func.func @bitcastConstantItoFP() -> f32 {
// CHECK: %[[C0:.+]] = arith.constant 0.0{{.*}} : f32 // CHECK: %[[C0:.+]] = arith.constant 0.0{{.*}} : f32
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant 0 : i32 %c0 = arith.constant 0 : i32
%res = arith.bitcast %c0 : i32 to f32 %res = arith.bitcast %c0 : i32 to f32
return %res : f32 return %res : f32
} }
// ----- // -----
// CHECK-LABEL: @bitcastConstantFPtoFP( // CHECK-LABEL: @bitcastConstantFPtoFP(
func.func @bitcastConstantFPtoFP() -> f16 { func.func @bitcastConstantFPtoFP() -> f16 {
// CHECK: %[[C0:.+]] = arith.constant 0.0{{.*}} : f16 // CHECK: %[[C0:.+]] = arith.constant 0.0{{.*}} : f16
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant 0.0 : bf16 %c0 = arith.constant 0.0 : bf16
%res = arith.bitcast %c0 : bf16 to f16 %res = arith.bitcast %c0 : bf16 to f16
return %res : f16 return %res : f16
} }
// ----- // -----
// CHECK-LABEL: @bitcastConstantVecFPtoI( // CHECK-LABEL: @bitcastConstantVecFPtoI(
func.func @bitcastConstantVecFPtoI() -> vector<3xf32> { func.func @bitcastConstantVecFPtoI() -> vector<3xf32> {
// CHECK: %[[C0:.+]] = arith.constant dense<0.0{{.*}}> : vector<3xf32> // CHECK: %[[C0:.+]] = arith.constant dense<0.0{{.*}}> : vector<3xf32>
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant dense<0> : vector<3xi32> %c0 = arith.constant dense<0> : vector<3xi32>
%res = arith.bitcast %c0 : vector<3xi32> to vector<3xf32> %res = arith.bitcast %c0 : vector<3xi32> to vector<3xf32>
return %res : vector<3xf32> return %res : vector<3xf32>
} }
// ----- // -----
// CHECK-LABEL: @bitcastConstantVecItoFP( // CHECK-LABEL: @bitcastConstantVecItoFP(
func.func @bitcastConstantVecItoFP() -> vector<3xi32> { func.func @bitcastConstantVecItoFP() -> vector<3xi32> {
// CHECK: %[[C0:.+]] = arith.constant dense<0> : vector<3xi32> // CHECK: %[[C0:.+]] = arith.constant dense<0> : vector<3xi32>
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant dense<0.0> : vector<3xf32> %c0 = arith.constant dense<0.0> : vector<3xf32>
%res = arith.bitcast %c0 : vector<3xf32> to vector<3xi32> %res = arith.bitcast %c0 : vector<3xf32> to vector<3xi32>
return %res : vector<3xi32> return %res : vector<3xi32>
} }
// ----- // -----
// CHECK-LABEL: @bitcastConstantVecFPtoFP( // CHECK-LABEL: @bitcastConstantVecFPtoFP(
func.func @bitcastConstantVecFPtoFP() -> vector<3xbf16> { func.func @bitcastConstantVecFPtoFP() -> vector<3xbf16> {
// CHECK: %[[C0:.+]] = arith.constant dense<0.0{{.*}}> : vector<3xbf16> // CHECK: %[[C0:.+]] = arith.constant dense<0.0{{.*}}> : vector<3xbf16>
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant dense<0.0> : vector<3xf16> %c0 = arith.constant dense<0.0> : vector<3xf16>
%res = arith.bitcast %c0 : vector<3xf16> to vector<3xbf16> %res = arith.bitcast %c0 : vector<3xf16> to vector<3xbf16>
return %res : vector<3xbf16> return %res : vector<3xbf16>
} }
// ----- // -----
// CHECK-LABEL: @bitcastBackAndForth( // CHECK-LABEL: @bitcastBackAndForth(
// CHECK-SAME: %[[ARG:[a-zA-Z0-9_]*]] // CHECK-SAME: %[[ARG:[a-zA-Z0-9_]*]]
func.func @bitcastBackAndForth(%arg : i32) -> i32 { func.func @bitcastBackAndForth(%arg : i32) -> i32 {
// CHECK: return %[[ARG]] // CHECK: return %[[ARG]]
%f = arith.bitcast %arg : i32 to f32 %f = arith.bitcast %arg : i32 to f32
%res = arith.bitcast %f : f32 to i32 %res = arith.bitcast %f : f32 to i32
return %res : i32 return %res : i32
} }
// ----- // -----
// CHECK-LABEL: @bitcastOfBitcast( // CHECK-LABEL: @bitcastOfBitcast(
// CHECK-SAME: %[[ARG:[a-zA-Z0-9_]*]] // CHECK-SAME: %[[ARG:[a-zA-Z0-9_]*]]
func.func @bitcastOfBitcast(%arg : i16) -> i16 { func.func @bitcastOfBitcast(%arg : i16) -> i16 {
// CHECK: return %[[ARG]] // CHECK: return %[[ARG]]
%f = arith.bitcast %arg : i16 to f16 %f = arith.bitcast %arg : i16 to f16
%bf = arith.bitcast %f : f16 to bf16 %bf = arith.bitcast %f : f16 to bf16
%res = arith.bitcast %bf : bf16 to i16 %res = arith.bitcast %bf : bf16 to i16
return %res : i16 return %res : i16
} }
// ----- // -----
// CHECK-LABEL: test_maxsi // CHECK-LABEL: test_maxsi
// CHECK-DAG: %[[C0:.+]] = arith.constant 42 // CHECK-DAG: %[[C0:.+]] = arith.constant 42
// CHECK-DAG: %[[MAX_INT_CST:.+]] = arith.constant 127 // CHECK-DAG: %[[MAX_INT_CST:.+]] = arith.constant 127
// CHECK: %[[X:.+]] = arith.maxsi %arg0, %[[C0]] // CHECK: %[[X:.+]] = arith.maxsi %arg0, %[[C0]]
// CHECK: return %arg0, %[[MAX_INT_CST]], %arg0, %[[X]] // CHECK: return %arg0, %[[MAX_INT_CST]], %arg0, %[[X]]
func.func @test_maxsi(%arg0 : i8) -> (i8, i8, i8, i8) { func.func @test_maxsi(%arg0 : i8) -> (i8, i8, i8, i8) {
%maxIntCst = arith.constant 127 : i8 %maxIntCst = arith.constant 127 : i8
%minIntCst = arith.constant -128 : i8 %minIntCst = arith.constant -128 : i8
%c0 = arith.constant 42 : i8 %c0 = arith.constant 42 : i8
%0 = arith.maxsi %arg0, %arg0 : i8 %0 = arith.maxsi %arg0, %arg0 : i8
%1 = arith.maxsi %arg0, %maxIntCst : i8 %1 = arith.maxsi %arg0, %maxIntCst : i8
%2 = arith.maxsi %arg0, %minIntCst : i8 %2 = arith.maxsi %arg0, %minIntCst : i8
%3 = arith.maxsi %arg0, %c0 : i8 %3 = arith.maxsi %arg0, %c0 : i8
return %0, %1, %2, %3: i8, i8, i8, i8 return %0, %1, %2, %3: i8, i8, i8, i8
} }
// CHECK-LABEL: test_maxsi2 // CHECK-LABEL: test_maxsi2
// CHECK-DAG: %[[C0:.+]] = arith.constant 42 // CHECK-DAG: %[[C0:.+]] = arith.constant 42
// CHECK-DAG: %[[MAX_INT_CST:.+]] = arith.constant 127 // CHECK-DAG: %[[MAX_INT_CST:.+]] = arith.constant 127
// CHECK: %[[X:.+]] = arith.maxsi %arg0, %[[C0]] // CHECK: %[[X:.+]] = arith.maxsi %arg0, %[[C0]]
// CHECK: return %arg0, %[[MAX_INT_CST]], %arg0, %[[X]] // CHECK: return %arg0, %[[MAX_INT_CST]], %arg0, %[[X]]
func.func @test_maxsi2(%arg0 : i8) -> (i8, i8, i8, i8) { func.func @test_maxsi2(%arg0 : i8) -> (i8, i8, i8, i8) {
%maxIntCst = arith.constant 127 : i8 %maxIntCst = arith.constant 127 : i8
%minIntCst = arith.constant -128 : i8 %minIntCst = arith.constant -128 : i8
%c0 = arith.constant 42 : i8 %c0 = arith.constant 42 : i8
%0 = arith.maxsi %arg0, %arg0 : i8 %0 = arith.maxsi %arg0, %arg0 : i8
%1 = arith.maxsi %maxIntCst, %arg0: i8 %1 = arith.maxsi %maxIntCst, %arg0: i8
%2 = arith.maxsi %minIntCst, %arg0: i8 %2 = arith.maxsi %minIntCst, %arg0: i8
%3 = arith.maxsi %c0, %arg0 : i8 %3 = arith.maxsi %c0, %arg0 : i8
return %0, %1, %2, %3: i8, i8, i8, i8 return %0, %1, %2, %3: i8, i8, i8, i8
} }
// ----- // -----
// CHECK-LABEL: test_maxui // CHECK-LABEL: test_maxui
// CHECK-DAG: %[[C0:.+]] = arith.constant 42 // CHECK-DAG: %[[C0:.+]] = arith.constant 42
// CHECK-DAG: %[[MAX_INT_CST:.+]] = arith.constant -1 // CHECK-DAG: %[[MAX_INT_CST:.+]] = arith.constant -1
// CHECK: %[[X:.+]] = arith.maxui %arg0, %[[C0]] // CHECK: %[[X:.+]] = arith.maxui %arg0, %[[C0]]
// CHECK: return %arg0, %[[MAX_INT_CST]], %arg0, %[[X]] // CHECK: return %arg0, %[[MAX_INT_CST]], %arg0, %[[X]]
func.func @test_maxui(%arg0 : i8) -> (i8, i8, i8, i8) { func.func @test_maxui(%arg0 : i8) -> (i8, i8, i8, i8) {
%maxIntCst = arith.constant 255 : i8 %maxIntCst = arith.constant 255 : i8
%minIntCst = arith.constant 0 : i8 %minIntCst = arith.constant 0 : i8
%c0 = arith.constant 42 : i8 %c0 = arith.constant 42 : i8
%0 = arith.maxui %arg0, %arg0 : i8 %0 = arith.maxui %arg0, %arg0 : i8
%1 = arith.maxui %arg0, %maxIntCst : i8 %1 = arith.maxui %arg0, %maxIntCst : i8
%2 = arith.maxui %arg0, %minIntCst : i8 %2 = arith.maxui %arg0, %minIntCst : i8
%3 = arith.maxui %arg0, %c0 : i8 %3 = arith.maxui %arg0, %c0 : i8
return %0, %1, %2, %3: i8, i8, i8, i8 return %0, %1, %2, %3: i8, i8, i8, i8
} }
// CHECK-LABEL: test_maxui // CHECK-LABEL: test_maxui
// CHECK-DAG: %[[C0:.+]] = arith.constant 42 // CHECK-DAG: %[[C0:.+]] = arith.constant 42
// CHECK-DAG: %[[MAX_INT_CST:.+]] = arith.constant -1 // CHECK-DAG: %[[MAX_INT_CST:.+]] = arith.constant -1
// CHECK: %[[X:.+]] = arith.maxui %arg0, %[[C0]] // CHECK: %[[X:.+]] = arith.maxui %arg0, %[[C0]]
// CHECK: return %arg0, %[[MAX_INT_CST]], %arg0, %[[X]] // CHECK: return %arg0, %[[MAX_INT_CST]], %arg0, %[[X]]
func.func @test_maxui2(%arg0 : i8) -> (i8, i8, i8, i8) { func.func @test_maxui2(%arg0 : i8) -> (i8, i8, i8, i8) {
%maxIntCst = arith.constant 255 : i8 %maxIntCst = arith.constant 255 : i8
%minIntCst = arith.constant 0 : i8 %minIntCst = arith.constant 0 : i8
%c0 = arith.constant 42 : i8 %c0 = arith.constant 42 : i8
%0 = arith.maxui %arg0, %arg0 : i8 %0 = arith.maxui %arg0, %arg0 : i8
%1 = arith.maxui %maxIntCst, %arg0 : i8 %1 = arith.maxui %maxIntCst, %arg0 : i8
%2 = arith.maxui %minIntCst, %arg0 : i8 %2 = arith.maxui %minIntCst, %arg0 : i8
%3 = arith.maxui %c0, %arg0 : i8 %3 = arith.maxui %c0, %arg0 : i8
return %0, %1, %2, %3: i8, i8, i8, i8 return %0, %1, %2, %3: i8, i8, i8, i8
} }
// ----- // -----
// CHECK-LABEL: test_minsi // CHECK-LABEL: test_minsi
// CHECK-DAG: %[[C0:.+]] = arith.constant 42 // CHECK-DAG: %[[C0:.+]] = arith.constant 42
// CHECK-DAG: %[[MIN_INT_CST:.+]] = arith.constant -128 // CHECK-DAG: %[[MIN_INT_CST:.+]] = arith.constant -128
// CHECK: %[[X:.+]] = arith.minsi %arg0, %[[C0]] // CHECK: %[[X:.+]] = arith.minsi %arg0, %[[C0]]
// CHECK: return %arg0, %arg0, %[[MIN_INT_CST]], %[[X]] // CHECK: return %arg0, %arg0, %[[MIN_INT_CST]], %[[X]]
func.func @test_minsi(%arg0 : i8) -> (i8, i8, i8, i8) { func.func @test_minsi(%arg0 : i8) -> (i8, i8, i8, i8) {
%maxIntCst = arith.constant 127 : i8 %maxIntCst = arith.constant 127 : i8
%minIntCst = arith.constant -128 : i8 %minIntCst = arith.constant -128 : i8
%c0 = arith.constant 42 : i8 %c0 = arith.constant 42 : i8
%0 = arith.minsi %arg0, %arg0 : i8 %0 = arith.minsi %arg0, %arg0 : i8
%1 = arith.minsi %arg0, %maxIntCst : i8 %1 = arith.minsi %arg0, %maxIntCst : i8
%2 = arith.minsi %arg0, %minIntCst : i8 %2 = arith.minsi %arg0, %minIntCst : i8
%3 = arith.minsi %arg0, %c0 : i8 %3 = arith.minsi %arg0, %c0 : i8
return %0, %1, %2, %3: i8, i8, i8, i8 return %0, %1, %2, %3: i8, i8, i8, i8
} }
// CHECK-LABEL: test_minsi // CHECK-LABEL: test_minsi
// CHECK-DAG: %[[C0:.+]] = arith.constant 42 // CHECK-DAG: %[[C0:.+]] = arith.constant 42
// CHECK-DAG: %[[MIN_INT_CST:.+]] = arith.constant -128 // CHECK-DAG: %[[MIN_INT_CST:.+]] = arith.constant -128
// CHECK: %[[X:.+]] = arith.minsi %arg0, %[[C0]] // CHECK: %[[X:.+]] = arith.minsi %arg0, %[[C0]]
// CHECK: return %arg0, %arg0, %[[MIN_INT_CST]], %[[X]] // CHECK: return %arg0, %arg0, %[[MIN_INT_CST]], %[[X]]
func.func @test_minsi2(%arg0 : i8) -> (i8, i8, i8, i8) { func.func @test_minsi2(%arg0 : i8) -> (i8, i8, i8, i8) {
%maxIntCst = arith.constant 127 : i8 %maxIntCst = arith.constant 127 : i8
%minIntCst = arith.constant -128 : i8 %minIntCst = arith.constant -128 : i8
%c0 = arith.constant 42 : i8 %c0 = arith.constant 42 : i8
%0 = arith.minsi %arg0, %arg0 : i8 %0 = arith.minsi %arg0, %arg0 : i8
%1 = arith.minsi %maxIntCst, %arg0 : i8 %1 = arith.minsi %maxIntCst, %arg0 : i8
%2 = arith.minsi %minIntCst, %arg0 : i8 %2 = arith.minsi %minIntCst, %arg0 : i8
%3 = arith.minsi %c0, %arg0 : i8 %3 = arith.minsi %c0, %arg0 : i8
return %0, %1, %2, %3: i8, i8, i8, i8 return %0, %1, %2, %3: i8, i8, i8, i8
} }
// ----- // -----
// CHECK-LABEL: test_minui // CHECK-LABEL: test_minui
// CHECK-DAG: %[[C0:.+]] = arith.constant 42 // CHECK-DAG: %[[C0:.+]] = arith.constant 42
// CHECK-DAG: %[[MIN_INT_CST:.+]] = arith.constant 0 // CHECK-DAG: %[[MIN_INT_CST:.+]] = arith.constant 0
// CHECK: %[[X:.+]] = arith.minui %arg0, %[[C0]] // CHECK: %[[X:.+]] = arith.minui %arg0, %[[C0]]
// CHECK: return %arg0, %arg0, %[[MIN_INT_CST]], %[[X]] // CHECK: return %arg0, %arg0, %[[MIN_INT_CST]], %[[X]]
func.func @test_minui(%arg0 : i8) -> (i8, i8, i8, i8) { func.func @test_minui(%arg0 : i8) -> (i8, i8, i8, i8) {
%maxIntCst = arith.constant 255 : i8 %maxIntCst = arith.constant 255 : i8
%minIntCst = arith.constant 0 : i8 %minIntCst = arith.constant 0 : i8
%c0 = arith.constant 42 : i8 %c0 = arith.constant 42 : i8
%0 = arith.minui %arg0, %arg0 : i8 %0 = arith.minui %arg0, %arg0 : i8
%1 = arith.minui %arg0, %maxIntCst : i8 %1 = arith.minui %arg0, %maxIntCst : i8
%2 = arith.minui %arg0, %minIntCst : i8 %2 = arith.minui %arg0, %minIntCst : i8
%3 = arith.minui %arg0, %c0 : i8 %3 = arith.minui %arg0, %c0 : i8
return %0, %1, %2, %3: i8, i8, i8, i8 return %0, %1, %2, %3: i8, i8, i8, i8
} }
// CHECK-LABEL: test_minui // CHECK-LABEL: test_minui
// CHECK-DAG: %[[C0:.+]] = arith.constant 42 // CHECK-DAG: %[[C0:.+]] = arith.constant 42
// CHECK-DAG: %[[MIN_INT_CST:.+]] = arith.constant 0 // CHECK-DAG: %[[MIN_INT_CST:.+]] = arith.constant 0
// CHECK: %[[X:.+]] = arith.minui %arg0, %[[C0]] // CHECK: %[[X:.+]] = arith.minui %arg0, %[[C0]]
// CHECK: return %arg0, %arg0, %[[MIN_INT_CST]], %[[X]] // CHECK: return %arg0, %arg0, %[[MIN_INT_CST]], %[[X]]
func.func @test_minui2(%arg0 : i8) -> (i8, i8, i8, i8) { func.func @test_minui2(%arg0 : i8) -> (i8, i8, i8, i8) {
%maxIntCst = arith.constant 255 : i8 %maxIntCst = arith.constant 255 : i8
%minIntCst = arith.constant 0 : i8 %minIntCst = arith.constant 0 : i8
%c0 = arith.constant 42 : i8 %c0 = arith.constant 42 : i8
%0 = arith.minui %arg0, %arg0 : i8 %0 = arith.minui %arg0, %arg0 : i8
%1 = arith.minui %maxIntCst, %arg0 : i8 %1 = arith.minui %maxIntCst, %arg0 : i8
%2 = arith.minui %minIntCst, %arg0 : i8 %2 = arith.minui %minIntCst, %arg0 : i8
%3 = arith.minui %c0, %arg0 : i8 %3 = arith.minui %c0, %arg0 : i8
return %0, %1, %2, %3: i8, i8, i8, i8 return %0, %1, %2, %3: i8, i8, i8, i8
} }
// ----- // -----
// CHECK-LABEL: @test_minf( // CHECK-LABEL: @test_minf(
func.func @test_minf(%arg0 : f32) -> (f32, f32, f32) { func.func @test_minf(%arg0 : f32) -> (f32, f32, f32) {
// CHECK-DAG: %[[C0:.+]] = arith.constant 0.0 // CHECK-DAG: %[[C0:.+]] = arith.constant 0.0
// CHECK-NEXT: %[[X:.+]] = arith.minf %arg0, %[[C0]] // CHECK-NEXT: %[[X:.+]] = arith.minf %arg0, %[[C0]]
// CHECK-NEXT: return %[[X]], %arg0, %arg0 // CHECK-NEXT: return %[[X]], %arg0, %arg0
%c0 = arith.constant 0.0 : f32 %c0 = arith.constant 0.0 : f32
%inf = arith.constant 0x7F800000 : f32 %inf = arith.constant 0x7F800000 : f32
%0 = arith.minf %c0, %arg0 : f32 %0 = arith.minf %c0, %arg0 : f32
%1 = arith.minf %arg0, %arg0 : f32 %1 = arith.minf %arg0, %arg0 : f32
%2 = arith.minf %inf, %arg0 : f32 %2 = arith.minf %inf, %arg0 : f32
return %0, %1, %2 : f32, f32, f32 return %0, %1, %2 : f32, f32, f32
} }
// ----- // -----
// CHECK-LABEL: @test_maxf( // CHECK-LABEL: @test_maxf(
func.func @test_maxf(%arg0 : f32) -> (f32, f32, f32) { func.func @test_maxf(%arg0 : f32) -> (f32, f32, f32) {
// CHECK-DAG: %[[C0:.+]] = arith.constant // CHECK-DAG: %[[C0:.+]] = arith.constant
// CHECK-NEXT: %[[X:.+]] = arith.maxf %arg0, %[[C0]] // CHECK-NEXT: %[[X:.+]] = arith.maxf %arg0, %[[C0]]
// CHECK-NEXT: return %[[X]], %arg0, %arg0 // CHECK-NEXT: return %[[X]], %arg0, %arg0
%c0 = arith.constant 0.0 : f32 %c0 = arith.constant 0.0 : f32
%-inf = arith.constant 0xFF800000 : f32 %-inf = arith.constant 0xFF800000 : f32
%0 = arith.maxf %c0, %arg0 : f32 %0 = arith.maxf %c0, %arg0 : f32
%1 = arith.maxf %arg0, %arg0 : f32 %1 = arith.maxf %arg0, %arg0 : f32
%2 = arith.maxf %-inf, %arg0 : f32 %2 = arith.maxf %-inf, %arg0 : f32
return %0, %1, %2 : f32, f32, f32 return %0, %1, %2 : f32, f32, f32
} }
// ----- // -----
// CHECK-LABEL: @test_addf( // CHECK-LABEL: @test_addf(
func.func @test_addf(%arg0 : f32) -> (f32, f32, f32, f32) { func.func @test_addf(%arg0 : f32) -> (f32, f32, f32, f32) {
// CHECK-DAG: %[[C2:.+]] = arith.constant 2.0 // CHECK-DAG: %[[C2:.+]] = arith.constant 2.0
// CHECK-DAG: %[[C0:.+]] = arith.constant 0.0 // CHECK-DAG: %[[C0:.+]] = arith.constant 0.0
// CHECK-NEXT: %[[X:.+]] = arith.addf %arg0, %[[C0]] // CHECK-NEXT: %[[X:.+]] = arith.addf %arg0, %[[C0]]
// CHECK-NEXT: return %[[X]], %arg0, %arg0, %[[C2]] // CHECK-NEXT: return %[[X]], %arg0, %arg0, %[[C2]]
%c0 = arith.constant 0.0 : f32 %c0 = arith.constant 0.0 : f32
%c-0 = arith.constant -0.0 : f32 %c-0 = arith.constant -0.0 : f32
%c1 = arith.constant 1.0 : f32 %c1 = arith.constant 1.0 : f32
%0 = arith.addf %c0, %arg0 : f32 %0 = arith.addf %c0, %arg0 : f32
%1 = arith.addf %arg0, %c-0 : f32 %1 = arith.addf %arg0, %c-0 : f32
%2 = arith.addf %c-0, %arg0 : f32 %2 = arith.addf %c-0, %arg0 : f32
%3 = arith.addf %c1, %c1 : f32 %3 = arith.addf %c1, %c1 : f32
return %0, %1, %2, %3 : f32, f32, f32, f32 return %0, %1, %2, %3 : f32, f32, f32, f32
} }
// ----- // -----
// CHECK-LABEL: @test_subf( // CHECK-LABEL: @test_subf(
func.func @test_subf(%arg0 : f16) -> (f16, f16, f16) { func.func @test_subf(%arg0 : f16) -> (f16, f16, f16) {
// CHECK-DAG: %[[C1:.+]] = arith.constant -1.0 // CHECK-DAG: %[[C1:.+]] = arith.constant -1.0
// CHECK-DAG: %[[C0:.+]] = arith.constant -0.0 // CHECK-DAG: %[[C0:.+]] = arith.constant -0.0
// CHECK-NEXT: %[[X:.+]] = arith.subf %arg0, %[[C0]] // CHECK-NEXT: %[[X:.+]] = arith.subf %arg0, %[[C0]]
// CHECK-NEXT: return %arg0, %[[X]], %[[C1]] // CHECK-NEXT: return %arg0, %[[X]], %[[C1]]
%c0 = arith.constant 0.0 : f16 %c0 = arith.constant 0.0 : f16
%c-0 = arith.constant -0.0 : f16 %c-0 = arith.constant -0.0 : f16
%c1 = arith.constant 1.0 : f16 %c1 = arith.constant 1.0 : f16
%0 = arith.subf %arg0, %c0 : f16 %0 = arith.subf %arg0, %c0 : f16
%1 = arith.subf %arg0, %c-0 : f16 %1 = arith.subf %arg0, %c-0 : f16
%2 = arith.subf %c0, %c1 : f16 %2 = arith.subf %c0, %c1 : f16
return %0, %1, %2 : f16, f16, f16 return %0, %1, %2 : f16, f16, f16
} }
// ----- // -----
// CHECK-LABEL: @test_mulf( // CHECK-LABEL: @test_mulf(
func.func @test_mulf(%arg0 : f32) -> (f32, f32, f32, f32) { func.func @test_mulf(%arg0 : f32) -> (f32, f32, f32, f32) {
// CHECK-DAG: %[[C2:.+]] = arith.constant 2.0 // CHECK-DAG: %[[C2:.+]] = arith.constant 2.0
// CHECK-DAG: %[[C4:.+]] = arith.constant 4.0 // CHECK-DAG: %[[C4:.+]] = arith.constant 4.0
// CHECK-NEXT: %[[X:.+]] = arith.mulf %arg0, %[[C2]] // CHECK-NEXT: %[[X:.+]] = arith.mulf %arg0, %[[C2]]
// CHECK-NEXT: return %[[X]], %arg0, %arg0, %[[C4]] // CHECK-NEXT: return %[[X]], %arg0, %arg0, %[[C4]]
%c1 = arith.constant 1.0 : f32 %c1 = arith.constant 1.0 : f32
%c2 = arith.constant 2.0 : f32 %c2 = arith.constant 2.0 : f32
%0 = arith.mulf %c2, %arg0 : f32 %0 = arith.mulf %c2, %arg0 : f32
%1 = arith.mulf %arg0, %c1 : f32 %1 = arith.mulf %arg0, %c1 : f32
%2 = arith.mulf %c1, %arg0 : f32 %2 = arith.mulf %c1, %arg0 : f32
%3 = arith.mulf %c2, %c2 : f32 %3 = arith.mulf %c2, %c2 : f32
return %0, %1, %2, %3 : f32, f32, f32, f32 return %0, %1, %2, %3 : f32, f32, f32, f32
} }
// CHECK-LABEL: @test_mulf1( // CHECK-LABEL: @test_mulf1(
func.func @test_mulf1(%arg0 : f32, %arg1 : f32) -> (f32) { func.func @test_mulf1(%arg0 : f32, %arg1 : f32) -> (f32) {
// CHECK-NEXT: %[[X:.+]] = arith.mulf %arg0, %arg1 : f32 // CHECK-NEXT: %[[X:.+]] = arith.mulf %arg0, %arg1 : f32
// CHECK-NEXT: return %[[X]] // CHECK-NEXT: return %[[X]]
%0 = arith.negf %arg0 : f32 %0 = arith.negf %arg0 : f32
%1 = arith.negf %arg1 : f32 %1 = arith.negf %arg1 : f32
%2 = arith.mulf %0, %1 : f32 %2 = arith.mulf %0, %1 : f32
return %2 : f32 return %2 : f32
} }
// ----- // -----
// CHECK-LABEL: @test_divf( // CHECK-LABEL: @test_divf(
func.func @test_divf(%arg0 : f64) -> (f64, f64) { func.func @test_divf(%arg0 : f64) -> (f64, f64) {
// CHECK-NEXT: %[[C5:.+]] = arith.constant 5.000000e-01 // CHECK-NEXT: %[[C5:.+]] = arith.constant 5.000000e-01
// CHECK-NEXT: return %arg0, %[[C5]] // CHECK-NEXT: return %arg0, %[[C5]]
%c1 = arith.constant 1.0 : f64 %c1 = arith.constant 1.0 : f64
%c2 = arith.constant 2.0 : f64 %c2 = arith.constant 2.0 : f64
%0 = arith.divf %arg0, %c1 : f64 %0 = arith.divf %arg0, %c1 : f64
%1 = arith.divf %c1, %c2 : f64 %1 = arith.divf %c1, %c2 : f64
return %0, %1 : f64, f64 return %0, %1 : f64, f64
} }
// CHECK-LABEL: @test_divf1( // CHECK-LABEL: @test_divf1(
func.func @test_divf1(%arg0 : f32, %arg1 : f32) -> (f32) { func.func @test_divf1(%arg0 : f32, %arg1 : f32) -> (f32) {
// CHECK-NEXT: %[[X:.+]] = arith.divf %arg0, %arg1 : f32 // CHECK-NEXT: %[[X:.+]] = arith.divf %arg0, %arg1 : f32
// CHECK-NEXT: return %[[X]] // CHECK-NEXT: return %[[X]]
%0 = arith.negf %arg0 : f32 %0 = arith.negf %arg0 : f32
%1 = arith.negf %arg1 : f32 %1 = arith.negf %arg1 : f32
%2 = arith.divf %0, %1 : f32 %2 = arith.divf %0, %1 : f32
return %2 : f32 return %2 : f32
} }
// ----- // -----
// CHECK-LABEL: @test_cmpf( // CHECK-LABEL: @test_cmpf(
func.func @test_cmpf(%arg0 : f32) -> (i1, i1, i1, i1) { func.func @test_cmpf(%arg0 : f32) -> (i1, i1, i1, i1) {
// CHECK-DAG: %[[T:.*]] = arith.constant true // CHECK-DAG: %[[T:.*]] = arith.constant true
// CHECK-DAG: %[[F:.*]] = arith.constant false // CHECK-DAG: %[[F:.*]] = arith.constant false
// CHECK: return %[[F]], %[[F]], %[[T]], %[[T]] // CHECK: return %[[F]], %[[F]], %[[T]], %[[T]]
%nan = arith.constant 0x7fffffff : f32 %nan = arith.constant 0x7fffffff : f32
%0 = arith.cmpf olt, %nan, %arg0 : f32 %0 = arith.cmpf olt, %nan, %arg0 : f32
%1 = arith.cmpf olt, %arg0, %nan : f32 %1 = arith.cmpf olt, %arg0, %nan : f32
%2 = arith.cmpf ugt, %nan, %arg0 : f32 %2 = arith.cmpf ugt, %nan, %arg0 : f32
%3 = arith.cmpf ugt, %arg0, %nan : f32 %3 = arith.cmpf ugt, %arg0, %nan : f32
return %0, %1, %2, %3 : i1, i1, i1, i1 return %0, %1, %2, %3 : i1, i1, i1, i1
} }
// ----- // -----
// CHECK-LABEL: @constant_FPtoUI( // CHECK-LABEL: @constant_FPtoUI(
func.func @constant_FPtoUI() -> i32 { func.func @constant_FPtoUI() -> i32 {
// CHECK: %[[C0:.+]] = arith.constant 2 : i32 // CHECK: %[[C0:.+]] = arith.constant 2 : i32
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant 2.0 : f32 %c0 = arith.constant 2.0 : f32
%res = arith.fptoui %c0 : f32 to i32 %res = arith.fptoui %c0 : f32 to i32
return %res : i32 return %res : i32
} }
// CHECK-LABEL: @constant_FPtoUI_splat( // CHECK-LABEL: @constant_FPtoUI_splat(
func.func @constant_FPtoUI_splat() -> vector<4xi32> { func.func @constant_FPtoUI_splat() -> vector<4xi32> {
// CHECK: %[[C0:.+]] = arith.constant dense<2> : vector<4xi32> // CHECK: %[[C0:.+]] = arith.constant dense<2> : vector<4xi32>
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant 2.0 : f32 %c0 = arith.constant 2.0 : f32
%splat = vector.splat %c0 : vector<4xf32> %splat = vector.splat %c0 : vector<4xf32>
%res = arith.fptoui %splat : vector<4xf32> to vector<4xi32> %res = arith.fptoui %splat : vector<4xf32> to vector<4xi32>
return %res : vector<4xi32> return %res : vector<4xi32>
} }
// CHECK-LABEL: @constant_FPtoUI_vector( // CHECK-LABEL: @constant_FPtoUI_vector(
func.func @constant_FPtoUI_vector() -> vector<4xi32> { func.func @constant_FPtoUI_vector() -> vector<4xi32> {
// CHECK: %[[C0:.+]] = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32> // CHECK: %[[C0:.+]] = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32>
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%vector = arith.constant dense<[1.0, 3.0, 5.0, 7.0]> : vector<4xf32> %vector = arith.constant dense<[1.0, 3.0, 5.0, 7.0]> : vector<4xf32>
%res = arith.fptoui %vector : vector<4xf32> to vector<4xi32> %res = arith.fptoui %vector : vector<4xf32> to vector<4xi32>
return %res : vector<4xi32> return %res : vector<4xi32>
} }
// ----- // -----
// CHECK-LABEL: @invalid_constant_FPtoUI( // CHECK-LABEL: @invalid_constant_FPtoUI(
func.func @invalid_constant_FPtoUI() -> i32 { func.func @invalid_constant_FPtoUI() -> i32 {
// CHECK: %[[C0:.+]] = arith.constant -2.000000e+00 : f32 // CHECK: %[[C0:.+]] = arith.constant -2.000000e+00 : f32
// CHECK: %[[C1:.+]] = arith.fptoui %[[C0]] : f32 to i32 // CHECK: %[[C1:.+]] = arith.fptoui %[[C0]] : f32 to i32
// CHECK: return %[[C1]] // CHECK: return %[[C1]]
%c0 = arith.constant -2.0 : f32 %c0 = arith.constant -2.0 : f32
%res = arith.fptoui %c0 : f32 to i32 %res = arith.fptoui %c0 : f32 to i32
return %res : i32 return %res : i32
} }
// ----- // -----
// CHECK-LABEL: @constant_FPtoSI( // CHECK-LABEL: @constant_FPtoSI(
func.func @constant_FPtoSI() -> i32 { func.func @constant_FPtoSI() -> i32 {
// CHECK: %[[C0:.+]] = arith.constant -2 : i32 // CHECK: %[[C0:.+]] = arith.constant -2 : i32
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant -2.0 : f32 %c0 = arith.constant -2.0 : f32
%res = arith.fptosi %c0 : f32 to i32 %res = arith.fptosi %c0 : f32 to i32
return %res : i32 return %res : i32
} }
// CHECK-LABEL: @constant_FPtoSI_splat( // CHECK-LABEL: @constant_FPtoSI_splat(
func.func @constant_FPtoSI_splat() -> vector<4xi32> { func.func @constant_FPtoSI_splat() -> vector<4xi32> {
// CHECK: %[[C0:.+]] = arith.constant dense<-2> : vector<4xi32> // CHECK: %[[C0:.+]] = arith.constant dense<-2> : vector<4xi32>
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant -2.0 : f32 %c0 = arith.constant -2.0 : f32
%splat = vector.splat %c0 : vector<4xf32> %splat = vector.splat %c0 : vector<4xf32>
%res = arith.fptosi %splat : vector<4xf32> to vector<4xi32> %res = arith.fptosi %splat : vector<4xf32> to vector<4xi32>
return %res : vector<4xi32> return %res : vector<4xi32>
} }
// CHECK-LABEL: @constant_FPtoSI_vector( // CHECK-LABEL: @constant_FPtoSI_vector(
func.func @constant_FPtoSI_vector() -> vector<4xi32> { func.func @constant_FPtoSI_vector() -> vector<4xi32> {
// CHECK: %[[C0:.+]] = arith.constant dense<[-1, -3, -5, -7]> : vector<4xi32> // CHECK: %[[C0:.+]] = arith.constant dense<[-1, -3, -5, -7]> : vector<4xi32>
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%vector = arith.constant dense<[-1.0, -3.0, -5.0, -7.0]> : vector<4xf32> %vector = arith.constant dense<[-1.0, -3.0, -5.0, -7.0]> : vector<4xf32>
%res = arith.fptosi %vector : vector<4xf32> to vector<4xi32> %res = arith.fptosi %vector : vector<4xf32> to vector<4xi32>
return %res : vector<4xi32> return %res : vector<4xi32>
} }
// ----- // -----
// CHECK-LABEL: @invalid_constant_FPtoSI( // CHECK-LABEL: @invalid_constant_FPtoSI(
func.func @invalid_constant_FPtoSI() -> i8 { func.func @invalid_constant_FPtoSI() -> i8 {
// CHECK: %[[C0:.+]] = arith.constant 2.000000e+10 : f32 // CHECK: %[[C0:.+]] = arith.constant 2.000000e+10 : f32
// CHECK: %[[C1:.+]] = arith.fptosi %[[C0]] : f32 to i8 // CHECK: %[[C1:.+]] = arith.fptosi %[[C0]] : f32 to i8
// CHECK: return %[[C1]] // CHECK: return %[[C1]]
%c0 = arith.constant 2.0e10 : f32 %c0 = arith.constant 2.0e10 : f32
%res = arith.fptosi %c0 : f32 to i8 %res = arith.fptosi %c0 : f32 to i8
return %res : i8 return %res : i8
} }
// CHECK-LABEL: @constant_SItoFP( // CHECK-LABEL: @constant_SItoFP(
func.func @constant_SItoFP() -> f32 { func.func @constant_SItoFP() -> f32 {
// CHECK: %[[C0:.+]] = arith.constant -2.000000e+00 : f32 // CHECK: %[[C0:.+]] = arith.constant -2.000000e+00 : f32
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant -2 : i32 %c0 = arith.constant -2 : i32
%res = arith.sitofp %c0 : i32 to f32 %res = arith.sitofp %c0 : i32 to f32
return %res : f32 return %res : f32
} }
// CHECK-LABEL: @constant_SItoFP_splat( // CHECK-LABEL: @constant_SItoFP_splat(
func.func @constant_SItoFP_splat() -> vector<4xf32> { func.func @constant_SItoFP_splat() -> vector<4xf32> {
// CHECK: %[[C0:.+]] = arith.constant dense<2.000000e+00> : vector<4xf32> // CHECK: %[[C0:.+]] = arith.constant dense<2.000000e+00> : vector<4xf32>
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant 2 : i32 %c0 = arith.constant 2 : i32
%splat = vector.splat %c0 : vector<4xi32> %splat = vector.splat %c0 : vector<4xi32>
%res = arith.sitofp %splat : vector<4xi32> to vector<4xf32> %res = arith.sitofp %splat : vector<4xi32> to vector<4xf32>
return %res : vector<4xf32> return %res : vector<4xf32>
} }
// CHECK-LABEL: @constant_SItoFP_vector( // CHECK-LABEL: @constant_SItoFP_vector(
func.func @constant_SItoFP_vector() -> vector<4xf32> { func.func @constant_SItoFP_vector() -> vector<4xf32> {
// CHECK: %[[C0:.+]] = arith.constant dense<[1.000000e+00, 3.000000e+00, 5.000000e+00, 7.000000e+00]> : vector<4xf32> // CHECK: %[[C0:.+]] = arith.constant dense<[1.000000e+00, 3.000000e+00, 5.000000e+00, 7.000000e+00]> : vector<4xf32>
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%vector = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32> %vector = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32>
%res = arith.sitofp %vector : vector<4xi32> to vector<4xf32> %res = arith.sitofp %vector : vector<4xi32> to vector<4xf32>
return %res : vector<4xf32> return %res : vector<4xf32>
} }
// ----- // -----
// CHECK-LABEL: @constant_UItoFP( // CHECK-LABEL: @constant_UItoFP(
func.func @constant_UItoFP() -> f32 { func.func @constant_UItoFP() -> f32 {
// CHECK: %[[C0:.+]] = arith.constant 2.000000e+00 : f32 // CHECK: %[[C0:.+]] = arith.constant 2.000000e+00 : f32
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant 2 : i32 %c0 = arith.constant 2 : i32
%res = arith.uitofp %c0 : i32 to f32 %res = arith.uitofp %c0 : i32 to f32
return %res : f32 return %res : f32
} }
// CHECK-LABEL: @constant_UItoFP_splat( // CHECK-LABEL: @constant_UItoFP_splat(
func.func @constant_UItoFP_splat() -> vector<4xf32> { func.func @constant_UItoFP_splat() -> vector<4xf32> {
// CHECK: %[[C0:.+]] = arith.constant dense<2.000000e+00> : vector<4xf32> // CHECK: %[[C0:.+]] = arith.constant dense<2.000000e+00> : vector<4xf32>
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%c0 = arith.constant 2 : i32 %c0 = arith.constant 2 : i32
%splat = vector.splat %c0 : vector<4xi32> %splat = vector.splat %c0 : vector<4xi32>
%res = arith.uitofp %splat : vector<4xi32> to vector<4xf32> %res = arith.uitofp %splat : vector<4xi32> to vector<4xf32>
return %res : vector<4xf32> return %res : vector<4xf32>
} }
// CHECK-LABEL: @constant_UItoFP_vector( // CHECK-LABEL: @constant_UItoFP_vector(
func.func @constant_UItoFP_vector() -> vector<4xf32> { func.func @constant_UItoFP_vector() -> vector<4xf32> {
// CHECK: %[[C0:.+]] = arith.constant dense<[1.000000e+00, 3.000000e+00, 5.000000e+00, 7.000000e+00]> : vector<4xf32> // CHECK: %[[C0:.+]] = arith.constant dense<[1.000000e+00, 3.000000e+00, 5.000000e+00, 7.000000e+00]> : vector<4xf32>
// CHECK: return %[[C0]] // CHECK: return %[[C0]]
%vector = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32> %vector = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32>
%res = arith.uitofp %vector : vector<4xi32> to vector<4xf32> %res = arith.uitofp %vector : vector<4xi32> to vector<4xf32>
return %res : vector<4xf32> return %res : vector<4xf32>
} }
// ----- // -----
// Tests rewritten from https://github.com/llvm/llvm-project/blob/main/llvm/test/Transforms/InstCombine/2008-11-08-FCmp.ll // Tests rewritten from https://github.com/llvm/llvm-project/blob/main/llvm/test/Transforms/InstCombine/2008-11-08-FCmp.ll
// When inst combining an FCMP with the LHS coming from a arith.uitofp instruction, we // When inst combining an FCMP with the LHS coming from a arith.uitofp instruction, we
// can lower it to signed ICMP instructions. // can lower it to signed ICMP instructions.
// CHECK-LABEL: @test1( // CHECK-LABEL: @test1(
// CHECK-SAME: %[[arg0:.+]]: // CHECK-SAME: %[[arg0:.+]]:
func.func @test1(%arg0: i32) -> i1 { func.func @test1(%arg0: i32) -> i1 {
%cst = arith.constant 0.000000e+00 : f64 %cst = arith.constant 0.000000e+00 : f64
%1 = arith.uitofp %arg0: i32 to f64 %1 = arith.uitofp %arg0: i32 to f64
%2 = arith.cmpf ole, %1, %cst : f64 %2 = arith.cmpf ole, %1, %cst : f64
// CHECK: %[[c0:.+]] = arith.constant 0 : i32 // CHECK: %[[c0:.+]] = arith.constant 0 : i32
// CHECK: arith.cmpi ule, %[[arg0]], %[[c0]] : i32 // CHECK: arith.cmpi ule, %[[arg0]], %[[c0]] : i32
return %2 : i1 return %2 : i1
} }
// CHECK-LABEL: @test2( // CHECK-LABEL: @test2(
// CHECK-SAME: %[[arg0:.+]]: // CHECK-SAME: %[[arg0:.+]]:
func.func @test2(%arg0: i32) -> i1 { func.func @test2(%arg0: i32) -> i1 {
%cst = arith.constant 0.000000e+00 : f64 %cst = arith.constant 0.000000e+00 : f64
%1 = arith.uitofp %arg0: i32 to f64 %1 = arith.uitofp %arg0: i32 to f64
%2 = arith.cmpf olt, %1, %cst : f64 %2 = arith.cmpf olt, %1, %cst : f64
return %2 : i1 return %2 : i1
// CHECK: %[[c0:.+]] = arith.constant 0 : i32 // CHECK: %[[c0:.+]] = arith.constant 0 : i32
// CHECK: arith.cmpi ult, %[[arg0]], %[[c0]] : i32 // CHECK: arith.cmpi ult, %[[arg0]], %[[c0]] : i32
} }
// CHECK-LABEL: @test3( // CHECK-LABEL: @test3(
// CHECK-SAME: %[[arg0:.+]]: // CHECK-SAME: %[[arg0:.+]]:
func.func @test3(%arg0: i32) -> i1 { func.func @test3(%arg0: i32) -> i1 {
%cst = arith.constant 0.000000e+00 : f64 %cst = arith.constant 0.000000e+00 : f64
%1 = arith.uitofp %arg0: i32 to f64 %1 = arith.uitofp %arg0: i32 to f64
%2 = arith.cmpf oge, %1, %cst : f64 %2 = arith.cmpf oge, %1, %cst : f64
return %2 : i1 return %2 : i1
// CHECK: %[[c0:.+]] = arith.constant 0 : i32 // CHECK: %[[c0:.+]] = arith.constant 0 : i32
// CHECK: arith.cmpi uge, %[[arg0]], %[[c0]] : i32 // CHECK: arith.cmpi uge, %[[arg0]], %[[c0]] : i32
} }
// CHECK-LABEL: @test4( // CHECK-LABEL: @test4(
// CHECK-SAME: %[[arg0:.+]]: // CHECK-SAME: %[[arg0:.+]]:
func.func @test4(%arg0: i32) -> i1 { func.func @test4(%arg0: i32) -> i1 {
%cst = arith.constant 0.000000e+00 : f64 %cst = arith.constant 0.000000e+00 : f64
%1 = arith.uitofp %arg0: i32 to f64 %1 = arith.uitofp %arg0: i32 to f64
%2 = arith.cmpf ogt, %1, %cst : f64 %2 = arith.cmpf ogt, %1, %cst : f64
// CHECK: %[[c0:.+]] = arith.constant 0 : i32 // CHECK: %[[c0:.+]] = arith.constant 0 : i32
// CHECK: arith.cmpi ugt, %[[arg0]], %[[c0]] : i32 // CHECK: arith.cmpi ugt, %[[arg0]], %[[c0]] : i32
return %2 : i1 return %2 : i1
} }
// CHECK-LABEL: @test5( // CHECK-LABEL: @test5(
func.func @test5(%arg0: i32) -> i1 { func.func @test5(%arg0: i32) -> i1 {
%cst = arith.constant -4.400000e+00 : f64 %cst = arith.constant -4.400000e+00 : f64
%1 = arith.uitofp %arg0: i32 to f64 %1 = arith.uitofp %arg0: i32 to f64
%2 = arith.cmpf ogt, %1, %cst : f64 %2 = arith.cmpf ogt, %1, %cst : f64
return %2 : i1 return %2 : i1
// CHECK: %[[true:.+]] = arith.constant true // CHECK: %[[true:.+]] = arith.constant true
// CHECK: return %[[true]] : i1 // CHECK: return %[[true]] : i1
} }
// CHECK-LABEL: @test6( // CHECK-LABEL: @test6(
func.func @test6(%arg0: i32) -> i1 { func.func @test6(%arg0: i32) -> i1 {
%cst = arith.constant -4.400000e+00 : f64 %cst = arith.constant -4.400000e+00 : f64
%1 = arith.uitofp %arg0: i32 to f64 %1 = arith.uitofp %arg0: i32 to f64
%2 = arith.cmpf olt, %1, %cst : f64 %2 = arith.cmpf olt, %1, %cst : f64
return %2 : i1 return %2 : i1
// CHECK: %[[false:.+]] = arith.constant false // CHECK: %[[false:.+]] = arith.constant false
// CHECK: return %[[false]] : i1 // CHECK: return %[[false]] : i1
} }
// Check that optimizing unsigned >= comparisons correctly distinguishes // Check that optimizing unsigned >= comparisons correctly distinguishes
// positive and negative constants. // positive and negative constants.
// CHECK-LABEL: @test7( // CHECK-LABEL: @test7(
// CHECK-SAME: %[[arg0:.+]]: // CHECK-SAME: %[[arg0:.+]]:
func.func @test7(%arg0: i32) -> i1 { func.func @test7(%arg0: i32) -> i1 {
%cst = arith.constant 3.200000e+00 : f64 %cst = arith.constant 3.200000e+00 : f64
%1 = arith.uitofp %arg0: i32 to f64 %1 = arith.uitofp %arg0: i32 to f64
%2 = arith.cmpf oge, %1, %cst : f64 %2 = arith.cmpf oge, %1, %cst : f64
return %2 : i1 return %2 : i1
// CHECK: %[[c3:.+]] = arith.constant 3 : i32 // CHECK: %[[c3:.+]] = arith.constant 3 : i32
// CHECK: arith.cmpi ugt, %[[arg0]], %[[c3]] : i32 // CHECK: arith.cmpi ugt, %[[arg0]], %[[c3]] : i32
} }
// ----- // -----
// CHECK-LABEL: @foldShl( // CHECK-LABEL: @foldShl(
// CHECK: %[[res:.+]] = arith.constant 4294967296 : i64 // CHECK: %[[res:.+]] = arith.constant 4294967296 : i64
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @foldShl() -> i64 { func.func @foldShl() -> i64 {
%c1 = arith.constant 1 : i64 %c1 = arith.constant 1 : i64
%c32 = arith.constant 32 : i64 %c32 = arith.constant 32 : i64
%r = arith.shli %c1, %c32 : i64 %r = arith.shli %c1, %c32 : i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: @nofoldShl( // CHECK-LABEL: @nofoldShl(
// CHECK: %[[res:.+]] = arith.shli // CHECK: %[[res:.+]] = arith.shli
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @nofoldShl() -> i64 { func.func @nofoldShl() -> i64 {
%c1 = arith.constant 1 : i64 %c1 = arith.constant 1 : i64
%c132 = arith.constant 132 : i64 %c132 = arith.constant 132 : i64
%r = arith.shli %c1, %c132 : i64 %r = arith.shli %c1, %c132 : i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: @nofoldShl2( // CHECK-LABEL: @nofoldShl2(
// CHECK: %[[res:.+]] = arith.shli // CHECK: %[[res:.+]] = arith.shli
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @nofoldShl2() -> i64 { func.func @nofoldShl2() -> i64 {
%c1 = arith.constant 1 : i64 %c1 = arith.constant 1 : i64
%cm32 = arith.constant -32 : i64 %cm32 = arith.constant -32 : i64
%r = arith.shli %c1, %cm32 : i64 %r = arith.shli %c1, %cm32 : i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: @foldShru( // CHECK-LABEL: @foldShru(
// CHECK: %[[res:.+]] = arith.constant 2 : i64 // CHECK: %[[res:.+]] = arith.constant 2 : i64
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @foldShru() -> i64 { func.func @foldShru() -> i64 {
%c1 = arith.constant 8 : i64 %c1 = arith.constant 8 : i64
%c32 = arith.constant 2 : i64 %c32 = arith.constant 2 : i64
%r = arith.shrui %c1, %c32 : i64 %r = arith.shrui %c1, %c32 : i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: @foldShru2( // CHECK-LABEL: @foldShru2(
// CHECK: %[[res:.+]] = arith.constant 9223372036854775807 : i64 // CHECK: %[[res:.+]] = arith.constant 9223372036854775807 : i64
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @foldShru2() -> i64 { func.func @foldShru2() -> i64 {
%c1 = arith.constant -2 : i64 %c1 = arith.constant -2 : i64
%c32 = arith.constant 1 : i64 %c32 = arith.constant 1 : i64
%r = arith.shrui %c1, %c32 : i64 %r = arith.shrui %c1, %c32 : i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: @nofoldShru( // CHECK-LABEL: @nofoldShru(
// CHECK: %[[res:.+]] = arith.shrui // CHECK: %[[res:.+]] = arith.shrui
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @nofoldShru() -> i64 { func.func @nofoldShru() -> i64 {
%c1 = arith.constant 8 : i64 %c1 = arith.constant 8 : i64
%c132 = arith.constant 132 : i64 %c132 = arith.constant 132 : i64
%r = arith.shrui %c1, %c132 : i64 %r = arith.shrui %c1, %c132 : i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: @nofoldShru2( // CHECK-LABEL: @nofoldShru2(
// CHECK: %[[res:.+]] = arith.shrui // CHECK: %[[res:.+]] = arith.shrui
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @nofoldShru2() -> i64 { func.func @nofoldShru2() -> i64 {
%c1 = arith.constant 8 : i64 %c1 = arith.constant 8 : i64
%cm32 = arith.constant -32 : i64 %cm32 = arith.constant -32 : i64
%r = arith.shrui %c1, %cm32 : i64 %r = arith.shrui %c1, %cm32 : i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: @foldShrs( // CHECK-LABEL: @foldShrs(
// CHECK: %[[res:.+]] = arith.constant 2 : i64 // CHECK: %[[res:.+]] = arith.constant 2 : i64
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @foldShrs() -> i64 { func.func @foldShrs() -> i64 {
%c1 = arith.constant 8 : i64 %c1 = arith.constant 8 : i64
%c32 = arith.constant 2 : i64 %c32 = arith.constant 2 : i64
%r = arith.shrsi %c1, %c32 : i64 %r = arith.shrsi %c1, %c32 : i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: @foldShrs2( // CHECK-LABEL: @foldShrs2(
// CHECK: %[[res:.+]] = arith.constant -1 : i64 // CHECK: %[[res:.+]] = arith.constant -1 : i64
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @foldShrs2() -> i64 { func.func @foldShrs2() -> i64 {
%c1 = arith.constant -2 : i64 %c1 = arith.constant -2 : i64
%c32 = arith.constant 1 : i64 %c32 = arith.constant 1 : i64
%r = arith.shrsi %c1, %c32 : i64 %r = arith.shrsi %c1, %c32 : i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: @nofoldShrs( // CHECK-LABEL: @nofoldShrs(
// CHECK: %[[res:.+]] = arith.shrsi // CHECK: %[[res:.+]] = arith.shrsi
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @nofoldShrs() -> i64 { func.func @nofoldShrs() -> i64 {
%c1 = arith.constant 8 : i64 %c1 = arith.constant 8 : i64
%c132 = arith.constant 132 : i64 %c132 = arith.constant 132 : i64
%r = arith.shrsi %c1, %c132 : i64 %r = arith.shrsi %c1, %c132 : i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: @nofoldShrs2( // CHECK-LABEL: @nofoldShrs2(
// CHECK: %[[res:.+]] = arith.shrsi // CHECK: %[[res:.+]] = arith.shrsi
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @nofoldShrs2() -> i64 { func.func @nofoldShrs2() -> i64 {
%c1 = arith.constant 8 : i64 %c1 = arith.constant 8 : i64
%cm32 = arith.constant -32 : i64 %cm32 = arith.constant -32 : i64
%r = arith.shrsi %c1, %cm32 : i64 %r = arith.shrsi %c1, %cm32 : i64
return %r : i64 return %r : i64
} }
// ----- // -----
// CHECK-LABEL: @test_negf( // CHECK-LABEL: @test_negf(
// CHECK: %[[res:.+]] = arith.constant -2.0 // CHECK: %[[res:.+]] = arith.constant -2.0
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @test_negf() -> (f32) { func.func @test_negf() -> (f32) {
%c = arith.constant 2.0 : f32 %c = arith.constant 2.0 : f32
%0 = arith.negf %c : f32 %0 = arith.negf %c : f32
return %0: f32 return %0: f32
} }
// CHECK-LABEL: @test_negf1( // CHECK-LABEL: @test_negf1(
// CHECK-SAME: %[[arg0:.+]]: // CHECK-SAME: %[[arg0:.+]]:
// CHECK: return %[[arg0]] // CHECK: return %[[arg0]]
func.func @test_negf1(%f : f32) -> (f32) { func.func @test_negf1(%f : f32) -> (f32) {
%0 = arith.negf %f : f32 %0 = arith.negf %f : f32
%1 = arith.negf %0 : f32 %1 = arith.negf %0 : f32
return %1: f32 return %1: f32
} }
// ----- // -----
// CHECK-LABEL: @test_remui( // CHECK-LABEL: @test_remui(
// CHECK: %[[res:.+]] = arith.constant dense<[0, 0, 4, 2]> : vector<4xi32> // CHECK: %[[res:.+]] = arith.constant dense<[0, 0, 4, 2]> : vector<4xi32>
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @test_remui() -> (vector<4xi32>) { func.func @test_remui() -> (vector<4xi32>) {
%v1 = arith.constant dense<[9, 9, 9, 9]> : vector<4xi32> %v1 = arith.constant dense<[9, 9, 9, 9]> : vector<4xi32>
%v2 = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32> %v2 = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32>
%0 = arith.remui %v1, %v2 : vector<4xi32> %0 = arith.remui %v1, %v2 : vector<4xi32>
return %0 : vector<4xi32> return %0 : vector<4xi32>
} }
// // ----- // // -----
// CHECK-LABEL: @test_remui_1( // CHECK-LABEL: @test_remui_1(
// CHECK: %[[res:.+]] = arith.constant dense<0> : vector<4xi32> // CHECK: %[[res:.+]] = arith.constant dense<0> : vector<4xi32>
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @test_remui_1(%arg : vector<4xi32>) -> (vector<4xi32>) { func.func @test_remui_1(%arg : vector<4xi32>) -> (vector<4xi32>) {
%v = arith.constant dense<[1, 1, 1, 1]> : vector<4xi32> %v = arith.constant dense<[1, 1, 1, 1]> : vector<4xi32>
%0 = arith.remui %arg, %v : vector<4xi32> %0 = arith.remui %arg, %v : vector<4xi32>
return %0 : vector<4xi32> return %0 : vector<4xi32>
} }
// ----- // -----
// CHECK-LABEL: @test_remsi( // CHECK-LABEL: @test_remsi(
// CHECK: %[[res:.+]] = arith.constant dense<[0, 0, 4, 2]> : vector<4xi32> // CHECK: %[[res:.+]] = arith.constant dense<[0, 0, 4, 2]> : vector<4xi32>
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @test_remsi() -> (vector<4xi32>) { func.func @test_remsi() -> (vector<4xi32>) {
%v1 = arith.constant dense<[9, 9, 9, 9]> : vector<4xi32> %v1 = arith.constant dense<[9, 9, 9, 9]> : vector<4xi32>
%v2 = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32> %v2 = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32>
%0 = arith.remsi %v1, %v2 : vector<4xi32> %0 = arith.remsi %v1, %v2 : vector<4xi32>
return %0 : vector<4xi32> return %0 : vector<4xi32>
} }
// // ----- // // -----
// CHECK-LABEL: @test_remsi_1( // CHECK-LABEL: @test_remsi_1(
// CHECK: %[[res:.+]] = arith.constant dense<0> : vector<4xi32> // CHECK: %[[res:.+]] = arith.constant dense<0> : vector<4xi32>
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @test_remsi_1(%arg : vector<4xi32>) -> (vector<4xi32>) { func.func @test_remsi_1(%arg : vector<4xi32>) -> (vector<4xi32>) {
%v = arith.constant dense<[1, 1, 1, 1]> : vector<4xi32> %v = arith.constant dense<[1, 1, 1, 1]> : vector<4xi32>
%0 = arith.remsi %arg, %v : vector<4xi32> %0 = arith.remsi %arg, %v : vector<4xi32>
return %0 : vector<4xi32> return %0 : vector<4xi32>
} }
// ----- // -----
// CHECK-LABEL: @test_remf( // CHECK-LABEL: @test_remf(
// CHECK: %[[res:.+]] = arith.constant -1.000000e+00 : f32 // CHECK: %[[res:.+]] = arith.constant -1.000000e+00 : f32
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @test_remf() -> (f32) { func.func @test_remf() -> (f32) {
%v1 = arith.constant 3.0 : f32 %v1 = arith.constant 3.0 : f32
%v2 = arith.constant 2.0 : f32 %v2 = arith.constant 2.0 : f32
%0 = arith.remf %v1, %v2 : f32 %0 = arith.remf %v1, %v2 : f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: @test_remf_vec( // CHECK-LABEL: @test_remf_vec(
// CHECK: %[[res:.+]] = arith.constant dense<[1.000000e+00, 0.000000e+00, -1.000000e+00, 0.000000e+00]> : vector<4xf32> // CHECK: %[[res:.+]] = arith.constant dense<[1.000000e+00, 0.000000e+00, -1.000000e+00, 0.000000e+00]> : vector<4xf32>
// CHECK: return %[[res]] // CHECK: return %[[res]]
func.func @test_remf_vec() -> (vector<4xf32>) { func.func @test_remf_vec() -> (vector<4xf32>) {
%v1 = arith.constant dense<[1.0, 2.0, 3.0, 4.0]> : vector<4xf32> %v1 = arith.constant dense<[1.0, 2.0, 3.0, 4.0]> : vector<4xf32>
%v2 = arith.constant dense<[2.0, 2.0, 2.0, 2.0]> : vector<4xf32> %v2 = arith.constant dense<[2.0, 2.0, 2.0, 2.0]> : vector<4xf32>
%0 = arith.remf %v1, %v2 : vector<4xf32> %0 = arith.remf %v1, %v2 : vector<4xf32>
return %0 : vector<4xf32> return %0 : vector<4xf32>
} }
// ----- // -----
// CHECK-LABEL: @test_andi_not_fold_rhs( // CHECK-LABEL: @test_andi_not_fold_rhs(
// CHECK-SAME: %[[ARG0:[[:alnum:]]+]] // CHECK-SAME: %[[ARG0:[[:alnum:]]+]]
// CHECK: %[[C:.*]] = arith.constant 0 : index // CHECK: %[[C:.*]] = arith.constant 0 : index
// CHECK: return %[[C]] // CHECK: return %[[C]]
func.func @test_andi_not_fold_rhs(%arg0 : index) -> index { func.func @test_andi_not_fold_rhs(%arg0 : index) -> index {
%0 = arith.constant -1 : index %0 = arith.constant -1 : index
%1 = arith.xori %arg0, %0 : index %1 = arith.xori %arg0, %0 : index
%2 = arith.andi %arg0, %1 : index %2 = arith.andi %arg0, %1 : index
return %2 : index return %2 : index
} }
// CHECK-LABEL: @test_andi_not_fold_lhs( // CHECK-LABEL: @test_andi_not_fold_lhs(
// CHECK-SAME: %[[ARG0:[[:alnum:]]+]] // CHECK-SAME: %[[ARG0:[[:alnum:]]+]]
// CHECK: %[[C:.*]] = arith.constant 0 : index // CHECK: %[[C:.*]] = arith.constant 0 : index
// CHECK: return %[[C]] // CHECK: return %[[C]]
func.func @test_andi_not_fold_lhs(%arg0 : index) -> index { func.func @test_andi_not_fold_lhs(%arg0 : index) -> index {
%0 = arith.constant -1 : index %0 = arith.constant -1 : index
%1 = arith.xori %arg0, %0 : index %1 = arith.xori %arg0, %0 : index
%2 = arith.andi %1, %arg0 : index %2 = arith.andi %1, %arg0 : index
return %2 : index return %2 : index
} }
// ----- // -----
/// xor(xor(x, a), a) -> x /// xor(xor(x, a), a) -> x
// CHECK-LABEL: @xorxor0( // CHECK-LABEL: @xorxor0(
// CHECK-NOT: xori // CHECK-NOT: xori
// CHECK: return %arg0 // CHECK: return %arg0
func.func @xorxor0(%a : i32, %b : i32) -> i32 { func.func @xorxor0(%a : i32, %b : i32) -> i32 {
%c = arith.xori %a, %b : i32 %c = arith.xori %a, %b : i32
%res = arith.xori %c, %b : i32 %res = arith.xori %c, %b : i32
return %res : i32 return %res : i32
} }
// ----- // -----
/// xor(xor(a, x), a) -> x /// xor(xor(a, x), a) -> x
// CHECK-LABEL: @xorxor1( // CHECK-LABEL: @xorxor1(
// CHECK-NOT: xori // CHECK-NOT: xori
// CHECK: return %arg0 // CHECK: return %arg0
func.func @xorxor1(%a : i32, %b : i32) -> i32 { func.func @xorxor1(%a : i32, %b : i32) -> i32 {
%c = arith.xori %b, %a : i32 %c = arith.xori %b, %a : i32
%res = arith.xori %c, %b : i32 %res = arith.xori %c, %b : i32
return %res : i32 return %res : i32
} }
// ----- // -----
/// xor(a, xor(x, a)) -> x /// xor(a, xor(x, a)) -> x
// CHECK-LABEL: @xorxor2( // CHECK-LABEL: @xorxor2(
// CHECK-NOT: xori // CHECK-NOT: xori
// CHECK: return %arg0 // CHECK: return %arg0
func.func @xorxor2(%a : i32, %b : i32) -> i32 { func.func @xorxor2(%a : i32, %b : i32) -> i32 {
%c = arith.xori %a, %b : i32 %c = arith.xori %a, %b : i32
%res = arith.xori %b, %c : i32 %res = arith.xori %b, %c : i32
return %res : i32 return %res : i32
} }
// ----- // -----
/// xor(a, xor(a, x)) -> x /// xor(a, xor(a, x)) -> x
// CHECK-LABEL: @xorxor3( // CHECK-LABEL: @xorxor3(
// CHECK-NOT: xori // CHECK-NOT: xori
// CHECK: return %arg0 // CHECK: return %arg0
func.func @xorxor3(%a : i32, %b : i32) -> i32 { func.func @xorxor3(%a : i32, %b : i32) -> i32 {
%c = arith.xori %b, %a : i32 %c = arith.xori %b, %a : i32
%res = arith.xori %b, %c : i32 %res = arith.xori %b, %c : i32
return %res : i32 return %res : i32
} }

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.
// Check that emulation of wery wide types (>64 bits) works as expected. // Check that emulation of wery wide types (>64 bits) works as expected.
// RUN: mlir-opt --arith-emulate-wide-int="widest-int-supported=512" %s | FileCheck %s // RUN: mlir-opt --arith-emulate-wide-int="widest-int-supported=512" %s | FileCheck %s
// CHECK-LABEL: func.func @muli_scalar // CHECK-LABEL: func.func @muli_scalar
// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi512>, [[ARG1:%.+]]: vector<2xi512>) -> vector<2xi512> // CHECK-SAME: ([[ARG0:%.+]]: vector<2xi512>, [[ARG1:%.+]]: vector<2xi512>) -> vector<2xi512>
// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : vector<2xi512> // CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : vector<2xi512>
// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : vector<2xi512> // CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : vector<2xi512>
// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : vector<2xi512> // CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : vector<2xi512>
// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : vector<2xi512> // CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : vector<2xi512>
// //
// Check that the mask for the low 256-bits was generated correctly. The exact expected value is 2^256 - 1. // Check that the mask for the low 256-bits was generated correctly. The exact expected value is 2^256 - 1.
// CHECK-NEXT: {{.+}} = arith.constant 115792089237316195423570985008687907853269984665640564039457584007913129639935 : i512 // CHECK-NEXT: {{.+}} = arith.constant 115792089237316195423570985008687907853269984665640564039457584007913129639935 : i512
// CHECK: return {{%.+}} : vector<2xi512> // CHECK: return {{%.+}} : vector<2xi512>
func.func @muli_scalar(%a : i1024, %b : i1024) -> i1024 { func.func @muli_scalar(%a : i1024, %b : i1024) -> i1024 {
%m = arith.muli %a, %b : i1024 %m = arith.muli %a, %b : i1024
return %m : i1024 return %m : i1024
} }

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

  • This file was moved from mlir/test/Dialect/Arithmetic/emulate-wide-int.mlir.
// RUN: mlir-opt --arith-emulate-wide-int="widest-int-supported=32" %s | FileCheck %s // RUN: mlir-opt --arith-emulate-wide-int="widest-int-supported=32" %s | FileCheck %s
// Expect no conversions, i32 is supported. // Expect no conversions, i32 is supported.
// CHECK-LABEL: func @addi_same_i32 // CHECK-LABEL: func @addi_same_i32
// CHECK-SAME: ([[ARG:%.+]]: i32) -> i32 // CHECK-SAME: ([[ARG:%.+]]: i32) -> i32
// CHECK-NEXT: [[X:%.+]] = arith.addi [[ARG]], [[ARG]] : i32 // CHECK-NEXT: [[X:%.+]] = arith.addi [[ARG]], [[ARG]] : i32
// CHECK-NEXT: return [[X]] : i32 // CHECK-NEXT: return [[X]] : i32
func.func @addi_same_i32(%a : i32) -> i32 { func.func @addi_same_i32(%a : i32) -> i32 {
%x = arith.addi %a, %a : i32 %x = arith.addi %a, %a : i32
return %x : i32 return %x : i32
} }
// Expect no conversions, i32 is supported. // Expect no conversions, i32 is supported.
// CHECK-LABEL: func @addi_same_vector_i32 // CHECK-LABEL: func @addi_same_vector_i32
// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> vector<2xi32> // CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> vector<2xi32>
// CHECK-NEXT: [[X:%.+]] = arith.addi [[ARG]], [[ARG]] : vector<2xi32> // CHECK-NEXT: [[X:%.+]] = arith.addi [[ARG]], [[ARG]] : vector<2xi32>
// CHECK-NEXT: return [[X]] : vector<2xi32> // CHECK-NEXT: return [[X]] : vector<2xi32>
func.func @addi_same_vector_i32(%a : vector<2xi32>) -> vector<2xi32> { func.func @addi_same_vector_i32(%a : vector<2xi32>) -> vector<2xi32> {
%x = arith.addi %a, %a : vector<2xi32> %x = arith.addi %a, %a : vector<2xi32>
return %x : vector<2xi32> return %x : vector<2xi32>
} }
// CHECK-LABEL: func @identity_scalar // CHECK-LABEL: func @identity_scalar
// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> vector<2xi32> // CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> vector<2xi32>
// CHECK-NEXT: return [[ARG]] : vector<2xi32> // CHECK-NEXT: return [[ARG]] : vector<2xi32>
func.func @identity_scalar(%x : i64) -> i64 { func.func @identity_scalar(%x : i64) -> i64 {
return %x : i64 return %x : i64
} }
// CHECK-LABEL: func @identity_vector // CHECK-LABEL: func @identity_vector
// CHECK-SAME: ([[ARG:%.+]]: vector<4x2xi32>) -> vector<4x2xi32> // CHECK-SAME: ([[ARG:%.+]]: vector<4x2xi32>) -> vector<4x2xi32>
// CHECK-NEXT: return [[ARG]] : vector<4x2xi32> // CHECK-NEXT: return [[ARG]] : vector<4x2xi32>
func.func @identity_vector(%x : vector<4xi64>) -> vector<4xi64> { func.func @identity_vector(%x : vector<4xi64>) -> vector<4xi64> {
return %x : vector<4xi64> return %x : vector<4xi64>
} }
// CHECK-LABEL: func @identity_vector2d // CHECK-LABEL: func @identity_vector2d
// CHECK-SAME: ([[ARG:%.+]]: vector<3x4x2xi32>) -> vector<3x4x2xi32> // CHECK-SAME: ([[ARG:%.+]]: vector<3x4x2xi32>) -> vector<3x4x2xi32>
// CHECK-NEXT: return [[ARG]] : vector<3x4x2xi32> // CHECK-NEXT: return [[ARG]] : vector<3x4x2xi32>
func.func @identity_vector2d(%x : vector<3x4xi64>) -> vector<3x4xi64> { func.func @identity_vector2d(%x : vector<3x4xi64>) -> vector<3x4xi64> {
return %x : vector<3x4xi64> return %x : vector<3x4xi64>
} }
// CHECK-LABEL: func @call // CHECK-LABEL: func @call
// CHECK-SAME: ([[ARG:%.+]]: vector<4x2xi32>) -> vector<4x2xi32> // CHECK-SAME: ([[ARG:%.+]]: vector<4x2xi32>) -> vector<4x2xi32>
// CHECK-NEXT: [[RES:%.+]] = call @identity_vector([[ARG]]) : (vector<4x2xi32>) -> vector<4x2xi32> // CHECK-NEXT: [[RES:%.+]] = call @identity_vector([[ARG]]) : (vector<4x2xi32>) -> vector<4x2xi32>
// CHECK-NEXT: return [[RES]] : vector<4x2xi32> // CHECK-NEXT: return [[RES]] : vector<4x2xi32>
func.func @call(%a : vector<4xi64>) -> vector<4xi64> { func.func @call(%a : vector<4xi64>) -> vector<4xi64> {
%res = func.call @identity_vector(%a) : (vector<4xi64>) -> vector<4xi64> %res = func.call @identity_vector(%a) : (vector<4xi64>) -> vector<4xi64>
return %res : vector<4xi64> return %res : vector<4xi64>
} }
// CHECK-LABEL: func @constant_scalar // CHECK-LABEL: func @constant_scalar
// CHECK-SAME: () -> vector<2xi32> // CHECK-SAME: () -> vector<2xi32>
// CHECK-NEXT: [[C0:%.+]] = arith.constant dense<0> : vector<2xi32> // CHECK-NEXT: [[C0:%.+]] = arith.constant dense<0> : vector<2xi32>
// CHECK-NEXT: [[C1:%.+]] = arith.constant dense<[0, 1]> : vector<2xi32> // CHECK-NEXT: [[C1:%.+]] = arith.constant dense<[0, 1]> : vector<2xi32>
// CHECK-NEXT: [[C2:%.+]] = arith.constant dense<[-7, -1]> : vector<2xi32> // CHECK-NEXT: [[C2:%.+]] = arith.constant dense<[-7, -1]> : vector<2xi32>
// CHECK-NEXT: return [[C0]] : vector<2xi32> // CHECK-NEXT: return [[C0]] : vector<2xi32>
func.func @constant_scalar() -> i64 { func.func @constant_scalar() -> i64 {
%c0 = arith.constant 0 : i64 %c0 = arith.constant 0 : i64
%c1 = arith.constant 4294967296 : i64 %c1 = arith.constant 4294967296 : i64
%c2 = arith.constant -7 : i64 %c2 = arith.constant -7 : i64
return %c0 : i64 return %c0 : i64
} }
// CHECK-LABEL: func @constant_vector // CHECK-LABEL: func @constant_vector
// CHECK-SAME: () -> vector<3x2xi32> // CHECK-SAME: () -> vector<3x2xi32>
// CHECK-NEXT: [[C0:%.+]] = arith.constant dense // CHECK-NEXT: [[C0:%.+]] = arith.constant dense
// CHECK-SAME{LITERAL}: <[[0, 1], [0, 1], [0, 1]]> : vector<3x2xi32> // CHECK-SAME{LITERAL}: <[[0, 1], [0, 1], [0, 1]]> : vector<3x2xi32>
// CHECK-NEXT: [[C1:%.+]] = arith.constant dense // CHECK-NEXT: [[C1:%.+]] = arith.constant dense
// CHECK-SAME{LITERAL}: <[[0, 0], [1, 0], [-2, -1]]> : vector<3x2xi32> // CHECK-SAME{LITERAL}: <[[0, 0], [1, 0], [-2, -1]]> : vector<3x2xi32>
// CHECK-NEXT: return [[C0]] : vector<3x2xi32> // CHECK-NEXT: return [[C0]] : vector<3x2xi32>
func.func @constant_vector() -> vector<3xi64> { func.func @constant_vector() -> vector<3xi64> {
%c0 = arith.constant dense<4294967296> : vector<3xi64> %c0 = arith.constant dense<4294967296> : vector<3xi64>
%c1 = arith.constant dense<[0, 1, -2]> : vector<3xi64> %c1 = arith.constant dense<[0, 1, -2]> : vector<3xi64>
return %c0 : vector<3xi64> return %c0 : vector<3xi64>
} }
// CHECK-LABEL: func @addi_scalar_a_b // CHECK-LABEL: func @addi_scalar_a_b
// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32> // CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>
// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : vector<2xi32> // CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : vector<2xi32>
// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : vector<2xi32> // CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : vector<2xi32>
// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : vector<2xi32> // CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : vector<2xi32>
// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : vector<2xi32> // CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : vector<2xi32>
// CHECK-NEXT: [[SUM_L:%.+]], [[CB:%.+]] = arith.addui_carry [[LOW0]], [[LOW1]] : i32, i1 // CHECK-NEXT: [[SUM_L:%.+]], [[CB:%.+]] = arith.addui_carry [[LOW0]], [[LOW1]] : i32, i1
// CHECK-NEXT: [[CARRY:%.+]] = arith.extui [[CB]] : i1 to i32 // CHECK-NEXT: [[CARRY:%.+]] = arith.extui [[CB]] : i1 to i32
// CHECK-NEXT: [[SUM_H0:%.+]] = arith.addi [[CARRY]], [[HIGH0]] : i32 // CHECK-NEXT: [[SUM_H0:%.+]] = arith.addi [[CARRY]], [[HIGH0]] : i32
// CHECK-NEXT: [[SUM_H1:%.+]] = arith.addi [[SUM_H0]], [[HIGH1]] : i32 // CHECK-NEXT: [[SUM_H1:%.+]] = arith.addi [[SUM_H0]], [[HIGH1]] : i32
// CHECK: [[INS0:%.+]] = vector.insert [[SUM_L]], {{%.+}} [0] : i32 into vector<2xi32> // CHECK: [[INS0:%.+]] = vector.insert [[SUM_L]], {{%.+}} [0] : i32 into vector<2xi32>
// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[SUM_H1]], [[INS0]] [1] : i32 into vector<2xi32> // CHECK-NEXT: [[INS1:%.+]] = vector.insert [[SUM_H1]], [[INS0]] [1] : i32 into vector<2xi32>
// CHECK-NEXT: return [[INS1]] : vector<2xi32> // CHECK-NEXT: return [[INS1]] : vector<2xi32>
func.func @addi_scalar_a_b(%a : i64, %b : i64) -> i64 { func.func @addi_scalar_a_b(%a : i64, %b : i64) -> i64 {
%x = arith.addi %a, %b : i64 %x = arith.addi %a, %b : i64
return %x : i64 return %x : i64
} }
// CHECK-LABEL: func @addi_vector_a_b // CHECK-LABEL: func @addi_vector_a_b
// CHECK-SAME: ([[ARG0:%.+]]: vector<4x2xi32>, [[ARG1:%.+]]: vector<4x2xi32>) -> vector<4x2xi32> // CHECK-SAME: ([[ARG0:%.+]]: vector<4x2xi32>, [[ARG1:%.+]]: vector<4x2xi32>) -> vector<4x2xi32>
// CHECK-NEXT: [[LOW0:%.+]] = vector.extract_strided_slice [[ARG0]] {offsets = [0, 0], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32> // CHECK-NEXT: [[LOW0:%.+]] = vector.extract_strided_slice [[ARG0]] {offsets = [0, 0], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>
// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract_strided_slice [[ARG0]] {offsets = [0, 1], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32> // CHECK-NEXT: [[HIGH0:%.+]] = vector.extract_strided_slice [[ARG0]] {offsets = [0, 1], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>
// CHECK-NEXT: [[LOW1:%.+]] = vector.extract_strided_slice [[ARG1]] {offsets = [0, 0], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32> // CHECK-NEXT: [[LOW1:%.+]] = vector.extract_strided_slice [[ARG1]] {offsets = [0, 0], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>
// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract_strided_slice [[ARG1]] {offsets = [0, 1], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32> // CHECK-NEXT: [[HIGH1:%.+]] = vector.extract_strided_slice [[ARG1]] {offsets = [0, 1], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>
// CHECK-NEXT: [[SUM_L:%.+]], [[CB:%.+]] = arith.addui_carry [[LOW0]], [[LOW1]] : vector<4x1xi32>, vector<4x1xi1> // CHECK-NEXT: [[SUM_L:%.+]], [[CB:%.+]] = arith.addui_carry [[LOW0]], [[LOW1]] : vector<4x1xi32>, vector<4x1xi1>
// CHECK-NEXT: [[CARRY:%.+]] = arith.extui [[CB]] : vector<4x1xi1> to vector<4x1xi32> // CHECK-NEXT: [[CARRY:%.+]] = arith.extui [[CB]] : vector<4x1xi1> to vector<4x1xi32>
// CHECK-NEXT: [[SUM_H0:%.+]] = arith.addi [[CARRY]], [[HIGH0]] : vector<4x1xi32> // CHECK-NEXT: [[SUM_H0:%.+]] = arith.addi [[CARRY]], [[HIGH0]] : vector<4x1xi32>
// CHECK-NEXT: [[SUM_H1:%.+]] = arith.addi [[SUM_H0]], [[HIGH1]] : vector<4x1xi32> // CHECK-NEXT: [[SUM_H1:%.+]] = arith.addi [[SUM_H0]], [[HIGH1]] : vector<4x1xi32>
// CHECK: [[INS0:%.+]] = vector.insert_strided_slice [[SUM_L]], {{%.+}} {offsets = [0, 0], strides = [1, 1]} : vector<4x1xi32> into vector<4x2xi32> // CHECK: [[INS0:%.+]] = vector.insert_strided_slice [[SUM_L]], {{%.+}} {offsets = [0, 0], strides = [1, 1]} : vector<4x1xi32> into vector<4x2xi32>
// CHECK-NEXT: [[INS1:%.+]] = vector.insert_strided_slice [[SUM_H1]], [[INS0]] {offsets = [0, 1], strides = [1, 1]} : vector<4x1xi32> into vector<4x2xi32> // CHECK-NEXT: [[INS1:%.+]] = vector.insert_strided_slice [[SUM_H1]], [[INS0]] {offsets = [0, 1], strides = [1, 1]} : vector<4x1xi32> into vector<4x2xi32>
// CHECK-NEXT: return [[INS1]] : vector<4x2xi32> // CHECK-NEXT: return [[INS1]] : vector<4x2xi32>
func.func @addi_vector_a_b(%a : vector<4xi64>, %b : vector<4xi64>) -> vector<4xi64> { func.func @addi_vector_a_b(%a : vector<4xi64>, %b : vector<4xi64>) -> vector<4xi64> {
%x = arith.addi %a, %b : vector<4xi64> %x = arith.addi %a, %b : vector<4xi64>
return %x : vector<4xi64> return %x : vector<4xi64>
} }
// CHECK-LABEL: func @extsi_scalar // CHECK-LABEL: func @extsi_scalar
// CHECK-SAME: ([[ARG:%.+]]: i16) -> vector<2xi32> // CHECK-SAME: ([[ARG:%.+]]: i16) -> vector<2xi32>
// CHECK-NEXT: [[EXT:%.+]] = arith.extsi [[ARG]] : i16 to i32 // CHECK-NEXT: [[EXT:%.+]] = arith.extsi [[ARG]] : i16 to i32
// CHECK-NEXT: [[SZ:%.+]] = arith.constant 0 : i32 // CHECK-NEXT: [[SZ:%.+]] = arith.constant 0 : i32
// CHECK-NEXT: [[SB:%.+]] = arith.cmpi slt, [[EXT]], [[SZ]] : i32 // CHECK-NEXT: [[SB:%.+]] = arith.cmpi slt, [[EXT]], [[SZ]] : i32
// CHECK-NEXT: [[SV:%.+]] = arith.extsi [[SB]] : i1 to i32 // CHECK-NEXT: [[SV:%.+]] = arith.extsi [[SB]] : i1 to i32
// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32> // CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>
// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[EXT]], [[VZ]] [0] : i32 into vector<2xi32> // CHECK-NEXT: [[INS0:%.+]] = vector.insert [[EXT]], [[VZ]] [0] : i32 into vector<2xi32>
// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[SV]], [[INS0]] [1] : i32 into vector<2xi32> // CHECK-NEXT: [[INS1:%.+]] = vector.insert [[SV]], [[INS0]] [1] : i32 into vector<2xi32>
// CHECK: return [[INS1]] : vector<2xi32> // CHECK: return [[INS1]] : vector<2xi32>
func.func @extsi_scalar(%a : i16) -> i64 { func.func @extsi_scalar(%a : i16) -> i64 {
%r = arith.extsi %a : i16 to i64 %r = arith.extsi %a : i16 to i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: func @extsi_vector // CHECK-LABEL: func @extsi_vector
// CHECK-SAME: ([[ARG:%.+]]: vector<3xi16>) -> vector<3x2xi32> // CHECK-SAME: ([[ARG:%.+]]: vector<3xi16>) -> vector<3x2xi32>
// CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[ARG]] : vector<3xi16> to vector<3x1xi16> // CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[ARG]] : vector<3xi16> to vector<3x1xi16>
// CHECK-NEXT: [[EXT:%.+]] = arith.extsi [[SHAPE]] : vector<3x1xi16> to vector<3x1xi32> // CHECK-NEXT: [[EXT:%.+]] = arith.extsi [[SHAPE]] : vector<3x1xi16> to vector<3x1xi32>
// CHECK-NEXT: [[CSTE:%.+]] = arith.constant dense<0> : vector<3x1xi32> // CHECK-NEXT: [[CSTE:%.+]] = arith.constant dense<0> : vector<3x1xi32>
// CHECK-NEXT: [[CMP:%.+]] = arith.cmpi slt, [[EXT]], [[CSTE]] : vector<3x1xi32> // CHECK-NEXT: [[CMP:%.+]] = arith.cmpi slt, [[EXT]], [[CSTE]] : vector<3x1xi32>
// CHECK-NEXT: [[HIGH:%.+]] = arith.extsi [[CMP]] : vector<3x1xi1> to vector<3x1xi32> // CHECK-NEXT: [[HIGH:%.+]] = arith.extsi [[CMP]] : vector<3x1xi1> to vector<3x1xi32>
// CHECK-NEXT: [[CSTZ:%.+]] = arith.constant dense<0> : vector<3x2xi32> // CHECK-NEXT: [[CSTZ:%.+]] = arith.constant dense<0> : vector<3x2xi32>
// CHECK-NEXT: [[INS0:%.+]] = vector.insert_strided_slice [[EXT]], [[CSTZ]] {offsets = [0, 0], strides = [1, 1]} : vector<3x1xi32> into vector<3x2xi32> // CHECK-NEXT: [[INS0:%.+]] = vector.insert_strided_slice [[EXT]], [[CSTZ]] {offsets = [0, 0], strides = [1, 1]} : vector<3x1xi32> into vector<3x2xi32>
// CHECK-NEXT: [[INS1:%.+]] = vector.insert_strided_slice [[HIGH]], [[INS0]] {offsets = [0, 1], strides = [1, 1]} : vector<3x1xi32> into vector<3x2xi32> // CHECK-NEXT: [[INS1:%.+]] = vector.insert_strided_slice [[HIGH]], [[INS0]] {offsets = [0, 1], strides = [1, 1]} : vector<3x1xi32> into vector<3x2xi32>
// CHECK-NEXT: return [[INS1]] : vector<3x2xi32> // CHECK-NEXT: return [[INS1]] : vector<3x2xi32>
func.func @extsi_vector(%a : vector<3xi16>) -> vector<3xi64> { func.func @extsi_vector(%a : vector<3xi16>) -> vector<3xi64> {
%r = arith.extsi %a : vector<3xi16> to vector<3xi64> %r = arith.extsi %a : vector<3xi16> to vector<3xi64>
return %r : vector<3xi64> return %r : vector<3xi64>
} }
// CHECK-LABEL: func @extui_scalar1 // CHECK-LABEL: func @extui_scalar1
// CHECK-SAME: ([[ARG:%.+]]: i16) -> vector<2xi32> // CHECK-SAME: ([[ARG:%.+]]: i16) -> vector<2xi32>
// CHECK-NEXT: [[EXT:%.+]] = arith.extui [[ARG]] : i16 to i32 // CHECK-NEXT: [[EXT:%.+]] = arith.extui [[ARG]] : i16 to i32
// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32> // CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>
// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[EXT]], [[VZ]] [0] : i32 into vector<2xi32> // CHECK-NEXT: [[INS0:%.+]] = vector.insert [[EXT]], [[VZ]] [0] : i32 into vector<2xi32>
// CHECK: return [[INS0]] : vector<2xi32> // CHECK: return [[INS0]] : vector<2xi32>
func.func @extui_scalar1(%a : i16) -> i64 { func.func @extui_scalar1(%a : i16) -> i64 {
%r = arith.extui %a : i16 to i64 %r = arith.extui %a : i16 to i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: func @extui_scalar2 // CHECK-LABEL: func @extui_scalar2
// CHECK-SAME: ([[ARG:%.+]]: i32) -> vector<2xi32> // CHECK-SAME: ([[ARG:%.+]]: i32) -> vector<2xi32>
// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32> // CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>
// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[ARG]], [[VZ]] [0] : i32 into vector<2xi32> // CHECK-NEXT: [[INS0:%.+]] = vector.insert [[ARG]], [[VZ]] [0] : i32 into vector<2xi32>
// CHECK: return [[INS0]] : vector<2xi32> // CHECK: return [[INS0]] : vector<2xi32>
func.func @extui_scalar2(%a : i32) -> i64 { func.func @extui_scalar2(%a : i32) -> i64 {
%r = arith.extui %a : i32 to i64 %r = arith.extui %a : i32 to i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: func @extui_vector // CHECK-LABEL: func @extui_vector
// CHECK-SAME: ([[ARG:%.+]]: vector<3xi16>) -> vector<3x2xi32> // CHECK-SAME: ([[ARG:%.+]]: vector<3xi16>) -> vector<3x2xi32>
// CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[ARG]] : vector<3xi16> to vector<3x1xi16> // CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[ARG]] : vector<3xi16> to vector<3x1xi16>
// CHECK-NEXT: [[EXT:%.+]] = arith.extui [[SHAPE]] : vector<3x1xi16> to vector<3x1xi32> // CHECK-NEXT: [[EXT:%.+]] = arith.extui [[SHAPE]] : vector<3x1xi16> to vector<3x1xi32>
// CHECK-NEXT: [[CST:%.+]] = arith.constant dense<0> : vector<3x2xi32> // CHECK-NEXT: [[CST:%.+]] = arith.constant dense<0> : vector<3x2xi32>
// CHECK-NEXT: [[INS0:%.+]] = vector.insert_strided_slice [[EXT]], [[CST]] {offsets = [0, 0], strides = [1, 1]} : vector<3x1xi32> into vector<3x2xi32> // CHECK-NEXT: [[INS0:%.+]] = vector.insert_strided_slice [[EXT]], [[CST]] {offsets = [0, 0], strides = [1, 1]} : vector<3x1xi32> into vector<3x2xi32>
// CHECK: return [[INS0]] : vector<3x2xi32> // CHECK: return [[INS0]] : vector<3x2xi32>
func.func @extui_vector(%a : vector<3xi16>) -> vector<3xi64> { func.func @extui_vector(%a : vector<3xi16>) -> vector<3xi64> {
%r = arith.extui %a : vector<3xi16> to vector<3xi64> %r = arith.extui %a : vector<3xi16> to vector<3xi64>
return %r : vector<3xi64> return %r : vector<3xi64>
} }
// CHECK-LABEL: func @trunci_scalar1 // CHECK-LABEL: func @trunci_scalar1
// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> i32 // CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> i32
// CHECK-NEXT: [[EXT:%.+]] = vector.extract [[ARG]][0] : vector<2xi32> // CHECK-NEXT: [[EXT:%.+]] = vector.extract [[ARG]][0] : vector<2xi32>
// CHECK-NEXT: return [[EXT]] : i32 // CHECK-NEXT: return [[EXT]] : i32
func.func @trunci_scalar1(%a : i64) -> i32 { func.func @trunci_scalar1(%a : i64) -> i32 {
%b = arith.trunci %a : i64 to i32 %b = arith.trunci %a : i64 to i32
return %b : i32 return %b : i32
} }
// CHECK-LABEL: func @trunci_scalar2 // CHECK-LABEL: func @trunci_scalar2
// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> i16 // CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> i16
// CHECK-NEXT: [[EXTR:%.+]] = vector.extract [[ARG]][0] : vector<2xi32> // CHECK-NEXT: [[EXTR:%.+]] = vector.extract [[ARG]][0] : vector<2xi32>
// CHECK-NEXT: [[TRNC:%.+]] = arith.trunci [[EXTR]] : i32 to i16 // CHECK-NEXT: [[TRNC:%.+]] = arith.trunci [[EXTR]] : i32 to i16
// CHECK-NEXT: return [[TRNC]] : i16 // CHECK-NEXT: return [[TRNC]] : i16
func.func @trunci_scalar2(%a : i64) -> i16 { func.func @trunci_scalar2(%a : i64) -> i16 {
%b = arith.trunci %a : i64 to i16 %b = arith.trunci %a : i64 to i16
return %b : i16 return %b : i16
} }
// CHECK-LABEL: func @trunci_vector // CHECK-LABEL: func @trunci_vector
// CHECK-SAME: ([[ARG:%.+]]: vector<3x2xi32>) -> vector<3xi16> // CHECK-SAME: ([[ARG:%.+]]: vector<3x2xi32>) -> vector<3xi16>
// CHECK-NEXT: [[EXTR:%.+]] = vector.extract_strided_slice [[ARG]] {offsets = [0, 0], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32> // CHECK-NEXT: [[EXTR:%.+]] = vector.extract_strided_slice [[ARG]] {offsets = [0, 0], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>
// CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[EXTR]] : vector<3x1xi32> to vector<3xi32> // CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[EXTR]] : vector<3x1xi32> to vector<3xi32>
// CHECK-NEXT: [[TRNC:%.+]] = arith.trunci [[SHAPE]] : vector<3xi32> to vector<3xi16> // CHECK-NEXT: [[TRNC:%.+]] = arith.trunci [[SHAPE]] : vector<3xi32> to vector<3xi16>
// CHECK-NEXT: return [[TRNC]] : vector<3xi16> // CHECK-NEXT: return [[TRNC]] : vector<3xi16>
func.func @trunci_vector(%a : vector<3xi64>) -> vector<3xi16> { func.func @trunci_vector(%a : vector<3xi64>) -> vector<3xi16> {
%b = arith.trunci %a : vector<3xi64> to vector<3xi16> %b = arith.trunci %a : vector<3xi64> to vector<3xi16>
return %b : vector<3xi16> return %b : vector<3xi16>
} }
// CHECK-LABEL: func.func @muli_scalar // CHECK-LABEL: func.func @muli_scalar
// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32> // CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>
// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : vector<2xi32> // CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : vector<2xi32>
// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : vector<2xi32> // CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : vector<2xi32>
// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : vector<2xi32> // CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : vector<2xi32>
// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : vector<2xi32> // CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : vector<2xi32>
// //
// CHECK-DAG: [[MASK:%.+]] = arith.constant 65535 : i32 // CHECK-DAG: [[MASK:%.+]] = arith.constant 65535 : i32
// CHECK-DAG: [[C16:%.+]] = arith.constant 16 : i32 // CHECK-DAG: [[C16:%.+]] = arith.constant 16 : i32
// //
// CHECK: [[LOWLOW0:%.+]] = arith.andi [[LOW0]], [[MASK]] : i32 // CHECK: [[LOWLOW0:%.+]] = arith.andi [[LOW0]], [[MASK]] : i32
// CHECK-NEXT: [[HIGHLOW0:%.+]] = arith.shrui [[LOW0]], [[C16]] : i32 // CHECK-NEXT: [[HIGHLOW0:%.+]] = arith.shrui [[LOW0]], [[C16]] : i32
// CHECK-NEXT: [[LOWHIGH0:%.+]] = arith.andi [[HIGH0]], [[MASK]] : i32 // CHECK-NEXT: [[LOWHIGH0:%.+]] = arith.andi [[HIGH0]], [[MASK]] : i32
// CHECK-NEXT: [[HIGHHIGH0:%.+]] = arith.shrui [[HIGH0]], [[C16]] : i32 // CHECK-NEXT: [[HIGHHIGH0:%.+]] = arith.shrui [[HIGH0]], [[C16]] : i32
// CHECK-NEXT: [[LOWLOW1:%.+]] = arith.andi [[LOW1]], [[MASK]] : i32 // CHECK-NEXT: [[LOWLOW1:%.+]] = arith.andi [[LOW1]], [[MASK]] : i32
// CHECK-NEXT: [[HIGHLOW1:%.+]] = arith.shrui [[LOW1]], [[C16]] : i32 // CHECK-NEXT: [[HIGHLOW1:%.+]] = arith.shrui [[LOW1]], [[C16]] : i32
// CHECK-NEXT: [[LOWHIGH1:%.+]] = arith.andi [[HIGH1]], [[MASK]] : i32 // CHECK-NEXT: [[LOWHIGH1:%.+]] = arith.andi [[HIGH1]], [[MASK]] : i32
// CHECK-NEXT: [[HIGHHIGH1:%.+]] = arith.shrui [[HIGH1]], [[C16]] : i32 // CHECK-NEXT: [[HIGHHIGH1:%.+]] = arith.shrui [[HIGH1]], [[C16]] : i32
// //
// CHECK-DAG: {{%.+}} = arith.muli [[LOWLOW0]], [[LOWLOW1]] : i32 // CHECK-DAG: {{%.+}} = arith.muli [[LOWLOW0]], [[LOWLOW1]] : i32
// CHECK-DAG {{%.+}} = arith.muli [[LOWLOW0]], [[HIGHLOW1]] : i32 // CHECK-DAG {{%.+}} = arith.muli [[LOWLOW0]], [[HIGHLOW1]] : i32
// CHECK-DAG: {{%.+}} = arith.muli [[LOWLOW0]], [[LOWHIGH1]] : i32 // CHECK-DAG: {{%.+}} = arith.muli [[LOWLOW0]], [[LOWHIGH1]] : i32
// CHECK-DAG: {{%.+}} = arith.muli [[LOWLOW0]], [[HIGHHIGH1]] : i32 // CHECK-DAG: {{%.+}} = arith.muli [[LOWLOW0]], [[HIGHHIGH1]] : i32
// //
// CHECK-DAG: {{%.+}} = arith.muli [[HIGHLOW0]], [[LOWLOW1]] : i32 // CHECK-DAG: {{%.+}} = arith.muli [[HIGHLOW0]], [[LOWLOW1]] : i32
// CHECK-DAG: {{%.+}} = arith.muli [[HIGHLOW0]], [[HIGHLOW1]] : i32 // CHECK-DAG: {{%.+}} = arith.muli [[HIGHLOW0]], [[HIGHLOW1]] : i32
// CHECK-DAG: {{%.+}} = arith.muli [[HIGHLOW0]], [[LOWHIGH1]] : i32 // CHECK-DAG: {{%.+}} = arith.muli [[HIGHLOW0]], [[LOWHIGH1]] : i32
// //
// CHECK-DAG: {{%.+}} = arith.muli [[LOWHIGH0]], [[LOWLOW1]] : i32 // CHECK-DAG: {{%.+}} = arith.muli [[LOWHIGH0]], [[LOWLOW1]] : i32
// CHECK-DAG: {{%.+}} = arith.muli [[LOWHIGH0]], [[HIGHLOW1]] : i32 // CHECK-DAG: {{%.+}} = arith.muli [[LOWHIGH0]], [[HIGHLOW1]] : i32
// //
// CHECK-DAG: {{%.+}} = arith.muli [[HIGHHIGH0]], [[LOWLOW1]] : i32 // CHECK-DAG: {{%.+}} = arith.muli [[HIGHHIGH0]], [[LOWLOW1]] : i32
// //
// CHECK: [[RESHIGH0:%.+]] = arith.shli {{%.+}}, [[C16]] : i32 // CHECK: [[RESHIGH0:%.+]] = arith.shli {{%.+}}, [[C16]] : i32
// CHECK-NEXT: [[RES0:%.+]] = arith.ori {{%.+}}, [[RESHIGH0]] : i32 // CHECK-NEXT: [[RES0:%.+]] = arith.ori {{%.+}}, [[RESHIGH0]] : i32
// CHECK-NEXT: [[RESHIGH1:%.+]] = arith.shli {{%.+}}, [[C16]] : i32 // CHECK-NEXT: [[RESHIGH1:%.+]] = arith.shli {{%.+}}, [[C16]] : i32
// CHECK-NEXT: [[RES1:%.+]] = arith.ori {{%.+}}, [[RESHIGH1]] : i32 // CHECK-NEXT: [[RES1:%.+]] = arith.ori {{%.+}}, [[RESHIGH1]] : i32
// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32> // CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>
// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[RES0]], [[VZ]] [0] : i32 into vector<2xi32> // CHECK-NEXT: [[INS0:%.+]] = vector.insert [[RES0]], [[VZ]] [0] : i32 into vector<2xi32>
// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[RES1]], [[INS0]] [1] : i32 into vector<2xi32> // CHECK-NEXT: [[INS1:%.+]] = vector.insert [[RES1]], [[INS0]] [1] : i32 into vector<2xi32>
// CHECK-NEXT: return [[INS1]] : vector<2xi32> // CHECK-NEXT: return [[INS1]] : vector<2xi32>
func.func @muli_scalar(%a : i64, %b : i64) -> i64 { func.func @muli_scalar(%a : i64, %b : i64) -> i64 {
%m = arith.muli %a, %b : i64 %m = arith.muli %a, %b : i64
return %m : i64 return %m : i64
} }
// CHECK-LABEL: func.func @muli_vector // CHECK-LABEL: func.func @muli_vector
// CHECK-SAME: ({{%.+}}: vector<3x2xi32>, {{%.+}}: vector<3x2xi32>) -> vector<3x2xi32> // CHECK-SAME: ({{%.+}}: vector<3x2xi32>, {{%.+}}: vector<3x2xi32>) -> vector<3x2xi32>
// CHECK: return {{%.+}} : vector<3x2xi32> // CHECK: return {{%.+}} : vector<3x2xi32>
func.func @muli_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> { func.func @muli_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {
%m = arith.muli %a, %b : vector<3xi64> %m = arith.muli %a, %b : vector<3xi64>
return %m : vector<3xi64> return %m : vector<3xi64>
} }
// CHECK-LABEL: func.func @shrui_scalar // CHECK-LABEL: func.func @shrui_scalar
// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32> // CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>
// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : vector<2xi32> // CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : vector<2xi32>
// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : vector<2xi32> // CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : vector<2xi32>
// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : vector<2xi32> // CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : vector<2xi32>
// CHECK-NEXT: [[CST0:%.+]] = arith.constant 0 : i32 // CHECK-NEXT: [[CST0:%.+]] = arith.constant 0 : i32
// CHECK-NEXT: [[CST32:%.+]] = arith.constant 32 : i32 // CHECK-NEXT: [[CST32:%.+]] = arith.constant 32 : i32
// CHECK-DAG: [[OOB:%.+]] = arith.cmpi uge, [[LOW1]], [[CST32]] : i32 // CHECK-DAG: [[OOB:%.+]] = arith.cmpi uge, [[LOW1]], [[CST32]] : i32
// CHECK-DAG: [[SHLOW0:%.+]] = arith.shrui [[LOW0]], [[LOW1]] : i32 // CHECK-DAG: [[SHLOW0:%.+]] = arith.shrui [[LOW0]], [[LOW1]] : i32
// CHECK-NEXT: [[RES0LOW:%.+]] = arith.select [[OOB]], [[CST0]], [[SHLOW0]] : i32 // CHECK-NEXT: [[RES0LOW:%.+]] = arith.select [[OOB]], [[CST0]], [[SHLOW0]] : i32
// CHECK-NEXT: [[SHRHIGH0:%.+]] = arith.shrui [[HIGH0]], [[LOW1]] : i32 // CHECK-NEXT: [[SHRHIGH0:%.+]] = arith.shrui [[HIGH0]], [[LOW1]] : i32
// CHECK-NEXT: [[RESLOW1:%.+]] = arith.select [[OOB]], [[CST0]], [[SHRHIGH0]] : i32 // CHECK-NEXT: [[RESLOW1:%.+]] = arith.select [[OOB]], [[CST0]], [[SHRHIGH0]] : i32
// CHECK-NEXT: [[SHAMT:%.+]] = arith.select [[OOB]], [[CST32]], [[LOW1]] : i32 // CHECK-NEXT: [[SHAMT:%.+]] = arith.select [[OOB]], [[CST32]], [[LOW1]] : i32
// CHECK-NEXT: [[LSHAMT:%.+]] = arith.subi [[CST32]], [[SHAMT]] : i32 // CHECK-NEXT: [[LSHAMT:%.+]] = arith.subi [[CST32]], [[SHAMT]] : i32
// CHECK-NEXT: [[SHLHIGH0:%.+]] = arith.shli [[HIGH0]], [[LSHAMT]] : i32 // CHECK-NEXT: [[SHLHIGH0:%.+]] = arith.shli [[HIGH0]], [[LSHAMT]] : i32
// CHECK-NEXT: [[RSHAMT:%.+]] = arith.subi [[LOW1]], [[CST32]] : i32 // CHECK-NEXT: [[RSHAMT:%.+]] = arith.subi [[LOW1]], [[CST32]] : i32
// CHECK-NEXT: [[SHRHIGH0:%.+]] = arith.shrui [[HIGH0]], [[RSHAMT]] : i32 // CHECK-NEXT: [[SHRHIGH0:%.+]] = arith.shrui [[HIGH0]], [[RSHAMT]] : i32
// CHECK-NEXT: [[RES0HIGH:%.+]] = arith.select [[OOB]], [[SHRHIGH0]], [[SHLHIGH0]] : i32 // CHECK-NEXT: [[RES0HIGH:%.+]] = arith.select [[OOB]], [[SHRHIGH0]], [[SHLHIGH0]] : i32
// CHECK-NEXT: [[RES0:%.+]] = arith.ori [[RES0LOW]], [[RES0HIGH]] : i32 // CHECK-NEXT: [[RES0:%.+]] = arith.ori [[RES0LOW]], [[RES0HIGH]] : i32
// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32> // CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>
// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[RES0]], [[VZ]] [0] : i32 into vector<2xi32> // CHECK-NEXT: [[INS0:%.+]] = vector.insert [[RES0]], [[VZ]] [0] : i32 into vector<2xi32>
// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[RESLOW1]], [[INS0]] [1] : i32 into vector<2xi32> // CHECK-NEXT: [[INS1:%.+]] = vector.insert [[RESLOW1]], [[INS0]] [1] : i32 into vector<2xi32>
// CHECK-NEXT: return [[INS1]] : vector<2xi32> // CHECK-NEXT: return [[INS1]] : vector<2xi32>
func.func @shrui_scalar(%a : i64, %b : i64) -> i64 { func.func @shrui_scalar(%a : i64, %b : i64) -> i64 {
%c = arith.shrui %a, %b : i64 %c = arith.shrui %a, %b : i64
return %c : i64 return %c : i64
} }
// CHECK-LABEL: func.func @shrui_scalar_cst_2 // CHECK-LABEL: func.func @shrui_scalar_cst_2
// CHECK-SAME: ({{%.+}}: vector<2xi32>) -> vector<2xi32> // CHECK-SAME: ({{%.+}}: vector<2xi32>) -> vector<2xi32>
// CHECK: return {{%.+}} : vector<2xi32> // CHECK: return {{%.+}} : vector<2xi32>
func.func @shrui_scalar_cst_2(%a : i64) -> i64 { func.func @shrui_scalar_cst_2(%a : i64) -> i64 {
%b = arith.constant 2 : i64 %b = arith.constant 2 : i64
%c = arith.shrui %a, %b : i64 %c = arith.shrui %a, %b : i64
return %c : i64 return %c : i64
} }
// CHECK-LABEL: func.func @shrui_scalar_cst_36 // CHECK-LABEL: func.func @shrui_scalar_cst_36
// CHECK-SAME: ({{%.+}}: vector<2xi32>) -> vector<2xi32> // CHECK-SAME: ({{%.+}}: vector<2xi32>) -> vector<2xi32>
// CHECK: return {{%.+}} : vector<2xi32> // CHECK: return {{%.+}} : vector<2xi32>
func.func @shrui_scalar_cst_36(%a : i64) -> i64 { func.func @shrui_scalar_cst_36(%a : i64) -> i64 {
%b = arith.constant 36 : i64 %b = arith.constant 36 : i64
%c = arith.shrui %a, %b : i64 %c = arith.shrui %a, %b : i64
return %c : i64 return %c : i64
} }
// CHECK-LABEL: func.func @shrui_vector // CHECK-LABEL: func.func @shrui_vector
// CHECK-SAME: ({{%.+}}: vector<3x2xi32>, {{%.+}}: vector<3x2xi32>) -> vector<3x2xi32> // CHECK-SAME: ({{%.+}}: vector<3x2xi32>, {{%.+}}: vector<3x2xi32>) -> vector<3x2xi32>
// CHECK: return {{%.+}} : vector<3x2xi32> // CHECK: return {{%.+}} : vector<3x2xi32>
func.func @shrui_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> { func.func @shrui_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {
%m = arith.shrui %a, %b : vector<3xi64> %m = arith.shrui %a, %b : vector<3xi64>
return %m : vector<3xi64> return %m : vector<3xi64>
} }

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

  • This file was moved from mlir/test/Dialect/Arithmetic/expand-ops.mlir.
// RUN: mlir-opt %s -arith-expand -split-input-file | FileCheck %s // RUN: mlir-opt %s -arith-expand -split-input-file | FileCheck %s
// Test ceil divide with signed integer // Test ceil divide with signed integer
// CHECK-LABEL: func @ceildivi // CHECK-LABEL: func @ceildivi
// CHECK-SAME: ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> i32 { // CHECK-SAME: ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> i32 {
func.func @ceildivi(%arg0: i32, %arg1: i32) -> (i32) { func.func @ceildivi(%arg0: i32, %arg1: i32) -> (i32) {
%res = arith.ceildivsi %arg0, %arg1 : i32 %res = arith.ceildivsi %arg0, %arg1 : i32
return %res : i32 return %res : i32
// CHECK: [[ONE:%.+]] = arith.constant 1 : i32 // CHECK: [[ONE:%.+]] = arith.constant 1 : i32
// CHECK: [[ZERO:%.+]] = arith.constant 0 : i32 // CHECK: [[ZERO:%.+]] = arith.constant 0 : i32
// CHECK: [[MINONE:%.+]] = arith.constant -1 : i32 // CHECK: [[MINONE:%.+]] = arith.constant -1 : i32
// CHECK: [[CMP1:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : i32 // CHECK: [[CMP1:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : i32
// CHECK: [[X:%.+]] = arith.select [[CMP1]], [[MINONE]], [[ONE]] : i32 // CHECK: [[X:%.+]] = arith.select [[CMP1]], [[MINONE]], [[ONE]] : i32
// CHECK: [[TRUE1:%.+]] = arith.addi [[X]], [[ARG0]] : i32 // CHECK: [[TRUE1:%.+]] = arith.addi [[X]], [[ARG0]] : i32
// CHECK: [[TRUE2:%.+]] = arith.divsi [[TRUE1]], [[ARG1]] : i32 // CHECK: [[TRUE2:%.+]] = arith.divsi [[TRUE1]], [[ARG1]] : i32
// CHECK: [[TRUE3:%.+]] = arith.addi [[ONE]], [[TRUE2]] : i32 // CHECK: [[TRUE3:%.+]] = arith.addi [[ONE]], [[TRUE2]] : i32
// CHECK: [[FALSE1:%.+]] = arith.subi [[ZERO]], [[ARG0]] : i32 // CHECK: [[FALSE1:%.+]] = arith.subi [[ZERO]], [[ARG0]] : i32
// CHECK: [[FALSE2:%.+]] = arith.divsi [[FALSE1]], [[ARG1]] : i32 // CHECK: [[FALSE2:%.+]] = arith.divsi [[FALSE1]], [[ARG1]] : i32
// CHECK: [[FALSE3:%.+]] = arith.subi [[ZERO]], [[FALSE2]] : i32 // CHECK: [[FALSE3:%.+]] = arith.subi [[ZERO]], [[FALSE2]] : i32
// CHECK: [[NNEG:%.+]] = arith.cmpi slt, [[ARG0]], [[ZERO]] : i32 // CHECK: [[NNEG:%.+]] = arith.cmpi slt, [[ARG0]], [[ZERO]] : i32
// CHECK: [[NPOS:%.+]] = arith.cmpi sgt, [[ARG0]], [[ZERO]] : i32 // CHECK: [[NPOS:%.+]] = arith.cmpi sgt, [[ARG0]], [[ZERO]] : i32
// CHECK: [[MNEG:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : i32 // CHECK: [[MNEG:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : i32
// CHECK: [[MPOS:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : i32 // CHECK: [[MPOS:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : i32
// CHECK: [[TERM1:%.+]] = arith.andi [[NNEG]], [[MNEG]] : i1 // CHECK: [[TERM1:%.+]] = arith.andi [[NNEG]], [[MNEG]] : i1
// CHECK: [[TERM2:%.+]] = arith.andi [[NPOS]], [[MPOS]] : i1 // CHECK: [[TERM2:%.+]] = arith.andi [[NPOS]], [[MPOS]] : i1
// CHECK: [[CMP2:%.+]] = arith.ori [[TERM1]], [[TERM2]] : i1 // CHECK: [[CMP2:%.+]] = arith.ori [[TERM1]], [[TERM2]] : i1
// CHECK: [[RES:%.+]] = arith.select [[CMP2]], [[TRUE3]], [[FALSE3]] : i32 // CHECK: [[RES:%.+]] = arith.select [[CMP2]], [[TRUE3]], [[FALSE3]] : i32
} }
// ----- // -----
// Test ceil divide with index type // Test ceil divide with index type
// CHECK-LABEL: func @ceildivi_index // CHECK-LABEL: func @ceildivi_index
// CHECK-SAME: ([[ARG0:%.+]]: index, [[ARG1:%.+]]: index) -> index { // CHECK-SAME: ([[ARG0:%.+]]: index, [[ARG1:%.+]]: index) -> index {
func.func @ceildivi_index(%arg0: index, %arg1: index) -> (index) { func.func @ceildivi_index(%arg0: index, %arg1: index) -> (index) {
%res = arith.ceildivsi %arg0, %arg1 : index %res = arith.ceildivsi %arg0, %arg1 : index
return %res : index return %res : index
// CHECK: [[ONE:%.+]] = arith.constant 1 : index // CHECK: [[ONE:%.+]] = arith.constant 1 : index
// CHECK: [[ZERO:%.+]] = arith.constant 0 : index // CHECK: [[ZERO:%.+]] = arith.constant 0 : index
// CHECK: [[MINONE:%.+]] = arith.constant -1 : index // CHECK: [[MINONE:%.+]] = arith.constant -1 : index
// CHECK: [[CMP1:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : index // CHECK: [[CMP1:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : index
// CHECK: [[X:%.+]] = arith.select [[CMP1]], [[MINONE]], [[ONE]] : index // CHECK: [[X:%.+]] = arith.select [[CMP1]], [[MINONE]], [[ONE]] : index
// CHECK: [[TRUE1:%.+]] = arith.addi [[X]], [[ARG0]] : index // CHECK: [[TRUE1:%.+]] = arith.addi [[X]], [[ARG0]] : index
// CHECK: [[TRUE2:%.+]] = arith.divsi [[TRUE1]], [[ARG1]] : index // CHECK: [[TRUE2:%.+]] = arith.divsi [[TRUE1]], [[ARG1]] : index
// CHECK: [[TRUE3:%.+]] = arith.addi [[ONE]], [[TRUE2]] : index // CHECK: [[TRUE3:%.+]] = arith.addi [[ONE]], [[TRUE2]] : index
// CHECK: [[FALSE1:%.+]] = arith.subi [[ZERO]], [[ARG0]] : index // CHECK: [[FALSE1:%.+]] = arith.subi [[ZERO]], [[ARG0]] : index
// CHECK: [[FALSE2:%.+]] = arith.divsi [[FALSE1]], [[ARG1]] : index // CHECK: [[FALSE2:%.+]] = arith.divsi [[FALSE1]], [[ARG1]] : index
// CHECK: [[FALSE3:%.+]] = arith.subi [[ZERO]], [[FALSE2]] : index // CHECK: [[FALSE3:%.+]] = arith.subi [[ZERO]], [[FALSE2]] : index
// CHECK: [[NNEG:%.+]] = arith.cmpi slt, [[ARG0]], [[ZERO]] : index // CHECK: [[NNEG:%.+]] = arith.cmpi slt, [[ARG0]], [[ZERO]] : index
// CHECK: [[NPOS:%.+]] = arith.cmpi sgt, [[ARG0]], [[ZERO]] : index // CHECK: [[NPOS:%.+]] = arith.cmpi sgt, [[ARG0]], [[ZERO]] : index
// CHECK: [[MNEG:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : index // CHECK: [[MNEG:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : index
// CHECK: [[MPOS:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : index // CHECK: [[MPOS:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : index
// CHECK: [[TERM1:%.+]] = arith.andi [[NNEG]], [[MNEG]] : i1 // CHECK: [[TERM1:%.+]] = arith.andi [[NNEG]], [[MNEG]] : i1
// CHECK: [[TERM2:%.+]] = arith.andi [[NPOS]], [[MPOS]] : i1 // CHECK: [[TERM2:%.+]] = arith.andi [[NPOS]], [[MPOS]] : i1
// CHECK: [[CMP2:%.+]] = arith.ori [[TERM1]], [[TERM2]] : i1 // CHECK: [[CMP2:%.+]] = arith.ori [[TERM1]], [[TERM2]] : i1
// CHECK: [[RES:%.+]] = arith.select [[CMP2]], [[TRUE3]], [[FALSE3]] : index // CHECK: [[RES:%.+]] = arith.select [[CMP2]], [[TRUE3]], [[FALSE3]] : index
} }
// ----- // -----
// Test floor divide with signed integer // Test floor divide with signed integer
// CHECK-LABEL: func @floordivi // CHECK-LABEL: func @floordivi
// CHECK-SAME: ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> i32 { // CHECK-SAME: ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> i32 {
func.func @floordivi(%arg0: i32, %arg1: i32) -> (i32) { func.func @floordivi(%arg0: i32, %arg1: i32) -> (i32) {
%res = arith.floordivsi %arg0, %arg1 : i32 %res = arith.floordivsi %arg0, %arg1 : i32
return %res : i32 return %res : i32
// CHECK: [[ONE:%.+]] = arith.constant 1 : i32 // CHECK: [[ONE:%.+]] = arith.constant 1 : i32
// CHECK: [[ZERO:%.+]] = arith.constant 0 : i32 // CHECK: [[ZERO:%.+]] = arith.constant 0 : i32
// CHECK: [[MIN1:%.+]] = arith.constant -1 : i32 // CHECK: [[MIN1:%.+]] = arith.constant -1 : i32
// CHECK: [[CMP1:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : i32 // CHECK: [[CMP1:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : i32
// CHECK: [[X:%.+]] = arith.select [[CMP1]], [[ONE]], [[MIN1]] : i32 // CHECK: [[X:%.+]] = arith.select [[CMP1]], [[ONE]], [[MIN1]] : i32
// CHECK: [[TRUE1:%.+]] = arith.subi [[X]], [[ARG0]] : i32 // CHECK: [[TRUE1:%.+]] = arith.subi [[X]], [[ARG0]] : i32
// CHECK: [[TRUE2:%.+]] = arith.divsi [[TRUE1]], [[ARG1]] : i32 // CHECK: [[TRUE2:%.+]] = arith.divsi [[TRUE1]], [[ARG1]] : i32
// CHECK: [[TRUE3:%.+]] = arith.subi [[MIN1]], [[TRUE2]] : i32 // CHECK: [[TRUE3:%.+]] = arith.subi [[MIN1]], [[TRUE2]] : i32
// CHECK: [[FALSE:%.+]] = arith.divsi [[ARG0]], [[ARG1]] : i32 // CHECK: [[FALSE:%.+]] = arith.divsi [[ARG0]], [[ARG1]] : i32
// CHECK: [[NNEG:%.+]] = arith.cmpi slt, [[ARG0]], [[ZERO]] : i32 // CHECK: [[NNEG:%.+]] = arith.cmpi slt, [[ARG0]], [[ZERO]] : i32
// CHECK: [[NPOS:%.+]] = arith.cmpi sgt, [[ARG0]], [[ZERO]] : i32 // CHECK: [[NPOS:%.+]] = arith.cmpi sgt, [[ARG0]], [[ZERO]] : i32
// CHECK: [[MNEG:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : i32 // CHECK: [[MNEG:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : i32
// CHECK: [[MPOS:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : i32 // CHECK: [[MPOS:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : i32
// CHECK: [[TERM1:%.+]] = arith.andi [[NNEG]], [[MPOS]] : i1 // CHECK: [[TERM1:%.+]] = arith.andi [[NNEG]], [[MPOS]] : i1
// CHECK: [[TERM2:%.+]] = arith.andi [[NPOS]], [[MNEG]] : i1 // CHECK: [[TERM2:%.+]] = arith.andi [[NPOS]], [[MNEG]] : i1
// CHECK: [[CMP2:%.+]] = arith.ori [[TERM1]], [[TERM2]] : i1 // CHECK: [[CMP2:%.+]] = arith.ori [[TERM1]], [[TERM2]] : i1
// CHECK: [[RES:%.+]] = arith.select [[CMP2]], [[TRUE3]], [[FALSE]] : i32 // CHECK: [[RES:%.+]] = arith.select [[CMP2]], [[TRUE3]], [[FALSE]] : i32
} }
// ----- // -----
// Test floor divide with index type // Test floor divide with index type
// CHECK-LABEL: func @floordivi_index // CHECK-LABEL: func @floordivi_index
// CHECK-SAME: ([[ARG0:%.+]]: index, [[ARG1:%.+]]: index) -> index { // CHECK-SAME: ([[ARG0:%.+]]: index, [[ARG1:%.+]]: index) -> index {
func.func @floordivi_index(%arg0: index, %arg1: index) -> (index) { func.func @floordivi_index(%arg0: index, %arg1: index) -> (index) {
%res = arith.floordivsi %arg0, %arg1 : index %res = arith.floordivsi %arg0, %arg1 : index
return %res : index return %res : index
// CHECK: [[ONE:%.+]] = arith.constant 1 : index // CHECK: [[ONE:%.+]] = arith.constant 1 : index
// CHECK: [[ZERO:%.+]] = arith.constant 0 : index // CHECK: [[ZERO:%.+]] = arith.constant 0 : index
// CHECK: [[MIN1:%.+]] = arith.constant -1 : index // CHECK: [[MIN1:%.+]] = arith.constant -1 : index
// CHECK: [[CMP1:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : index // CHECK: [[CMP1:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : index
// CHECK: [[X:%.+]] = arith.select [[CMP1]], [[ONE]], [[MIN1]] : index // CHECK: [[X:%.+]] = arith.select [[CMP1]], [[ONE]], [[MIN1]] : index
// CHECK: [[TRUE1:%.+]] = arith.subi [[X]], [[ARG0]] : index // CHECK: [[TRUE1:%.+]] = arith.subi [[X]], [[ARG0]] : index
// CHECK: [[TRUE2:%.+]] = arith.divsi [[TRUE1]], [[ARG1]] : index // CHECK: [[TRUE2:%.+]] = arith.divsi [[TRUE1]], [[ARG1]] : index
// CHECK: [[TRUE3:%.+]] = arith.subi [[MIN1]], [[TRUE2]] : index // CHECK: [[TRUE3:%.+]] = arith.subi [[MIN1]], [[TRUE2]] : index
// CHECK: [[FALSE:%.+]] = arith.divsi [[ARG0]], [[ARG1]] : index // CHECK: [[FALSE:%.+]] = arith.divsi [[ARG0]], [[ARG1]] : index
// CHECK: [[NNEG:%.+]] = arith.cmpi slt, [[ARG0]], [[ZERO]] : index // CHECK: [[NNEG:%.+]] = arith.cmpi slt, [[ARG0]], [[ZERO]] : index
// CHECK: [[NPOS:%.+]] = arith.cmpi sgt, [[ARG0]], [[ZERO]] : index // CHECK: [[NPOS:%.+]] = arith.cmpi sgt, [[ARG0]], [[ZERO]] : index
// CHECK: [[MNEG:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : index // CHECK: [[MNEG:%.+]] = arith.cmpi slt, [[ARG1]], [[ZERO]] : index
// CHECK: [[MPOS:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : index // CHECK: [[MPOS:%.+]] = arith.cmpi sgt, [[ARG1]], [[ZERO]] : index
// CHECK: [[TERM1:%.+]] = arith.andi [[NNEG]], [[MPOS]] : i1 // CHECK: [[TERM1:%.+]] = arith.andi [[NNEG]], [[MPOS]] : i1
// CHECK: [[TERM2:%.+]] = arith.andi [[NPOS]], [[MNEG]] : i1 // CHECK: [[TERM2:%.+]] = arith.andi [[NPOS]], [[MNEG]] : i1
// CHECK: [[CMP2:%.+]] = arith.ori [[TERM1]], [[TERM2]] : i1 // CHECK: [[CMP2:%.+]] = arith.ori [[TERM1]], [[TERM2]] : i1
// CHECK: [[RES:%.+]] = arith.select [[CMP2]], [[TRUE3]], [[FALSE]] : index // CHECK: [[RES:%.+]] = arith.select [[CMP2]], [[TRUE3]], [[FALSE]] : index
} }
// ----- // -----
// Test ceil divide with unsigned integer // Test ceil divide with unsigned integer
// CHECK-LABEL: func @ceildivui // CHECK-LABEL: func @ceildivui
// CHECK-SAME: ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> i32 { // CHECK-SAME: ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> i32 {
func.func @ceildivui(%arg0: i32, %arg1: i32) -> (i32) { func.func @ceildivui(%arg0: i32, %arg1: i32) -> (i32) {
%res = arith.ceildivui %arg0, %arg1 : i32 %res = arith.ceildivui %arg0, %arg1 : i32
return %res : i32 return %res : i32
// CHECK: [[ZERO:%.+]] = arith.constant 0 : i32 // CHECK: [[ZERO:%.+]] = arith.constant 0 : i32
// CHECK: [[ISZERO:%.+]] = arith.cmpi eq, %arg0, [[ZERO]] : i32 // CHECK: [[ISZERO:%.+]] = arith.cmpi eq, %arg0, [[ZERO]] : i32
// CHECK: [[ONE:%.+]] = arith.constant 1 : i32 // CHECK: [[ONE:%.+]] = arith.constant 1 : i32
// CHECK: [[SUB:%.+]] = arith.subi %arg0, [[ONE]] : i32 // CHECK: [[SUB:%.+]] = arith.subi %arg0, [[ONE]] : i32
// CHECK: [[DIV:%.+]] = arith.divui [[SUB]], %arg1 : i32 // CHECK: [[DIV:%.+]] = arith.divui [[SUB]], %arg1 : i32
// CHECK: [[REM:%.+]] = arith.addi [[DIV]], [[ONE]] : i32 // CHECK: [[REM:%.+]] = arith.addi [[DIV]], [[ONE]] : i32
// CHECK: [[RES:%.+]] = arith.select [[ISZERO]], [[ZERO]], [[REM]] : i32 // CHECK: [[RES:%.+]] = arith.select [[ISZERO]], [[ZERO]], [[REM]] : i32
} }
// ----- // -----
// Test unsigned ceil divide with index // Test unsigned ceil divide with index
// CHECK-LABEL: func @ceildivui_index // CHECK-LABEL: func @ceildivui_index
// CHECK-SAME: ([[ARG0:%.+]]: index, [[ARG1:%.+]]: index) -> index { // CHECK-SAME: ([[ARG0:%.+]]: index, [[ARG1:%.+]]: index) -> index {
func.func @ceildivui_index(%arg0: index, %arg1: index) -> (index) { func.func @ceildivui_index(%arg0: index, %arg1: index) -> (index) {
%res = arith.ceildivui %arg0, %arg1 : index %res = arith.ceildivui %arg0, %arg1 : index
return %res : index return %res : index
// CHECK: [[ZERO:%.+]] = arith.constant 0 : index // CHECK: [[ZERO:%.+]] = arith.constant 0 : index
// CHECK: [[ISZERO:%.+]] = arith.cmpi eq, %arg0, [[ZERO]] : index // CHECK: [[ISZERO:%.+]] = arith.cmpi eq, %arg0, [[ZERO]] : index
// CHECK: [[ONE:%.+]] = arith.constant 1 : index // CHECK: [[ONE:%.+]] = arith.constant 1 : index
// CHECK: [[SUB:%.+]] = arith.subi %arg0, [[ONE]] : index // CHECK: [[SUB:%.+]] = arith.subi %arg0, [[ONE]] : index
// CHECK: [[DIV:%.+]] = arith.divui [[SUB]], %arg1 : index // CHECK: [[DIV:%.+]] = arith.divui [[SUB]], %arg1 : index
// CHECK: [[REM:%.+]] = arith.addi [[DIV]], [[ONE]] : index // CHECK: [[REM:%.+]] = arith.addi [[DIV]], [[ONE]] : index
// CHECK: [[RES:%.+]] = arith.select [[ISZERO]], [[ZERO]], [[REM]] : index // CHECK: [[RES:%.+]] = arith.select [[ISZERO]], [[ZERO]], [[REM]] : index
} }
// ----- // -----
// CHECK-LABEL: func @maxf // CHECK-LABEL: func @maxf
func.func @maxf(%a: f32, %b: f32) -> f32 { func.func @maxf(%a: f32, %b: f32) -> f32 {
%result = arith.maxf %a, %b : f32 %result = arith.maxf %a, %b : f32
return %result : f32 return %result : f32
} }
// CHECK-SAME: %[[LHS:.*]]: f32, %[[RHS:.*]]: f32) // CHECK-SAME: %[[LHS:.*]]: f32, %[[RHS:.*]]: f32)
// CHECK-NEXT: %[[CMP:.*]] = arith.cmpf ugt, %[[LHS]], %[[RHS]] : f32 // CHECK-NEXT: %[[CMP:.*]] = arith.cmpf ugt, %[[LHS]], %[[RHS]] : f32
// CHECK-NEXT: %[[SELECT:.*]] = arith.select %[[CMP]], %[[LHS]], %[[RHS]] : f32 // CHECK-NEXT: %[[SELECT:.*]] = arith.select %[[CMP]], %[[LHS]], %[[RHS]] : f32
// CHECK-NEXT: %[[IS_NAN:.*]] = arith.cmpf uno, %[[RHS]], %[[RHS]] : f32 // CHECK-NEXT: %[[IS_NAN:.*]] = arith.cmpf uno, %[[RHS]], %[[RHS]] : f32
// CHECK-NEXT: %[[RESULT:.*]] = arith.select %[[IS_NAN]], %[[RHS]], %[[SELECT]] : f32 // CHECK-NEXT: %[[RESULT:.*]] = arith.select %[[IS_NAN]], %[[RHS]], %[[SELECT]] : f32
// CHECK-NEXT: return %[[RESULT]] : f32 // CHECK-NEXT: return %[[RESULT]] : f32
// ----- // -----
// CHECK-LABEL: func @maxf_vector // CHECK-LABEL: func @maxf_vector
func.func @maxf_vector(%a: vector<4xf16>, %b: vector<4xf16>) -> vector<4xf16> { func.func @maxf_vector(%a: vector<4xf16>, %b: vector<4xf16>) -> vector<4xf16> {
%result = arith.maxf %a, %b : vector<4xf16> %result = arith.maxf %a, %b : vector<4xf16>
return %result : vector<4xf16> return %result : vector<4xf16>
} }
// CHECK-SAME: %[[LHS:.*]]: vector<4xf16>, %[[RHS:.*]]: vector<4xf16>) // CHECK-SAME: %[[LHS:.*]]: vector<4xf16>, %[[RHS:.*]]: vector<4xf16>)
// CHECK-NEXT: %[[CMP:.*]] = arith.cmpf ugt, %[[LHS]], %[[RHS]] : vector<4xf16> // CHECK-NEXT: %[[CMP:.*]] = arith.cmpf ugt, %[[LHS]], %[[RHS]] : vector<4xf16>
// CHECK-NEXT: %[[SELECT:.*]] = arith.select %[[CMP]], %[[LHS]], %[[RHS]] // CHECK-NEXT: %[[SELECT:.*]] = arith.select %[[CMP]], %[[LHS]], %[[RHS]]
// CHECK-NEXT: %[[IS_NAN:.*]] = arith.cmpf uno, %[[RHS]], %[[RHS]] : vector<4xf16> // CHECK-NEXT: %[[IS_NAN:.*]] = arith.cmpf uno, %[[RHS]], %[[RHS]] : vector<4xf16>
// CHECK-NEXT: %[[RESULT:.*]] = arith.select %[[IS_NAN]], %[[RHS]], %[[SELECT]] // CHECK-NEXT: %[[RESULT:.*]] = arith.select %[[IS_NAN]], %[[RHS]], %[[SELECT]]
// CHECK-NEXT: return %[[RESULT]] : vector<4xf16> // CHECK-NEXT: return %[[RESULT]] : vector<4xf16>
// ----- // -----
// CHECK-LABEL: func @minf // CHECK-LABEL: func @minf
func.func @minf(%a: f32, %b: f32) -> f32 { func.func @minf(%a: f32, %b: f32) -> f32 {
%result = arith.minf %a, %b : f32 %result = arith.minf %a, %b : f32
return %result : f32 return %result : f32
} }
// CHECK-SAME: %[[LHS:.*]]: f32, %[[RHS:.*]]: f32) // CHECK-SAME: %[[LHS:.*]]: f32, %[[RHS:.*]]: f32)
// CHECK-NEXT: %[[CMP:.*]] = arith.cmpf ult, %[[LHS]], %[[RHS]] : f32 // CHECK-NEXT: %[[CMP:.*]] = arith.cmpf ult, %[[LHS]], %[[RHS]] : f32
// CHECK-NEXT: %[[SELECT:.*]] = arith.select %[[CMP]], %[[LHS]], %[[RHS]] : f32 // CHECK-NEXT: %[[SELECT:.*]] = arith.select %[[CMP]], %[[LHS]], %[[RHS]] : f32
// CHECK-NEXT: %[[IS_NAN:.*]] = arith.cmpf uno, %[[RHS]], %[[RHS]] : f32 // CHECK-NEXT: %[[IS_NAN:.*]] = arith.cmpf uno, %[[RHS]], %[[RHS]] : f32
// CHECK-NEXT: %[[RESULT:.*]] = arith.select %[[IS_NAN]], %[[RHS]], %[[SELECT]] : f32 // CHECK-NEXT: %[[RESULT:.*]] = arith.select %[[IS_NAN]], %[[RHS]], %[[SELECT]] : f32
// CHECK-NEXT: return %[[RESULT]] : f32 // CHECK-NEXT: return %[[RESULT]] : f32
// ----- // -----
// CHECK-LABEL: func @maxsi // CHECK-LABEL: func @maxsi
func.func @maxsi(%a: i32, %b: i32) -> i32 { func.func @maxsi(%a: i32, %b: i32) -> i32 {
%result = arith.maxsi %a, %b : i32 %result = arith.maxsi %a, %b : i32
return %result : i32 return %result : i32
} }
// CHECK-SAME: %[[LHS:.*]]: i32, %[[RHS:.*]]: i32) // CHECK-SAME: %[[LHS:.*]]: i32, %[[RHS:.*]]: i32)
// CHECK-NEXT: %[[CMP:.*]] = arith.cmpi sgt, %[[LHS]], %[[RHS]] : i32 // CHECK-NEXT: %[[CMP:.*]] = arith.cmpi sgt, %[[LHS]], %[[RHS]] : i32
// ----- // -----
// CHECK-LABEL: func @minsi // CHECK-LABEL: func @minsi
func.func @minsi(%a: i32, %b: i32) -> i32 { func.func @minsi(%a: i32, %b: i32) -> i32 {
%result = arith.minsi %a, %b : i32 %result = arith.minsi %a, %b : i32
return %result : i32 return %result : i32
} }
// CHECK-SAME: %[[LHS:.*]]: i32, %[[RHS:.*]]: i32) // CHECK-SAME: %[[LHS:.*]]: i32, %[[RHS:.*]]: i32)
// CHECK-NEXT: %[[CMP:.*]] = arith.cmpi slt, %[[LHS]], %[[RHS]] : i32 // CHECK-NEXT: %[[CMP:.*]] = arith.cmpi slt, %[[LHS]], %[[RHS]] : i32
// ----- // -----
// CHECK-LABEL: func @maxui // CHECK-LABEL: func @maxui
func.func @maxui(%a: i32, %b: i32) -> i32 { func.func @maxui(%a: i32, %b: i32) -> i32 {
%result = arith.maxui %a, %b : i32 %result = arith.maxui %a, %b : i32
return %result : i32 return %result : i32
} }
// CHECK-SAME: %[[LHS:.*]]: i32, %[[RHS:.*]]: i32) // CHECK-SAME: %[[LHS:.*]]: i32, %[[RHS:.*]]: i32)
// CHECK-NEXT: %[[CMP:.*]] = arith.cmpi ugt, %[[LHS]], %[[RHS]] : i32 // CHECK-NEXT: %[[CMP:.*]] = arith.cmpi ugt, %[[LHS]], %[[RHS]] : i32
// ----- // -----
// CHECK-LABEL: func @minui // CHECK-LABEL: func @minui
func.func @minui(%a: i32, %b: i32) -> i32 { func.func @minui(%a: i32, %b: i32) -> i32 {
%result = arith.minui %a, %b : i32 %result = arith.minui %a, %b : i32
return %result : i32 return %result : i32
} }
// CHECK-SAME: %[[LHS:.*]]: i32, %[[RHS:.*]]: i32) // CHECK-SAME: %[[LHS:.*]]: i32, %[[RHS:.*]]: i32)
// CHECK-NEXT: %[[CMP:.*]] = arith.cmpi ult, %[[LHS]], %[[RHS]] : i32 // CHECK-NEXT: %[[CMP:.*]] = arith.cmpi ult, %[[LHS]], %[[RHS]] : i32

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

  • This file was moved from mlir/test/Dialect/Arithmetic/int-range-interface.mlir.
// RUN: mlir-opt -test-int-range-inference -canonicalize %s | FileCheck %s // RUN: mlir-opt -test-int-range-inference -canonicalize %s | FileCheck %s
// CHECK-LABEL: func @add_min_max // CHECK-LABEL: func @add_min_max
// CHECK: %[[c3:.*]] = arith.constant 3 : index // CHECK: %[[c3:.*]] = arith.constant 3 : index
// CHECK: return %[[c3]] // CHECK: return %[[c3]]
func.func @add_min_max(%a: index, %b: index) -> index { func.func @add_min_max(%a: index, %b: index) -> index {
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%0 = arith.minsi %a, %c1 : index %0 = arith.minsi %a, %c1 : index
%1 = arith.maxsi %0, %c1 : index %1 = arith.maxsi %0, %c1 : index
%2 = arith.minui %b, %c2 : index %2 = arith.minui %b, %c2 : index
%3 = arith.maxui %2, %c2 : index %3 = arith.maxui %2, %c2 : index
%4 = arith.addi %1, %3 : index %4 = arith.addi %1, %3 : index
func.return %4 : index func.return %4 : index
} }
// CHECK-LABEL: func @add_lower_bound // CHECK-LABEL: func @add_lower_bound
// CHECK: %[[sge:.*]] = arith.cmpi sge // CHECK: %[[sge:.*]] = arith.cmpi sge
// CHECK: return %[[sge]] // CHECK: return %[[sge]]
func.func @add_lower_bound(%a : i32, %b : i32) -> i1 { func.func @add_lower_bound(%a : i32, %b : i32) -> i1 {
%c1 = arith.constant 1 : i32 %c1 = arith.constant 1 : i32
%c2 = arith.constant 2 : i32 %c2 = arith.constant 2 : i32
%0 = arith.maxsi %a, %c1 : i32 %0 = arith.maxsi %a, %c1 : i32
%1 = arith.maxsi %b, %c1 : i32 %1 = arith.maxsi %b, %c1 : i32
%2 = arith.addi %0, %1 : i32 %2 = arith.addi %0, %1 : i32
%3 = arith.cmpi sge, %2, %c2 : i32 %3 = arith.cmpi sge, %2, %c2 : i32
%4 = arith.cmpi uge, %2, %c2 : i32 %4 = arith.cmpi uge, %2, %c2 : i32
%5 = arith.andi %3, %4 : i1 %5 = arith.andi %3, %4 : i1
func.return %5 : i1 func.return %5 : i1
} }
// CHECK-LABEL: func @sub_signed_vs_unsigned // CHECK-LABEL: func @sub_signed_vs_unsigned
// CHECK-NOT: arith.cmpi sle // CHECK-NOT: arith.cmpi sle
// CHECK: %[[unsigned:.*]] = arith.cmpi ule // CHECK: %[[unsigned:.*]] = arith.cmpi ule
// CHECK: return %[[unsigned]] : i1 // CHECK: return %[[unsigned]] : i1
func.func @sub_signed_vs_unsigned(%v : i64) -> i1 { func.func @sub_signed_vs_unsigned(%v : i64) -> i1 {
%c0 = arith.constant 0 : i64 %c0 = arith.constant 0 : i64
%c2 = arith.constant 2 : i64 %c2 = arith.constant 2 : i64
%c-5 = arith.constant -5 : i64 %c-5 = arith.constant -5 : i64
%0 = arith.minsi %v, %c2 : i64 %0 = arith.minsi %v, %c2 : i64
%1 = arith.maxsi %0, %c-5 : i64 %1 = arith.maxsi %0, %c-5 : i64
%2 = arith.subi %1, %c2 : i64 %2 = arith.subi %1, %c2 : i64
%3 = arith.cmpi sle, %2, %c0 : i64 %3 = arith.cmpi sle, %2, %c0 : i64
%4 = arith.cmpi ule, %2, %c0 : i64 %4 = arith.cmpi ule, %2, %c0 : i64
%5 = arith.andi %3, %4 : i1 %5 = arith.andi %3, %4 : i1
func.return %5 : i1 func.return %5 : i1
} }
// CHECK-LABEL: func @multiply_negatives // CHECK-LABEL: func @multiply_negatives
// CHECK: %[[false:.*]] = arith.constant false // CHECK: %[[false:.*]] = arith.constant false
// CHECK: return %[[false]] // CHECK: return %[[false]]
func.func @multiply_negatives(%a : index, %b : index) -> i1 { func.func @multiply_negatives(%a : index, %b : index) -> i1 {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c3 = arith.constant 3 : index %c3 = arith.constant 3 : index
%c_1 = arith.constant -1 : index %c_1 = arith.constant -1 : index
%c_2 = arith.constant -2 : index %c_2 = arith.constant -2 : index
%c_4 = arith.constant -4 : index %c_4 = arith.constant -4 : index
%c_12 = arith.constant -12 : index %c_12 = arith.constant -12 : index
%0 = arith.maxsi %a, %c2 : index %0 = arith.maxsi %a, %c2 : index
%1 = arith.minsi %0, %c3 : index %1 = arith.minsi %0, %c3 : index
%2 = arith.minsi %b, %c_1 : index %2 = arith.minsi %b, %c_1 : index
%3 = arith.maxsi %2, %c_4 : index %3 = arith.maxsi %2, %c_4 : index
%4 = arith.muli %1, %3 : index %4 = arith.muli %1, %3 : index
%5 = arith.cmpi slt, %4, %c_12 : index %5 = arith.cmpi slt, %4, %c_12 : index
%6 = arith.cmpi slt, %c_1, %4 : index %6 = arith.cmpi slt, %c_1, %4 : index
%7 = arith.ori %5, %6 : i1 %7 = arith.ori %5, %6 : i1
func.return %7 : i1 func.return %7 : i1
} }
// CHECK-LABEL: func @multiply_unsigned_bounds // CHECK-LABEL: func @multiply_unsigned_bounds
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @multiply_unsigned_bounds(%a : i16, %b : i16) -> i1 { func.func @multiply_unsigned_bounds(%a : i16, %b : i16) -> i1 {
%c0 = arith.constant 0 : i16 %c0 = arith.constant 0 : i16
%c4 = arith.constant 4 : i16 %c4 = arith.constant 4 : i16
%c_mask = arith.constant 0x3fff : i16 %c_mask = arith.constant 0x3fff : i16
%c_bound = arith.constant 0xfffc : i16 %c_bound = arith.constant 0xfffc : i16
%0 = arith.andi %a, %c_mask : i16 %0 = arith.andi %a, %c_mask : i16
%1 = arith.minui %b, %c4 : i16 %1 = arith.minui %b, %c4 : i16
%2 = arith.muli %0, %1 : i16 %2 = arith.muli %0, %1 : i16
%3 = arith.cmpi uge, %2, %c0 : i16 %3 = arith.cmpi uge, %2, %c0 : i16
%4 = arith.cmpi ule, %2, %c_bound : i16 %4 = arith.cmpi ule, %2, %c_bound : i16
%5 = arith.andi %3, %4 : i1 %5 = arith.andi %3, %4 : i1
func.return %5 : i1 func.return %5 : i1
} }
// CHECK-LABEL: @for_loop_with_increasing_arg // CHECK-LABEL: @for_loop_with_increasing_arg
// CHECK: %[[ret:.*]] = arith.cmpi ule // CHECK: %[[ret:.*]] = arith.cmpi ule
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @for_loop_with_increasing_arg() -> i1 { func.func @for_loop_with_increasing_arg() -> i1 {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%c16 = arith.constant 16 : index %c16 = arith.constant 16 : index
%0 = scf.for %arg0 = %c0 to %c4 step %c1 iter_args(%arg1 = %c0) -> index { %0 = scf.for %arg0 = %c0 to %c4 step %c1 iter_args(%arg1 = %c0) -> index {
%10 = arith.addi %arg0, %arg1 : index %10 = arith.addi %arg0, %arg1 : index
scf.yield %10 : index scf.yield %10 : index
} }
%1 = arith.cmpi ule, %0, %c16 : index %1 = arith.cmpi ule, %0, %c16 : index
func.return %1 : i1 func.return %1 : i1
} }
// CHECK-LABEL: @for_loop_with_constant_result // CHECK-LABEL: @for_loop_with_constant_result
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @for_loop_with_constant_result() -> i1 { func.func @for_loop_with_constant_result() -> i1 {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%true = arith.constant true %true = arith.constant true
%0 = scf.for %arg0 = %c0 to %c4 step %c1 iter_args(%arg1 = %true) -> i1 { %0 = scf.for %arg0 = %c0 to %c4 step %c1 iter_args(%arg1 = %true) -> i1 {
%10 = arith.cmpi ule, %arg0, %c4 : index %10 = arith.cmpi ule, %arg0, %c4 : index
%11 = arith.andi %10, %arg1 : i1 %11 = arith.andi %10, %arg1 : i1
scf.yield %11 : i1 scf.yield %11 : i1
} }
func.return %0 : i1 func.return %0 : i1
} }
// Test to catch a bug present in some versions of the data flow analysis // Test to catch a bug present in some versions of the data flow analysis
// CHECK-LABEL: func @while_false // CHECK-LABEL: func @while_false
// CHECK: %[[false:.*]] = arith.constant false // CHECK: %[[false:.*]] = arith.constant false
// CHECK: scf.condition(%[[false]]) // CHECK: scf.condition(%[[false]])
func.func @while_false(%arg0 : index) -> index { func.func @while_false(%arg0 : index) -> index {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%0 = arith.divui %arg0, %c2 : index %0 = arith.divui %arg0, %c2 : index
%1 = scf.while (%arg1 = %0) : (index) -> index { %1 = scf.while (%arg1 = %0) : (index) -> index {
%2 = arith.cmpi slt, %arg1, %c0 : index %2 = arith.cmpi slt, %arg1, %c0 : index
scf.condition(%2) %arg1 : index scf.condition(%2) %arg1 : index
} do { } do {
^bb0(%arg2 : index): ^bb0(%arg2 : index):
scf.yield %c2 : index scf.yield %c2 : index
} }
func.return %1 : index func.return %1 : index
} }
// CHECK-LABEL: func @div_bounds_positive // CHECK-LABEL: func @div_bounds_positive
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @div_bounds_positive(%arg0 : index) -> i1 { func.func @div_bounds_positive(%arg0 : index) -> i1 {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%0 = arith.maxsi %arg0, %c2 : index %0 = arith.maxsi %arg0, %c2 : index
%1 = arith.divsi %c4, %0 : index %1 = arith.divsi %c4, %0 : index
%2 = arith.divui %c4, %0 : index %2 = arith.divui %c4, %0 : index
%3 = arith.cmpi sge, %1, %c0 : index %3 = arith.cmpi sge, %1, %c0 : index
%4 = arith.cmpi sle, %1, %c2 : index %4 = arith.cmpi sle, %1, %c2 : index
%5 = arith.cmpi sge, %2, %c0 : index %5 = arith.cmpi sge, %2, %c0 : index
%6 = arith.cmpi sle, %1, %c2 : index %6 = arith.cmpi sle, %1, %c2 : index
%7 = arith.andi %3, %4 : i1 %7 = arith.andi %3, %4 : i1
%8 = arith.andi %7, %5 : i1 %8 = arith.andi %7, %5 : i1
%9 = arith.andi %8, %6 : i1 %9 = arith.andi %8, %6 : i1
func.return %9 : i1 func.return %9 : i1
} }
// CHECK-LABEL: func @div_bounds_negative // CHECK-LABEL: func @div_bounds_negative
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @div_bounds_negative(%arg0 : index) -> i1 { func.func @div_bounds_negative(%arg0 : index) -> i1 {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c_2 = arith.constant -2 : index %c_2 = arith.constant -2 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%0 = arith.minsi %arg0, %c_2 : index %0 = arith.minsi %arg0, %c_2 : index
%1 = arith.divsi %c4, %0 : index %1 = arith.divsi %c4, %0 : index
%2 = arith.divui %c4, %0 : index %2 = arith.divui %c4, %0 : index
%3 = arith.cmpi sle, %1, %c0 : index %3 = arith.cmpi sle, %1, %c0 : index
%4 = arith.cmpi sge, %1, %c_2 : index %4 = arith.cmpi sge, %1, %c_2 : index
%5 = arith.cmpi eq, %2, %c0 : index %5 = arith.cmpi eq, %2, %c0 : index
%7 = arith.andi %3, %4 : i1 %7 = arith.andi %3, %4 : i1
%8 = arith.andi %7, %5 : i1 %8 = arith.andi %7, %5 : i1
func.return %8 : i1 func.return %8 : i1
} }
// CHECK-LABEL: func @div_zero_undefined // CHECK-LABEL: func @div_zero_undefined
// CHECK: %[[ret:.*]] = arith.cmpi ule // CHECK: %[[ret:.*]] = arith.cmpi ule
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @div_zero_undefined(%arg0 : index) -> i1 { func.func @div_zero_undefined(%arg0 : index) -> i1 {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%0 = arith.andi %arg0, %c1 : index %0 = arith.andi %arg0, %c1 : index
%1 = arith.divui %c4, %0 : index %1 = arith.divui %c4, %0 : index
%2 = arith.cmpi ule, %1, %c4 : index %2 = arith.cmpi ule, %1, %c4 : index
func.return %2 : i1 func.return %2 : i1
} }
// CHECK-LABEL: func @ceil_divui // CHECK-LABEL: func @ceil_divui
// CHECK: %[[ret:.*]] = arith.cmpi eq // CHECK: %[[ret:.*]] = arith.cmpi eq
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @ceil_divui(%arg0 : index) -> i1 { func.func @ceil_divui(%arg0 : index) -> i1 {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c3 = arith.constant 3 : index %c3 = arith.constant 3 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%0 = arith.minui %arg0, %c3 : index %0 = arith.minui %arg0, %c3 : index
%1 = arith.maxui %0, %c1 : index %1 = arith.maxui %0, %c1 : index
%2 = arith.ceildivui %1, %c4 : index %2 = arith.ceildivui %1, %c4 : index
%3 = arith.cmpi eq, %2, %c1 : index %3 = arith.cmpi eq, %2, %c1 : index
%4 = arith.maxui %0, %c0 : index %4 = arith.maxui %0, %c0 : index
%5 = arith.ceildivui %4, %c4 : index %5 = arith.ceildivui %4, %c4 : index
%6 = arith.cmpi eq, %5, %c1 : index %6 = arith.cmpi eq, %5, %c1 : index
%7 = arith.andi %3, %6 : i1 %7 = arith.andi %3, %6 : i1
func.return %7 : i1 func.return %7 : i1
} }
// CHECK-LABEL: func @ceil_divsi // CHECK-LABEL: func @ceil_divsi
// CHECK: %[[ret:.*]] = arith.cmpi eq // CHECK: %[[ret:.*]] = arith.cmpi eq
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @ceil_divsi(%arg0 : index) -> i1 { func.func @ceil_divsi(%arg0 : index) -> i1 {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c3 = arith.constant 3 : index %c3 = arith.constant 3 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%c-4 = arith.constant -4 : index %c-4 = arith.constant -4 : index
%0 = arith.minsi %arg0, %c3 : index %0 = arith.minsi %arg0, %c3 : index
%1 = arith.maxsi %0, %c1 : index %1 = arith.maxsi %0, %c1 : index
%2 = arith.ceildivsi %1, %c4 : index %2 = arith.ceildivsi %1, %c4 : index
%3 = arith.cmpi eq, %2, %c1 : index %3 = arith.cmpi eq, %2, %c1 : index
%4 = arith.ceildivsi %1, %c-4 : index %4 = arith.ceildivsi %1, %c-4 : index
%5 = arith.cmpi eq, %4, %c0 : index %5 = arith.cmpi eq, %4, %c0 : index
%6 = arith.andi %3, %5 : i1 %6 = arith.andi %3, %5 : i1
%7 = arith.maxsi %0, %c0 : index %7 = arith.maxsi %0, %c0 : index
%8 = arith.ceildivsi %7, %c4 : index %8 = arith.ceildivsi %7, %c4 : index
%9 = arith.cmpi eq, %8, %c1 : index %9 = arith.cmpi eq, %8, %c1 : index
%10 = arith.andi %6, %9 : i1 %10 = arith.andi %6, %9 : i1
func.return %10 : i1 func.return %10 : i1
} }
// CHECK-LABEL: func @floor_divsi // CHECK-LABEL: func @floor_divsi
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @floor_divsi(%arg0 : index) -> i1 { func.func @floor_divsi(%arg0 : index) -> i1 {
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%c-1 = arith.constant -1 : index %c-1 = arith.constant -1 : index
%c-3 = arith.constant -3 : index %c-3 = arith.constant -3 : index
%c-4 = arith.constant -4 : index %c-4 = arith.constant -4 : index
%0 = arith.minsi %arg0, %c-1 : index %0 = arith.minsi %arg0, %c-1 : index
%1 = arith.maxsi %0, %c-4 : index %1 = arith.maxsi %0, %c-4 : index
%2 = arith.floordivsi %1, %c4 : index %2 = arith.floordivsi %1, %c4 : index
%3 = arith.cmpi eq, %2, %c-1 : index %3 = arith.cmpi eq, %2, %c-1 : index
func.return %3 : i1 func.return %3 : i1
} }
// CHECK-LABEL: func @remui_base // CHECK-LABEL: func @remui_base
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @remui_base(%arg0 : index, %arg1 : index ) -> i1 { func.func @remui_base(%arg0 : index, %arg1 : index ) -> i1 {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%0 = arith.minui %arg1, %c4 : index %0 = arith.minui %arg1, %c4 : index
%1 = arith.maxui %0, %c2 : index %1 = arith.maxui %0, %c2 : index
%2 = arith.remui %arg0, %1 : index %2 = arith.remui %arg0, %1 : index
%3 = arith.cmpi ult, %2, %c4 : index %3 = arith.cmpi ult, %2, %c4 : index
func.return %3 : i1 func.return %3 : i1
} }
// CHECK-LABEL: func @remsi_base // CHECK-LABEL: func @remsi_base
// CHECK: %[[ret:.*]] = arith.cmpi sge // CHECK: %[[ret:.*]] = arith.cmpi sge
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @remsi_base(%arg0 : index, %arg1 : index ) -> i1 { func.func @remsi_base(%arg0 : index, %arg1 : index ) -> i1 {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%c-4 = arith.constant -4 : index %c-4 = arith.constant -4 : index
%true = arith.constant true %true = arith.constant true
%0 = arith.minsi %arg1, %c4 : index %0 = arith.minsi %arg1, %c4 : index
%1 = arith.maxsi %0, %c2 : index %1 = arith.maxsi %0, %c2 : index
%2 = arith.remsi %arg0, %1 : index %2 = arith.remsi %arg0, %1 : index
%3 = arith.cmpi sgt, %2, %c-4 : index %3 = arith.cmpi sgt, %2, %c-4 : index
%4 = arith.cmpi slt, %2, %c4 : index %4 = arith.cmpi slt, %2, %c4 : index
%5 = arith.cmpi sge, %2, %c0 : index %5 = arith.cmpi sge, %2, %c0 : index
%6 = arith.andi %3, %4 : i1 %6 = arith.andi %3, %4 : i1
%7 = arith.andi %5, %6 : i1 %7 = arith.andi %5, %6 : i1
func.return %7 : i1 func.return %7 : i1
} }
// CHECK-LABEL: func @remsi_positive // CHECK-LABEL: func @remsi_positive
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @remsi_positive(%arg0 : index, %arg1 : index ) -> i1 { func.func @remsi_positive(%arg0 : index, %arg1 : index ) -> i1 {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%true = arith.constant true %true = arith.constant true
%0 = arith.minsi %arg1, %c4 : index %0 = arith.minsi %arg1, %c4 : index
%1 = arith.maxsi %0, %c2 : index %1 = arith.maxsi %0, %c2 : index
%2 = arith.maxsi %arg0, %c0 : index %2 = arith.maxsi %arg0, %c0 : index
%3 = arith.remsi %2, %1 : index %3 = arith.remsi %2, %1 : index
%4 = arith.cmpi sge, %3, %c0 : index %4 = arith.cmpi sge, %3, %c0 : index
%5 = arith.cmpi slt, %3, %c4 : index %5 = arith.cmpi slt, %3, %c4 : index
%6 = arith.andi %4, %5 : i1 %6 = arith.andi %4, %5 : i1
func.return %6 : i1 func.return %6 : i1
} }
// CHECK-LABEL: func @remui_restricted // CHECK-LABEL: func @remui_restricted
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @remui_restricted(%arg0 : index) -> i1 { func.func @remui_restricted(%arg0 : index) -> i1 {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c3 = arith.constant 3 : index %c3 = arith.constant 3 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%0 = arith.minui %arg0, %c3 : index %0 = arith.minui %arg0, %c3 : index
%1 = arith.maxui %0, %c2 : index %1 = arith.maxui %0, %c2 : index
%2 = arith.remui %1, %c4 : index %2 = arith.remui %1, %c4 : index
%3 = arith.cmpi ule, %2, %c3 : index %3 = arith.cmpi ule, %2, %c3 : index
%4 = arith.cmpi uge, %2, %c2 : index %4 = arith.cmpi uge, %2, %c2 : index
%5 = arith.andi %3, %4 : i1 %5 = arith.andi %3, %4 : i1
func.return %5 : i1 func.return %5 : i1
} }
// CHECK-LABEL: func @remsi_restricted // CHECK-LABEL: func @remsi_restricted
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @remsi_restricted(%arg0 : index) -> i1 { func.func @remsi_restricted(%arg0 : index) -> i1 {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c3 = arith.constant 3 : index %c3 = arith.constant 3 : index
%c-4 = arith.constant -4 : index %c-4 = arith.constant -4 : index
%0 = arith.minsi %arg0, %c3 : index %0 = arith.minsi %arg0, %c3 : index
%1 = arith.maxsi %0, %c2 : index %1 = arith.maxsi %0, %c2 : index
%2 = arith.remsi %1, %c-4 : index %2 = arith.remsi %1, %c-4 : index
%3 = arith.cmpi ule, %2, %c3 : index %3 = arith.cmpi ule, %2, %c3 : index
%4 = arith.cmpi uge, %2, %c2 : index %4 = arith.cmpi uge, %2, %c2 : index
%5 = arith.andi %3, %4 : i1 %5 = arith.andi %3, %4 : i1
func.return %5 : i1 func.return %5 : i1
} }
// CHECK-LABEL: func @remui_restricted_fails // CHECK-LABEL: func @remui_restricted_fails
// CHECK: %[[ret:.*]] = arith.cmpi ne // CHECK: %[[ret:.*]] = arith.cmpi ne
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @remui_restricted_fails(%arg0 : index) -> i1 { func.func @remui_restricted_fails(%arg0 : index) -> i1 {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c3 = arith.constant 3 : index %c3 = arith.constant 3 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%c5 = arith.constant 5 : index %c5 = arith.constant 5 : index
%0 = arith.minui %arg0, %c5 : index %0 = arith.minui %arg0, %c5 : index
%1 = arith.maxui %0, %c3 : index %1 = arith.maxui %0, %c3 : index
%2 = arith.remui %1, %c4 : index %2 = arith.remui %1, %c4 : index
%3 = arith.cmpi ne, %2, %c2 : index %3 = arith.cmpi ne, %2, %c2 : index
func.return %3 : i1 func.return %3 : i1
} }
// CHECK-LABEL: func @remsi_restricted_fails // CHECK-LABEL: func @remsi_restricted_fails
// CHECK: %[[ret:.*]] = arith.cmpi ne // CHECK: %[[ret:.*]] = arith.cmpi ne
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @remsi_restricted_fails(%arg0 : index) -> i1 { func.func @remsi_restricted_fails(%arg0 : index) -> i1 {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c3 = arith.constant 3 : index %c3 = arith.constant 3 : index
%c5 = arith.constant 5 : index %c5 = arith.constant 5 : index
%c-4 = arith.constant -4 : index %c-4 = arith.constant -4 : index
%0 = arith.minsi %arg0, %c5 : index %0 = arith.minsi %arg0, %c5 : index
%1 = arith.maxsi %0, %c3 : index %1 = arith.maxsi %0, %c3 : index
%2 = arith.remsi %1, %c-4 : index %2 = arith.remsi %1, %c-4 : index
%3 = arith.cmpi ne, %2, %c2 : index %3 = arith.cmpi ne, %2, %c2 : index
func.return %3 : i1 func.return %3 : i1
} }
// CHECK-LABEL: func @andi // CHECK-LABEL: func @andi
// CHECK: %[[ret:.*]] = arith.cmpi ugt // CHECK: %[[ret:.*]] = arith.cmpi ugt
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @andi(%arg0 : index) -> i1 { func.func @andi(%arg0 : index) -> i1 {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c5 = arith.constant 5 : index %c5 = arith.constant 5 : index
%c7 = arith.constant 7 : index %c7 = arith.constant 7 : index
%0 = arith.minsi %arg0, %c5 : index %0 = arith.minsi %arg0, %c5 : index
%1 = arith.maxsi %0, %c2 : index %1 = arith.maxsi %0, %c2 : index
%2 = arith.andi %1, %c7 : index %2 = arith.andi %1, %c7 : index
%3 = arith.cmpi ugt, %2, %c5 : index %3 = arith.cmpi ugt, %2, %c5 : index
%4 = arith.cmpi ule, %2, %c7 : index %4 = arith.cmpi ule, %2, %c7 : index
%5 = arith.andi %3, %4 : i1 %5 = arith.andi %3, %4 : i1
func.return %5 : i1 func.return %5 : i1
} }
// CHECK-LABEL: func @andi_doesnt_make_nonnegative // CHECK-LABEL: func @andi_doesnt_make_nonnegative
// CHECK: %[[ret:.*]] = arith.cmpi sge // CHECK: %[[ret:.*]] = arith.cmpi sge
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @andi_doesnt_make_nonnegative(%arg0 : index) -> i1 { func.func @andi_doesnt_make_nonnegative(%arg0 : index) -> i1 {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%0 = arith.addi %arg0, %c1 : index %0 = arith.addi %arg0, %c1 : index
%1 = arith.andi %arg0, %0 : index %1 = arith.andi %arg0, %0 : index
%2 = arith.cmpi sge, %1, %c0 : index %2 = arith.cmpi sge, %1, %c0 : index
func.return %2 : i1 func.return %2 : i1
} }
// CHECK-LABEL: func @ori // CHECK-LABEL: func @ori
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @ori(%arg0 : i128, %arg1 : i128) -> i1 { func.func @ori(%arg0 : i128, %arg1 : i128) -> i1 {
%c-1 = arith.constant -1 : i128 %c-1 = arith.constant -1 : i128
%c0 = arith.constant 0 : i128 %c0 = arith.constant 0 : i128
%0 = arith.minsi %arg1, %c-1 : i128 %0 = arith.minsi %arg1, %c-1 : i128
%1 = arith.ori %arg0, %0 : i128 %1 = arith.ori %arg0, %0 : i128
%2 = arith.cmpi slt, %1, %c0 : i128 %2 = arith.cmpi slt, %1, %c0 : i128
func.return %2 : i1 func.return %2 : i1
} }
// CHECK-LABEL: func @xori // CHECK-LABEL: func @xori
// CHECK: %[[false:.*]] = arith.constant false // CHECK: %[[false:.*]] = arith.constant false
// CHECK: return %[[false]] // CHECK: return %[[false]]
func.func @xori(%arg0 : i64, %arg1 : i64) -> i1 { func.func @xori(%arg0 : i64, %arg1 : i64) -> i1 {
%c0 = arith.constant 0 : i64 %c0 = arith.constant 0 : i64
%c7 = arith.constant 7 : i64 %c7 = arith.constant 7 : i64
%c15 = arith.constant 15 : i64 %c15 = arith.constant 15 : i64
%true = arith.constant true %true = arith.constant true
%0 = arith.minui %arg0, %c7 : i64 %0 = arith.minui %arg0, %c7 : i64
%1 = arith.minui %arg1, %c15 : i64 %1 = arith.minui %arg1, %c15 : i64
%2 = arith.xori %0, %1 : i64 %2 = arith.xori %0, %1 : i64
%3 = arith.cmpi sle, %2, %c15 : i64 %3 = arith.cmpi sle, %2, %c15 : i64
%4 = arith.xori %3, %true : i1 %4 = arith.xori %3, %true : i1
func.return %4 : i1 func.return %4 : i1
} }
// CHECK-LABEL: func @extui // CHECK-LABEL: func @extui
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @extui(%arg0 : i16) -> i1 { func.func @extui(%arg0 : i16) -> i1 {
%ci16_max = arith.constant 0xffff : i32 %ci16_max = arith.constant 0xffff : i32
%0 = arith.extui %arg0 : i16 to i32 %0 = arith.extui %arg0 : i16 to i32
%1 = arith.cmpi ule, %0, %ci16_max : i32 %1 = arith.cmpi ule, %0, %ci16_max : i32
func.return %1 : i1 func.return %1 : i1
} }
// CHECK-LABEL: func @extsi // CHECK-LABEL: func @extsi
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @extsi(%arg0 : i16) -> i1 { func.func @extsi(%arg0 : i16) -> i1 {
%ci16_smax = arith.constant 0x7fff : i32 %ci16_smax = arith.constant 0x7fff : i32
%ci16_smin = arith.constant 0xffff8000 : i32 %ci16_smin = arith.constant 0xffff8000 : i32
%0 = arith.extsi %arg0 : i16 to i32 %0 = arith.extsi %arg0 : i16 to i32
%1 = arith.cmpi sle, %0, %ci16_smax : i32 %1 = arith.cmpi sle, %0, %ci16_smax : i32
%2 = arith.cmpi sge, %0, %ci16_smin : i32 %2 = arith.cmpi sge, %0, %ci16_smin : i32
%3 = arith.andi %1, %2 : i1 %3 = arith.andi %1, %2 : i1
func.return %3 : i1 func.return %3 : i1
} }
// CHECK-LABEL: func @trunci // CHECK-LABEL: func @trunci
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @trunci(%arg0 : i32) -> i1 { func.func @trunci(%arg0 : i32) -> i1 {
%c-14_i32 = arith.constant -14 : i32 %c-14_i32 = arith.constant -14 : i32
%c-14_i16 = arith.constant -14 : i16 %c-14_i16 = arith.constant -14 : i16
%ci16_smin = arith.constant 0xffff8000 : i32 %ci16_smin = arith.constant 0xffff8000 : i32
%0 = arith.minsi %arg0, %c-14_i32 : i32 %0 = arith.minsi %arg0, %c-14_i32 : i32
%1 = arith.maxsi %0, %ci16_smin : i32 %1 = arith.maxsi %0, %ci16_smin : i32
%2 = arith.trunci %1 : i32 to i16 %2 = arith.trunci %1 : i32 to i16
%3 = arith.cmpi sle, %2, %c-14_i16 : i16 %3 = arith.cmpi sle, %2, %c-14_i16 : i16
%4 = arith.extsi %2 : i16 to i32 %4 = arith.extsi %2 : i16 to i32
%5 = arith.cmpi sle, %4, %c-14_i32 : i32 %5 = arith.cmpi sle, %4, %c-14_i32 : i32
%6 = arith.cmpi sge, %4, %ci16_smin : i32 %6 = arith.cmpi sge, %4, %ci16_smin : i32
%7 = arith.andi %3, %5 : i1 %7 = arith.andi %3, %5 : i1
%8 = arith.andi %7, %6 : i1 %8 = arith.andi %7, %6 : i1
func.return %8 : i1 func.return %8 : i1
} }
// CHECK-LABEL: func @index_cast // CHECK-LABEL: func @index_cast
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @index_cast(%arg0 : index) -> i1 { func.func @index_cast(%arg0 : index) -> i1 {
%ci32_smin = arith.constant 0xffffffff80000000 : i64 %ci32_smin = arith.constant 0xffffffff80000000 : i64
%0 = arith.index_cast %arg0 : index to i32 %0 = arith.index_cast %arg0 : index to i32
%1 = arith.index_cast %0 : i32 to index %1 = arith.index_cast %0 : i32 to index
%2 = arith.index_cast %ci32_smin : i64 to index %2 = arith.index_cast %ci32_smin : i64 to index
%3 = arith.cmpi sge, %1, %2 : index %3 = arith.cmpi sge, %1, %2 : index
func.return %3 : i1 func.return %3 : i1
} }
// CHECK-LABEL: func @shli // CHECK-LABEL: func @shli
// CHECK: %[[ret:.*]] = arith.cmpi sgt // CHECK: %[[ret:.*]] = arith.cmpi sgt
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @shli(%arg0 : i32, %arg1 : i1) -> i1 { func.func @shli(%arg0 : i32, %arg1 : i1) -> i1 {
%c2 = arith.constant 2 : i32 %c2 = arith.constant 2 : i32
%c4 = arith.constant 4 : i32 %c4 = arith.constant 4 : i32
%c8 = arith.constant 8 : i32 %c8 = arith.constant 8 : i32
%c32 = arith.constant 32 : i32 %c32 = arith.constant 32 : i32
%c-1 = arith.constant -1 : i32 %c-1 = arith.constant -1 : i32
%c-16 = arith.constant -16 : i32 %c-16 = arith.constant -16 : i32
%0 = arith.maxsi %arg0, %c-1 : i32 %0 = arith.maxsi %arg0, %c-1 : i32
%1 = arith.minsi %0, %c2 : i32 %1 = arith.minsi %0, %c2 : i32
%2 = arith.select %arg1, %c2, %c4 : i32 %2 = arith.select %arg1, %c2, %c4 : i32
%3 = arith.shli %1, %2 : i32 %3 = arith.shli %1, %2 : i32
%4 = arith.cmpi sge, %3, %c-16 : i32 %4 = arith.cmpi sge, %3, %c-16 : i32
%5 = arith.cmpi sle, %3, %c32 : i32 %5 = arith.cmpi sle, %3, %c32 : i32
%6 = arith.cmpi sgt, %3, %c8 : i32 %6 = arith.cmpi sgt, %3, %c8 : i32
%7 = arith.andi %4, %5 : i1 %7 = arith.andi %4, %5 : i1
%8 = arith.andi %7, %6 : i1 %8 = arith.andi %7, %6 : i1
func.return %8 : i1 func.return %8 : i1
} }
// CHECK-LABEL: func @shrui // CHECK-LABEL: func @shrui
// CHECK: %[[ret:.*]] = arith.cmpi uge // CHECK: %[[ret:.*]] = arith.cmpi uge
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @shrui(%arg0 : i1) -> i1 { func.func @shrui(%arg0 : i1) -> i1 {
%c2 = arith.constant 2 : i32 %c2 = arith.constant 2 : i32
%c4 = arith.constant 4 : i32 %c4 = arith.constant 4 : i32
%c8 = arith.constant 8 : i32 %c8 = arith.constant 8 : i32
%c32 = arith.constant 32 : i32 %c32 = arith.constant 32 : i32
%0 = arith.select %arg0, %c2, %c4 : i32 %0 = arith.select %arg0, %c2, %c4 : i32
%1 = arith.shrui %c32, %0 : i32 %1 = arith.shrui %c32, %0 : i32
%2 = arith.cmpi ule, %1, %c8 : i32 %2 = arith.cmpi ule, %1, %c8 : i32
%3 = arith.cmpi uge, %1, %c2 : i32 %3 = arith.cmpi uge, %1, %c2 : i32
%4 = arith.cmpi uge, %1, %c8 : i32 %4 = arith.cmpi uge, %1, %c8 : i32
%5 = arith.andi %2, %3 : i1 %5 = arith.andi %2, %3 : i1
%6 = arith.andi %5, %4 : i1 %6 = arith.andi %5, %4 : i1
func.return %6 : i1 func.return %6 : i1
} }
// CHECK-LABEL: func @shrsi // CHECK-LABEL: func @shrsi
// CHECK: %[[ret:.*]] = arith.cmpi slt // CHECK: %[[ret:.*]] = arith.cmpi slt
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @shrsi(%arg0 : i32, %arg1 : i1) -> i1 { func.func @shrsi(%arg0 : i32, %arg1 : i1) -> i1 {
%c2 = arith.constant 2 : i32 %c2 = arith.constant 2 : i32
%c4 = arith.constant 4 : i32 %c4 = arith.constant 4 : i32
%c8 = arith.constant 8 : i32 %c8 = arith.constant 8 : i32
%c32 = arith.constant 32 : i32 %c32 = arith.constant 32 : i32
%c-8 = arith.constant -8 : i32 %c-8 = arith.constant -8 : i32
%c-32 = arith.constant -32 : i32 %c-32 = arith.constant -32 : i32
%0 = arith.maxsi %arg0, %c-32 : i32 %0 = arith.maxsi %arg0, %c-32 : i32
%1 = arith.minsi %0, %c32 : i32 %1 = arith.minsi %0, %c32 : i32
%2 = arith.select %arg1, %c2, %c4 : i32 %2 = arith.select %arg1, %c2, %c4 : i32
%3 = arith.shrsi %1, %2 : i32 %3 = arith.shrsi %1, %2 : i32
%4 = arith.cmpi sge, %3, %c-8 : i32 %4 = arith.cmpi sge, %3, %c-8 : i32
%5 = arith.cmpi sle, %3, %c8 : i32 %5 = arith.cmpi sle, %3, %c8 : i32
%6 = arith.cmpi slt, %3, %c2 : i32 %6 = arith.cmpi slt, %3, %c2 : i32
%7 = arith.andi %4, %5 : i1 %7 = arith.andi %4, %5 : i1
%8 = arith.andi %7, %6 : i1 %8 = arith.andi %7, %6 : i1
func.return %8 : i1 func.return %8 : i1
} }
// CHECK-LABEL: func @no_aggressive_eq // CHECK-LABEL: func @no_aggressive_eq
// CHECK: %[[ret:.*]] = arith.cmpi eq // CHECK: %[[ret:.*]] = arith.cmpi eq
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @no_aggressive_eq(%arg0 : index) -> i1 { func.func @no_aggressive_eq(%arg0 : index) -> i1 {
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%0 = arith.andi %arg0, %c1 : index %0 = arith.andi %arg0, %c1 : index
%1 = arith.minui %arg0, %c1 : index %1 = arith.minui %arg0, %c1 : index
%2 = arith.cmpi eq, %0, %1 : index %2 = arith.cmpi eq, %0, %1 : index
func.return %2 : i1 func.return %2 : i1
} }
// CHECK-LABEL: func @select_union // CHECK-LABEL: func @select_union
// CHECK: %[[ret:.*]] = arith.cmpi ne // CHECK: %[[ret:.*]] = arith.cmpi ne
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @select_union(%arg0 : index, %arg1 : i1) -> i1 { func.func @select_union(%arg0 : index, %arg1 : i1) -> i1 {
%c64 = arith.constant 64 : index %c64 = arith.constant 64 : index
%c100 = arith.constant 100 : index %c100 = arith.constant 100 : index
%c128 = arith.constant 128 : index %c128 = arith.constant 128 : index
%c192 = arith.constant 192 : index %c192 = arith.constant 192 : index
%0 = arith.remui %arg0, %c64 : index %0 = arith.remui %arg0, %c64 : index
%1 = arith.addi %0, %c128 : index %1 = arith.addi %0, %c128 : index
%2 = arith.select %arg1, %0, %1 : index %2 = arith.select %arg1, %0, %1 : index
%3 = arith.cmpi slt, %2, %c192 : index %3 = arith.cmpi slt, %2, %c192 : index
%4 = arith.cmpi ne, %c100, %2 : index %4 = arith.cmpi ne, %c100, %2 : index
%5 = arith.andi %3, %4 : i1 %5 = arith.andi %3, %4 : i1
func.return %5 : i1 func.return %5 : i1
} }
// CHECK-LABEL: func @if_union // CHECK-LABEL: func @if_union
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @if_union(%arg0 : index, %arg1 : i1) -> i1 { func.func @if_union(%arg0 : index, %arg1 : i1) -> i1 {
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%c16 = arith.constant 16 : index %c16 = arith.constant 16 : index
%c-1 = arith.constant -1 : index %c-1 = arith.constant -1 : index
%c-4 = arith.constant -4 : index %c-4 = arith.constant -4 : index
%0 = arith.minui %arg0, %c4 : index %0 = arith.minui %arg0, %c4 : index
%1 = scf.if %arg1 -> index { %1 = scf.if %arg1 -> index {
%10 = arith.muli %0, %0 : index %10 = arith.muli %0, %0 : index
scf.yield %10 : index scf.yield %10 : index
} else { } else {
%20 = arith.muli %0, %c-1 : index %20 = arith.muli %0, %c-1 : index
scf.yield %20 : index scf.yield %20 : index
} }
%2 = arith.cmpi sle, %1, %c16 : index %2 = arith.cmpi sle, %1, %c16 : index
%3 = arith.cmpi sge, %1, %c-4 : index %3 = arith.cmpi sge, %1, %c-4 : index
%4 = arith.andi %2, %3 : i1 %4 = arith.andi %2, %3 : i1
func.return %4 : i1 func.return %4 : i1
} }
// CHECK-LABEL: func @branch_union // CHECK-LABEL: func @branch_union
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @branch_union(%arg0 : index, %arg1 : i1) -> i1 { func.func @branch_union(%arg0 : index, %arg1 : i1) -> i1 {
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%c16 = arith.constant 16 : index %c16 = arith.constant 16 : index
%c-1 = arith.constant -1 : index %c-1 = arith.constant -1 : index
%c-4 = arith.constant -4 : index %c-4 = arith.constant -4 : index
%0 = arith.minui %arg0, %c4 : index %0 = arith.minui %arg0, %c4 : index
cf.cond_br %arg1, ^bb1, ^bb2 cf.cond_br %arg1, ^bb1, ^bb2
^bb1 : ^bb1 :
%1 = arith.muli %0, %0 : index %1 = arith.muli %0, %0 : index
cf.br ^bb3(%1 : index) cf.br ^bb3(%1 : index)
^bb2 : ^bb2 :
%2 = arith.muli %0, %c-1 : index %2 = arith.muli %0, %c-1 : index
cf.br ^bb3(%2 : index) cf.br ^bb3(%2 : index)
^bb3(%3 : index) : ^bb3(%3 : index) :
%4 = arith.cmpi sle, %3, %c16 : index %4 = arith.cmpi sle, %3, %c16 : index
%5 = arith.cmpi sge, %3, %c-4 : index %5 = arith.cmpi sge, %3, %c-4 : index
%6 = arith.andi %4, %5 : i1 %6 = arith.andi %4, %5 : i1
func.return %6 : i1 func.return %6 : i1
} }
// CHECK-LABEL: func @loop_bound_not_inferred_with_branch // CHECK-LABEL: func @loop_bound_not_inferred_with_branch
// CHECK-DAG: %[[min:.*]] = arith.cmpi sge // CHECK-DAG: %[[min:.*]] = arith.cmpi sge
// CHECK-DAG: %[[max:.*]] = arith.cmpi slt // CHECK-DAG: %[[max:.*]] = arith.cmpi slt
// CHECK-DAG: %[[ret:.*]] = arith.andi %[[min]], %[[max]] // CHECK-DAG: %[[ret:.*]] = arith.andi %[[min]], %[[max]]
// CHECK: return %[[ret]] // CHECK: return %[[ret]]
func.func @loop_bound_not_inferred_with_branch(%arg0 : index, %arg1 : i1) -> i1 { func.func @loop_bound_not_inferred_with_branch(%arg0 : index, %arg1 : i1) -> i1 {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%0 = arith.minui %arg0, %c4 : index %0 = arith.minui %arg0, %c4 : index
cf.br ^bb2(%c0 : index) cf.br ^bb2(%c0 : index)
^bb1(%1 : index) : ^bb1(%1 : index) :
%2 = arith.addi %1, %c1 : index %2 = arith.addi %1, %c1 : index
cf.br ^bb2(%2 : index) cf.br ^bb2(%2 : index)
^bb2(%3 : index): ^bb2(%3 : index):
%4 = arith.cmpi ult, %3, %c4 : index %4 = arith.cmpi ult, %3, %c4 : index
cf.cond_br %4, ^bb1(%3 : index), ^bb3(%3 : index) cf.cond_br %4, ^bb1(%3 : index), ^bb3(%3 : index)
^bb3(%5 : index) : ^bb3(%5 : index) :
%6 = arith.cmpi sge, %5, %c0 : index %6 = arith.cmpi sge, %5, %c0 : index
%7 = arith.cmpi slt, %5, %c4 : index %7 = arith.cmpi slt, %5, %c4 : index
%8 = arith.andi %6, %7 : i1 %8 = arith.andi %6, %7 : i1
func.return %8 : i1 func.return %8 : i1
} }
// Test fon a bug where the noive implementation of trunctation led to the cast // Test fon a bug where the noive implementation of trunctation led to the cast
// value being set to [0, 0]. // value being set to [0, 0].
// CHECK-LABEL: func.func @truncation_spillover // CHECK-LABEL: func.func @truncation_spillover
// CHECK: %[[unreplaced:.*]] = arith.index_cast // CHECK: %[[unreplaced:.*]] = arith.index_cast
// CHECK: memref.store %[[unreplaced]] // CHECK: memref.store %[[unreplaced]]
func.func @truncation_spillover(%arg0 : memref<?xi32>) -> index { func.func @truncation_spillover(%arg0 : memref<?xi32>) -> index {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c49 = arith.constant 49 : index %c49 = arith.constant 49 : index
%0 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %c0) -> index { %0 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %c0) -> index {
%1 = arith.divsi %arg2, %c49 : index %1 = arith.divsi %arg2, %c49 : index
%2 = arith.index_cast %1 : index to i32 %2 = arith.index_cast %1 : index to i32
memref.store %2, %arg0[%c0] : memref<?xi32> memref.store %2, %arg0[%c0] : memref<?xi32>
%3 = arith.addi %arg2, %arg1 : index %3 = arith.addi %arg2, %arg1 : index
scf.yield %3 : index scf.yield %3 : index
} }
func.return %0 : index func.return %0 : index
} }
// CHECK-LABEL: func.func @trunc_catches_overflow // CHECK-LABEL: func.func @trunc_catches_overflow
// CHECK: %[[sge:.*]] = arith.cmpi sge // CHECK: %[[sge:.*]] = arith.cmpi sge
// CHECK: return %[[sge]] // CHECK: return %[[sge]]
func.func @trunc_catches_overflow(%arg0 : i16) -> i1 { func.func @trunc_catches_overflow(%arg0 : i16) -> i1 {
%c0_i16 = arith.constant 0 : i16 %c0_i16 = arith.constant 0 : i16
%c130_i16 = arith.constant 130 : i16 %c130_i16 = arith.constant 130 : i16
%c0_i8 = arith.constant 0 : i8 %c0_i8 = arith.constant 0 : i8
%0 = arith.maxui %arg0, %c0_i16 : i16 %0 = arith.maxui %arg0, %c0_i16 : i16
%1 = arith.minui %0, %c130_i16 : i16 %1 = arith.minui %0, %c130_i16 : i16
%2 = arith.trunci %1 : i16 to i8 %2 = arith.trunci %1 : i16 to i8
%3 = arith.cmpi sge, %2, %c0_i8 : i8 %3 = arith.cmpi sge, %2, %c0_i8 : i8
%4 = arith.cmpi uge, %2, %c0_i8 : i8 %4 = arith.cmpi uge, %2, %c0_i8 : i8
%5 = arith.andi %3, %4 : i1 %5 = arith.andi %3, %4 : i1
func.return %5 : i1 func.return %5 : i1
} }
// CHECK-LABEL: func.func @trunc_respects_same_high_half // CHECK-LABEL: func.func @trunc_respects_same_high_half
// CHECK: %[[false:.*]] = arith.constant false // CHECK: %[[false:.*]] = arith.constant false
// CHECK: return %[[false]] // CHECK: return %[[false]]
func.func @trunc_respects_same_high_half(%arg0 : i16) -> i1 { func.func @trunc_respects_same_high_half(%arg0 : i16) -> i1 {
%c256_i16 = arith.constant 256 : i16 %c256_i16 = arith.constant 256 : i16
%c257_i16 = arith.constant 257 : i16 %c257_i16 = arith.constant 257 : i16
%c2_i8 = arith.constant 2 : i8 %c2_i8 = arith.constant 2 : i8
%0 = arith.maxui %arg0, %c256_i16 : i16 %0 = arith.maxui %arg0, %c256_i16 : i16
%1 = arith.minui %0, %c257_i16 : i16 %1 = arith.minui %0, %c257_i16 : i16
%2 = arith.trunci %1 : i16 to i8 %2 = arith.trunci %1 : i16 to i8
%3 = arith.cmpi sge, %2, %c2_i8 : i8 %3 = arith.cmpi sge, %2, %c2_i8 : i8
func.return %3 : i1 func.return %3 : i1
} }
// CHECK-LABEL: func.func @trunc_handles_small_signed_ranges // CHECK-LABEL: func.func @trunc_handles_small_signed_ranges
// CHECK: %[[true:.*]] = arith.constant true // CHECK: %[[true:.*]] = arith.constant true
// CHECK: return %[[true]] // CHECK: return %[[true]]
func.func @trunc_handles_small_signed_ranges(%arg0 : i16) -> i1 { func.func @trunc_handles_small_signed_ranges(%arg0 : i16) -> i1 {
%c-2_i16 = arith.constant -2 : i16 %c-2_i16 = arith.constant -2 : i16
%c2_i16 = arith.constant 2 : i16 %c2_i16 = arith.constant 2 : i16
%c-2_i8 = arith.constant -2 : i8 %c-2_i8 = arith.constant -2 : i8
%c2_i8 = arith.constant 2 : i8 %c2_i8 = arith.constant 2 : i8
%0 = arith.maxsi %arg0, %c-2_i16 : i16 %0 = arith.maxsi %arg0, %c-2_i16 : i16
%1 = arith.minsi %0, %c2_i16 : i16 %1 = arith.minsi %0, %c2_i16 : i16
%2 = arith.trunci %1 : i16 to i8 %2 = arith.trunci %1 : i16 to i8
%3 = arith.cmpi sge, %2, %c-2_i8 : i8 %3 = arith.cmpi sge, %2, %c-2_i8 : i8
%4 = arith.cmpi sle, %2, %c2_i8 : i8 %4 = arith.cmpi sle, %2, %c2_i8 : i8
%5 = arith.andi %3, %4 : i1 %5 = arith.andi %3, %4 : i1
func.return %5 : i1 func.return %5 : i1
} }

mlir/test/Dialect/Arith/invalid.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/invalid.mlir.
// RUN: mlir-opt -split-input-file %s -verify-diagnostics // RUN: mlir-opt -split-input-file %s -verify-diagnostics
func.func @test_index_cast_shape_error(%arg0 : tensor<index>) -> tensor<2xi64> { func.func @test_index_cast_shape_error(%arg0 : tensor<index>) -> tensor<2xi64> {
// expected-error @+1 {{'arith.index_cast' op requires the same shape for all operands and results}} // expected-error @+1 {{'arith.index_cast' op requires the same shape for all operands and results}}
%0 = arith.index_cast %arg0 : tensor<index> to tensor<2xi64> %0 = arith.index_cast %arg0 : tensor<index> to tensor<2xi64>
return %0 : tensor<2xi64> return %0 : tensor<2xi64>
} }
// ----- // -----
func.func @test_index_cast_tensor_error(%arg0 : tensor<index>) -> i64 { func.func @test_index_cast_tensor_error(%arg0 : tensor<index>) -> i64 {
// expected-error @+1 {{'arith.index_cast' op requires the same shape for all operands and results}} // expected-error @+1 {{'arith.index_cast' op requires the same shape for all operands and results}}
%0 = arith.index_cast %arg0 : tensor<index> to i64 %0 = arith.index_cast %arg0 : tensor<index> to i64
return %0 : i64 return %0 : i64
} }
// ----- // -----
func.func @non_signless_constant() { func.func @non_signless_constant() {
// expected-error @+1 {{'arith.constant' op integer return type must be signless}} // expected-error @+1 {{'arith.constant' op integer return type must be signless}}
%0 = arith.constant 0 : ui32 %0 = arith.constant 0 : ui32
return return
} }
// ----- // -----
func.func @complex_constant_wrong_attribute_type() { func.func @complex_constant_wrong_attribute_type() {
// expected-error @+1 {{'arith.constant' op failed to verify that all of {value, result} have same type}} // expected-error @+1 {{'arith.constant' op failed to verify that all of {value, result} have same type}}
%0 = "arith.constant" () {value = 1.0 : f32} : () -> complex<f32> %0 = "arith.constant" () {value = 1.0 : f32} : () -> complex<f32>
return return
} }
// ----- // -----
func.func @non_signless_constant() { func.func @non_signless_constant() {
// expected-error @+1 {{'arith.constant' op integer return type must be signless}} // expected-error @+1 {{'arith.constant' op integer return type must be signless}}
%0 = arith.constant 0 : si32 %0 = arith.constant 0 : si32
return return
} }
// ----- // -----
func.func @bitcast_different_bit_widths(%arg : f16) -> f32 { func.func @bitcast_different_bit_widths(%arg : f16) -> f32 {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%res = arith.bitcast %arg : f16 to f32 %res = arith.bitcast %arg : f16 to f32
return %res : f32 return %res : f32
} }
// ----- // -----
func.func @constant() { func.func @constant() {
^bb: ^bb:
%x = "arith.constant"(){value = "xyz"} : () -> i32 // expected-error {{'arith.constant' op failed to verify that all of {value, result} have same type}} %x = "arith.constant"(){value = "xyz"} : () -> i32 // expected-error {{'arith.constant' op failed to verify that all of {value, result} have same type}}
return return
} }
// ----- // -----
func.func @constant_out_of_range() { func.func @constant_out_of_range() {
^bb: ^bb:
%x = "arith.constant"(){value = 100} : () -> i1 // expected-error {{'arith.constant' op failed to verify that all of {value, result} have same type}} %x = "arith.constant"(){value = 100} : () -> i1 // expected-error {{'arith.constant' op failed to verify that all of {value, result} have same type}}
return return
} }
// ----- // -----
func.func @constant_wrong_type() { func.func @constant_wrong_type() {
^bb: ^bb:
%x = "arith.constant"(){value = 10.} : () -> f32 // expected-error {{'arith.constant' op failed to verify that all of {value, result} have same type}} %x = "arith.constant"(){value = 10.} : () -> f32 // expected-error {{'arith.constant' op failed to verify that all of {value, result} have same type}}
return return
} }
// ----- // -----
func.func @intlimit2() { func.func @intlimit2() {
^bb: ^bb:
%0 = "arith.constant"() {value = 0} : () -> i16777215 %0 = "arith.constant"() {value = 0} : () -> i16777215
%1 = "arith.constant"() {value = 1} : () -> i16777216 // expected-error {{integer bitwidth is limited to 16777215 bits}} %1 = "arith.constant"() {value = 1} : () -> i16777216 // expected-error {{integer bitwidth is limited to 16777215 bits}}
return return
} }
// ----- // -----
func.func @func_with_ops(f32) { func.func @func_with_ops(f32) {
^bb0(%a : f32): ^bb0(%a : f32):
%sf = arith.addf %a, %a, %a : f32 // expected-error {{expected ':'}} %sf = arith.addf %a, %a, %a : f32 // expected-error {{expected ':'}}
} }
// ----- // -----
func.func @func_with_ops(f32) { func.func @func_with_ops(f32) {
^bb0(%a : f32): ^bb0(%a : f32):
%sf = arith.addf(%a, %a) : f32 // expected-error {{expected SSA operand}} %sf = arith.addf(%a, %a) : f32 // expected-error {{expected SSA operand}}
} }
// ----- // -----
func.func @func_with_ops(f32) { func.func @func_with_ops(f32) {
^bb0(%a : f32): ^bb0(%a : f32):
%sf = arith.addf{%a, %a} : f32 // expected-error {{expected SSA operand}} %sf = arith.addf{%a, %a} : f32 // expected-error {{expected SSA operand}}
} }
// ----- // -----
func.func @func_with_ops(f32) { func.func @func_with_ops(f32) {
^bb0(%a : f32): ^bb0(%a : f32):
// expected-error@+1 {{'arith.addi' op operand #0 must be signless-integer-like}} // expected-error@+1 {{'arith.addi' op operand #0 must be signless-integer-like}}
%sf = arith.addi %a, %a : f32 %sf = arith.addi %a, %a : f32
} }
// ----- // -----
func.func @func_with_ops(%a: f32) { func.func @func_with_ops(%a: f32) {
// expected-error@+1 {{'arith.addui_carry' op operand #0 must be signless-integer-like}} // expected-error@+1 {{'arith.addui_carry' op operand #0 must be signless-integer-like}}
%r:2 = arith.addui_carry %a, %a : f32, i32 %r:2 = arith.addui_carry %a, %a : f32, i32
return return
} }
// ----- // -----
func.func @func_with_ops(%a: i32) { func.func @func_with_ops(%a: i32) {
// expected-error@+1 {{'arith.addui_carry' op result #1 must be bool-like}} // expected-error@+1 {{'arith.addui_carry' op result #1 must be bool-like}}
%r:2 = arith.addui_carry %a, %a : i32, i32 %r:2 = arith.addui_carry %a, %a : i32, i32
return return
} }
// ----- // -----
func.func @func_with_ops(%a: vector<8xi32>) { func.func @func_with_ops(%a: vector<8xi32>) {
// expected-error@+1 {{'arith.addui_carry' op if an operand is non-scalar, then all results must be non-scalar}} // expected-error@+1 {{'arith.addui_carry' op if an operand is non-scalar, then all results must be non-scalar}}
%r:2 = arith.addui_carry %a, %a : vector<8xi32>, i1 %r:2 = arith.addui_carry %a, %a : vector<8xi32>, i1
return return
} }
// ----- // -----
func.func @func_with_ops(%a: vector<8xi32>) { func.func @func_with_ops(%a: vector<8xi32>) {
// expected-error@+1 {{'arith.addui_carry' op all non-scalar operands/results must have the same shape and base type}} // expected-error@+1 {{'arith.addui_carry' op all non-scalar operands/results must have the same shape and base type}}
%r:2 = arith.addui_carry %a, %a : vector<8xi32>, tensor<8xi1> %r:2 = arith.addui_carry %a, %a : vector<8xi32>, tensor<8xi1>
return return
} }
// ----- // -----
func.func @func_with_ops(i32) { func.func @func_with_ops(i32) {
^bb0(%a : i32): ^bb0(%a : i32):
%sf = arith.addf %a, %a : i32 // expected-error {{'arith.addf' op operand #0 must be floating-point-like}} %sf = arith.addf %a, %a : i32 // expected-error {{'arith.addf' op operand #0 must be floating-point-like}}
} }
// ----- // -----
func.func @func_with_ops(i32) { func.func @func_with_ops(i32) {
^bb0(%a : i32): ^bb0(%a : i32):
// expected-error@+1 {{failed to satisfy constraint: allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}} // expected-error@+1 {{failed to satisfy constraint: allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}}
%r = "arith.cmpi"(%a, %a) {predicate = 42} : (i32, i32) -> i1 %r = "arith.cmpi"(%a, %a) {predicate = 42} : (i32, i32) -> i1
} }
// ----- // -----
// Comparison are defined for arguments of the same type. // Comparison are defined for arguments of the same type.
func.func @func_with_ops(i32, i64) { func.func @func_with_ops(i32, i64) {
^bb0(%a : i32, %b : i64): // expected-note {{prior use here}} ^bb0(%a : i32, %b : i64): // expected-note {{prior use here}}
%r = arith.cmpi eq, %a, %b : i32 // expected-error {{use of value '%b' expects different type than prior uses}} %r = arith.cmpi eq, %a, %b : i32 // expected-error {{use of value '%b' expects different type than prior uses}}
} }
// ----- // -----
// Comparisons must have the "predicate" attribute. // Comparisons must have the "predicate" attribute.
func.func @func_with_ops(i32, i32) { func.func @func_with_ops(i32, i32) {
^bb0(%a : i32, %b : i32): ^bb0(%a : i32, %b : i32):
%r = arith.cmpi %a, %b : i32 // expected-error {{expected string or keyword containing one of the following enum values}} %r = arith.cmpi %a, %b : i32 // expected-error {{expected string or keyword containing one of the following enum values}}
} }
// ----- // -----
// Integer comparisons are not recognized for float types. // Integer comparisons are not recognized for float types.
func.func @func_with_ops(f32, f32) { func.func @func_with_ops(f32, f32) {
^bb0(%a : f32, %b : f32): ^bb0(%a : f32, %b : f32):
%r = arith.cmpi eq, %a, %b : f32 // expected-error {{'lhs' must be signless-integer-like, but got 'f32'}} %r = arith.cmpi eq, %a, %b : f32 // expected-error {{'lhs' must be signless-integer-like, but got 'f32'}}
} }
// ----- // -----
// Result type must be boolean like. // Result type must be boolean like.
func.func @func_with_ops(i32, i32) { func.func @func_with_ops(i32, i32) {
^bb0(%a : i32, %b : i32): ^bb0(%a : i32, %b : i32):
%r = "arith.cmpi"(%a, %b) {predicate = 0} : (i32, i32) -> i32 // expected-error {{op result #0 must be bool-like}} %r = "arith.cmpi"(%a, %b) {predicate = 0} : (i32, i32) -> i32 // expected-error {{op result #0 must be bool-like}}
} }
// ----- // -----
func.func @func_with_ops(i32, i32) { func.func @func_with_ops(i32, i32) {
^bb0(%a : i32, %b : i32): ^bb0(%a : i32, %b : i32):
// expected-error@+1 {{requires attribute 'predicate'}} // expected-error@+1 {{requires attribute 'predicate'}}
%r = "arith.cmpi"(%a, %b) {foo = 1} : (i32, i32) -> i1 %r = "arith.cmpi"(%a, %b) {foo = 1} : (i32, i32) -> i1
} }
// ----- // -----
func.func @func_with_ops() { func.func @func_with_ops() {
^bb0: ^bb0:
%c = arith.constant dense<0> : vector<42 x i32> %c = arith.constant dense<0> : vector<42 x i32>
// expected-error@+1 {{op failed to verify that result type has i1 element type and same shape as operands}} // expected-error@+1 {{op failed to verify that result type has i1 element type and same shape as operands}}
%r = "arith.cmpi"(%c, %c) {predicate = 0} : (vector<42 x i32>, vector<42 x i32>) -> vector<41 x i1> %r = "arith.cmpi"(%c, %c) {predicate = 0} : (vector<42 x i32>, vector<42 x i32>) -> vector<41 x i1>
} }
// ----- // -----
func.func @invalid_cmp_shape(%idx : () -> ()) { func.func @invalid_cmp_shape(%idx : () -> ()) {
// expected-error@+1 {{'lhs' must be signless-integer-like, but got '() -> ()'}} // expected-error@+1 {{'lhs' must be signless-integer-like, but got '() -> ()'}}
%cmp = arith.cmpi eq, %idx, %idx : () -> () %cmp = arith.cmpi eq, %idx, %idx : () -> ()
// ----- // -----
func.func @invalid_cmp_attr(%idx : i32) { func.func @invalid_cmp_attr(%idx : i32) {
// expected-error@+1 {{expected string or keyword containing one of the following enum values}} // expected-error@+1 {{expected string or keyword containing one of the following enum values}}
%cmp = arith.cmpi i1, %idx, %idx : i32 %cmp = arith.cmpi i1, %idx, %idx : i32
// ----- // -----
func.func @cmpf_generic_invalid_predicate_value(%a : f32) { func.func @cmpf_generic_invalid_predicate_value(%a : f32) {
// expected-error@+1 {{attribute 'predicate' failed to satisfy constraint: allowed 64-bit signless integer cases}} // expected-error@+1 {{attribute 'predicate' failed to satisfy constraint: allowed 64-bit signless integer cases}}
%r = "arith.cmpf"(%a, %a) {predicate = 42} : (f32, f32) -> i1 %r = "arith.cmpf"(%a, %a) {predicate = 42} : (f32, f32) -> i1
} }
// ----- // -----
func.func @cmpf_canonical_invalid_predicate_value(%a : f32) { func.func @cmpf_canonical_invalid_predicate_value(%a : f32) {
// expected-error@+1 {{expected string or keyword containing one of the following enum values}} // expected-error@+1 {{expected string or keyword containing one of the following enum values}}
%r = arith.cmpf foo, %a, %a : f32 %r = arith.cmpf foo, %a, %a : f32
} }
// ----- // -----
func.func @cmpf_canonical_invalid_predicate_value_signed(%a : f32) { func.func @cmpf_canonical_invalid_predicate_value_signed(%a : f32) {
// expected-error@+1 {{expected string or keyword containing one of the following enum values}} // expected-error@+1 {{expected string or keyword containing one of the following enum values}}
%r = arith.cmpf sge, %a, %a : f32 %r = arith.cmpf sge, %a, %a : f32
} }
// ----- // -----
func.func @cmpf_canonical_invalid_predicate_value_no_order(%a : f32) { func.func @cmpf_canonical_invalid_predicate_value_no_order(%a : f32) {
// expected-error@+1 {{expected string or keyword containing one of the following enum values}} // expected-error@+1 {{expected string or keyword containing one of the following enum values}}
%r = arith.cmpf eq, %a, %a : f32 %r = arith.cmpf eq, %a, %a : f32
} }
// ----- // -----
func.func @cmpf_canonical_no_predicate_attr(%a : f32, %b : f32) { func.func @cmpf_canonical_no_predicate_attr(%a : f32, %b : f32) {
%r = arith.cmpf %a, %b : f32 // expected-error {{}} %r = arith.cmpf %a, %b : f32 // expected-error {{}}
} }
// ----- // -----
func.func @cmpf_generic_no_predicate_attr(%a : f32, %b : f32) { func.func @cmpf_generic_no_predicate_attr(%a : f32, %b : f32) {
// expected-error@+1 {{requires attribute 'predicate'}} // expected-error@+1 {{requires attribute 'predicate'}}
%r = "arith.cmpf"(%a, %b) {foo = 1} : (f32, f32) -> i1 %r = "arith.cmpf"(%a, %b) {foo = 1} : (f32, f32) -> i1
} }
// ----- // -----
func.func @cmpf_wrong_type(%a : i32, %b : i32) { func.func @cmpf_wrong_type(%a : i32, %b : i32) {
%r = arith.cmpf oeq, %a, %b : i32 // expected-error {{must be floating-point-like}} %r = arith.cmpf oeq, %a, %b : i32 // expected-error {{must be floating-point-like}}
} }
// ----- // -----
func.func @cmpf_generic_wrong_result_type(%a : f32, %b : f32) { func.func @cmpf_generic_wrong_result_type(%a : f32, %b : f32) {
// expected-error@+1 {{result #0 must be bool-like}} // expected-error@+1 {{result #0 must be bool-like}}
%r = "arith.cmpf"(%a, %b) {predicate = 0} : (f32, f32) -> f32 %r = "arith.cmpf"(%a, %b) {predicate = 0} : (f32, f32) -> f32
} }
// ----- // -----
func.func @cmpf_canonical_wrong_result_type(%a : f32, %b : f32) -> f32 { func.func @cmpf_canonical_wrong_result_type(%a : f32, %b : f32) -> f32 {
%r = arith.cmpf oeq, %a, %b : f32 // expected-note {{prior use here}} %r = arith.cmpf oeq, %a, %b : f32 // expected-note {{prior use here}}
// expected-error@+1 {{use of value '%r' expects different type than prior uses}} // expected-error@+1 {{use of value '%r' expects different type than prior uses}}
return %r : f32 return %r : f32
} }
// ----- // -----
func.func @cmpf_result_shape_mismatch(%a : vector<42xf32>) { func.func @cmpf_result_shape_mismatch(%a : vector<42xf32>) {
// expected-error@+1 {{op failed to verify that result type has i1 element type and same shape as operands}} // expected-error@+1 {{op failed to verify that result type has i1 element type and same shape as operands}}
%r = "arith.cmpf"(%a, %a) {predicate = 0} : (vector<42 x f32>, vector<42 x f32>) -> vector<41 x i1> %r = "arith.cmpf"(%a, %a) {predicate = 0} : (vector<42 x f32>, vector<42 x f32>) -> vector<41 x i1>
} }
// ----- // -----
func.func @cmpf_operand_shape_mismatch(%a : vector<42xf32>, %b : vector<41xf32>) { func.func @cmpf_operand_shape_mismatch(%a : vector<42xf32>, %b : vector<41xf32>) {
// expected-error@+1 {{op requires all operands to have the same type}} // expected-error@+1 {{op requires all operands to have the same type}}
%r = "arith.cmpf"(%a, %b) {predicate = 0} : (vector<42 x f32>, vector<41 x f32>) -> vector<42 x i1> %r = "arith.cmpf"(%a, %b) {predicate = 0} : (vector<42 x f32>, vector<41 x f32>) -> vector<42 x i1>
} }
// ----- // -----
func.func @cmpf_generic_operand_type_mismatch(%a : f32, %b : f64) { func.func @cmpf_generic_operand_type_mismatch(%a : f32, %b : f64) {
// expected-error@+1 {{op requires all operands to have the same type}} // expected-error@+1 {{op requires all operands to have the same type}}
%r = "arith.cmpf"(%a, %b) {predicate = 0} : (f32, f64) -> i1 %r = "arith.cmpf"(%a, %b) {predicate = 0} : (f32, f64) -> i1
} }
// ----- // -----
func.func @cmpf_canonical_type_mismatch(%a : f32, %b : f64) { // expected-note {{prior use here}} func.func @cmpf_canonical_type_mismatch(%a : f32, %b : f64) { // expected-note {{prior use here}}
// expected-error@+1 {{use of value '%b' expects different type than prior uses}} // expected-error@+1 {{use of value '%b' expects different type than prior uses}}
%r = arith.cmpf oeq, %a, %b : f32 %r = arith.cmpf oeq, %a, %b : f32
} }
// ----- // -----
func.func @index_cast_index_to_index(%arg0: index) { func.func @index_cast_index_to_index(%arg0: index) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.index_cast %arg0: index to index %0 = arith.index_cast %arg0: index to index
return return
} }
// ----- // -----
func.func @index_cast_float(%arg0: index, %arg1: f32) { func.func @index_cast_float(%arg0: index, %arg1: f32) {
// expected-error@+1 {{op result #0 must be signless-integer-like or memref of signless-integer, but got 'f32'}} // expected-error@+1 {{op result #0 must be signless-integer-like or memref of signless-integer, but got 'f32'}}
%0 = arith.index_cast %arg0 : index to f32 %0 = arith.index_cast %arg0 : index to f32
return return
} }
// ----- // -----
func.func @index_cast_float_to_index(%arg0: f32) { func.func @index_cast_float_to_index(%arg0: f32) {
// expected-error@+1 {{op operand #0 must be signless-integer-like or memref of signless-integer, but got 'f32'}} // expected-error@+1 {{op operand #0 must be signless-integer-like or memref of signless-integer, but got 'f32'}}
%0 = arith.index_cast %arg0 : f32 to index %0 = arith.index_cast %arg0 : f32 to index
return return
} }
// ----- // -----
func.func @sitofp_i32_to_i64(%arg0 : i32) { func.func @sitofp_i32_to_i64(%arg0 : i32) {
// expected-error@+1 {{op result #0 must be floating-point-like, but got 'i64'}} // expected-error@+1 {{op result #0 must be floating-point-like, but got 'i64'}}
%0 = arith.sitofp %arg0 : i32 to i64 %0 = arith.sitofp %arg0 : i32 to i64
return return
} }
// ----- // -----
func.func @sitofp_f32_to_i32(%arg0 : f32) { func.func @sitofp_f32_to_i32(%arg0 : f32) {
// expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'f32'}} // expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'f32'}}
%0 = arith.sitofp %arg0 : f32 to i32 %0 = arith.sitofp %arg0 : f32 to i32
return return
} }
// ----- // -----
func.func @fpext_f32_to_f16(%arg0 : f32) { func.func @fpext_f32_to_f16(%arg0 : f32) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.extf %arg0 : f32 to f16 %0 = arith.extf %arg0 : f32 to f16
return return
} }
// ----- // -----
func.func @fpext_f16_to_f16(%arg0 : f16) { func.func @fpext_f16_to_f16(%arg0 : f16) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.extf %arg0 : f16 to f16 %0 = arith.extf %arg0 : f16 to f16
return return
} }
// ----- // -----
func.func @fpext_i32_to_f32(%arg0 : i32) { func.func @fpext_i32_to_f32(%arg0 : i32) {
// expected-error@+1 {{op operand #0 must be floating-point-like, but got 'i32'}} // expected-error@+1 {{op operand #0 must be floating-point-like, but got 'i32'}}
%0 = arith.extf %arg0 : i32 to f32 %0 = arith.extf %arg0 : i32 to f32
return return
} }
// ----- // -----
func.func @fpext_f32_to_i32(%arg0 : f32) { func.func @fpext_f32_to_i32(%arg0 : f32) {
// expected-error@+1 {{op result #0 must be floating-point-like, but got 'i32'}} // expected-error@+1 {{op result #0 must be floating-point-like, but got 'i32'}}
%0 = arith.extf %arg0 : f32 to i32 %0 = arith.extf %arg0 : f32 to i32
return return
} }
// ----- // -----
func.func @fpext_vec(%arg0 : vector<2xf16>) { func.func @fpext_vec(%arg0 : vector<2xf16>) {
// expected-error@+1 {{op requires the same shape for all operands and results}} // expected-error@+1 {{op requires the same shape for all operands and results}}
%0 = arith.extf %arg0 : vector<2xf16> to vector<3xf32> %0 = arith.extf %arg0 : vector<2xf16> to vector<3xf32>
return return
} }
// ----- // -----
func.func @fpext_vec_f32_to_f16(%arg0 : vector<2xf32>) { func.func @fpext_vec_f32_to_f16(%arg0 : vector<2xf32>) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.extf %arg0 : vector<2xf32> to vector<2xf16> %0 = arith.extf %arg0 : vector<2xf32> to vector<2xf16>
return return
} }
// ----- // -----
func.func @fpext_vec_f16_to_f16(%arg0 : vector<2xf16>) { func.func @fpext_vec_f16_to_f16(%arg0 : vector<2xf16>) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.extf %arg0 : vector<2xf16> to vector<2xf16> %0 = arith.extf %arg0 : vector<2xf16> to vector<2xf16>
return return
} }
// ----- // -----
func.func @fpext_vec_i32_to_f32(%arg0 : vector<2xi32>) { func.func @fpext_vec_i32_to_f32(%arg0 : vector<2xi32>) {
// expected-error@+1 {{op operand #0 must be floating-point-like, but got 'vector<2xi32>'}} // expected-error@+1 {{op operand #0 must be floating-point-like, but got 'vector<2xi32>'}}
%0 = arith.extf %arg0 : vector<2xi32> to vector<2xf32> %0 = arith.extf %arg0 : vector<2xi32> to vector<2xf32>
return return
} }
// ----- // -----
func.func @fpext_vec_f32_to_i32(%arg0 : vector<2xf32>) { func.func @fpext_vec_f32_to_i32(%arg0 : vector<2xf32>) {
// expected-error@+1 {{op result #0 must be floating-point-like, but got 'vector<2xi32>'}} // expected-error@+1 {{op result #0 must be floating-point-like, but got 'vector<2xi32>'}}
%0 = arith.extf %arg0 : vector<2xf32> to vector<2xi32> %0 = arith.extf %arg0 : vector<2xf32> to vector<2xi32>
return return
} }
// ----- // -----
func.func @fptrunc_f16_to_f32(%arg0 : f16) { func.func @fptrunc_f16_to_f32(%arg0 : f16) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.truncf %arg0 : f16 to f32 %0 = arith.truncf %arg0 : f16 to f32
return return
} }
// ----- // -----
func.func @fptrunc_f32_to_f32(%arg0 : f32) { func.func @fptrunc_f32_to_f32(%arg0 : f32) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.truncf %arg0 : f32 to f32 %0 = arith.truncf %arg0 : f32 to f32
return return
} }
// ----- // -----
func.func @fptrunc_i32_to_f32(%arg0 : i32) { func.func @fptrunc_i32_to_f32(%arg0 : i32) {
// expected-error@+1 {{op operand #0 must be floating-point-like, but got 'i32'}} // expected-error@+1 {{op operand #0 must be floating-point-like, but got 'i32'}}
%0 = arith.truncf %arg0 : i32 to f32 %0 = arith.truncf %arg0 : i32 to f32
return return
} }
// ----- // -----
func.func @fptrunc_f32_to_i32(%arg0 : f32) { func.func @fptrunc_f32_to_i32(%arg0 : f32) {
// expected-error@+1 {{op result #0 must be floating-point-like, but got 'i32'}} // expected-error@+1 {{op result #0 must be floating-point-like, but got 'i32'}}
%0 = arith.truncf %arg0 : f32 to i32 %0 = arith.truncf %arg0 : f32 to i32
return return
} }
// ----- // -----
func.func @fptrunc_vec(%arg0 : vector<2xf16>) { func.func @fptrunc_vec(%arg0 : vector<2xf16>) {
// expected-error@+1 {{op requires the same shape for all operands and results}} // expected-error@+1 {{op requires the same shape for all operands and results}}
%0 = arith.truncf %arg0 : vector<2xf16> to vector<3xf32> %0 = arith.truncf %arg0 : vector<2xf16> to vector<3xf32>
return return
} }
// ----- // -----
func.func @fptrunc_vec_f16_to_f32(%arg0 : vector<2xf16>) { func.func @fptrunc_vec_f16_to_f32(%arg0 : vector<2xf16>) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.truncf %arg0 : vector<2xf16> to vector<2xf32> %0 = arith.truncf %arg0 : vector<2xf16> to vector<2xf32>
return return
} }
// ----- // -----
func.func @fptrunc_vec_f32_to_f32(%arg0 : vector<2xf32>) { func.func @fptrunc_vec_f32_to_f32(%arg0 : vector<2xf32>) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.truncf %arg0 : vector<2xf32> to vector<2xf32> %0 = arith.truncf %arg0 : vector<2xf32> to vector<2xf32>
return return
} }
// ----- // -----
func.func @fptrunc_vec_i32_to_f32(%arg0 : vector<2xi32>) { func.func @fptrunc_vec_i32_to_f32(%arg0 : vector<2xi32>) {
// expected-error@+1 {{op operand #0 must be floating-point-like, but got 'vector<2xi32>'}} // expected-error@+1 {{op operand #0 must be floating-point-like, but got 'vector<2xi32>'}}
%0 = arith.truncf %arg0 : vector<2xi32> to vector<2xf32> %0 = arith.truncf %arg0 : vector<2xi32> to vector<2xf32>
return return
} }
// ----- // -----
func.func @fptrunc_vec_f32_to_i32(%arg0 : vector<2xf32>) { func.func @fptrunc_vec_f32_to_i32(%arg0 : vector<2xf32>) {
// expected-error@+1 {{op result #0 must be floating-point-like, but got 'vector<2xi32>'}} // expected-error@+1 {{op result #0 must be floating-point-like, but got 'vector<2xi32>'}}
%0 = arith.truncf %arg0 : vector<2xf32> to vector<2xi32> %0 = arith.truncf %arg0 : vector<2xf32> to vector<2xi32>
return return
} }
// ----- // -----
func.func @sexti_index_as_operand(%arg0 : index) { func.func @sexti_index_as_operand(%arg0 : index) {
// expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'index'}} // expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'index'}}
%0 = arith.extsi %arg0 : index to i128 %0 = arith.extsi %arg0 : index to i128
return return
} }
// ----- // -----
func.func @zexti_index_as_operand(%arg0 : index) { func.func @zexti_index_as_operand(%arg0 : index) {
// expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'index'}} // expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'index'}}
%0 = arith.extui %arg0 : index to i128 %0 = arith.extui %arg0 : index to i128
return return
} }
// ----- // -----
func.func @trunci_index_as_operand(%arg0 : index) { func.func @trunci_index_as_operand(%arg0 : index) {
// expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'index'}} // expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'index'}}
%2 = arith.trunci %arg0 : index to i128 %2 = arith.trunci %arg0 : index to i128
return return
} }
// ----- // -----
func.func @sexti_index_as_result(%arg0 : i1) { func.func @sexti_index_as_result(%arg0 : i1) {
// expected-error@+1 {{op result #0 must be signless-fixed-width-integer-like, but got 'index'}} // expected-error@+1 {{op result #0 must be signless-fixed-width-integer-like, but got 'index'}}
%0 = arith.extsi %arg0 : i1 to index %0 = arith.extsi %arg0 : i1 to index
return return
} }
// ----- // -----
func.func @zexti_index_as_operand(%arg0 : i1) { func.func @zexti_index_as_operand(%arg0 : i1) {
// expected-error@+1 {{op result #0 must be signless-fixed-width-integer-like, but got 'index'}} // expected-error@+1 {{op result #0 must be signless-fixed-width-integer-like, but got 'index'}}
%0 = arith.extui %arg0 : i1 to index %0 = arith.extui %arg0 : i1 to index
return return
} }
// ----- // -----
func.func @trunci_index_as_result(%arg0 : i128) { func.func @trunci_index_as_result(%arg0 : i128) {
// expected-error@+1 {{op result #0 must be signless-fixed-width-integer-like, but got 'index'}} // expected-error@+1 {{op result #0 must be signless-fixed-width-integer-like, but got 'index'}}
%2 = arith.trunci %arg0 : i128 to index %2 = arith.trunci %arg0 : i128 to index
return return
} }
// ----- // -----
func.func @sexti_cast_to_narrower(%arg0 : i16) { func.func @sexti_cast_to_narrower(%arg0 : i16) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.extsi %arg0 : i16 to i15 %0 = arith.extsi %arg0 : i16 to i15
return return
} }
// ----- // -----
func.func @zexti_cast_to_narrower(%arg0 : i16) { func.func @zexti_cast_to_narrower(%arg0 : i16) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.extui %arg0 : i16 to i15 %0 = arith.extui %arg0 : i16 to i15
return return
} }
// ----- // -----
func.func @trunci_cast_to_wider(%arg0 : i16) { func.func @trunci_cast_to_wider(%arg0 : i16) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.trunci %arg0 : i16 to i17 %0 = arith.trunci %arg0 : i16 to i17
return return
} }
// ----- // -----
func.func @sexti_cast_to_same_width(%arg0 : i16) { func.func @sexti_cast_to_same_width(%arg0 : i16) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.extsi %arg0 : i16 to i16 %0 = arith.extsi %arg0 : i16 to i16
return return
} }
// ----- // -----
func.func @zexti_cast_to_same_width(%arg0 : i16) { func.func @zexti_cast_to_same_width(%arg0 : i16) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.extui %arg0 : i16 to i16 %0 = arith.extui %arg0 : i16 to i16
return return
} }
// ----- // -----
func.func @trunci_cast_to_same_width(%arg0 : i16) { func.func @trunci_cast_to_same_width(%arg0 : i16) {
// expected-error@+1 {{are cast incompatible}} // expected-error@+1 {{are cast incompatible}}
%0 = arith.trunci %arg0 : i16 to i16 %0 = arith.trunci %arg0 : i16 to i16
return return
} }
// ----- // -----
func.func @trunci_scalable_to_fl(%arg0 : vector<[4]xi32>) { func.func @trunci_scalable_to_fl(%arg0 : vector<[4]xi32>) {
// expected-error@+1 {{'arith.trunci' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.trunci' op requires the same shape for all operands and results}}
%0 = arith.trunci %arg0 : vector<[4]xi32> to vector<4xi8> %0 = arith.trunci %arg0 : vector<[4]xi32> to vector<4xi8>
return return
} }
// ----- // -----
func.func @truncf_scalable_to_fl(%arg0 : vector<[4]xf64>) { func.func @truncf_scalable_to_fl(%arg0 : vector<[4]xf64>) {
// expected-error@+1 {{'arith.truncf' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.truncf' op requires the same shape for all operands and results}}
%0 = arith.truncf %arg0 : vector<[4]xf64> to vector<4xf32> %0 = arith.truncf %arg0 : vector<[4]xf64> to vector<4xf32>
return return
} }
// ----- // -----
func.func @extui_scalable_to_fl(%arg0 : vector<[4]xi32>) { func.func @extui_scalable_to_fl(%arg0 : vector<[4]xi32>) {
// expected-error@+1 {{'arith.extui' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.extui' op requires the same shape for all operands and results}}
%0 = arith.extui %arg0 : vector<[4]xi32> to vector<4xi64> %0 = arith.extui %arg0 : vector<[4]xi32> to vector<4xi64>
return return
} }
// ----- // -----
func.func @extsi_scalable_to_fl(%arg0 : vector<[4]xi32>) { func.func @extsi_scalable_to_fl(%arg0 : vector<[4]xi32>) {
// expected-error@+1 {{'arith.extsi' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.extsi' op requires the same shape for all operands and results}}
%0 = arith.extsi %arg0 : vector<[4]xi32> to vector<4xi64> %0 = arith.extsi %arg0 : vector<[4]xi32> to vector<4xi64>
return return
} }
// ----- // -----
func.func @extf_scalable_to_fl(%arg0 : vector<[4]xf32>) { func.func @extf_scalable_to_fl(%arg0 : vector<[4]xf32>) {
// expected-error@+1 {{'arith.extf' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.extf' op requires the same shape for all operands and results}}
%0 = arith.extf %arg0 : vector<[4]xf32> to vector<4xf64> %0 = arith.extf %arg0 : vector<[4]xf32> to vector<4xf64>
return return
} }
// ----- // -----
func.func @fptoui_scalable_to_fl(%arg0 : vector<[4]xf64>) { func.func @fptoui_scalable_to_fl(%arg0 : vector<[4]xf64>) {
// expected-error@+1 {{'arith.fptoui' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.fptoui' op requires the same shape for all operands and results}}
%0 = arith.fptoui %arg0 : vector<[4]xf64> to vector<4xi32> %0 = arith.fptoui %arg0 : vector<[4]xf64> to vector<4xi32>
return return
} }
// ----- // -----
func.func @fptosi_scalable_to_fl(%arg0 : vector<[4]xf32>) { func.func @fptosi_scalable_to_fl(%arg0 : vector<[4]xf32>) {
// expected-error@+1 {{'arith.fptosi' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.fptosi' op requires the same shape for all operands and results}}
%0 = arith.fptosi %arg0 : vector<[4]xf32> to vector<4xi32> %0 = arith.fptosi %arg0 : vector<[4]xf32> to vector<4xi32>
return return
} }
// ----- // -----
func.func @uitofp_scalable_to_fl(%arg0 : vector<[4]xi32>) { func.func @uitofp_scalable_to_fl(%arg0 : vector<[4]xi32>) {
// expected-error@+1 {{'arith.uitofp' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.uitofp' op requires the same shape for all operands and results}}
%0 = arith.uitofp %arg0 : vector<[4]xi32> to vector<4xf32> %0 = arith.uitofp %arg0 : vector<[4]xi32> to vector<4xf32>
return return
} }
// ----- // -----
func.func @sitofp_scalable_to_fl(%arg0 : vector<[4]xi32>) { func.func @sitofp_scalable_to_fl(%arg0 : vector<[4]xi32>) {
// expected-error@+1 {{'arith.sitofp' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.sitofp' op requires the same shape for all operands and results}}
%0 = arith.sitofp %arg0 : vector<[4]xi32> to vector<4xf32> %0 = arith.sitofp %arg0 : vector<[4]xi32> to vector<4xf32>
return return
} }
// ----- // -----
func.func @bitcast_scalable_to_fl(%arg0 : vector<[4]xf32>) { func.func @bitcast_scalable_to_fl(%arg0 : vector<[4]xf32>) {
// expected-error@+1 {{'arith.bitcast' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.bitcast' op requires the same shape for all operands and results}}
%0 = arith.bitcast %arg0 : vector<[4]xf32> to vector<4xi32> %0 = arith.bitcast %arg0 : vector<[4]xf32> to vector<4xi32>
return return
} }
// ----- // -----
func.func @trunci_fl_to_scalable(%arg0 : vector<4xi32>) { func.func @trunci_fl_to_scalable(%arg0 : vector<4xi32>) {
// expected-error@+1 {{'arith.trunci' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.trunci' op requires the same shape for all operands and results}}
%0 = arith.trunci %arg0 : vector<4xi32> to vector<[4]xi8> %0 = arith.trunci %arg0 : vector<4xi32> to vector<[4]xi8>
return return
} }
// ----- // -----
func.func @truncf_fl_to_scalable(%arg0 : vector<4xf64>) { func.func @truncf_fl_to_scalable(%arg0 : vector<4xf64>) {
// expected-error@+1 {{'arith.truncf' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.truncf' op requires the same shape for all operands and results}}
%0 = arith.truncf %arg0 : vector<4xf64> to vector<[4]xf32> %0 = arith.truncf %arg0 : vector<4xf64> to vector<[4]xf32>
return return
} }
// ----- // -----
func.func @extui_fl_to_scalable(%arg0 : vector<4xi32>) { func.func @extui_fl_to_scalable(%arg0 : vector<4xi32>) {
// expected-error@+1 {{'arith.extui' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.extui' op requires the same shape for all operands and results}}
%0 = arith.extui %arg0 : vector<4xi32> to vector<[4]xi64> %0 = arith.extui %arg0 : vector<4xi32> to vector<[4]xi64>
return return
} }
// ----- // -----
func.func @extsi_fl_to_scalable(%arg0 : vector<4xi32>) { func.func @extsi_fl_to_scalable(%arg0 : vector<4xi32>) {
// expected-error@+1 {{'arith.extsi' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.extsi' op requires the same shape for all operands and results}}
%0 = arith.extsi %arg0 : vector<4xi32> to vector<[4]xi64> %0 = arith.extsi %arg0 : vector<4xi32> to vector<[4]xi64>
return return
} }
// ----- // -----
func.func @extf_fl_to_scalable(%arg0 : vector<4xf32>) { func.func @extf_fl_to_scalable(%arg0 : vector<4xf32>) {
// expected-error@+1 {{'arith.extf' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.extf' op requires the same shape for all operands and results}}
%0 = arith.extf %arg0 : vector<4xf32> to vector<[4]xf64> %0 = arith.extf %arg0 : vector<4xf32> to vector<[4]xf64>
return return
} }
// ----- // -----
func.func @fptoui_fl_to_scalable(%arg0 : vector<4xf64>) { func.func @fptoui_fl_to_scalable(%arg0 : vector<4xf64>) {
// expected-error@+1 {{'arith.fptoui' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.fptoui' op requires the same shape for all operands and results}}
%0 = arith.fptoui %arg0 : vector<4xf64> to vector<[4]xi32> %0 = arith.fptoui %arg0 : vector<4xf64> to vector<[4]xi32>
return return
} }
// ----- // -----
func.func @fptosi_fl_to_scalable(%arg0 : vector<4xf32>) { func.func @fptosi_fl_to_scalable(%arg0 : vector<4xf32>) {
// expected-error@+1 {{'arith.fptosi' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.fptosi' op requires the same shape for all operands and results}}
%0 = arith.fptosi %arg0 : vector<4xf32> to vector<[4]xi32> %0 = arith.fptosi %arg0 : vector<4xf32> to vector<[4]xi32>
return return
} }
// ----- // -----
func.func @uitofp_fl_to_scalable(%arg0 : vector<4xi32>) { func.func @uitofp_fl_to_scalable(%arg0 : vector<4xi32>) {
// expected-error@+1 {{'arith.uitofp' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.uitofp' op requires the same shape for all operands and results}}
%0 = arith.uitofp %arg0 : vector<4xi32> to vector<[4]xf32> %0 = arith.uitofp %arg0 : vector<4xi32> to vector<[4]xf32>
return return
} }
// ----- // -----
func.func @sitofp_fl_to_scalable(%arg0 : vector<4xi32>) { func.func @sitofp_fl_to_scalable(%arg0 : vector<4xi32>) {
// expected-error@+1 {{'arith.sitofp' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.sitofp' op requires the same shape for all operands and results}}
%0 = arith.sitofp %arg0 : vector<4xi32> to vector<[4]xf32> %0 = arith.sitofp %arg0 : vector<4xi32> to vector<[4]xf32>
return return
} }
// ----- // -----
func.func @bitcast_fl_to_scalable(%arg0 : vector<4xf32>) { func.func @bitcast_fl_to_scalable(%arg0 : vector<4xf32>) {
// expected-error@+1 {{'arith.bitcast' op requires the same shape for all operands and results}} // expected-error@+1 {{'arith.bitcast' op requires the same shape for all operands and results}}
%0 = arith.bitcast %arg0 : vector<4xf32> to vector<[4]xi32> %0 = arith.bitcast %arg0 : vector<4xf32> to vector<[4]xi32>
return return
} }
// ----- // -----
func.func @func() { func.func @func() {
%c0 = arith.constant // expected-error {{expected attribute value}} %c0 = arith.constant // expected-error {{expected attribute value}}
%x = arith.constant 1 : i32 %x = arith.constant 1 : i32
} }

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.
// RUN: mlir-opt %s -one-shot-bufferize="must-infer-memory-space" -split-input-file -verify-diagnostics // RUN: mlir-opt %s -one-shot-bufferize="must-infer-memory-space" -split-input-file -verify-diagnostics
func.func @inconsistent_memory_space_arith_select(%c: i1) -> tensor<10xf32> { func.func @inconsistent_memory_space_arith_select(%c: i1) -> tensor<10xf32> {
// Selecting tensors with different memory spaces. Such IR cannot be // Selecting tensors with different memory spaces. Such IR cannot be
// bufferized. // bufferized.
%0 = bufferization.alloc_tensor() {memory_space = 0 : ui64} : tensor<10xf32> %0 = bufferization.alloc_tensor() {memory_space = 0 : ui64} : tensor<10xf32>
%1 = bufferization.alloc_tensor() {memory_space = 1 : ui64} : tensor<10xf32> %1 = bufferization.alloc_tensor() {memory_space = 1 : ui64} : tensor<10xf32>
// expected-error @+2 {{inconsistent memory space on true/false operands}} // expected-error @+2 {{inconsistent memory space on true/false operands}}
// expected-error @+1 {{failed to bufferize op}} // expected-error @+1 {{failed to bufferize op}}
%r = arith.select %c, %0, %1 : tensor<10xf32> %r = arith.select %c, %0, %1 : tensor<10xf32>
func.return %r : tensor<10xf32> func.return %r : tensor<10xf32>
} }
// ----- // -----
func.func @constant_memory_space(%idx: index, %v: i32) -> tensor<3xi32> { func.func @constant_memory_space(%idx: index, %v: i32) -> tensor<3xi32> {
// expected-error @+2 {{memory space not implemented yet}} // expected-error @+2 {{memory space not implemented yet}}
// expected-error @+1 {{failed to bufferize op}} // expected-error @+1 {{failed to bufferize op}}
%cst = arith.constant dense<[5, 1000, 20]> : tensor<3xi32> %cst = arith.constant dense<[5, 1000, 20]> : tensor<3xi32>
%0 = tensor.insert %v into %cst[%idx] : tensor<3xi32> %0 = tensor.insert %v into %cst[%idx] : tensor<3xi32>
return %0 : tensor<3xi32> return %0 : tensor<3xi32>
} }
No newline at end of file No newline at end of file

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

  • This file was moved from mlir/test/Dialect/Arithmetic/one-shot-bufferize.mlir.
// RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs bufferize-function-boundaries" -split-input-file | FileCheck %s // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs bufferize-function-boundaries" -split-input-file | FileCheck %s
// Run fuzzer with different seeds. // Run fuzzer with different seeds.
// RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=23 bufferize-function-boundaries" -split-input-file -o /dev/null // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=23 bufferize-function-boundaries" -split-input-file -o /dev/null
// RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=59 bufferize-function-boundaries" -split-input-file -o /dev/null // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=59 bufferize-function-boundaries" -split-input-file -o /dev/null
// RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=91 bufferize-function-boundaries" -split-input-file -o /dev/null // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=91 bufferize-function-boundaries" -split-input-file -o /dev/null
// Test bufferization using memref types that have no layout map. // Test bufferization using memref types that have no layout map.
// RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs unknown-type-conversion=identity-layout-map function-boundary-type-conversion=identity-layout-map bufferize-function-boundaries" -split-input-file -o /dev/null // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs unknown-type-conversion=identity-layout-map function-boundary-type-conversion=identity-layout-map bufferize-function-boundaries" -split-input-file -o /dev/null
// CHECK-LABEL: func @write_to_select_op_source // CHECK-LABEL: func @write_to_select_op_source
// CHECK-SAME: %[[t1:.*]]: memref<?xf32, strided{{.*}}>, %[[t2:.*]]: memref<?xf32, strided{{.*}}> // CHECK-SAME: %[[t1:.*]]: memref<?xf32, strided{{.*}}>, %[[t2:.*]]: memref<?xf32, strided{{.*}}>
func.func @write_to_select_op_source( func.func @write_to_select_op_source(
%t1 : tensor<?xf32> {bufferization.writable = true}, %t1 : tensor<?xf32> {bufferization.writable = true},
%t2 : tensor<?xf32> {bufferization.writable = true}, %t2 : tensor<?xf32> {bufferization.writable = true},
%c : i1) %c : i1)
-> (tensor<?xf32>, tensor<?xf32>) -> (tensor<?xf32>, tensor<?xf32>)
{ {
%cst = arith.constant 0.0 : f32 %cst = arith.constant 0.0 : f32
%idx = arith.constant 0 : index %idx = arith.constant 0 : index
// CHECK: %[[alloc:.*]] = memref.alloc // CHECK: %[[alloc:.*]] = memref.alloc
// CHECK: memref.copy %[[t1]], %[[alloc]] // CHECK: memref.copy %[[t1]], %[[alloc]]
// CHECK: memref.store %{{.*}}, %[[alloc]] // CHECK: memref.store %{{.*}}, %[[alloc]]
%w = tensor.insert %cst into %t1[%idx] : tensor<?xf32> %w = tensor.insert %cst into %t1[%idx] : tensor<?xf32>
// CHECK: %[[select:.*]] = arith.select %{{.*}}, %[[t1]], %[[t2]] // CHECK: %[[select:.*]] = arith.select %{{.*}}, %[[t1]], %[[t2]]
%s = arith.select %c, %t1, %t2 : tensor<?xf32> %s = arith.select %c, %t1, %t2 : tensor<?xf32>
// CHECK: return %[[select]], %[[alloc]] // CHECK: return %[[select]], %[[alloc]]
return %s, %w : tensor<?xf32>, tensor<?xf32> return %s, %w : tensor<?xf32>, tensor<?xf32>
} }
// ----- // -----
// Due to the out-of-place bufferization of %t1, buffers with different layout // Due to the out-of-place bufferization of %t1, buffers with different layout
// maps are passed to arith.select. A cast must be inserted. // maps are passed to arith.select. A cast must be inserted.
// CHECK-LABEL: func @write_after_select_read_one // CHECK-LABEL: func @write_after_select_read_one
// CHECK-SAME: %[[t1:.*]]: memref<?xf32, strided{{.*}}>, %[[t2:.*]]: memref<?xf32, strided{{.*}}> // CHECK-SAME: %[[t1:.*]]: memref<?xf32, strided{{.*}}>, %[[t2:.*]]: memref<?xf32, strided{{.*}}>
func.func @write_after_select_read_one( func.func @write_after_select_read_one(
%t1 : tensor<?xf32> {bufferization.writable = true}, %t1 : tensor<?xf32> {bufferization.writable = true},
%t2 : tensor<?xf32> {bufferization.writable = true}, %t2 : tensor<?xf32> {bufferization.writable = true},
%c : i1) %c : i1)
-> (f32, tensor<?xf32>) -> (f32, tensor<?xf32>)
{ {
%cst = arith.constant 0.0 : f32 %cst = arith.constant 0.0 : f32
%idx = arith.constant 0 : index %idx = arith.constant 0 : index
// CHECK: %[[alloc:.*]] = memref.alloc // CHECK: %[[alloc:.*]] = memref.alloc
// CHECK-DAG: %[[casted:.*]] = memref.cast %[[alloc]] // CHECK-DAG: %[[casted:.*]] = memref.cast %[[alloc]]
// CHECK-DAG: memref.copy %[[t1]], %[[alloc]] // CHECK-DAG: memref.copy %[[t1]], %[[alloc]]
// CHECK: %[[select:.*]] = arith.select %{{.*}}, %[[casted]], %[[t2]] // CHECK: %[[select:.*]] = arith.select %{{.*}}, %[[casted]], %[[t2]]
%s = arith.select %c, %t1, %t2 : tensor<?xf32> %s = arith.select %c, %t1, %t2 : tensor<?xf32>
// CHECK: memref.store %{{.*}}, %[[select]] // CHECK: memref.store %{{.*}}, %[[select]]
%w = tensor.insert %cst into %s[%idx] : tensor<?xf32> %w = tensor.insert %cst into %s[%idx] : tensor<?xf32>
// CHECK: %[[f:.*]] = memref.load %[[t1]] // CHECK: %[[f:.*]] = memref.load %[[t1]]
%f = tensor.extract %t1[%idx] : tensor<?xf32> %f = tensor.extract %t1[%idx] : tensor<?xf32>
// CHECK: return %[[f]], %[[select]] // CHECK: return %[[f]], %[[select]]
return %f, %w : f32, tensor<?xf32> return %f, %w : f32, tensor<?xf32>
} }

mlir/test/Dialect/Arith/ops.mlir

  • This file was moved from mlir/test/Dialect/Arithmetic/ops.mlir.
// RUN: mlir-opt %s | mlir-opt | FileCheck %s // RUN: mlir-opt %s | mlir-opt | FileCheck %s
// RUN: mlir-opt %s --mlir-print-op-generic | mlir-opt | FileCheck %s // RUN: mlir-opt %s --mlir-print-op-generic | mlir-opt | FileCheck %s
// CHECK-LABEL: test_addi // CHECK-LABEL: test_addi
func.func @test_addi(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_addi(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.addi %arg0, %arg1 : i64 %0 = arith.addi %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_addi_tensor // CHECK-LABEL: test_addi_tensor
func.func @test_addi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_addi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.addi %arg0, %arg1 : tensor<8x8xi64> %0 = arith.addi %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_addi_vector // CHECK-LABEL: test_addi_vector
func.func @test_addi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_addi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.addi %arg0, %arg1 : vector<8xi64> %0 = arith.addi %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_addi_scalable_vector // CHECK-LABEL: test_addi_scalable_vector
func.func @test_addi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_addi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.addi %arg0, %arg1 : vector<[8]xi64> %0 = arith.addi %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_addui_carry // CHECK-LABEL: test_addui_carry
func.func @test_addui_carry(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_addui_carry(%arg0 : i64, %arg1 : i64) -> i64 {
%sum, %carry = arith.addui_carry %arg0, %arg1 : i64, i1 %sum, %carry = arith.addui_carry %arg0, %arg1 : i64, i1
return %sum : i64 return %sum : i64
} }
// CHECK-LABEL: test_addui_carry_tensor // CHECK-LABEL: test_addui_carry_tensor
func.func @test_addui_carry_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_addui_carry_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%sum, %carry = arith.addui_carry %arg0, %arg1 : tensor<8x8xi64>, tensor<8x8xi1> %sum, %carry = arith.addui_carry %arg0, %arg1 : tensor<8x8xi64>, tensor<8x8xi1>
return %sum : tensor<8x8xi64> return %sum : tensor<8x8xi64>
} }
// CHECK-LABEL: test_addui_carry_vector // CHECK-LABEL: test_addui_carry_vector
func.func @test_addui_carry_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_addui_carry_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0:2 = arith.addui_carry %arg0, %arg1 : vector<8xi64>, vector<8xi1> %0:2 = arith.addui_carry %arg0, %arg1 : vector<8xi64>, vector<8xi1>
return %0#0 : vector<8xi64> return %0#0 : vector<8xi64>
} }
// CHECK-LABEL: test_addui_carry_scalable_vector // CHECK-LABEL: test_addui_carry_scalable_vector
func.func @test_addui_carry_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_addui_carry_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0:2 = arith.addui_carry %arg0, %arg1 : vector<[8]xi64>, vector<[8]xi1> %0:2 = arith.addui_carry %arg0, %arg1 : vector<[8]xi64>, vector<[8]xi1>
return %0#0 : vector<[8]xi64> return %0#0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_subi // CHECK-LABEL: test_subi
func.func @test_subi(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_subi(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.subi %arg0, %arg1 : i64 %0 = arith.subi %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_subi_tensor // CHECK-LABEL: test_subi_tensor
func.func @test_subi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_subi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.subi %arg0, %arg1 : tensor<8x8xi64> %0 = arith.subi %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_subi_vector // CHECK-LABEL: test_subi_vector
func.func @test_subi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_subi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.subi %arg0, %arg1 : vector<8xi64> %0 = arith.subi %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_subi_scalable_vector // CHECK-LABEL: test_subi_scalable_vector
func.func @test_subi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_subi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.subi %arg0, %arg1 : vector<[8]xi64> %0 = arith.subi %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_muli // CHECK-LABEL: test_muli
func.func @test_muli(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_muli(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.muli %arg0, %arg1 : i64 %0 = arith.muli %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_muli_tensor // CHECK-LABEL: test_muli_tensor
func.func @test_muli_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_muli_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.muli %arg0, %arg1 : tensor<8x8xi64> %0 = arith.muli %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_muli_vector // CHECK-LABEL: test_muli_vector
func.func @test_muli_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_muli_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.muli %arg0, %arg1 : vector<8xi64> %0 = arith.muli %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_muli_scalable_vector // CHECK-LABEL: test_muli_scalable_vector
func.func @test_muli_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_muli_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.muli %arg0, %arg1 : vector<[8]xi64> %0 = arith.muli %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_divui // CHECK-LABEL: test_divui
func.func @test_divui(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_divui(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.divui %arg0, %arg1 : i64 %0 = arith.divui %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_divui_tensor // CHECK-LABEL: test_divui_tensor
func.func @test_divui_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_divui_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.divui %arg0, %arg1 : tensor<8x8xi64> %0 = arith.divui %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_divui_vector // CHECK-LABEL: test_divui_vector
func.func @test_divui_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_divui_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.divui %arg0, %arg1 : vector<8xi64> %0 = arith.divui %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_divui_scalable_vector // CHECK-LABEL: test_divui_scalable_vector
func.func @test_divui_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_divui_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.divui %arg0, %arg1 : vector<[8]xi64> %0 = arith.divui %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_divsi // CHECK-LABEL: test_divsi
func.func @test_divsi(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_divsi(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.divsi %arg0, %arg1 : i64 %0 = arith.divsi %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_divsi_tensor // CHECK-LABEL: test_divsi_tensor
func.func @test_divsi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_divsi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.divsi %arg0, %arg1 : tensor<8x8xi64> %0 = arith.divsi %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_divsi_vector // CHECK-LABEL: test_divsi_vector
func.func @test_divsi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_divsi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.divsi %arg0, %arg1 : vector<8xi64> %0 = arith.divsi %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_divsi_scalable_vector // CHECK-LABEL: test_divsi_scalable_vector
func.func @test_divsi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_divsi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.divsi %arg0, %arg1 : vector<[8]xi64> %0 = arith.divsi %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_remui // CHECK-LABEL: test_remui
func.func @test_remui(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_remui(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.remui %arg0, %arg1 : i64 %0 = arith.remui %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_remui_tensor // CHECK-LABEL: test_remui_tensor
func.func @test_remui_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_remui_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.remui %arg0, %arg1 : tensor<8x8xi64> %0 = arith.remui %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_remui_vector // CHECK-LABEL: test_remui_vector
func.func @test_remui_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_remui_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.remui %arg0, %arg1 : vector<8xi64> %0 = arith.remui %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_remui_scalable_vector // CHECK-LABEL: test_remui_scalable_vector
func.func @test_remui_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_remui_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.remui %arg0, %arg1 : vector<[8]xi64> %0 = arith.remui %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_remsi // CHECK-LABEL: test_remsi
func.func @test_remsi(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_remsi(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.remsi %arg0, %arg1 : i64 %0 = arith.remsi %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_remsi_tensor // CHECK-LABEL: test_remsi_tensor
func.func @test_remsi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_remsi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.remsi %arg0, %arg1 : tensor<8x8xi64> %0 = arith.remsi %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_remsi_vector // CHECK-LABEL: test_remsi_vector
func.func @test_remsi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_remsi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.remsi %arg0, %arg1 : vector<8xi64> %0 = arith.remsi %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_remsi_scalable_vector // CHECK-LABEL: test_remsi_scalable_vector
func.func @test_remsi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_remsi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.remsi %arg0, %arg1 : vector<[8]xi64> %0 = arith.remsi %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_andi // CHECK-LABEL: test_andi
func.func @test_andi(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_andi(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.andi %arg0, %arg1 : i64 %0 = arith.andi %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_andi_tensor // CHECK-LABEL: test_andi_tensor
func.func @test_andi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_andi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.andi %arg0, %arg1 : tensor<8x8xi64> %0 = arith.andi %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_andi_vector // CHECK-LABEL: test_andi_vector
func.func @test_andi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_andi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.andi %arg0, %arg1 : vector<8xi64> %0 = arith.andi %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_andi_scalable_vector // CHECK-LABEL: test_andi_scalable_vector
func.func @test_andi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_andi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.andi %arg0, %arg1 : vector<[8]xi64> %0 = arith.andi %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_ori // CHECK-LABEL: test_ori
func.func @test_ori(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_ori(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.ori %arg0, %arg1 : i64 %0 = arith.ori %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_ori_tensor // CHECK-LABEL: test_ori_tensor
func.func @test_ori_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_ori_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.ori %arg0, %arg1 : tensor<8x8xi64> %0 = arith.ori %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_ori_vector // CHECK-LABEL: test_ori_vector
func.func @test_ori_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_ori_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.ori %arg0, %arg1 : vector<8xi64> %0 = arith.ori %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_ori_scalable_vector // CHECK-LABEL: test_ori_scalable_vector
func.func @test_ori_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_ori_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.ori %arg0, %arg1 : vector<[8]xi64> %0 = arith.ori %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_xori // CHECK-LABEL: test_xori
func.func @test_xori(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_xori(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.xori %arg0, %arg1 : i64 %0 = arith.xori %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_xori_tensor // CHECK-LABEL: test_xori_tensor
func.func @test_xori_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_xori_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.xori %arg0, %arg1 : tensor<8x8xi64> %0 = arith.xori %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_xori_vector // CHECK-LABEL: test_xori_vector
func.func @test_xori_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_xori_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.xori %arg0, %arg1 : vector<8xi64> %0 = arith.xori %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_xori_scalable_vector // CHECK-LABEL: test_xori_scalable_vector
func.func @test_xori_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_xori_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.xori %arg0, %arg1 : vector<[8]xi64> %0 = arith.xori %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_ceildivsi // CHECK-LABEL: test_ceildivsi
func.func @test_ceildivsi(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_ceildivsi(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.ceildivsi %arg0, %arg1 : i64 %0 = arith.ceildivsi %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_ceildivsi_tensor // CHECK-LABEL: test_ceildivsi_tensor
func.func @test_ceildivsi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_ceildivsi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.ceildivsi %arg0, %arg1 : tensor<8x8xi64> %0 = arith.ceildivsi %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_ceildivsi_vector // CHECK-LABEL: test_ceildivsi_vector
func.func @test_ceildivsi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_ceildivsi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.ceildivsi %arg0, %arg1 : vector<8xi64> %0 = arith.ceildivsi %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_ceildivsi_scalable_vector // CHECK-LABEL: test_ceildivsi_scalable_vector
func.func @test_ceildivsi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_ceildivsi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.ceildivsi %arg0, %arg1 : vector<[8]xi64> %0 = arith.ceildivsi %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_floordivsi // CHECK-LABEL: test_floordivsi
func.func @test_floordivsi(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_floordivsi(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.floordivsi %arg0, %arg1 : i64 %0 = arith.floordivsi %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_floordivsi_tensor // CHECK-LABEL: test_floordivsi_tensor
func.func @test_floordivsi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_floordivsi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.floordivsi %arg0, %arg1 : tensor<8x8xi64> %0 = arith.floordivsi %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_floordivsi_vector // CHECK-LABEL: test_floordivsi_vector
func.func @test_floordivsi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_floordivsi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.floordivsi %arg0, %arg1 : vector<8xi64> %0 = arith.floordivsi %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_floordivsi_scalable_vector // CHECK-LABEL: test_floordivsi_scalable_vector
func.func @test_floordivsi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_floordivsi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.floordivsi %arg0, %arg1 : vector<[8]xi64> %0 = arith.floordivsi %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_shli // CHECK-LABEL: test_shli
func.func @test_shli(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_shli(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.shli %arg0, %arg1 : i64 %0 = arith.shli %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_shli_tensor // CHECK-LABEL: test_shli_tensor
func.func @test_shli_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_shli_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.shli %arg0, %arg1 : tensor<8x8xi64> %0 = arith.shli %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_shli_vector // CHECK-LABEL: test_shli_vector
func.func @test_shli_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_shli_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.shli %arg0, %arg1 : vector<8xi64> %0 = arith.shli %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_shli_scalable_vector // CHECK-LABEL: test_shli_scalable_vector
func.func @test_shli_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_shli_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.shli %arg0, %arg1 : vector<[8]xi64> %0 = arith.shli %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_shrui // CHECK-LABEL: test_shrui
func.func @test_shrui(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_shrui(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.shrui %arg0, %arg1 : i64 %0 = arith.shrui %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_shrui_tensor // CHECK-LABEL: test_shrui_tensor
func.func @test_shrui_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_shrui_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.shrui %arg0, %arg1 : tensor<8x8xi64> %0 = arith.shrui %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_shrui_vector // CHECK-LABEL: test_shrui_vector
func.func @test_shrui_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_shrui_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.shrui %arg0, %arg1 : vector<8xi64> %0 = arith.shrui %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_shrui_scalable_vector // CHECK-LABEL: test_shrui_scalable_vector
func.func @test_shrui_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_shrui_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.shrui %arg0, %arg1 : vector<[8]xi64> %0 = arith.shrui %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_shrsi // CHECK-LABEL: test_shrsi
func.func @test_shrsi(%arg0 : i64, %arg1 : i64) -> i64 { func.func @test_shrsi(%arg0 : i64, %arg1 : i64) -> i64 {
%0 = arith.shrsi %arg0, %arg1 : i64 %0 = arith.shrsi %arg0, %arg1 : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_shrsi_tensor // CHECK-LABEL: test_shrsi_tensor
func.func @test_shrsi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> { func.func @test_shrsi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
%0 = arith.shrsi %arg0, %arg1 : tensor<8x8xi64> %0 = arith.shrsi %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_shrsi_vector // CHECK-LABEL: test_shrsi_vector
func.func @test_shrsi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> { func.func @test_shrsi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
%0 = arith.shrsi %arg0, %arg1 : vector<8xi64> %0 = arith.shrsi %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_shrsi_scalable_vector // CHECK-LABEL: test_shrsi_scalable_vector
func.func @test_shrsi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> { func.func @test_shrsi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi64> {
%0 = arith.shrsi %arg0, %arg1 : vector<[8]xi64> %0 = arith.shrsi %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_negf // CHECK-LABEL: test_negf
func.func @test_negf(%arg0 : f64) -> f64 { func.func @test_negf(%arg0 : f64) -> f64 {
%0 = arith.negf %arg0 : f64 %0 = arith.negf %arg0 : f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: test_negf_tensor // CHECK-LABEL: test_negf_tensor
func.func @test_negf_tensor(%arg0 : tensor<8x8xf64>) -> tensor<8x8xf64> { func.func @test_negf_tensor(%arg0 : tensor<8x8xf64>) -> tensor<8x8xf64> {
%0 = arith.negf %arg0 : tensor<8x8xf64> %0 = arith.negf %arg0 : tensor<8x8xf64>
return %0 : tensor<8x8xf64> return %0 : tensor<8x8xf64>
} }
// CHECK-LABEL: test_negf_vector // CHECK-LABEL: test_negf_vector
func.func @test_negf_vector(%arg0 : vector<8xf64>) -> vector<8xf64> { func.func @test_negf_vector(%arg0 : vector<8xf64>) -> vector<8xf64> {
%0 = arith.negf %arg0 : vector<8xf64> %0 = arith.negf %arg0 : vector<8xf64>
return %0 : vector<8xf64> return %0 : vector<8xf64>
} }
// CHECK-LABEL: test_negf_scalable_vector // CHECK-LABEL: test_negf_scalable_vector
func.func @test_negf_scalable_vector(%arg0 : vector<[8]xf64>) -> vector<[8]xf64> { func.func @test_negf_scalable_vector(%arg0 : vector<[8]xf64>) -> vector<[8]xf64> {
%0 = arith.negf %arg0 : vector<[8]xf64> %0 = arith.negf %arg0 : vector<[8]xf64>
return %0 : vector<[8]xf64> return %0 : vector<[8]xf64>
} }
// CHECK-LABEL: test_addf // CHECK-LABEL: test_addf
func.func @test_addf(%arg0 : f64, %arg1 : f64) -> f64 { func.func @test_addf(%arg0 : f64, %arg1 : f64) -> f64 {
%0 = arith.addf %arg0, %arg1 : f64 %0 = arith.addf %arg0, %arg1 : f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: test_addf_tensor // CHECK-LABEL: test_addf_tensor
func.func @test_addf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xf64> { func.func @test_addf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xf64> {
%0 = arith.addf %arg0, %arg1 : tensor<8x8xf64> %0 = arith.addf %arg0, %arg1 : tensor<8x8xf64>
return %0 : tensor<8x8xf64> return %0 : tensor<8x8xf64>
} }
// CHECK-LABEL: test_addf_vector // CHECK-LABEL: test_addf_vector
func.func @test_addf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xf64> { func.func @test_addf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xf64> {
%0 = arith.addf %arg0, %arg1 : vector<8xf64> %0 = arith.addf %arg0, %arg1 : vector<8xf64>
return %0 : vector<8xf64> return %0 : vector<8xf64>
} }
// CHECK-LABEL: test_addf_scalable_vector // CHECK-LABEL: test_addf_scalable_vector
func.func @test_addf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xf64> { func.func @test_addf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xf64> {
%0 = arith.addf %arg0, %arg1 : vector<[8]xf64> %0 = arith.addf %arg0, %arg1 : vector<[8]xf64>
return %0 : vector<[8]xf64> return %0 : vector<[8]xf64>
} }
// CHECK-LABEL: test_subf // CHECK-LABEL: test_subf
func.func @test_subf(%arg0 : f64, %arg1 : f64) -> f64 { func.func @test_subf(%arg0 : f64, %arg1 : f64) -> f64 {
%0 = arith.subf %arg0, %arg1 : f64 %0 = arith.subf %arg0, %arg1 : f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: test_subf_tensor // CHECK-LABEL: test_subf_tensor
func.func @test_subf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xf64> { func.func @test_subf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xf64> {
%0 = arith.subf %arg0, %arg1 : tensor<8x8xf64> %0 = arith.subf %arg0, %arg1 : tensor<8x8xf64>
return %0 : tensor<8x8xf64> return %0 : tensor<8x8xf64>
} }
// CHECK-LABEL: test_subf_vector // CHECK-LABEL: test_subf_vector
func.func @test_subf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xf64> { func.func @test_subf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xf64> {
%0 = arith.subf %arg0, %arg1 : vector<8xf64> %0 = arith.subf %arg0, %arg1 : vector<8xf64>
return %0 : vector<8xf64> return %0 : vector<8xf64>
} }
// CHECK-LABEL: test_subf_scalable_vector // CHECK-LABEL: test_subf_scalable_vector
func.func @test_subf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xf64> { func.func @test_subf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xf64> {
%0 = arith.subf %arg0, %arg1 : vector<[8]xf64> %0 = arith.subf %arg0, %arg1 : vector<[8]xf64>
return %0 : vector<[8]xf64> return %0 : vector<[8]xf64>
} }
// CHECK-LABEL: test_mulf // CHECK-LABEL: test_mulf
func.func @test_mulf(%arg0 : f64, %arg1 : f64) -> f64 { func.func @test_mulf(%arg0 : f64, %arg1 : f64) -> f64 {
%0 = arith.mulf %arg0, %arg1 : f64 %0 = arith.mulf %arg0, %arg1 : f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: test_mulf_tensor // CHECK-LABEL: test_mulf_tensor
func.func @test_mulf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xf64> { func.func @test_mulf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xf64> {
%0 = arith.mulf %arg0, %arg1 : tensor<8x8xf64> %0 = arith.mulf %arg0, %arg1 : tensor<8x8xf64>
return %0 : tensor<8x8xf64> return %0 : tensor<8x8xf64>
} }
// CHECK-LABEL: test_mulf_vector // CHECK-LABEL: test_mulf_vector
func.func @test_mulf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xf64> { func.func @test_mulf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xf64> {
%0 = arith.mulf %arg0, %arg1 : vector<8xf64> %0 = arith.mulf %arg0, %arg1 : vector<8xf64>
return %0 : vector<8xf64> return %0 : vector<8xf64>
} }
// CHECK-LABEL: test_mulf_scalable_vector // CHECK-LABEL: test_mulf_scalable_vector
func.func @test_mulf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xf64> { func.func @test_mulf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xf64> {
%0 = arith.mulf %arg0, %arg1 : vector<[8]xf64> %0 = arith.mulf %arg0, %arg1 : vector<[8]xf64>
return %0 : vector<[8]xf64> return %0 : vector<[8]xf64>
} }
// CHECK-LABEL: test_divf // CHECK-LABEL: test_divf
func.func @test_divf(%arg0 : f64, %arg1 : f64) -> f64 { func.func @test_divf(%arg0 : f64, %arg1 : f64) -> f64 {
%0 = arith.divf %arg0, %arg1 : f64 %0 = arith.divf %arg0, %arg1 : f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: test_divf_tensor // CHECK-LABEL: test_divf_tensor
func.func @test_divf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xf64> { func.func @test_divf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xf64> {
%0 = arith.divf %arg0, %arg1 : tensor<8x8xf64> %0 = arith.divf %arg0, %arg1 : tensor<8x8xf64>
return %0 : tensor<8x8xf64> return %0 : tensor<8x8xf64>
} }
// CHECK-LABEL: test_divf_vector // CHECK-LABEL: test_divf_vector
func.func @test_divf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xf64> { func.func @test_divf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xf64> {
%0 = arith.divf %arg0, %arg1 : vector<8xf64> %0 = arith.divf %arg0, %arg1 : vector<8xf64>
return %0 : vector<8xf64> return %0 : vector<8xf64>
} }
// CHECK-LABEL: test_divf_scalable_vector // CHECK-LABEL: test_divf_scalable_vector
func.func @test_divf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xf64> { func.func @test_divf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xf64> {
%0 = arith.divf %arg0, %arg1 : vector<[8]xf64> %0 = arith.divf %arg0, %arg1 : vector<[8]xf64>
return %0 : vector<[8]xf64> return %0 : vector<[8]xf64>
} }
// CHECK-LABEL: test_remf // CHECK-LABEL: test_remf
func.func @test_remf(%arg0 : f64, %arg1 : f64) -> f64 { func.func @test_remf(%arg0 : f64, %arg1 : f64) -> f64 {
%0 = arith.remf %arg0, %arg1 : f64 %0 = arith.remf %arg0, %arg1 : f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: test_remf_tensor // CHECK-LABEL: test_remf_tensor
func.func @test_remf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xf64> { func.func @test_remf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xf64> {
%0 = arith.remf %arg0, %arg1 : tensor<8x8xf64> %0 = arith.remf %arg0, %arg1 : tensor<8x8xf64>
return %0 : tensor<8x8xf64> return %0 : tensor<8x8xf64>
} }
// CHECK-LABEL: test_remf_vector // CHECK-LABEL: test_remf_vector
func.func @test_remf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xf64> { func.func @test_remf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xf64> {
%0 = arith.remf %arg0, %arg1 : vector<8xf64> %0 = arith.remf %arg0, %arg1 : vector<8xf64>
return %0 : vector<8xf64> return %0 : vector<8xf64>
} }
// CHECK-LABEL: test_remf_scalable_vector // CHECK-LABEL: test_remf_scalable_vector
func.func @test_remf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xf64> { func.func @test_remf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xf64> {
%0 = arith.remf %arg0, %arg1 : vector<[8]xf64> %0 = arith.remf %arg0, %arg1 : vector<[8]xf64>
return %0 : vector<[8]xf64> return %0 : vector<[8]xf64>
} }
// CHECK-LABEL: test_extui // CHECK-LABEL: test_extui
func.func @test_extui(%arg0 : i32) -> i64 { func.func @test_extui(%arg0 : i32) -> i64 {
%0 = arith.extui %arg0 : i32 to i64 %0 = arith.extui %arg0 : i32 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_extui_tensor // CHECK-LABEL: test_extui_tensor
func.func @test_extui_tensor(%arg0 : tensor<8x8xi32>) -> tensor<8x8xi64> { func.func @test_extui_tensor(%arg0 : tensor<8x8xi32>) -> tensor<8x8xi64> {
%0 = arith.extui %arg0 : tensor<8x8xi32> to tensor<8x8xi64> %0 = arith.extui %arg0 : tensor<8x8xi32> to tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_extui_vector // CHECK-LABEL: test_extui_vector
func.func @test_extui_vector(%arg0 : vector<8xi32>) -> vector<8xi64> { func.func @test_extui_vector(%arg0 : vector<8xi32>) -> vector<8xi64> {
%0 = arith.extui %arg0 : vector<8xi32> to vector<8xi64> %0 = arith.extui %arg0 : vector<8xi32> to vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_extui_scalable_vector // CHECK-LABEL: test_extui_scalable_vector
func.func @test_extui_scalable_vector(%arg0 : vector<[8]xi32>) -> vector<[8]xi64> { func.func @test_extui_scalable_vector(%arg0 : vector<[8]xi32>) -> vector<[8]xi64> {
%0 = arith.extui %arg0 : vector<[8]xi32> to vector<[8]xi64> %0 = arith.extui %arg0 : vector<[8]xi32> to vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_extsi // CHECK-LABEL: test_extsi
func.func @test_extsi(%arg0 : i32) -> i64 { func.func @test_extsi(%arg0 : i32) -> i64 {
%0 = arith.extsi %arg0 : i32 to i64 %0 = arith.extsi %arg0 : i32 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_extsi_tensor // CHECK-LABEL: test_extsi_tensor
func.func @test_extsi_tensor(%arg0 : tensor<8x8xi32>) -> tensor<8x8xi64> { func.func @test_extsi_tensor(%arg0 : tensor<8x8xi32>) -> tensor<8x8xi64> {
%0 = arith.extsi %arg0 : tensor<8x8xi32> to tensor<8x8xi64> %0 = arith.extsi %arg0 : tensor<8x8xi32> to tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_extsi_vector // CHECK-LABEL: test_extsi_vector
func.func @test_extsi_vector(%arg0 : vector<8xi32>) -> vector<8xi64> { func.func @test_extsi_vector(%arg0 : vector<8xi32>) -> vector<8xi64> {
%0 = arith.extsi %arg0 : vector<8xi32> to vector<8xi64> %0 = arith.extsi %arg0 : vector<8xi32> to vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_extsi_scalable_vector // CHECK-LABEL: test_extsi_scalable_vector
func.func @test_extsi_scalable_vector(%arg0 : vector<[8]xi32>) -> vector<[8]xi64> { func.func @test_extsi_scalable_vector(%arg0 : vector<[8]xi32>) -> vector<[8]xi64> {
%0 = arith.extsi %arg0 : vector<[8]xi32> to vector<[8]xi64> %0 = arith.extsi %arg0 : vector<[8]xi32> to vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_extf // CHECK-LABEL: test_extf
func.func @test_extf(%arg0 : f32) -> f64 { func.func @test_extf(%arg0 : f32) -> f64 {
%0 = arith.extf %arg0 : f32 to f64 %0 = arith.extf %arg0 : f32 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: test_extf_tensor // CHECK-LABEL: test_extf_tensor
func.func @test_extf_tensor(%arg0 : tensor<8x8xf32>) -> tensor<8x8xf64> { func.func @test_extf_tensor(%arg0 : tensor<8x8xf32>) -> tensor<8x8xf64> {
%0 = arith.extf %arg0 : tensor<8x8xf32> to tensor<8x8xf64> %0 = arith.extf %arg0 : tensor<8x8xf32> to tensor<8x8xf64>
return %0 : tensor<8x8xf64> return %0 : tensor<8x8xf64>
} }
// CHECK-LABEL: test_extf_vector // CHECK-LABEL: test_extf_vector
func.func @test_extf_vector(%arg0 : vector<8xf32>) -> vector<8xf64> { func.func @test_extf_vector(%arg0 : vector<8xf32>) -> vector<8xf64> {
%0 = arith.extf %arg0 : vector<8xf32> to vector<8xf64> %0 = arith.extf %arg0 : vector<8xf32> to vector<8xf64>
return %0 : vector<8xf64> return %0 : vector<8xf64>
} }
// CHECK-LABEL: test_extf_scalable_vector // CHECK-LABEL: test_extf_scalable_vector
func.func @test_extf_scalable_vector(%arg0 : vector<[8]xf32>) -> vector<[8]xf64> { func.func @test_extf_scalable_vector(%arg0 : vector<[8]xf32>) -> vector<[8]xf64> {
%0 = arith.extf %arg0 : vector<[8]xf32> to vector<[8]xf64> %0 = arith.extf %arg0 : vector<[8]xf32> to vector<[8]xf64>
return %0 : vector<[8]xf64> return %0 : vector<[8]xf64>
} }
// CHECK-LABEL: test_trunci // CHECK-LABEL: test_trunci
func.func @test_trunci(%arg0 : i32) -> i16 { func.func @test_trunci(%arg0 : i32) -> i16 {
%0 = arith.trunci %arg0 : i32 to i16 %0 = arith.trunci %arg0 : i32 to i16
return %0 : i16 return %0 : i16
} }
// CHECK-LABEL: test_trunci_tensor // CHECK-LABEL: test_trunci_tensor
func.func @test_trunci_tensor(%arg0 : tensor<8x8xi32>) -> tensor<8x8xi16> { func.func @test_trunci_tensor(%arg0 : tensor<8x8xi32>) -> tensor<8x8xi16> {
%0 = arith.trunci %arg0 : tensor<8x8xi32> to tensor<8x8xi16> %0 = arith.trunci %arg0 : tensor<8x8xi32> to tensor<8x8xi16>
return %0 : tensor<8x8xi16> return %0 : tensor<8x8xi16>
} }
// CHECK-LABEL: test_trunci_vector // CHECK-LABEL: test_trunci_vector
func.func @test_trunci_vector(%arg0 : vector<8xi32>) -> vector<8xi16> { func.func @test_trunci_vector(%arg0 : vector<8xi32>) -> vector<8xi16> {
%0 = arith.trunci %arg0 : vector<8xi32> to vector<8xi16> %0 = arith.trunci %arg0 : vector<8xi32> to vector<8xi16>
return %0 : vector<8xi16> return %0 : vector<8xi16>
} }
// CHECK-LABEL: test_trunci_scalable_vector // CHECK-LABEL: test_trunci_scalable_vector
func.func @test_trunci_scalable_vector(%arg0 : vector<[8]xi32>) -> vector<[8]xi16> { func.func @test_trunci_scalable_vector(%arg0 : vector<[8]xi32>) -> vector<[8]xi16> {
%0 = arith.trunci %arg0 : vector<[8]xi32> to vector<[8]xi16> %0 = arith.trunci %arg0 : vector<[8]xi32> to vector<[8]xi16>
return %0 : vector<[8]xi16> return %0 : vector<[8]xi16>
} }
// CHECK-LABEL: test_truncf // CHECK-LABEL: test_truncf
func.func @test_truncf(%arg0 : f32) -> bf16 { func.func @test_truncf(%arg0 : f32) -> bf16 {
%0 = arith.truncf %arg0 : f32 to bf16 %0 = arith.truncf %arg0 : f32 to bf16
return %0 : bf16 return %0 : bf16
} }
// CHECK-LABEL: test_truncf_tensor // CHECK-LABEL: test_truncf_tensor
func.func @test_truncf_tensor(%arg0 : tensor<8x8xf32>) -> tensor<8x8xbf16> { func.func @test_truncf_tensor(%arg0 : tensor<8x8xf32>) -> tensor<8x8xbf16> {
%0 = arith.truncf %arg0 : tensor<8x8xf32> to tensor<8x8xbf16> %0 = arith.truncf %arg0 : tensor<8x8xf32> to tensor<8x8xbf16>
return %0 : tensor<8x8xbf16> return %0 : tensor<8x8xbf16>
} }
// CHECK-LABEL: test_truncf_vector // CHECK-LABEL: test_truncf_vector
func.func @test_truncf_vector(%arg0 : vector<8xf32>) -> vector<8xbf16> { func.func @test_truncf_vector(%arg0 : vector<8xf32>) -> vector<8xbf16> {
%0 = arith.truncf %arg0 : vector<8xf32> to vector<8xbf16> %0 = arith.truncf %arg0 : vector<8xf32> to vector<8xbf16>
return %0 : vector<8xbf16> return %0 : vector<8xbf16>
} }
// CHECK-LABEL: test_truncf_scalable_vector // CHECK-LABEL: test_truncf_scalable_vector
func.func @test_truncf_scalable_vector(%arg0 : vector<[8]xf32>) -> vector<[8]xbf16> { func.func @test_truncf_scalable_vector(%arg0 : vector<[8]xf32>) -> vector<[8]xbf16> {
%0 = arith.truncf %arg0 : vector<[8]xf32> to vector<[8]xbf16> %0 = arith.truncf %arg0 : vector<[8]xf32> to vector<[8]xbf16>
return %0 : vector<[8]xbf16> return %0 : vector<[8]xbf16>
} }
// CHECK-LABEL: test_uitofp // CHECK-LABEL: test_uitofp
func.func @test_uitofp(%arg0 : i32) -> f32 { func.func @test_uitofp(%arg0 : i32) -> f32 {
%0 = arith.uitofp %arg0 : i32 to f32 %0 = arith.uitofp %arg0 : i32 to f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: test_uitofp_tensor // CHECK-LABEL: test_uitofp_tensor
func.func @test_uitofp_tensor(%arg0 : tensor<8x8xi32>) -> tensor<8x8xf32> { func.func @test_uitofp_tensor(%arg0 : tensor<8x8xi32>) -> tensor<8x8xf32> {
%0 = arith.uitofp %arg0 : tensor<8x8xi32> to tensor<8x8xf32> %0 = arith.uitofp %arg0 : tensor<8x8xi32> to tensor<8x8xf32>
return %0 : tensor<8x8xf32> return %0 : tensor<8x8xf32>
} }
// CHECK-LABEL: test_uitofp_vector // CHECK-LABEL: test_uitofp_vector
func.func @test_uitofp_vector(%arg0 : vector<8xi32>) -> vector<8xf32> { func.func @test_uitofp_vector(%arg0 : vector<8xi32>) -> vector<8xf32> {
%0 = arith.uitofp %arg0 : vector<8xi32> to vector<8xf32> %0 = arith.uitofp %arg0 : vector<8xi32> to vector<8xf32>
return %0 : vector<8xf32> return %0 : vector<8xf32>
} }
// CHECK-LABEL: test_uitofp_scalable_vector // CHECK-LABEL: test_uitofp_scalable_vector
func.func @test_uitofp_scalable_vector(%arg0 : vector<[8]xi32>) -> vector<[8]xf32> { func.func @test_uitofp_scalable_vector(%arg0 : vector<[8]xi32>) -> vector<[8]xf32> {
%0 = arith.uitofp %arg0 : vector<[8]xi32> to vector<[8]xf32> %0 = arith.uitofp %arg0 : vector<[8]xi32> to vector<[8]xf32>
return %0 : vector<[8]xf32> return %0 : vector<[8]xf32>
} }
// CHECK-LABEL: test_sitofp // CHECK-LABEL: test_sitofp
func.func @test_sitofp(%arg0 : i16) -> f64 { func.func @test_sitofp(%arg0 : i16) -> f64 {
%0 = arith.sitofp %arg0 : i16 to f64 %0 = arith.sitofp %arg0 : i16 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: test_sitofp_tensor // CHECK-LABEL: test_sitofp_tensor
func.func @test_sitofp_tensor(%arg0 : tensor<8x8xi16>) -> tensor<8x8xf64> { func.func @test_sitofp_tensor(%arg0 : tensor<8x8xi16>) -> tensor<8x8xf64> {
%0 = arith.sitofp %arg0 : tensor<8x8xi16> to tensor<8x8xf64> %0 = arith.sitofp %arg0 : tensor<8x8xi16> to tensor<8x8xf64>
return %0 : tensor<8x8xf64> return %0 : tensor<8x8xf64>
} }
// CHECK-LABEL: test_sitofp_vector // CHECK-LABEL: test_sitofp_vector
func.func @test_sitofp_vector(%arg0 : vector<8xi16>) -> vector<8xf64> { func.func @test_sitofp_vector(%arg0 : vector<8xi16>) -> vector<8xf64> {
%0 = arith.sitofp %arg0 : vector<8xi16> to vector<8xf64> %0 = arith.sitofp %arg0 : vector<8xi16> to vector<8xf64>
return %0 : vector<8xf64> return %0 : vector<8xf64>
} }
// CHECK-LABEL: test_sitofp_scalable_vector // CHECK-LABEL: test_sitofp_scalable_vector
func.func @test_sitofp_scalable_vector(%arg0 : vector<[8]xi16>) -> vector<[8]xf64> { func.func @test_sitofp_scalable_vector(%arg0 : vector<[8]xi16>) -> vector<[8]xf64> {
%0 = arith.sitofp %arg0 : vector<[8]xi16> to vector<[8]xf64> %0 = arith.sitofp %arg0 : vector<[8]xi16> to vector<[8]xf64>
return %0 : vector<[8]xf64> return %0 : vector<[8]xf64>
} }
// CHECK-LABEL: test_fptoui // CHECK-LABEL: test_fptoui
func.func @test_fptoui(%arg0 : bf16) -> i8 { func.func @test_fptoui(%arg0 : bf16) -> i8 {
%0 = arith.fptoui %arg0 : bf16 to i8 %0 = arith.fptoui %arg0 : bf16 to i8
return %0 : i8 return %0 : i8
} }
// CHECK-LABEL: test_fptoui_tensor // CHECK-LABEL: test_fptoui_tensor
func.func @test_fptoui_tensor(%arg0 : tensor<8x8xbf16>) -> tensor<8x8xi8> { func.func @test_fptoui_tensor(%arg0 : tensor<8x8xbf16>) -> tensor<8x8xi8> {
%0 = arith.fptoui %arg0 : tensor<8x8xbf16> to tensor<8x8xi8> %0 = arith.fptoui %arg0 : tensor<8x8xbf16> to tensor<8x8xi8>
return %0 : tensor<8x8xi8> return %0 : tensor<8x8xi8>
} }
// CHECK-LABEL: test_fptoui_vector // CHECK-LABEL: test_fptoui_vector
func.func @test_fptoui_vector(%arg0 : vector<8xbf16>) -> vector<8xi8> { func.func @test_fptoui_vector(%arg0 : vector<8xbf16>) -> vector<8xi8> {
%0 = arith.fptoui %arg0 : vector<8xbf16> to vector<8xi8> %0 = arith.fptoui %arg0 : vector<8xbf16> to vector<8xi8>
return %0 : vector<8xi8> return %0 : vector<8xi8>
} }
// CHECK-LABEL: test_fptoui_scalable_vector // CHECK-LABEL: test_fptoui_scalable_vector
func.func @test_fptoui_scalable_vector(%arg0 : vector<[8]xbf16>) -> vector<[8]xi8> { func.func @test_fptoui_scalable_vector(%arg0 : vector<[8]xbf16>) -> vector<[8]xi8> {
%0 = arith.fptoui %arg0 : vector<[8]xbf16> to vector<[8]xi8> %0 = arith.fptoui %arg0 : vector<[8]xbf16> to vector<[8]xi8>
return %0 : vector<[8]xi8> return %0 : vector<[8]xi8>
} }
// CHECK-LABEL: test_fptosi // CHECK-LABEL: test_fptosi
func.func @test_fptosi(%arg0 : f64) -> i64 { func.func @test_fptosi(%arg0 : f64) -> i64 {
%0 = arith.fptosi %arg0 : f64 to i64 %0 = arith.fptosi %arg0 : f64 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_fptosi_tensor // CHECK-LABEL: test_fptosi_tensor
func.func @test_fptosi_tensor(%arg0 : tensor<8x8xf64>) -> tensor<8x8xi64> { func.func @test_fptosi_tensor(%arg0 : tensor<8x8xf64>) -> tensor<8x8xi64> {
%0 = arith.fptosi %arg0 : tensor<8x8xf64> to tensor<8x8xi64> %0 = arith.fptosi %arg0 : tensor<8x8xf64> to tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_fptosi_vector // CHECK-LABEL: test_fptosi_vector
func.func @test_fptosi_vector(%arg0 : vector<8xf64>) -> vector<8xi64> { func.func @test_fptosi_vector(%arg0 : vector<8xf64>) -> vector<8xi64> {
%0 = arith.fptosi %arg0 : vector<8xf64> to vector<8xi64> %0 = arith.fptosi %arg0 : vector<8xf64> to vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_fptosi_scalable_vector // CHECK-LABEL: test_fptosi_scalable_vector
func.func @test_fptosi_scalable_vector(%arg0 : vector<[8]xf64>) -> vector<[8]xi64> { func.func @test_fptosi_scalable_vector(%arg0 : vector<[8]xf64>) -> vector<[8]xi64> {
%0 = arith.fptosi %arg0 : vector<[8]xf64> to vector<[8]xi64> %0 = arith.fptosi %arg0 : vector<[8]xf64> to vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_index_cast0 // CHECK-LABEL: test_index_cast0
func.func @test_index_cast0(%arg0 : i32) -> index { func.func @test_index_cast0(%arg0 : i32) -> index {
%0 = arith.index_cast %arg0 : i32 to index %0 = arith.index_cast %arg0 : i32 to index
return %0 : index return %0 : index
} }
// CHECK-LABEL: test_index_cast_tensor0 // CHECK-LABEL: test_index_cast_tensor0
func.func @test_index_cast_tensor0(%arg0 : tensor<8x8xi32>) -> tensor<8x8xindex> { func.func @test_index_cast_tensor0(%arg0 : tensor<8x8xi32>) -> tensor<8x8xindex> {
%0 = arith.index_cast %arg0 : tensor<8x8xi32> to tensor<8x8xindex> %0 = arith.index_cast %arg0 : tensor<8x8xi32> to tensor<8x8xindex>
return %0 : tensor<8x8xindex> return %0 : tensor<8x8xindex>
} }
// CHECK-LABEL: test_index_cast_vector0 // CHECK-LABEL: test_index_cast_vector0
func.func @test_index_cast_vector0(%arg0 : vector<8xi32>) -> vector<8xindex> { func.func @test_index_cast_vector0(%arg0 : vector<8xi32>) -> vector<8xindex> {
%0 = arith.index_cast %arg0 : vector<8xi32> to vector<8xindex> %0 = arith.index_cast %arg0 : vector<8xi32> to vector<8xindex>
return %0 : vector<8xindex> return %0 : vector<8xindex>
} }
// CHECK-LABEL: test_index_cast_scalable_vector0 // CHECK-LABEL: test_index_cast_scalable_vector0
func.func @test_index_cast_scalable_vector0(%arg0 : vector<[8]xi32>) -> vector<[8]xindex> { func.func @test_index_cast_scalable_vector0(%arg0 : vector<[8]xi32>) -> vector<[8]xindex> {
%0 = arith.index_cast %arg0 : vector<[8]xi32> to vector<[8]xindex> %0 = arith.index_cast %arg0 : vector<[8]xi32> to vector<[8]xindex>
return %0 : vector<[8]xindex> return %0 : vector<[8]xindex>
} }
// CHECK-LABEL: test_index_cast1 // CHECK-LABEL: test_index_cast1
func.func @test_index_cast1(%arg0 : index) -> i64 { func.func @test_index_cast1(%arg0 : index) -> i64 {
%0 = arith.index_cast %arg0 : index to i64 %0 = arith.index_cast %arg0 : index to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_index_cast_tensor1 // CHECK-LABEL: test_index_cast_tensor1
func.func @test_index_cast_tensor1(%arg0 : tensor<8x8xindex>) -> tensor<8x8xi64> { func.func @test_index_cast_tensor1(%arg0 : tensor<8x8xindex>) -> tensor<8x8xi64> {
%0 = arith.index_cast %arg0 : tensor<8x8xindex> to tensor<8x8xi64> %0 = arith.index_cast %arg0 : tensor<8x8xindex> to tensor<8x8xi64>
return %0 : tensor<8x8xi64> return %0 : tensor<8x8xi64>
} }
// CHECK-LABEL: test_index_cast_vector1 // CHECK-LABEL: test_index_cast_vector1
func.func @test_index_cast_vector1(%arg0 : vector<8xindex>) -> vector<8xi64> { func.func @test_index_cast_vector1(%arg0 : vector<8xindex>) -> vector<8xi64> {
%0 = arith.index_cast %arg0 : vector<8xindex> to vector<8xi64> %0 = arith.index_cast %arg0 : vector<8xindex> to vector<8xi64>
return %0 : vector<8xi64> return %0 : vector<8xi64>
} }
// CHECK-LABEL: test_index_cast_scalable_vector1 // CHECK-LABEL: test_index_cast_scalable_vector1
func.func @test_index_cast_scalable_vector1(%arg0 : vector<[8]xindex>) -> vector<[8]xi64> { func.func @test_index_cast_scalable_vector1(%arg0 : vector<[8]xindex>) -> vector<[8]xi64> {
%0 = arith.index_cast %arg0 : vector<[8]xindex> to vector<[8]xi64> %0 = arith.index_cast %arg0 : vector<[8]xindex> to vector<[8]xi64>
return %0 : vector<[8]xi64> return %0 : vector<[8]xi64>
} }
// CHECK-LABEL: test_bitcast0 // CHECK-LABEL: test_bitcast0
func.func @test_bitcast0(%arg0 : i64) -> f64 { func.func @test_bitcast0(%arg0 : i64) -> f64 {
%0 = arith.bitcast %arg0 : i64 to f64 %0 = arith.bitcast %arg0 : i64 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: test_bitcast_tensor0 // CHECK-LABEL: test_bitcast_tensor0
func.func @test_bitcast_tensor0(%arg0 : tensor<8x8xi64>) -> tensor<8x8xf64> { func.func @test_bitcast_tensor0(%arg0 : tensor<8x8xi64>) -> tensor<8x8xf64> {
%0 = arith.bitcast %arg0 : tensor<8x8xi64> to tensor<8x8xf64> %0 = arith.bitcast %arg0 : tensor<8x8xi64> to tensor<8x8xf64>
return %0 : tensor<8x8xf64> return %0 : tensor<8x8xf64>
} }
// CHECK-LABEL: test_bitcast_vector0 // CHECK-LABEL: test_bitcast_vector0
func.func @test_bitcast_vector0(%arg0 : vector<8xi64>) -> vector<8xf64> { func.func @test_bitcast_vector0(%arg0 : vector<8xi64>) -> vector<8xf64> {
%0 = arith.bitcast %arg0 : vector<8xi64> to vector<8xf64> %0 = arith.bitcast %arg0 : vector<8xi64> to vector<8xf64>
return %0 : vector<8xf64> return %0 : vector<8xf64>
} }
// CHECK-LABEL: test_bitcast_scalable_vector0 // CHECK-LABEL: test_bitcast_scalable_vector0
func.func @test_bitcast_scalable_vector0(%arg0 : vector<[8]xi64>) -> vector<[8]xf64> { func.func @test_bitcast_scalable_vector0(%arg0 : vector<[8]xi64>) -> vector<[8]xf64> {
%0 = arith.bitcast %arg0 : vector<[8]xi64> to vector<[8]xf64> %0 = arith.bitcast %arg0 : vector<[8]xi64> to vector<[8]xf64>
return %0 : vector<[8]xf64> return %0 : vector<[8]xf64>
} }
// CHECK-LABEL: test_bitcast1 // CHECK-LABEL: test_bitcast1
func.func @test_bitcast1(%arg0 : f32) -> i32 { func.func @test_bitcast1(%arg0 : f32) -> i32 {
%0 = arith.bitcast %arg0 : f32 to i32 %0 = arith.bitcast %arg0 : f32 to i32
return %0 : i32 return %0 : i32
} }
// CHECK-LABEL: test_bitcast_tensor1 // CHECK-LABEL: test_bitcast_tensor1
func.func @test_bitcast_tensor1(%arg0 : tensor<8x8xf32>) -> tensor<8x8xi32> { func.func @test_bitcast_tensor1(%arg0 : tensor<8x8xf32>) -> tensor<8x8xi32> {
%0 = arith.bitcast %arg0 : tensor<8x8xf32> to tensor<8x8xi32> %0 = arith.bitcast %arg0 : tensor<8x8xf32> to tensor<8x8xi32>
return %0 : tensor<8x8xi32> return %0 : tensor<8x8xi32>
} }
// CHECK-LABEL: test_bitcast_vector1 // CHECK-LABEL: test_bitcast_vector1
func.func @test_bitcast_vector1(%arg0 : vector<8xf32>) -> vector<8xi32> { func.func @test_bitcast_vector1(%arg0 : vector<8xf32>) -> vector<8xi32> {
%0 = arith.bitcast %arg0 : vector<8xf32> to vector<8xi32> %0 = arith.bitcast %arg0 : vector<8xf32> to vector<8xi32>
return %0 : vector<8xi32> return %0 : vector<8xi32>
} }
// CHECK-LABEL: test_bitcast_scalable_vector1 // CHECK-LABEL: test_bitcast_scalable_vector1
func.func @test_bitcast_scalable_vector1(%arg0 : vector<[8]xf32>) -> vector<[8]xi32> { func.func @test_bitcast_scalable_vector1(%arg0 : vector<[8]xf32>) -> vector<[8]xi32> {
%0 = arith.bitcast %arg0 : vector<[8]xf32> to vector<[8]xi32> %0 = arith.bitcast %arg0 : vector<[8]xf32> to vector<[8]xi32>
return %0 : vector<[8]xi32> return %0 : vector<[8]xi32>
} }
// CHECK-LABEL: test_cmpi // CHECK-LABEL: test_cmpi
func.func @test_cmpi(%arg0 : i64, %arg1 : i64) -> i1 { func.func @test_cmpi(%arg0 : i64, %arg1 : i64) -> i1 {
%0 = arith.cmpi ne, %arg0, %arg1 : i64 %0 = arith.cmpi ne, %arg0, %arg1 : i64
return %0 : i1 return %0 : i1
} }
// CHECK-LABEL: test_cmpi_tensor // CHECK-LABEL: test_cmpi_tensor
func.func @test_cmpi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi1> { func.func @test_cmpi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi1> {
%0 = arith.cmpi slt, %arg0, %arg1 : tensor<8x8xi64> %0 = arith.cmpi slt, %arg0, %arg1 : tensor<8x8xi64>
return %0 : tensor<8x8xi1> return %0 : tensor<8x8xi1>
} }
// CHECK-LABEL: test_cmpi_vector // CHECK-LABEL: test_cmpi_vector
func.func @test_cmpi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi1> { func.func @test_cmpi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi1> {
%0 = arith.cmpi ult, %arg0, %arg1 : vector<8xi64> %0 = arith.cmpi ult, %arg0, %arg1 : vector<8xi64>
return %0 : vector<8xi1> return %0 : vector<8xi1>
} }
// CHECK-LABEL: test_cmpi_scalable_vector // CHECK-LABEL: test_cmpi_scalable_vector
func.func @test_cmpi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi1> { func.func @test_cmpi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>) -> vector<[8]xi1> {
%0 = arith.cmpi ult, %arg0, %arg1 : vector<[8]xi64> %0 = arith.cmpi ult, %arg0, %arg1 : vector<[8]xi64>
return %0 : vector<[8]xi1> return %0 : vector<[8]xi1>
} }
// CHECK-LABEL: test_cmpi_vector_0d // CHECK-LABEL: test_cmpi_vector_0d
func.func @test_cmpi_vector_0d(%arg0 : vector<i64>, %arg1 : vector<i64>) -> vector<i1> { func.func @test_cmpi_vector_0d(%arg0 : vector<i64>, %arg1 : vector<i64>) -> vector<i1> {
%0 = arith.cmpi ult, %arg0, %arg1 : vector<i64> %0 = arith.cmpi ult, %arg0, %arg1 : vector<i64>
return %0 : vector<i1> return %0 : vector<i1>
} }
// CHECK-LABEL: test_cmpf // CHECK-LABEL: test_cmpf
func.func @test_cmpf(%arg0 : f64, %arg1 : f64) -> i1 { func.func @test_cmpf(%arg0 : f64, %arg1 : f64) -> i1 {
%0 = arith.cmpf oeq, %arg0, %arg1 : f64 %0 = arith.cmpf oeq, %arg0, %arg1 : f64
return %0 : i1 return %0 : i1
} }
// CHECK-LABEL: test_cmpf_tensor // CHECK-LABEL: test_cmpf_tensor
func.func @test_cmpf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xi1> { func.func @test_cmpf_tensor(%arg0 : tensor<8x8xf64>, %arg1 : tensor<8x8xf64>) -> tensor<8x8xi1> {
%0 = arith.cmpf olt, %arg0, %arg1 : tensor<8x8xf64> %0 = arith.cmpf olt, %arg0, %arg1 : tensor<8x8xf64>
return %0 : tensor<8x8xi1> return %0 : tensor<8x8xi1>
} }
// CHECK-LABEL: test_cmpf_vector // CHECK-LABEL: test_cmpf_vector
func.func @test_cmpf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xi1> { func.func @test_cmpf_vector(%arg0 : vector<8xf64>, %arg1 : vector<8xf64>) -> vector<8xi1> {
%0 = arith.cmpf ult, %arg0, %arg1 : vector<8xf64> %0 = arith.cmpf ult, %arg0, %arg1 : vector<8xf64>
return %0 : vector<8xi1> return %0 : vector<8xi1>
} }
// CHECK-LABEL: test_cmpf_scalable_vector // CHECK-LABEL: test_cmpf_scalable_vector
func.func @test_cmpf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xi1> { func.func @test_cmpf_scalable_vector(%arg0 : vector<[8]xf64>, %arg1 : vector<[8]xf64>) -> vector<[8]xi1> {
%0 = arith.cmpf ult, %arg0, %arg1 : vector<[8]xf64> %0 = arith.cmpf ult, %arg0, %arg1 : vector<[8]xf64>
return %0 : vector<[8]xi1> return %0 : vector<[8]xi1>
} }
// CHECK-LABEL: test_index_cast // CHECK-LABEL: test_index_cast
func.func @test_index_cast(%arg0 : index) -> i64 { func.func @test_index_cast(%arg0 : index) -> i64 {
%0 = arith.index_cast %arg0 : index to i64 %0 = arith.index_cast %arg0 : index to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: test_index_cast_tensor // CHECK-LABEL: test_index_cast_tensor
func.func @test_index_cast_tensor(%arg0 : tensor<index>) -> tensor<i64> { func.func @test_index_cast_tensor(%arg0 : tensor<index>) -> tensor<i64> {
%0 = arith.index_cast %arg0 : tensor<index> to tensor<i64> %0 = arith.index_cast %arg0 : tensor<index> to tensor<i64>
return %0 : tensor<i64> return %0 : tensor<i64>
} }
// CHECK-LABEL: test_index_cast_tensor_reverse // CHECK-LABEL: test_index_cast_tensor_reverse
func.func @test_index_cast_tensor_reverse(%arg0 : tensor<i64>) -> tensor<index> { func.func @test_index_cast_tensor_reverse(%arg0 : tensor<i64>) -> tensor<index> {
%0 = arith.index_cast %arg0 : tensor<i64> to tensor<index> %0 = arith.index_cast %arg0 : tensor<i64> to tensor<index>
return %0 : tensor<index> return %0 : tensor<index>
} }
// CHECK-LABEL: func @bitcast( // CHECK-LABEL: func @bitcast(
func.func @bitcast(%arg : f32) -> i32 { func.func @bitcast(%arg : f32) -> i32 {
%res = arith.bitcast %arg : f32 to i32 %res = arith.bitcast %arg : f32 to i32
return %res : i32 return %res : i32
} }
// CHECK-LABEL: test_constant // CHECK-LABEL: test_constant
func.func @test_constant() -> () { func.func @test_constant() -> () {
// CHECK: %c42_i32 = arith.constant 42 : i32 // CHECK: %c42_i32 = arith.constant 42 : i32
%0 = "arith.constant"(){value = 42 : i32} : () -> i32 %0 = "arith.constant"(){value = 42 : i32} : () -> i32
// CHECK: %c42_i32_0 = arith.constant 42 : i32 // CHECK: %c42_i32_0 = arith.constant 42 : i32
%1 = arith.constant 42 : i32 %1 = arith.constant 42 : i32
// CHECK: %c43 = arith.constant {crazy = "func.foo"} 43 : index // CHECK: %c43 = arith.constant {crazy = "func.foo"} 43 : index
%2 = arith.constant {crazy = "func.foo"} 43: index %2 = arith.constant {crazy = "func.foo"} 43: index
// CHECK: %cst = arith.constant 4.300000e+01 : bf16 // CHECK: %cst = arith.constant 4.300000e+01 : bf16
%3 = arith.constant 43.0 : bf16 %3 = arith.constant 43.0 : bf16
// CHECK: %cst_1 = arith.constant dense<0> : vector<4xi32> // CHECK: %cst_1 = arith.constant dense<0> : vector<4xi32>
%4 = arith.constant dense<0> : vector<4 x i32> %4 = arith.constant dense<0> : vector<4 x i32>
// CHECK: %cst_2 = arith.constant dense<0> : tensor<42xi32> // CHECK: %cst_2 = arith.constant dense<0> : tensor<42xi32>
%5 = arith.constant dense<0> : tensor<42 x i32> %5 = arith.constant dense<0> : tensor<42 x i32>
// CHECK: %cst_3 = arith.constant dense<0> : vector<42xi32> // CHECK: %cst_3 = arith.constant dense<0> : vector<42xi32>
%6 = arith.constant dense<0> : vector<42 x i32> %6 = arith.constant dense<0> : vector<42 x i32>
// CHECK: %true = arith.constant true // CHECK: %true = arith.constant true
%7 = arith.constant true %7 = arith.constant true
// CHECK: %false = arith.constant false // CHECK: %false = arith.constant false
%8 = arith.constant false %8 = arith.constant false
// CHECK: %c-1_i128 = arith.constant -1 : i128 // CHECK: %c-1_i128 = arith.constant -1 : i128
%9 = arith.constant 340282366920938463463374607431768211455 : i128 %9 = arith.constant 340282366920938463463374607431768211455 : i128
// CHECK: %c85070591730234615865843651857942052864_i128 = arith.constant 85070591730234615865843651857942052864 : i128 // CHECK: %c85070591730234615865843651857942052864_i128 = arith.constant 85070591730234615865843651857942052864 : i128
%10 = arith.constant 85070591730234615865843651857942052864 : i128 %10 = arith.constant 85070591730234615865843651857942052864 : i128
return return
} }
// CHECK-LABEL: func @maximum // CHECK-LABEL: func @maximum
func.func @maximum(%v1: vector<4xf32>, %v2: vector<4xf32>, func.func @maximum(%v1: vector<4xf32>, %v2: vector<4xf32>,
%sv1: vector<[4]xf32>, %sv2: vector<[4]xf32>, %sv1: vector<[4]xf32>, %sv2: vector<[4]xf32>,
%f1: f32, %f2: f32, %f1: f32, %f2: f32,
%i1: i32, %i2: i32) { %i1: i32, %i2: i32) {
%max_vector = arith.maxf %v1, %v2 : vector<4xf32> %max_vector = arith.maxf %v1, %v2 : vector<4xf32>
%max_scalable_vector = arith.maxf %sv1, %sv2 : vector<[4]xf32> %max_scalable_vector = arith.maxf %sv1, %sv2 : vector<[4]xf32>
%max_float = arith.maxf %f1, %f2 : f32 %max_float = arith.maxf %f1, %f2 : f32
%max_signed = arith.maxsi %i1, %i2 : i32 %max_signed = arith.maxsi %i1, %i2 : i32
%max_unsigned = arith.maxui %i1, %i2 : i32 %max_unsigned = arith.maxui %i1, %i2 : i32
return return
} }
// CHECK-LABEL: func @minimum // CHECK-LABEL: func @minimum
func.func @minimum(%v1: vector<4xf32>, %v2: vector<4xf32>, func.func @minimum(%v1: vector<4xf32>, %v2: vector<4xf32>,
%sv1: vector<[4]xf32>, %sv2: vector<[4]xf32>, %sv1: vector<[4]xf32>, %sv2: vector<[4]xf32>,
%f1: f32, %f2: f32, %f1: f32, %f2: f32,
%i1: i32, %i2: i32) { %i1: i32, %i2: i32) {
%min_vector = arith.minf %v1, %v2 : vector<4xf32> %min_vector = arith.minf %v1, %v2 : vector<4xf32>
%min_scalable_vector = arith.minf %sv1, %sv2 : vector<[4]xf32> %min_scalable_vector = arith.minf %sv1, %sv2 : vector<[4]xf32>
%min_float = arith.minf %f1, %f2 : f32 %min_float = arith.minf %f1, %f2 : f32
%min_signed = arith.minsi %i1, %i2 : i32 %min_signed = arith.minsi %i1, %i2 : i32
%min_unsigned = arith.minui %i1, %i2 : i32 %min_unsigned = arith.minui %i1, %i2 : i32
return return
} }

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.
// Check that the test version of the wide integer emulation pass applies // Check that the test version of the wide integer emulation pass applies
// conversion to functions whose name start with a given prefix only, and that // conversion to functions whose name start with a given prefix only, and that
// the function signatures are preserved. // the function signatures are preserved.
// RUN: mlir-opt %s --test-arith-emulate-wide-int="function-prefix=emulate_me_" | FileCheck %s // RUN: mlir-opt %s --test-arith-emulate-wide-int="function-prefix=emulate_me_" | FileCheck %s
// CHECK-LABEL: func.func @entry() // CHECK-LABEL: func.func @entry()
// CHECK: {{%.+}} = call @emulate_me_please({{.+}}) : (i64) -> i64 // CHECK: {{%.+}} = call @emulate_me_please({{.+}}) : (i64) -> i64
// CHECK-NEXT: {{%.+}} = call @foo({{.+}}) : (i64) -> i64 // CHECK-NEXT: {{%.+}} = call @foo({{.+}}) : (i64) -> i64
func.func @entry() { func.func @entry() {
%cst0 = arith.constant 0 : i64 %cst0 = arith.constant 0 : i64
func.call @emulate_me_please(%cst0) : (i64) -> (i64) func.call @emulate_me_please(%cst0) : (i64) -> (i64)
func.call @foo(%cst0) : (i64) -> (i64) func.call @foo(%cst0) : (i64) -> (i64)
return return
} }
// CHECK-LABEL: func.func @emulate_me_please // CHECK-LABEL: func.func @emulate_me_please
// CHECK-SAME: ([[ARG:%.+]]: i64) -> i64 { // CHECK-SAME: ([[ARG:%.+]]: i64) -> i64 {
// CHECK-NEXT: [[BCAST0:%.+]] = llvm.bitcast [[ARG]] : i64 to vector<2xi32> // CHECK-NEXT: [[BCAST0:%.+]] = llvm.bitcast [[ARG]] : i64 to vector<2xi32>
// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[BCAST0]][0] : vector<2xi32> // CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[BCAST0]][0] : vector<2xi32>
// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[BCAST0]][1] : vector<2xi32> // CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[BCAST0]][1] : vector<2xi32>
// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[BCAST0]][0] : vector<2xi32> // CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[BCAST0]][0] : vector<2xi32>
// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[BCAST0]][1] : vector<2xi32> // CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[BCAST0]][1] : vector<2xi32>
// CHECK-NEXT: {{%.+}}, {{%.+}} = arith.addui_carry [[LOW0]], [[LOW1]] : i32, i1 // CHECK-NEXT: {{%.+}}, {{%.+}} = arith.addui_carry [[LOW0]], [[LOW1]] : i32, i1
// CHECK: [[RES:%.+]] = llvm.bitcast {{%.+}} : vector<2xi32> to i64 // CHECK: [[RES:%.+]] = llvm.bitcast {{%.+}} : vector<2xi32> to i64
// CHECK-NEXt: return [[RES]] : i64 // CHECK-NEXt: return [[RES]] : i64
func.func @emulate_me_please(%x : i64) -> i64 { func.func @emulate_me_please(%x : i64) -> i64 {
%r = arith.addi %x, %x : i64 %r = arith.addi %x, %x : i64
return %r : i64 return %r : i64
} }
// CHECK-LABEL: func.func @foo // CHECK-LABEL: func.func @foo
// CHECK-SAME: ([[ARG:%.+]]: i64) -> i64 { // CHECK-SAME: ([[ARG:%.+]]: i64) -> i64 {
// CHECK-NEXT: [[RES:%.+]] = arith.addi [[ARG]], [[ARG]] : i64 // CHECK-NEXT: [[RES:%.+]] = arith.addi [[ARG]], [[ARG]] : i64
// CHECK-NEXT: return [[RES]] : i64 // CHECK-NEXT: return [[RES]] : i64
func.func @foo(%x : i64) -> i64 { func.func @foo(%x : i64) -> i64 {
%r = arith.addi %x, %x : i64 %r = arith.addi %x, %x : i64
return %r : i64 return %r : i64
} }

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

  • This file was moved from mlir/test/Dialect/Arithmetic/unsigned-when-equivalent.mlir.
// RUN: mlir-opt -arith-unsigned-when-equivalent %s | FileCheck %s // RUN: mlir-opt -arith-unsigned-when-equivalent %s | FileCheck %s
// CHECK-LABEL func @not_with_maybe_overflow // CHECK-LABEL func @not_with_maybe_overflow
// CHECK: arith.divsi // CHECK: arith.divsi
// CHECK: arith.ceildivsi // CHECK: arith.ceildivsi
// CHECK: arith.floordivsi // CHECK: arith.floordivsi
// CHECK: arith.remsi // CHECK: arith.remsi
// CHECK: arith.minsi // CHECK: arith.minsi
// CHECK: arith.maxsi // CHECK: arith.maxsi
// CHECK: arith.extsi // CHECK: arith.extsi
// CHECK: arith.cmpi sle // CHECK: arith.cmpi sle
// CHECK: arith.cmpi slt // CHECK: arith.cmpi slt
// CHECK: arith.cmpi sge // CHECK: arith.cmpi sge
// CHECK: arith.cmpi sgt // CHECK: arith.cmpi sgt
func.func @not_with_maybe_overflow(%arg0 : i32) { func.func @not_with_maybe_overflow(%arg0 : i32) {
%ci32_smax = arith.constant 0x7fffffff : i32 %ci32_smax = arith.constant 0x7fffffff : i32
%c1 = arith.constant 1 : i32 %c1 = arith.constant 1 : i32
%c4 = arith.constant 4 : i32 %c4 = arith.constant 4 : i32
%0 = arith.minui %arg0, %ci32_smax : i32 %0 = arith.minui %arg0, %ci32_smax : i32
%1 = arith.addi %0, %c1 : i32 %1 = arith.addi %0, %c1 : i32
%2 = arith.divsi %1, %c4 : i32 %2 = arith.divsi %1, %c4 : i32
%3 = arith.ceildivsi %1, %c4 : i32 %3 = arith.ceildivsi %1, %c4 : i32
%4 = arith.floordivsi %1, %c4 : i32 %4 = arith.floordivsi %1, %c4 : i32
%5 = arith.remsi %1, %c4 : i32 %5 = arith.remsi %1, %c4 : i32
%6 = arith.minsi %1, %c4 : i32 %6 = arith.minsi %1, %c4 : i32
%7 = arith.maxsi %1, %c4 : i32 %7 = arith.maxsi %1, %c4 : i32
%8 = arith.extsi %1 : i32 to i64 %8 = arith.extsi %1 : i32 to i64
%9 = arith.cmpi sle, %1, %c4 : i32 %9 = arith.cmpi sle, %1, %c4 : i32
%10 = arith.cmpi slt, %1, %c4 : i32 %10 = arith.cmpi slt, %1, %c4 : i32
%11 = arith.cmpi sge, %1, %c4 : i32 %11 = arith.cmpi sge, %1, %c4 : i32
%12 = arith.cmpi sgt, %1, %c4 : i32 %12 = arith.cmpi sgt, %1, %c4 : i32
func.return func.return
} }
// CHECK-LABEL func @yes_with_no_overflow // CHECK-LABEL func @yes_with_no_overflow
// CHECK: arith.divui // CHECK: arith.divui
// CHECK: arith.ceildivui // CHECK: arith.ceildivui
// CHECK: arith.divui // CHECK: arith.divui
// CHECK: arith.remui // CHECK: arith.remui
// CHECK: arith.minui // CHECK: arith.minui
// CHECK: arith.maxui // CHECK: arith.maxui
// CHECK: arith.extui // CHECK: arith.extui
// CHECK: arith.cmpi ule // CHECK: arith.cmpi ule
// CHECK: arith.cmpi ult // CHECK: arith.cmpi ult
// CHECK: arith.cmpi uge // CHECK: arith.cmpi uge
// CHECK: arith.cmpi ugt // CHECK: arith.cmpi ugt
func.func @yes_with_no_overflow(%arg0 : i32) { func.func @yes_with_no_overflow(%arg0 : i32) {
%ci32_almost_smax = arith.constant 0x7ffffffe : i32 %ci32_almost_smax = arith.constant 0x7ffffffe : i32
%c1 = arith.constant 1 : i32 %c1 = arith.constant 1 : i32
%c4 = arith.constant 4 : i32 %c4 = arith.constant 4 : i32
%0 = arith.minui %arg0, %ci32_almost_smax : i32 %0 = arith.minui %arg0, %ci32_almost_smax : i32
%1 = arith.addi %0, %c1 : i32 %1 = arith.addi %0, %c1 : i32
%2 = arith.divsi %1, %c4 : i32 %2 = arith.divsi %1, %c4 : i32
%3 = arith.ceildivsi %1, %c4 : i32 %3 = arith.ceildivsi %1, %c4 : i32
%4 = arith.floordivsi %1, %c4 : i32 %4 = arith.floordivsi %1, %c4 : i32
%5 = arith.remsi %1, %c4 : i32 %5 = arith.remsi %1, %c4 : i32
%6 = arith.minsi %1, %c4 : i32 %6 = arith.minsi %1, %c4 : i32
%7 = arith.maxsi %1, %c4 : i32 %7 = arith.maxsi %1, %c4 : i32
%8 = arith.extsi %1 : i32 to i64 %8 = arith.extsi %1 : i32 to i64
%9 = arith.cmpi sle, %1, %c4 : i32 %9 = arith.cmpi sle, %1, %c4 : i32
%10 = arith.cmpi slt, %1, %c4 : i32 %10 = arith.cmpi slt, %1, %c4 : i32
%11 = arith.cmpi sge, %1, %c4 : i32 %11 = arith.cmpi sge, %1, %c4 : i32
%12 = arith.cmpi sgt, %1, %c4 : i32 %12 = arith.cmpi sgt, %1, %c4 : i32
func.return func.return
} }
// CHECK-LABEL: func @preserves_structure // CHECK-LABEL: func @preserves_structure
// CHECK: scf.for %[[arg1:.*]] = // CHECK: scf.for %[[arg1:.*]] =
// CHECK: %[[v:.*]] = arith.remui %[[arg1]] // CHECK: %[[v:.*]] = arith.remui %[[arg1]]
// CHECK: %[[w:.*]] = arith.addi %[[v]], %[[v]] // CHECK: %[[w:.*]] = arith.addi %[[v]], %[[v]]
// CHECK: %[[test:.*]] = arith.cmpi ule, %[[w]] // CHECK: %[[test:.*]] = arith.cmpi ule, %[[w]]
// CHECK: scf.if %[[test]] // CHECK: scf.if %[[test]]
// CHECK: memref.store %[[w]] // CHECK: memref.store %[[w]]
func.func @preserves_structure(%arg0 : memref<8xindex>) { func.func @preserves_structure(%arg0 : memref<8xindex>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%c8 = arith.constant 8 : index %c8 = arith.constant 8 : index
scf.for %arg1 = %c0 to %c8 step %c1 { scf.for %arg1 = %c0 to %c8 step %c1 {
%v = arith.remsi %arg1, %c4 : index %v = arith.remsi %arg1, %c4 : index
%w = arith.addi %v, %v : index %w = arith.addi %v, %v : index
%test = arith.cmpi sle, %w, %c4 : index %test = arith.cmpi sle, %w, %c4 : index
scf.if %test { scf.if %test {
memref.store %w, %arg0[%arg1] : memref<8xindex> memref.store %w, %arg0[%arg1] : memref<8xindex>
} }
} }
func.return func.return
} }

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.
import sys import sys
# No JIT on win32. # No JIT on win32.
if sys.platform == 'win32': if sys.platform == 'win32':
config.unsupported = True config.unsupported = True

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.
// Check that the wide integer addition emulation produces the same result as // Check that the wide integer addition emulation produces the same result as
// wide addition. Emulate i16 ops with i8 ops. // wide addition. Emulate i16 ops with i8 ops.
// RUN: mlir-opt %s --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \ // RUN: mlir-opt %s --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \
// RUN: --convert-func-to-llvm --convert-arith-to-llvm | \ // RUN: --convert-func-to-llvm --convert-arith-to-llvm | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s --match-full-lines // RUN: FileCheck %s --match-full-lines
// RUN: mlir-opt %s --test-arith-emulate-wide-int="widest-int-supported=8" \ // RUN: mlir-opt %s --test-arith-emulate-wide-int="widest-int-supported=8" \
// RUN: --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \ // RUN: --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \
// RUN: --convert-func-to-llvm --convert-arith-to-llvm | \ // RUN: --convert-func-to-llvm --convert-arith-to-llvm | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s --match-full-lines // RUN: FileCheck %s --match-full-lines
// Ops in this function *only* will be emulated using i8 types. // Ops in this function *only* will be emulated using i8 types.
func.func @emulate_addi(%lhs : i16, %rhs : i16) -> (i16) { func.func @emulate_addi(%lhs : i16, %rhs : i16) -> (i16) {
%res = arith.addi %lhs, %rhs : i16 %res = arith.addi %lhs, %rhs : i16
return %res : i16 return %res : i16
} }
func.func @check_addi(%lhs : i16, %rhs : i16) -> () { func.func @check_addi(%lhs : i16, %rhs : i16) -> () {
%res = func.call @emulate_addi(%lhs, %rhs) : (i16, i16) -> (i16) %res = func.call @emulate_addi(%lhs, %rhs) : (i16, i16) -> (i16)
vector.print %res : i16 vector.print %res : i16
return return
} }
func.func @entry() { func.func @entry() {
%cst0 = arith.constant 0 : i16 %cst0 = arith.constant 0 : i16
%cst1 = arith.constant 1 : i16 %cst1 = arith.constant 1 : i16
%cst_n1 = arith.constant -1 : i16 %cst_n1 = arith.constant -1 : i16
%cst_n3 = arith.constant -3 : i16 %cst_n3 = arith.constant -3 : i16
%cst13 = arith.constant 13 : i16 %cst13 = arith.constant 13 : i16
%cst37 = arith.constant 37 : i16 %cst37 = arith.constant 37 : i16
%cst42 = arith.constant 42 : i16 %cst42 = arith.constant 42 : i16
%cst256 = arith.constant 256 : i16 %cst256 = arith.constant 256 : i16
%cst_i16_max = arith.constant 32767 : i16 %cst_i16_max = arith.constant 32767 : i16
%cst_i16_min = arith.constant -32768 : i16 %cst_i16_min = arith.constant -32768 : i16
// CHECK: 0 // CHECK: 0
func.call @check_addi(%cst0, %cst0) : (i16, i16) -> () func.call @check_addi(%cst0, %cst0) : (i16, i16) -> ()
// CHECK-NEXT: 1 // CHECK-NEXT: 1
func.call @check_addi(%cst0, %cst1) : (i16, i16) -> () func.call @check_addi(%cst0, %cst1) : (i16, i16) -> ()
// CHECK-NEXT: 2 // CHECK-NEXT: 2
func.call @check_addi(%cst1, %cst1) : (i16, i16) -> () func.call @check_addi(%cst1, %cst1) : (i16, i16) -> ()
// CHECK-NEXT: 0 // CHECK-NEXT: 0
func.call @check_addi(%cst1, %cst_n1) : (i16, i16) -> () func.call @check_addi(%cst1, %cst_n1) : (i16, i16) -> ()
// CHECK-NEXT: -2 // CHECK-NEXT: -2
func.call @check_addi(%cst_n1, %cst_n1) : (i16, i16) -> () func.call @check_addi(%cst_n1, %cst_n1) : (i16, i16) -> ()
// CHECK-NEXT: -2 // CHECK-NEXT: -2
func.call @check_addi(%cst1, %cst_n3) : (i16, i16) -> () func.call @check_addi(%cst1, %cst_n3) : (i16, i16) -> ()
// CHECK-NEXT: 26 // CHECK-NEXT: 26
func.call @check_addi(%cst13, %cst13) : (i16, i16) -> () func.call @check_addi(%cst13, %cst13) : (i16, i16) -> ()
// CHECK-NEXT: 50 // CHECK-NEXT: 50
func.call @check_addi(%cst13, %cst37) : (i16, i16) -> () func.call @check_addi(%cst13, %cst37) : (i16, i16) -> ()
// CHECK-NEXT: 79 // CHECK-NEXT: 79
func.call @check_addi(%cst37, %cst42) : (i16, i16) -> () func.call @check_addi(%cst37, %cst42) : (i16, i16) -> ()
// CHECK-NEXT: 255 // CHECK-NEXT: 255
func.call @check_addi(%cst_n1, %cst256) : (i16, i16) -> () func.call @check_addi(%cst_n1, %cst256) : (i16, i16) -> ()
// CHECK-NEXT: 269 // CHECK-NEXT: 269
func.call @check_addi(%cst256, %cst13) : (i16, i16) -> () func.call @check_addi(%cst256, %cst13) : (i16, i16) -> ()
// CHECK-NEXT: 293 // CHECK-NEXT: 293
func.call @check_addi(%cst256, %cst37) : (i16, i16) -> () func.call @check_addi(%cst256, %cst37) : (i16, i16) -> ()
// CHECK-NEXT: 253 // CHECK-NEXT: 253
func.call @check_addi(%cst256, %cst_n3) : (i16, i16) -> () func.call @check_addi(%cst256, %cst_n3) : (i16, i16) -> ()
// CHECK-NEXT: -32756 // CHECK-NEXT: -32756
func.call @check_addi(%cst13, %cst_i16_max) : (i16, i16) -> () func.call @check_addi(%cst13, %cst_i16_max) : (i16, i16) -> ()
// CHECK-NEXT: -32731 // CHECK-NEXT: -32731
func.call @check_addi(%cst_i16_min, %cst37) : (i16, i16) -> () func.call @check_addi(%cst_i16_min, %cst37) : (i16, i16) -> ()
// CHECK-NEXT: -2 // CHECK-NEXT: -2
func.call @check_addi(%cst_i16_max, %cst_i16_max) : (i16, i16) -> () func.call @check_addi(%cst_i16_max, %cst_i16_max) : (i16, i16) -> ()
// CHECK-NEXT: -32755 // CHECK-NEXT: -32755
func.call @check_addi(%cst_i16_min, %cst13) : (i16, i16) -> () func.call @check_addi(%cst_i16_min, %cst13) : (i16, i16) -> ()
// CHECK-NEXT: 0 // CHECK-NEXT: 0
func.call @check_addi(%cst_i16_min, %cst_i16_min) : (i16, i16) -> () func.call @check_addi(%cst_i16_min, %cst_i16_min) : (i16, i16) -> ()
return return
} }

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.
// Check that the wide integer emulation produces the same result as wide // Check that the wide integer emulation produces the same result as wide
// calculations. Emulate i16 ops with i8 ops. // calculations. Emulate i16 ops with i8 ops.
// RUN: mlir-opt %s --test-arith-emulate-wide-int="widest-int-supported=8" \ // RUN: mlir-opt %s --test-arith-emulate-wide-int="widest-int-supported=8" \
// RUN: --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \ // RUN: --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \
// RUN: --convert-func-to-llvm --convert-arith-to-llvm | \ // RUN: --convert-func-to-llvm --convert-arith-to-llvm | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: --shared-libs="%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext" | \ // RUN: --shared-libs="%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext" | \
// RUN: FileCheck %s // RUN: FileCheck %s
// CHECK-NOT: Mismatch // CHECK-NOT: Mismatch
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Common Utility Functions // Common Utility Functions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
llvm.mlir.global internal constant @str_mismatch("Mismatch\0A") llvm.mlir.global internal constant @str_mismatch("Mismatch\0A")
func.func private @printCString(!llvm.ptr<i8>) -> () func.func private @printCString(!llvm.ptr<i8>) -> ()
// Prints 'Mismatch' to stdout. // Prints 'Mismatch' to stdout.
func.func @printMismatch() -> () { func.func @printMismatch() -> () {
%0 = llvm.mlir.addressof @str_mismatch : !llvm.ptr<array<9 x i8>> %0 = llvm.mlir.addressof @str_mismatch : !llvm.ptr<array<9 x i8>>
%1 = llvm.mlir.constant(0 : index) : i64 %1 = llvm.mlir.constant(0 : index) : i64
%2 = llvm.getelementptr %0[%1, %1] %2 = llvm.getelementptr %0[%1, %1]
: (!llvm.ptr<array<9 x i8>>, i64, i64) -> !llvm.ptr<i8> : (!llvm.ptr<array<9 x i8>>, i64, i64) -> !llvm.ptr<i8>
func.call @printCString(%2) : (!llvm.ptr<i8>) -> () func.call @printCString(%2) : (!llvm.ptr<i8>) -> ()
return return
} }
// Prints both binary op operands and the first result. If the second result // Prints both binary op operands and the first result. If the second result
// does not match, prints the second result and a 'Mismatch' message. // does not match, prints the second result and a 'Mismatch' message.
func.func @check_results(%lhs : i16, %rhs : i16, %res0 : i16, %res1 : i16) -> () { func.func @check_results(%lhs : i16, %rhs : i16, %res0 : i16, %res1 : i16) -> () {
%vec_zero = arith.constant dense<0> : vector<2xi16> %vec_zero = arith.constant dense<0> : vector<2xi16>
%ins0 = vector.insert %lhs, %vec_zero[0] : i16 into vector<2xi16> %ins0 = vector.insert %lhs, %vec_zero[0] : i16 into vector<2xi16>
%operands = vector.insert %rhs, %ins0[1] : i16 into vector<2xi16> %operands = vector.insert %rhs, %ins0[1] : i16 into vector<2xi16>
vector.print %operands : vector<2xi16> vector.print %operands : vector<2xi16>
vector.print %res0 : i16 vector.print %res0 : i16
%mismatch = arith.cmpi ne, %res0, %res1 : i16 %mismatch = arith.cmpi ne, %res0, %res1 : i16
scf.if %mismatch -> () { scf.if %mismatch -> () {
vector.print %res1 : i16 vector.print %res1 : i16
func.call @printMismatch() : () -> () func.call @printMismatch() : () -> ()
} }
return return
} }
func.func @xorshift(%i : i16) -> (i16) { func.func @xorshift(%i : i16) -> (i16) {
%cst8 = arith.constant 8 : i16 %cst8 = arith.constant 8 : i16
%shifted = arith.shrui %i, %cst8 : i16 %shifted = arith.shrui %i, %cst8 : i16
%res = arith.xori %i, %shifted : i16 %res = arith.xori %i, %shifted : i16
return %res : i16 return %res : i16
} }
// Returns a hash of the input number. This is used we want to sample a bunch // Returns a hash of the input number. This is used we want to sample a bunch
// of i16 inputs with close to uniform distribution but without fixed offsets // of i16 inputs with close to uniform distribution but without fixed offsets
// between each sample. // between each sample.
func.func @xhash(%i : i16) -> (i16) { func.func @xhash(%i : i16) -> (i16) {
%pattern = arith.constant 21845 : i16 // Alternating ones and zeros. %pattern = arith.constant 21845 : i16 // Alternating ones and zeros.
%prime = arith.constant 25867 : i16 // Large i16 prime. %prime = arith.constant 25867 : i16 // Large i16 prime.
%xi = func.call @xorshift(%i) : (i16) -> (i16) %xi = func.call @xorshift(%i) : (i16) -> (i16)
%inner = arith.muli %xi, %pattern : i16 %inner = arith.muli %xi, %pattern : i16
%xinner = func.call @xorshift(%inner) : (i16) -> (i16) %xinner = func.call @xorshift(%inner) : (i16) -> (i16)
%res = arith.muli %xinner, %prime : i16 %res = arith.muli %xinner, %prime : i16
return %res : i16 return %res : i16
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Test arith.addi // Test arith.addi
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Ops in this function will be emulated using i8 ops. // Ops in this function will be emulated using i8 ops.
func.func @emulate_addi(%lhs : i16, %rhs : i16) -> (i16) { func.func @emulate_addi(%lhs : i16, %rhs : i16) -> (i16) {
%res = arith.addi %lhs, %rhs : i16 %res = arith.addi %lhs, %rhs : i16
return %res : i16 return %res : i16
} }
// Performs both wide and emulated `arith.muli`, and checks that the results // Performs both wide and emulated `arith.muli`, and checks that the results
// match. // match.
func.func @check_addi(%lhs : i16, %rhs : i16) -> () { func.func @check_addi(%lhs : i16, %rhs : i16) -> () {
%wide = arith.addi %lhs, %rhs : i16 %wide = arith.addi %lhs, %rhs : i16
%emulated = func.call @emulate_addi(%lhs, %rhs) : (i16, i16) -> (i16) %emulated = func.call @emulate_addi(%lhs, %rhs) : (i16, i16) -> (i16)
func.call @check_results(%lhs, %rhs, %wide, %emulated) : (i16, i16, i16, i16) -> () func.call @check_results(%lhs, %rhs, %wide, %emulated) : (i16, i16, i16, i16) -> ()
return return
} }
// Checks that `arith.addi` is emulated properly by sampling the input space. // Checks that `arith.addi` is emulated properly by sampling the input space.
// In total, this test function checks 500 * 500 = 250k input pairs. // In total, this test function checks 500 * 500 = 250k input pairs.
func.func @test_addi() -> () { func.func @test_addi() -> () {
%idx0 = arith.constant 0 : index %idx0 = arith.constant 0 : index
%idx1 = arith.constant 1 : index %idx1 = arith.constant 1 : index
%idx500 = arith.constant 500 : index %idx500 = arith.constant 500 : index
%cst0 = arith.constant 0 : i16 %cst0 = arith.constant 0 : i16
%cst1 = arith.constant 1 : i16 %cst1 = arith.constant 1 : i16
scf.for %lhs_idx = %idx0 to %idx500 step %idx1 iter_args(%lhs = %cst0) -> (i16) { scf.for %lhs_idx = %idx0 to %idx500 step %idx1 iter_args(%lhs = %cst0) -> (i16) {
%arg_lhs = func.call @xhash(%lhs) : (i16) -> (i16) %arg_lhs = func.call @xhash(%lhs) : (i16) -> (i16)
scf.for %rhs_idx = %idx0 to %idx500 step %idx1 iter_args(%rhs = %cst0) -> (i16) { scf.for %rhs_idx = %idx0 to %idx500 step %idx1 iter_args(%rhs = %cst0) -> (i16) {
%arg_rhs = func.call @xhash(%rhs) : (i16) -> (i16) %arg_rhs = func.call @xhash(%rhs) : (i16) -> (i16)
func.call @check_addi(%arg_lhs, %arg_rhs) : (i16, i16) -> () func.call @check_addi(%arg_lhs, %arg_rhs) : (i16, i16) -> ()
%rhs_next = arith.addi %rhs, %cst1 : i16 %rhs_next = arith.addi %rhs, %cst1 : i16
scf.yield %rhs_next : i16 scf.yield %rhs_next : i16
} }
%lhs_next = arith.addi %lhs, %cst1 : i16 %lhs_next = arith.addi %lhs, %cst1 : i16
scf.yield %lhs_next : i16 scf.yield %lhs_next : i16
} }
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Test arith.muli // Test arith.muli
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Ops in this function will be emulated using i8 ops. // Ops in this function will be emulated using i8 ops.
func.func @emulate_muli(%lhs : i16, %rhs : i16) -> (i16) { func.func @emulate_muli(%lhs : i16, %rhs : i16) -> (i16) {
%res = arith.muli %lhs, %rhs : i16 %res = arith.muli %lhs, %rhs : i16
return %res : i16 return %res : i16
} }
// Performs both wide and emulated `arith.muli`, and checks that the results // Performs both wide and emulated `arith.muli`, and checks that the results
// match. // match.
func.func @check_muli(%lhs : i16, %rhs : i16) -> () { func.func @check_muli(%lhs : i16, %rhs : i16) -> () {
%wide = arith.muli %lhs, %rhs : i16 %wide = arith.muli %lhs, %rhs : i16
%emulated = func.call @emulate_muli(%lhs, %rhs) : (i16, i16) -> (i16) %emulated = func.call @emulate_muli(%lhs, %rhs) : (i16, i16) -> (i16)
func.call @check_results(%lhs, %rhs, %wide, %emulated) : (i16, i16, i16, i16) -> () func.call @check_results(%lhs, %rhs, %wide, %emulated) : (i16, i16, i16, i16) -> ()
return return
} }
// Checks that `arith.muli` is emulated properly by sampling the input space. // Checks that `arith.muli` is emulated properly by sampling the input space.
// In total, this test function checks 500 * 500 = 250k input pairs. // In total, this test function checks 500 * 500 = 250k input pairs.
func.func @test_muli() -> () { func.func @test_muli() -> () {
%idx0 = arith.constant 0 : index %idx0 = arith.constant 0 : index
%idx1 = arith.constant 1 : index %idx1 = arith.constant 1 : index
%idx500 = arith.constant 500 : index %idx500 = arith.constant 500 : index
%cst0 = arith.constant 0 : i16 %cst0 = arith.constant 0 : i16
%cst1 = arith.constant 1 : i16 %cst1 = arith.constant 1 : i16
scf.for %lhs_idx = %idx0 to %idx500 step %idx1 iter_args(%lhs = %cst0) -> (i16) { scf.for %lhs_idx = %idx0 to %idx500 step %idx1 iter_args(%lhs = %cst0) -> (i16) {
%arg_lhs = func.call @xhash(%lhs) : (i16) -> (i16) %arg_lhs = func.call @xhash(%lhs) : (i16) -> (i16)
scf.for %rhs_idx = %idx0 to %idx500 step %idx1 iter_args(%rhs = %cst0) -> (i16) { scf.for %rhs_idx = %idx0 to %idx500 step %idx1 iter_args(%rhs = %cst0) -> (i16) {
%arg_rhs = func.call @xhash(%rhs) : (i16) -> (i16) %arg_rhs = func.call @xhash(%rhs) : (i16) -> (i16)
func.call @check_muli(%arg_lhs, %arg_rhs) : (i16, i16) -> () func.call @check_muli(%arg_lhs, %arg_rhs) : (i16, i16) -> ()
%rhs_next = arith.addi %rhs, %cst1 : i16 %rhs_next = arith.addi %rhs, %cst1 : i16
scf.yield %rhs_next : i16 scf.yield %rhs_next : i16
} }
%lhs_next = arith.addi %lhs, %cst1 : i16 %lhs_next = arith.addi %lhs, %cst1 : i16
scf.yield %lhs_next : i16 scf.yield %lhs_next : i16
} }
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Test arith.shrui // Test arith.shrui
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Ops in this function will be emulated using i8 ops. // Ops in this function will be emulated using i8 ops.
func.func @emulate_shrui(%lhs : i16, %rhs : i16) -> (i16) { func.func @emulate_shrui(%lhs : i16, %rhs : i16) -> (i16) {
%res = arith.shrui %lhs, %rhs : i16 %res = arith.shrui %lhs, %rhs : i16
return %res : i16 return %res : i16
} }
// Performs both wide and emulated `arith.shrui`, and checks that the results // Performs both wide and emulated `arith.shrui`, and checks that the results
// match. // match.
func.func @check_shrui(%lhs : i16, %rhs : i16) -> () { func.func @check_shrui(%lhs : i16, %rhs : i16) -> () {
%wide = arith.shrui %lhs, %rhs : i16 %wide = arith.shrui %lhs, %rhs : i16
%emulated = func.call @emulate_shrui(%lhs, %rhs) : (i16, i16) -> (i16) %emulated = func.call @emulate_shrui(%lhs, %rhs) : (i16, i16) -> (i16)
func.call @check_results(%lhs, %rhs, %wide, %emulated) : (i16, i16, i16, i16) -> () func.call @check_results(%lhs, %rhs, %wide, %emulated) : (i16, i16, i16, i16) -> ()
return return
} }
// Checks that `arith.shrui` is emulated properly by sampling the input space. // Checks that `arith.shrui` is emulated properly by sampling the input space.
// Checks all valid shift amounts for i16: 0 to 15. // Checks all valid shift amounts for i16: 0 to 15.
// In total, this test function checks 100 * 16 = 1.6k input pairs. // In total, this test function checks 100 * 16 = 1.6k input pairs.
func.func @test_shrui() -> () { func.func @test_shrui() -> () {
%idx0 = arith.constant 0 : index %idx0 = arith.constant 0 : index
%idx1 = arith.constant 1 : index %idx1 = arith.constant 1 : index
%idx16 = arith.constant 16 : index %idx16 = arith.constant 16 : index
%idx100 = arith.constant 100 : index %idx100 = arith.constant 100 : index
%cst0 = arith.constant 0 : i16 %cst0 = arith.constant 0 : i16
%cst1 = arith.constant 1 : i16 %cst1 = arith.constant 1 : i16
scf.for %lhs_idx = %idx0 to %idx100 step %idx1 iter_args(%lhs = %cst0) -> (i16) { scf.for %lhs_idx = %idx0 to %idx100 step %idx1 iter_args(%lhs = %cst0) -> (i16) {
%arg_lhs = func.call @xhash(%lhs) : (i16) -> (i16) %arg_lhs = func.call @xhash(%lhs) : (i16) -> (i16)
scf.for %rhs_idx = %idx0 to %idx16 step %idx1 iter_args(%rhs = %cst0) -> (i16) { scf.for %rhs_idx = %idx0 to %idx16 step %idx1 iter_args(%rhs = %cst0) -> (i16) {
func.call @check_shrui(%arg_lhs, %rhs) : (i16, i16) -> () func.call @check_shrui(%arg_lhs, %rhs) : (i16, i16) -> ()
%rhs_next = arith.addi %rhs, %cst1 : i16 %rhs_next = arith.addi %rhs, %cst1 : i16
scf.yield %rhs_next : i16 scf.yield %rhs_next : i16
} }
%lhs_next = arith.addi %lhs, %cst1 : i16 %lhs_next = arith.addi %lhs, %cst1 : i16
scf.yield %lhs_next : i16 scf.yield %lhs_next : i16
} }
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Entry Point // Entry Point
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func.func @entry() { func.func @entry() {
func.call @test_addi() : () -> () func.call @test_addi() : () -> ()
func.call @test_muli() : () -> () func.call @test_muli() : () -> ()
func.call @test_shrui() : () -> () func.call @test_shrui() : () -> ()
return return
} }

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.
// Check that the wide integer constant emulation produces the same result as wide // Check that the wide integer constant emulation produces the same result as wide
// constants and that printing works. Emulate i16 ops with i8 ops. // constants and that printing works. Emulate i16 ops with i8 ops.
// RUN: mlir-opt %s --test-arith-emulate-wide-int="widest-int-supported=8" \ // RUN: mlir-opt %s --test-arith-emulate-wide-int="widest-int-supported=8" \
// RUN: --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \ // RUN: --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \
// RUN: --convert-func-to-llvm --convert-arith-to-llvm | \ // RUN: --convert-func-to-llvm --convert-arith-to-llvm | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s --match-full-lines --check-prefix=EMULATED // RUN: FileCheck %s --match-full-lines --check-prefix=EMULATED
func.func @entry() { func.func @entry() {
%cst0 = arith.constant 0 : i16 %cst0 = arith.constant 0 : i16
func.call @emulate_constant(%cst0) : (i16) -> () func.call @emulate_constant(%cst0) : (i16) -> ()
func.call @foo(%cst0) : (i16) -> () func.call @foo(%cst0) : (i16) -> ()
return return
} }
func.func @emulate_constant(%first : i16) { func.func @emulate_constant(%first : i16) {
// EMULATED: ( 0, 0 ) // EMULATED: ( 0, 0 )
vector.print %first : i16 vector.print %first : i16
%cst0 = arith.constant 0 : i16 %cst0 = arith.constant 0 : i16
%cst1 = arith.constant 1 : i16 %cst1 = arith.constant 1 : i16
%cst_n1 = arith.constant -1 : i16 %cst_n1 = arith.constant -1 : i16
%cst_n3 = arith.constant -3 : i16 %cst_n3 = arith.constant -3 : i16
%cst13 = arith.constant 13 : i16 %cst13 = arith.constant 13 : i16
%cst256 = arith.constant 256 : i16 %cst256 = arith.constant 256 : i16
%cst_i16_max = arith.constant 32767 : i16 %cst_i16_max = arith.constant 32767 : i16
%cst_i16_min = arith.constant -32768 : i16 %cst_i16_min = arith.constant -32768 : i16
// EMULATED-NEXT: ( 0, 0 ) // EMULATED-NEXT: ( 0, 0 )
vector.print %cst0 : i16 vector.print %cst0 : i16
// EMULATED-NEXT: ( 1, 0 ) // EMULATED-NEXT: ( 1, 0 )
vector.print %cst1 : i16 vector.print %cst1 : i16
// EMULATED-NEXT: ( -1, -1 ) // EMULATED-NEXT: ( -1, -1 )
vector.print %cst_n1 : i16 vector.print %cst_n1 : i16
// EMULATED-NEXT: ( -3, -1 ) // EMULATED-NEXT: ( -3, -1 )
vector.print %cst_n3 : i16 vector.print %cst_n3 : i16
// EMULATED-NEXT: ( 13, 0 ) // EMULATED-NEXT: ( 13, 0 )
vector.print %cst13 : i16 vector.print %cst13 : i16
// EMULATED-NEXT: ( 0, 1 ) // EMULATED-NEXT: ( 0, 1 )
vector.print %cst256 : i16 vector.print %cst256 : i16
// EMULATED-NEXT: ( -1, 127 ) // EMULATED-NEXT: ( -1, 127 )
vector.print %cst_i16_max : i16 vector.print %cst_i16_max : i16
// EMULATED-NEXT: ( 0, -128 ) // EMULATED-NEXT: ( 0, -128 )
vector.print %cst_i16_min : i16 vector.print %cst_i16_min : i16
return return
} }
func.func @foo(%first: i16) { func.func @foo(%first: i16) {
// These should not be emulated because the function name does not start with // These should not be emulated because the function name does not start with
// 'emulated_'. // 'emulated_'.
// EMULATED-NEXT: 0 // EMULATED-NEXT: 0
vector.print %first : i16 vector.print %first : i16
// EMULATED-NEXT: 1 // EMULATED-NEXT: 1
%cst1 = arith.constant 1 : i16 %cst1 = arith.constant 1 : i16
vector.print %cst1 : i16 vector.print %cst1 : i16
return return
} }

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.
// Check that the wide integer multiplication emulation produces the same result as wide // Check that the wide integer multiplication emulation produces the same result as wide
// multiplication. Emulate i16 ops with i8 ops. // multiplication. Emulate i16 ops with i8 ops.
// RUN: mlir-opt %s --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \ // RUN: mlir-opt %s --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \
// RUN: --convert-func-to-llvm --convert-arith-to-llvm | \ // RUN: --convert-func-to-llvm --convert-arith-to-llvm | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s --match-full-lines // RUN: FileCheck %s --match-full-lines
// RUN: mlir-opt %s --test-arith-emulate-wide-int="widest-int-supported=8" \ // RUN: mlir-opt %s --test-arith-emulate-wide-int="widest-int-supported=8" \
// RUN: --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \ // RUN: --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \
// RUN: --convert-func-to-llvm --convert-arith-to-llvm | \ // RUN: --convert-func-to-llvm --convert-arith-to-llvm | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s --match-full-lines // RUN: FileCheck %s --match-full-lines
// Ops in this function *only* will be emulated using i8 types. // Ops in this function *only* will be emulated using i8 types.
func.func @emulate_muli(%lhs : i16, %rhs : i16) -> (i16) { func.func @emulate_muli(%lhs : i16, %rhs : i16) -> (i16) {
%res = arith.muli %lhs, %rhs : i16 %res = arith.muli %lhs, %rhs : i16
return %res : i16 return %res : i16
} }
func.func @check_muli(%lhs : i16, %rhs : i16) -> () { func.func @check_muli(%lhs : i16, %rhs : i16) -> () {
%res = func.call @emulate_muli(%lhs, %rhs) : (i16, i16) -> (i16) %res = func.call @emulate_muli(%lhs, %rhs) : (i16, i16) -> (i16)
vector.print %res : i16 vector.print %res : i16
return return
} }
func.func @entry() { func.func @entry() {
%cst0 = arith.constant 0 : i16 %cst0 = arith.constant 0 : i16
%cst1 = arith.constant 1 : i16 %cst1 = arith.constant 1 : i16
%cst_n1 = arith.constant -1 : i16 %cst_n1 = arith.constant -1 : i16
%cst_n3 = arith.constant -3 : i16 %cst_n3 = arith.constant -3 : i16
%cst13 = arith.constant 13 : i16 %cst13 = arith.constant 13 : i16
%cst37 = arith.constant 37 : i16 %cst37 = arith.constant 37 : i16
%cst42 = arith.constant 42 : i16 %cst42 = arith.constant 42 : i16
%cst256 = arith.constant 256 : i16 %cst256 = arith.constant 256 : i16
%cst_i16_max = arith.constant 32767 : i16 %cst_i16_max = arith.constant 32767 : i16
%cst_i16_min = arith.constant -32768 : i16 %cst_i16_min = arith.constant -32768 : i16
// CHECK: 0 // CHECK: 0
func.call @check_muli(%cst0, %cst0) : (i16, i16) -> () func.call @check_muli(%cst0, %cst0) : (i16, i16) -> ()
// CHECK-NEXT: 0 // CHECK-NEXT: 0
func.call @check_muli(%cst0, %cst1) : (i16, i16) -> () func.call @check_muli(%cst0, %cst1) : (i16, i16) -> ()
// CHECK-NEXT: 1 // CHECK-NEXT: 1
func.call @check_muli(%cst1, %cst1) : (i16, i16) -> () func.call @check_muli(%cst1, %cst1) : (i16, i16) -> ()
// CHECK-NEXT: -1 // CHECK-NEXT: -1
func.call @check_muli(%cst1, %cst_n1) : (i16, i16) -> () func.call @check_muli(%cst1, %cst_n1) : (i16, i16) -> ()
// CHECK-NEXT: 1 // CHECK-NEXT: 1
func.call @check_muli(%cst_n1, %cst_n1) : (i16, i16) -> () func.call @check_muli(%cst_n1, %cst_n1) : (i16, i16) -> ()
// CHECK-NEXT: -3 // CHECK-NEXT: -3
func.call @check_muli(%cst1, %cst_n3) : (i16, i16) -> () func.call @check_muli(%cst1, %cst_n3) : (i16, i16) -> ()
// CHECK-NEXT: 169 // CHECK-NEXT: 169
func.call @check_muli(%cst13, %cst13) : (i16, i16) -> () func.call @check_muli(%cst13, %cst13) : (i16, i16) -> ()
// CHECK-NEXT: 481 // CHECK-NEXT: 481
func.call @check_muli(%cst13, %cst37) : (i16, i16) -> () func.call @check_muli(%cst13, %cst37) : (i16, i16) -> ()
// CHECK-NEXT: 1554 // CHECK-NEXT: 1554
func.call @check_muli(%cst37, %cst42) : (i16, i16) -> () func.call @check_muli(%cst37, %cst42) : (i16, i16) -> ()
// CHECK-NEXT: -256 // CHECK-NEXT: -256
func.call @check_muli(%cst_n1, %cst256) : (i16, i16) -> () func.call @check_muli(%cst_n1, %cst256) : (i16, i16) -> ()
// CHECK-NEXT: 3328 // CHECK-NEXT: 3328
func.call @check_muli(%cst256, %cst13) : (i16, i16) -> () func.call @check_muli(%cst256, %cst13) : (i16, i16) -> ()
// CHECK-NEXT: 9472 // CHECK-NEXT: 9472
func.call @check_muli(%cst256, %cst37) : (i16, i16) -> () func.call @check_muli(%cst256, %cst37) : (i16, i16) -> ()
// CHECK-NEXT: -768 // CHECK-NEXT: -768
func.call @check_muli(%cst256, %cst_n3) : (i16, i16) -> () func.call @check_muli(%cst256, %cst_n3) : (i16, i16) -> ()
// CHECK-NEXT: 32755 // CHECK-NEXT: 32755
func.call @check_muli(%cst13, %cst_i16_max) : (i16, i16) -> () func.call @check_muli(%cst13, %cst_i16_max) : (i16, i16) -> ()
// CHECK-NEXT: -32768 // CHECK-NEXT: -32768
func.call @check_muli(%cst_i16_min, %cst37) : (i16, i16) -> () func.call @check_muli(%cst_i16_min, %cst37) : (i16, i16) -> ()
// CHECK-NEXT: 1 // CHECK-NEXT: 1
func.call @check_muli(%cst_i16_max, %cst_i16_max) : (i16, i16) -> () func.call @check_muli(%cst_i16_max, %cst_i16_max) : (i16, i16) -> ()
// CHECK-NEXT: -32768 // CHECK-NEXT: -32768
func.call @check_muli(%cst_i16_min, %cst13) : (i16, i16) -> () func.call @check_muli(%cst_i16_min, %cst13) : (i16, i16) -> ()
// CHECK-NEXT: 0 // CHECK-NEXT: 0
func.call @check_muli(%cst_i16_min, %cst_i16_min) : (i16, i16) -> () func.call @check_muli(%cst_i16_min, %cst_i16_min) : (i16, i16) -> ()
return return
} }

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.
// Check that the wide integer `arith.shrui` emulation produces the same result as wide // Check that the wide integer `arith.shrui` emulation produces the same result as wide
// `arith.shrui`. Emulate i16 ops with i8 ops. // `arith.shrui`. Emulate i16 ops with i8 ops.
// RUN: mlir-opt %s --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \ // RUN: mlir-opt %s --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \
// RUN: --convert-func-to-llvm --convert-arith-to-llvm | \ // RUN: --convert-func-to-llvm --convert-arith-to-llvm | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s --match-full-lines // RUN: FileCheck %s --match-full-lines
// RUN: mlir-opt %s --test-arith-emulate-wide-int="widest-int-supported=8" \ // RUN: mlir-opt %s --test-arith-emulate-wide-int="widest-int-supported=8" \
// RUN: --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \ // RUN: --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \
// RUN: --convert-func-to-llvm --convert-arith-to-llvm | \ // RUN: --convert-func-to-llvm --convert-arith-to-llvm | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s --match-full-lines // RUN: FileCheck %s --match-full-lines
// Ops in this function *only* will be emulated using i8 types. // Ops in this function *only* will be emulated using i8 types.
func.func @emulate_shrui(%lhs : i16, %rhs : i16) -> (i16) { func.func @emulate_shrui(%lhs : i16, %rhs : i16) -> (i16) {
%res = arith.shrui %lhs, %rhs : i16 %res = arith.shrui %lhs, %rhs : i16
return %res : i16 return %res : i16
} }
func.func @check_shrui(%lhs : i16, %rhs : i16) -> () { func.func @check_shrui(%lhs : i16, %rhs : i16) -> () {
%res = func.call @emulate_shrui(%lhs, %rhs) : (i16, i16) -> (i16) %res = func.call @emulate_shrui(%lhs, %rhs) : (i16, i16) -> (i16)
vector.print %res : i16 vector.print %res : i16
return return
} }
func.func @entry() { func.func @entry() {
%cst0 = arith.constant 0 : i16 %cst0 = arith.constant 0 : i16
%cst1 = arith.constant 1 : i16 %cst1 = arith.constant 1 : i16
%cst2 = arith.constant 2 : i16 %cst2 = arith.constant 2 : i16
%cst7 = arith.constant 7 : i16 %cst7 = arith.constant 7 : i16
%cst8 = arith.constant 8 : i16 %cst8 = arith.constant 8 : i16
%cst9 = arith.constant 9 : i16 %cst9 = arith.constant 9 : i16
%cst15 = arith.constant 15 : i16 %cst15 = arith.constant 15 : i16
%cst_n1 = arith.constant -1 : i16 %cst_n1 = arith.constant -1 : i16
%cst1337 = arith.constant 1337 : i16 %cst1337 = arith.constant 1337 : i16
%cst_i16_min = arith.constant -32768 : i16 %cst_i16_min = arith.constant -32768 : i16
// CHECK: 0 // CHECK: 0
// CHECK-NEXT: 0 // CHECK-NEXT: 0
// CHECK-NEXT: 0 // CHECK-NEXT: 0
// CHECK-NEXT: 1 // CHECK-NEXT: 1
// CHECK-NEXT: 32767 // CHECK-NEXT: 32767
// CHECK-NEXT: 1 // CHECK-NEXT: 1
func.call @check_shrui(%cst0, %cst0) : (i16, i16) -> () func.call @check_shrui(%cst0, %cst0) : (i16, i16) -> ()
func.call @check_shrui(%cst0, %cst1) : (i16, i16) -> () func.call @check_shrui(%cst0, %cst1) : (i16, i16) -> ()
func.call @check_shrui(%cst1, %cst1) : (i16, i16) -> () func.call @check_shrui(%cst1, %cst1) : (i16, i16) -> ()
func.call @check_shrui(%cst1, %cst0) : (i16, i16) -> () func.call @check_shrui(%cst1, %cst0) : (i16, i16) -> ()
func.call @check_shrui(%cst_n1, %cst1) : (i16, i16) -> () func.call @check_shrui(%cst_n1, %cst1) : (i16, i16) -> ()
func.call @check_shrui(%cst_n1, %cst15) : (i16, i16) -> () func.call @check_shrui(%cst_n1, %cst15) : (i16, i16) -> ()
// CHECK-NEXT: 1337 // CHECK-NEXT: 1337
// CHECK-NEXT: 334 // CHECK-NEXT: 334
// CHECK-NEXT: 10 // CHECK-NEXT: 10
// CHECK-NEXT: 5 // CHECK-NEXT: 5
// CHECK-NEXT: 2 // CHECK-NEXT: 2
// CHECK-NEXT: 0 // CHECK-NEXT: 0
func.call @check_shrui(%cst1337, %cst0) : (i16, i16) -> () func.call @check_shrui(%cst1337, %cst0) : (i16, i16) -> ()
func.call @check_shrui(%cst1337, %cst2) : (i16, i16) -> () func.call @check_shrui(%cst1337, %cst2) : (i16, i16) -> ()
func.call @check_shrui(%cst1337, %cst7) : (i16, i16) -> () func.call @check_shrui(%cst1337, %cst7) : (i16, i16) -> ()
func.call @check_shrui(%cst1337, %cst8) : (i16, i16) -> () func.call @check_shrui(%cst1337, %cst8) : (i16, i16) -> ()
func.call @check_shrui(%cst1337, %cst9) : (i16, i16) -> () func.call @check_shrui(%cst1337, %cst9) : (i16, i16) -> ()
func.call @check_shrui(%cst1337, %cst15) : (i16, i16) -> () func.call @check_shrui(%cst1337, %cst15) : (i16, i16) -> ()
// CHECK-NEXT: 16384 // CHECK-NEXT: 16384
// CHECK-NEXT: 8192 // CHECK-NEXT: 8192
// CHECK-NEXT: 256 // CHECK-NEXT: 256
// CHECK-NEXT: 128 // CHECK-NEXT: 128
// CHECK-NEXT: 64 // CHECK-NEXT: 64
// CHECK-NEXT: 1 // CHECK-NEXT: 1
func.call @check_shrui(%cst_i16_min, %cst1) : (i16, i16) -> () func.call @check_shrui(%cst_i16_min, %cst1) : (i16, i16) -> ()
func.call @check_shrui(%cst_i16_min, %cst2) : (i16, i16) -> () func.call @check_shrui(%cst_i16_min, %cst2) : (i16, i16) -> ()
func.call @check_shrui(%cst_i16_min, %cst7) : (i16, i16) -> () func.call @check_shrui(%cst_i16_min, %cst7) : (i16, i16) -> ()
func.call @check_shrui(%cst_i16_min, %cst8) : (i16, i16) -> () func.call @check_shrui(%cst_i16_min, %cst8) : (i16, i16) -> ()
func.call @check_shrui(%cst_i16_min, %cst9) : (i16, i16) -> () func.call @check_shrui(%cst_i16_min, %cst9) : (i16, i16) -> ()
func.call @check_shrui(%cst_i16_min, %cst15) : (i16, i16) -> () func.call @check_shrui(%cst_i16_min, %cst15) : (i16, i16) -> ()
return return
} }

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{
Show All 15 Lines

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-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/test/Integration/Dialect/Arith/CPU/test-wide-int-emulation-addi-i16.mlir