maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

NFC: Rename affine_apply to affine.apply. This is the first step to adding a namespace to the affine dialect. 

PiperOrigin-RevId: 232707862
This commit is contained in:
River Riddle 2019-02-06 11:08:18 -08:00 committed by jpienaar
parent b9dde91ea6
commit 3227dee15d
45 changed files with 773 additions and 773 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
mlir/g3doc/Canonicalization.md
View File

@ -53,7 +53,7 @@ These transformation are applied to all levels of IR:
These transformations are applied to builtin ops:
* `constant` ops are uniqued and hoisted into the entry block of a function.
* (TODO) Merge `affine_apply` instructions that directly feed each other.
* (TODO) Merge `affine.apply` instructions that directly feed each other.
## Standard Ops Canonicalizations

24
mlir/g3doc/Dialects/Affine.md
View File

@ -12,28 +12,28 @@ identifier can be bound to an SSA value that is either an argument to the
function, a value defined at the top level of that function (outside of all
loops and if instructions), the result of a
[`constant` operation](LangRef.md#'constant'-operation), or the result of an
[`affine_apply` operation](#'affine_apply'-operation) that recursively takes as
[`affine.apply` operation](#'affine.apply'-operation) that recursively takes as
arguments any symbolic identifiers. Dimensions may be bound not only to anything
that a symbol is bound to, but also to induction variables of enclosing
[for instructions](#'for'-operation), and the result of an
[`affine_apply` operation](#'affine_apply'-operation) (which recursively may use
[`affine.apply` operation](#'affine.apply'-operation) (which recursively may use
other dimensions and symbols).
## Operations {#operations}
#### 'affine_apply' operation {#'affine_apply'-operation}
#### 'affine.apply' operation {#'affine.apply'-operation}
Syntax:
``` {.ebnf}
operation ::= ssa-id `=` `affine_apply` affine-map dim-and-symbol-use-list
operation ::= ssa-id `=` `affine.apply` affine-map dim-and-symbol-use-list
```
The `affine_apply` instruction applies an
The `affine.apply` instruction applies an
[affine mapping](LangRef.md#affine-expressions) to a list of SSA values,
yielding a single SSA value. The number of dimension and symbol arguments to
affine_apply must be equal to the respective number of dimensional and symbolic
inputs to the affine mapping; the `affine_apply` instruction always returns one
affine.apply must be equal to the respective number of dimensional and symbolic
inputs to the affine mapping; the `affine.apply` instruction always returns one
value. The input operands and result must all have 'index' type.
Example:
@ -41,10 +41,10 @@ Example:
```mlir {.mlir}
#map10 = (d0, d1) -> (floordiv(d0,8) + floordiv(d1,128))
...
%1 = affine_apply #map10 (%s, %t)
%1 = affine.apply #map10 (%s, %t)
// Inline example.
%2 = affine_apply (i)[s0] -> (i+s0) (%42)[%n]
%2 = affine.apply (i)[s0] -> (i+s0) (%42)[%n]
```
#### 'for' operation {#'for'-operation}
@ -96,7 +96,7 @@ func @simple_example(%A: memref<?x?xf32>, %B: memref<?x?xf32>) {
%N = dim %A, 0 : memref<?x?xf32>
for %i = 0 to %N step 1 {
for %j = 0 to %N { // implicitly steps by 1
%0 = affine_apply #map57(%j)[%N]
%0 = affine.apply #map57(%j)[%N]
%tmp = call @F1(%A, %i, %0) : (memref<?x?xf32>, index, index)->(f32)
call @F2(%tmp, %B, %i, %0) : (f32, memref<?x?xf32>, index, index)->()
}
@ -132,10 +132,10 @@ Example:
func @reduced_domain_example(%A, %X, %N) : (memref<10xi32>, i32, i32) {
for %i = 0 to %N {
for %j = 0 to %N {
%0 = affine_apply #map42(%j)
%0 = affine.apply #map42(%j)
%tmp = call @S1(%X, %i, %0)
if #set(%i, %j)[%N] {
%1 = affine_apply #map43(%i, %j)
%1 = affine.apply #map43(%i, %j)
call @S2(%tmp, %A, %i, %1)
}
}

22
mlir/g3doc/LangRef.md
View File

@ -332,7 +332,7 @@ dimension indices and symbols into a list of results, with affine expressions
combining the indices and symbols. Affine maps distinguish between
[indices and symbols](#dimensions-and-symbols) because indices are inputs to the
affine map when the latter may be called through an operation, such as
[affine_apply](Dialects/Affine.md#'affine_apply'-operation) operation, whereas
[affine.apply](Dialects/Affine.md#'affine.apply'-operation) operation, whereas
symbols are bound when an affine mapping is established (e.g. when a memref is
formed, establishing a memory [layout map](#layout-map)).
@ -1216,7 +1216,7 @@ Example:
// Create memref which reshapes from 16x?xf32 to 16x4x?xf32.
#imapDR = (i, j, k)[S0] -> (i, j * S0 + k) size (16, 4 * S0)
%N4 = affine_apply (S -> floordiv(S,4)) (%N)
%N4 = affine.apply (S -> floordiv(S,4)) (%N)
%DR = reshape %D : memref<16x?xf32, #lmapD, hbm> (%N4)[%N4] to
(memref<16x?xf32, #lmapD, hbm> -> memref<16x4x?xf32, #imapDR, hbm>)
@ -1438,26 +1438,26 @@ In an `if` or `for` body, the indices of a load are restricted to SSA values
bound to surrounding loop induction variables,
[symbols](#dimensions-and-symbols), results of a
[`constant` operation](#'constant'-operation), or the result of an
`affine_apply` operation that can in turn take as arguments all of the
aforementioned SSA values or the recursively result of such an `affine_apply`
`affine.apply` operation that can in turn take as arguments all of the
aforementioned SSA values or the recursively result of such an `affine.apply`
operation.
Example:
```mlir {.mlir}
%1 = affine_apply (d0, d1) -> (3*d0) (%i, %j)
%2 = affine_apply (d0, d1) -> (d1+1) (%i, %j)
%1 = affine.apply (d0, d1) -> (3*d0) (%i, %j)
%2 = affine.apply (d0, d1) -> (d1+1) (%i, %j)
%12 = load %A[%1, %2] : memref<8x?xi32, #layout, hbm>
// Example of an indirect load (treated as non-affine)
%3 = affine_apply (d0) -> (2*d0 + 1)(%12)
%3 = affine.apply (d0) -> (2*d0 + 1)(%12)
%13 = load %A[%3, %2] : memref<4x?xi32, #layout, hbm>
```
**Context:** The `load` and `store` instructions are specifically crafted to
fully resolve a reference to an element of a memref, and (in affine `if` and
`for` instructions) the compiler can follow use-def chains (e.g. through
[`affine_apply`](Dialects/Affine.md#'affine_apply'-operation) operations) to
[`affine.apply`](Dialects/Affine.md#'affine.apply'-operation) operations) to
precisely analyze references at compile-time using polyhedral techniques. This
is possible because of the
[restrictions on dimensions and symbols](Dialects/Affine.md#restrictions-on-dimensions-and-symbols)
@ -1480,9 +1480,9 @@ In an affine context, the indices of a store are restricted to SSA values bound
to surrounding loop induction variables,
[symbols](Dialect/Affine.md#restrictions-on-dimensions-and-symbols), results of
a [`constant` operation](#'constant'-operation), or the result of an
[`affine_apply`](Dialect/Affine.md#'affine_apply'-operation) operation that can
[`affine.apply`](Dialect/Affine.md#'affine.apply'-operation) operation that can
in turn take as arguments all of the aforementioned SSA values or the
recursively result of such an `affine_apply` operation.
recursively result of such an `affine.apply` operation.
Example:
@ -1493,7 +1493,7 @@ store %100, %A[%1, 1023] : memref<4x?xf32, #layout, hbm>
**Context:** The `load` and `store` instructions are specifically crafted to
fully resolve a reference to an element of a memref, and (in polyhedral `if` and
`for` instructions) the compiler can follow use-def chains (e.g. through
[`affine_apply`](Dialects/Affine.md#'affine_apply'-operation) operations) to
[`affine.apply`](Dialects/Affine.md#'affine.apply'-operation) operations) to
precisely analyze references at compile-time using polyhedral techniques. This
is possible because of the
[restrictions on dimensions and symbols](Dialect/Affine.md#restrictions-on-dimensions-and-symbols)

6
mlir/g3doc/Passes.md
View File

@ -13,12 +13,12 @@ Loop statements are converted to a subgraph of blocks (initialization, condition
checking, subgraph of body blocks) with loop induction variable being passed as
the block argument of the condition checking block. Conditional statements are
converted to a subgraph of blocks (chain of condition checking with
short-circuit logic, subgraphs of 'then' and 'else' body blocks). `affine_apply`
short-circuit logic, subgraphs of 'then' and 'else' body blocks). `affine.apply`
operations are converted into sequences of primitive arithmetic operations that
have the same effect, using operands of the `index` type. Consequently, named
maps and sets may be removed from the module.
For example, `%r = affine_apply (d0, d1)[s0] -> (d0 + 2*d1 + s0)(%d0, %d1)[%s0]`
For example, `%r = affine.apply (d0, d1)[s0] -> (d0 + 2*d1 + s0)(%d0, %d1)[%s0]`
can be converted into:
```mlir
@ -49,7 +49,7 @@ present before the pass.
- The semantics of the other functions is preserved.
- Individual operations other than those mentioned above are not modified if
they do not depend on the loop iterator value or on the result of
`affine_apply`.
`affine.apply`.
## Standard+Builtin to LLVM IR dialect conversion (`-convert-to-llvmir`) {#convert-to-llvmir}

24
mlir/g3doc/Rationale.md
View File

@ -116,7 +116,7 @@ n-ranked tensor. This disallows the equivalent of pointer arithmetic or the
ability to index into the same memref in other ways (something which C arrays
allow for example). Furthermore, in an affine construct, the compiler can follow
use-def chains (e.g. through
[affine_apply instructions](Dialects/Affine.md#'affine_apply'-operation)) to
[affine.apply instructions](Dialects/Affine.md#'affine.apply'-operation)) to
precisely analyze references at compile-time using polyhedral techniques. This
is possible because of the
[restrictions on dimensions and symbols](Dialects/Affine.md#restrictions-on-dimensions-and-symbols).
@ -238,7 +238,7 @@ LLVM 2.0.
Index types are not allowed as elements of `vector`, `tensor` or `memref` type.
Index types are intended to be used for platform-specific "size" values and may
appear in subscripts, sizes of aggregate types and affine expressions. They are
also tightly coupled with `affine_apply` and load/store operations; having
also tightly coupled with `affine.apply` and load/store operations; having
`index` type is a necessary precondition of a value to be acceptable by these
operations. While it may be useful to have `memref<?xindex>` to express indirect
accesses in MLFunctions, e.g. sparse matrix manipulations or lookup tables, it
@ -567,7 +567,7 @@ func @search_body(%A: memref<?x?xi32>, %S: memref<?xi32>, %key: i32) {
```
As per the [MLIR spec](LangRef.md), the restrictions on dimensions and symbol
identifiers to be used with the affine_apply instruction only apply to accesses
identifiers to be used with the affine.apply instruction only apply to accesses
inside `for` and `if` instructions. However, an analysis of accesses inside the
called function (`@search_body`) is necessary to determine if the `%i` loop
could be parallelized: such function access analysis is calling context
@ -657,18 +657,18 @@ func @conv2d(memref<16x1024x1024x3xf32, #lm0, vmem> %input,
for %kw = 0 to %kernel_width {
for %if = 0 to %input_feature {
// Calculate input indices.
%1_0 = affine_apply #map1_0 (%0#1, %0#2, %0#4, %0#5)
%1_0 = affine.apply #map1_0 (%0#1, %0#2, %0#4, %0#5)
[%h_stride, %w_stride, %h_kernel_dilation, %w_kernel_dilation,
%h_pad_low, %w_pad_low]
%1_1 = affine_apply #map1_1 (%0#1, %0#2, %0#4, %0#5)
%1_1 = affine.apply #map1_1 (%0#1, %0#2, %0#4, %0#5)
[%h_stride, %w_stride, %h_kernel_dilation, %w_kernel_dilation,
%h_pad_low, %w_pad_low]
// Check if access is not in padding.
if #domain(%1_0, %1_1)
[%h_base_dilation, %w_kernel_dilation, %h_bound, %w_bound] {
%2_0 = affine_apply #map2 (%1_0, %1_1)
%2_1 = affine_apply #map2 (%1_0, %1_1)
%2_0 = affine.apply #map2 (%1_0, %1_1)
%2_1 = affine.apply #map2 (%1_0, %1_1)
// Compute: output[output_indices] += input[input_indices] * kernel[kernel_indices]
call @multiply_accumulate(%input, %kernel, %output, %b, %oh, %ow, %of, %kh, %kw, %if, %2_0, %2_1)
}
@ -750,27 +750,27 @@ func @matmul(%A, %B, %C, %M, %N, %K) : (...) { // %M, N, K are symbols
// t1, t2, t3, t4, t5, t6 are abstract polyhedral loops
mldim %t1 : {S1,S2,S3,S4,S5} floordiv (i, 128) {
mldim %t2 : {S1,S2,S3,S4,S5} floordiv (j, 128) {
// (%i, %j) = affine_apply (d0, d1) -> (128*d0, 128*d1) (%t1, %t2)
// (%i, %j) = affine.apply (d0, d1) -> (128*d0, 128*d1) (%t1, %t2)
call dma_hbm_to_vmem(%C, %i, %j, %M, %N, %K)
with @intset_ij(%i, %j) [%M, %N, %K]
mldim %t3 : {S2,S3,S4,S5} floordiv (k, 128) {
// (%i, %j, %k) = affine_apply (d0, d1, d2)
// (%i, %j, %k) = affine.apply (d0, d1, d2)
// -> (128*d0, 128*d1, 128*d2) (%t1, %t2, %t3)
call dma_hbm_to_vmem(%A, ...) with #inset_ijk (%i, %j, %k) [%M, %N, %K]
// (%i, %j, %k) = affine_apply (d0, d1, d2)
// (%i, %j, %k) = affine.apply (d0, d1, d2)
// -> (128*d0, 128*d1, 128*d2) (%t1, %t2, %t3)
call dma_hbm_to_vmem(%B, ...) with #inset_ijk (%i, %j, %k) [%M, %N, %K]
mldim %t4 : {S4} i mod 128 {
mldim %t5 : {S4} j mod 128 {
mldim %t6 : {S4} k mod 128 {
// (%i, %j, %k) = affine_apply #map0 (%t1, %t2, %t3, %t4, %t5, %t6)
// (%i, %j, %k) = affine.apply #map0 (%t1, %t2, %t3, %t4, %t5, %t6)
call matmul_body(A, B, C, %i, %j, %k, %M, %N, %K)
with #inset_ijk(%i, %j, %k) [%M, %N, %K]
} // end mld4im t6
} // end mldim t5
} // end mldim t4
} // end mldim t3
// (%i, %j) = affine_apply (d0, d1) -> (128*d0, 128*d1) (%t1, %t2)
// (%i, %j) = affine.apply (d0, d1) -> (128*d0, 128*d1) (%t1, %t2)
call $dma_vmem_to_hbm_C ... with #intset(%i, %j) [%M, %N, %K]
} // end mldim t2
} // end mldim t1

4
mlir/g3doc/RationaleSimplifiedPolyhedralForm.md
View File

@ -187,7 +187,7 @@ Our simple example above would be represented as:
for %i = 0 ... %N step 1 {
for %j = 0 ... %N step 1 {
// identity noop in this case, but can exist in general.
%0,%1 = affine_apply #57(%i, %j)
%0,%1 = affine.apply #57(%i, %j)
%tmp = call @S1(%X, %0, %1)
@ -212,7 +212,7 @@ The example with the reduced domain would be represented with an if instruction:
if (10 <= %i < %N-10), (10 <= %j < %N-10) {
%2,%3 = affine_apply(%i, %j) // identity noop in this case
%2,%3 = affine.apply(%i, %j) // identity noop in this case
call @S2(%tmp, %A, %2, %3)
}

8
mlir/include/mlir/AffineOps/AffineOps.h
View File

@ -38,19 +38,19 @@ public:
AffineOpsDialect(MLIRContext *context);
};
/// The "affine_apply" operation applies an affine map to a list of operands,
/// The "affine.apply" operation applies an affine map to a list of operands,
/// yielding a single result. The operand list must be the same size as the
/// number of arguments to the affine mapping. All operands and the result are
/// of type 'Index'. This operation requires a single affine map attribute named
/// "map". For example:
///
/// %y = "affine_apply" (%x) { map: (d0) -> (d0 + 1) } :
/// %y = "affine.apply" (%x) { map: (d0) -> (d0 + 1) } :
/// (index) -> (index)
///
/// equivalently:
///
/// #map42 = (d0)->(d0+1)
/// %y = affine_apply #map42(%x)
/// %y = affine.apply #map42(%x)
///
class AffineApplyOp : public Op<AffineApplyOp, OpTrait::VariadicOperands,
OpTrait::OneResult, OpTrait::HasNoSideEffect> {
@ -73,7 +73,7 @@ public:
/// Returns true if the result of this operation is a symbol.
bool isValidSymbol() const;
static StringRef getOperationName() { return "affine_apply"; }
static StringRef getOperationName() { return "affine.apply"; }
// Hooks to customize behavior of this op.
static bool parse(OpAsmParser *parser, OperationState *result);

2
mlir/include/mlir/Analysis/Utils.h
View File

@ -124,7 +124,7 @@ struct MemRefRegion {
/// identifiers as the rank of the memref, and *potentially* additional
/// symbolic identifiers which could include any of the loop IVs surrounding
/// opInst up until 'loopDepth' and another additional Function symbols
/// involved with the access (for eg., those appear in affine_apply's, loop
/// involved with the access (for eg., those appear in affine.apply's, loop
/// bounds, etc.). If 'sliceState' is non-null, operands from 'sliceState'
/// are added as symbols, and the following constraints are added to the
/// system:

12
mlir/include/mlir/Transforms/Utils.h
View File

@ -95,26 +95,26 @@ Instruction *createComposedAffineApplyOp(FuncBuilder *builder, Location loc,
/// Before
///
/// for %i = 0 to #map(%N)
/// %idx = affine_apply (d0) -> (d0 mod 2) (%i)
/// %idx = affine.apply (d0) -> (d0 mod 2) (%i)
/// send %A[%idx], ...
/// %v = "compute"(%idx, ...)
///
/// After
///
/// for %i = 0 to #map(%N)
/// %idx = affine_apply (d0) -> (d0 mod 2) (%i)
/// %idx = affine.apply (d0) -> (d0 mod 2) (%i)
/// send %A[%idx], ...
/// %idx_ = affine_apply (d0) -> (d0 mod 2) (%i)
/// %idx_ = affine.apply (d0) -> (d0 mod 2) (%i)
/// %v = "compute"(%idx_, ...)
/// This allows the application of different transformations on send and
/// compute (for eg. / different shifts/delays)
///
/// Returns nullptr either if none of opInst's operands were the result of an
/// affine_apply (i.e., there was no affine computation slice to create), or if
/// all the affine_apply op's supplying operands to this opInst did not have any
/// affine.apply (i.e., there was no affine computation slice to create), or if
/// all the affine.apply op's supplying operands to this opInst did not have any
/// uses other than those in this opInst. The method otherwise returns the list
/// of affine_apply operations created in output argument `sliceOps`.
/// of affine.apply operations created in output argument `sliceOps`.
void createAffineComputationSlice(
Instruction *opInst, SmallVectorImpl<OpPointer<AffineApplyOp>> *sliceOps);

6
mlir/lib/AffineOps/AffineOps.cpp
View File

@ -109,7 +109,7 @@ bool AffineApplyOp::parse(OpAsmParser *parser, OperationState *result) {
void AffineApplyOp::print(OpAsmPrinter *p) const {
auto map = getAffineMap();
*p << "affine_apply " << map;
*p << "affine.apply " << map;
printDimAndSymbolList(operand_begin(), operand_end(), map.getNumDims(), p);
p->printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/"map");
}
@ -185,13 +185,13 @@ namespace {
/// simplifications such as:
///
/// ```mlir
/// %1 = affine_apply (d0, d1) -> (d0 - d1) (%0, %0)
/// %1 = affine.apply (d0, d1) -> (d0 - d1) (%0, %0)
/// ```
///
/// into:
///
/// ```mlir
/// %1 = affine_apply () -> (0)
/// %1 = affine.apply () -> (0)
/// ```
struct AffineApplyNormalizer {
AffineApplyNormalizer(AffineMap map, ArrayRef<Value *> operands);

4
mlir/lib/Analysis/AffineAnalysis.cpp
View File

@ -758,7 +758,7 @@ void MemRefAccess::getAccessMap(AffineValueMap *accessMap) const {
//
// for %i0 = 0 to 100 {
// for %i1 = 0 to 50 {
// %a0 = affine_apply
// %a0 = affine.apply
// (d0, d1) -> (d0 * 2 - d1 * 4 + s1, d1 * 3 - s0) (%i0, %i1)[%M, %N]
// // Source memref access.
// store %v0, %m[%a0#0, %a0#1] : memref<4x4xf32>
@ -767,7 +767,7 @@ void MemRefAccess::getAccessMap(AffineValueMap *accessMap) const {
//
// for %i2 = 0 to 100 {
// for %i3 = 0 to 50 {
// %a1 = affine_apply
// %a1 = affine.apply
// (d0, d1) -> (d0 * 7 + d1 * 9 - s1, d1 * 11 + s0) (%i2, %i3)[%K, %M]
// // Destination memref access.
// %v1 = load %m[%a1#0, %a1#1] : memref<4x4xf32>

4
mlir/lib/StandardOps/StandardOps.cpp
View File

@ -1250,7 +1250,7 @@ bool LoadOp::verify() const {
// TODO: Verify we have the right number of indices.
// TODO: in Function verify that the indices are parameters, IV's, or the
// result of an affine_apply.
// result of an affine.apply.
return false;
}
@ -1561,7 +1561,7 @@ bool StoreOp::verify() const {
// TODO: Verify we have the right number of indices.
// TODO: in Function verify that the indices are parameters, IV's, or the
// result of an affine_apply.
// result of an affine.apply.
return false;
}

2
mlir/lib/Transforms/DmaGeneration.cpp
View File

@ -407,7 +407,7 @@ bool DmaGeneration::generateDma(const MemRefRegion &region, Block *block,
// access indices (subtracting out lower bound offsets for each dimension).
// Ex: to replace load %A[%i, %j] with load %Abuf[%i - %iT, %j - %jT],
// index remap will be (%i, %j) -> (%i - %iT, %j - %jT),
// i.e., affine_apply (d0, d1, d2, d3) -> (d2-d0, d3-d1) (%iT, %jT, %i, %j),
// i.e., affine.apply (d0, d1, d2, d3) -> (d2-d0, d3-d1) (%iT, %jT, %i, %j),
// and (%iT, %jT) will be the 'extraOperands' for 'rep all memref uses with'.
// d2, d3 correspond to the original indices (%i, %j).
SmallVector<AffineExpr, 4> remapExprs;

6
mlir/lib/Transforms/LowerAffine.cpp
View File

@ -414,7 +414,7 @@ bool LowerAffinePass::lowerAffineFor(OpPointer<AffineForOp> forOp) {
// +--------------------------------+
// | <code before the AffineIfOp> |
// | %zero = constant 0 : index |
// | %v = affine_apply #expr1(%ops) |
// | %v = affine.apply #expr1(%ops) |
// | %c = cmpi "sge" %v, %zero |
// | cond_br %c, %next, %else |
// +--------------------------------+
@ -516,7 +516,7 @@ bool LowerAffinePass::lowerAffineIf(AffineIfOp *ifOp) {
auto integerSet = ifOp->getIntegerSet();
// Implement short-circuit logic. For each affine expression in the 'if'
// condition, convert it into an affine map and call `affine_apply` to obtain
// condition, convert it into an affine map and call `affine.apply` to obtain
// the resulting value. Perform the equality or the greater-than-or-equality
// test between this value and zero depending on the equality flag of the
// condition. If the test fails, jump immediately to the false branch, which
@ -573,7 +573,7 @@ bool LowerAffinePass::lowerAffineIf(AffineIfOp *ifOp) {
return false;
}
// Convert an "affine_apply" operation into a sequence of arithmetic
// Convert an "affine.apply" operation into a sequence of arithmetic
// instructions using the StandardOps dialect. Return true on error.
bool LowerAffinePass::lowerAffineApply(AffineApplyOp *op) {
FuncBuilder builder(op->getInstruction());

8
mlir/lib/Transforms/MaterializeVectors.cpp
View File

@ -124,25 +124,25 @@
/// for %i1 = 0 to %arg1 step 4 {
/// for %i2 = 0 to %arg2 {
/// for %i3 = 0 to %arg3 step 4 {
/// %1 = affine_apply (d0, d1, d2, d3) -> (d0, d1, d2, d3)
/// %1 = affine.apply (d0, d1, d2, d3) -> (d0, d1, d2, d3)
/// (%i0, %i1, %i2, %i3)
/// vector_transfer_write f1, %0, %1#0, %1#1, %1#2, %1#3
/// {permutation_map: (d0, d1, d2, d3) -> (d1, d0)} :
/// vector<4x4xf32>, memref<?x?x?x?xf32>,
/// index, index, index, index
/// %2 = affine_apply (d0, d1, d2, d3) -> (d0, d1, d2, d3 + 1)
/// %2 = affine.apply (d0, d1, d2, d3) -> (d0, d1, d2, d3 + 1)
/// (%i0, %i1, %i2, %i3)
/// vector_transfer_write {{.*}}, %0, %2#0, %2#1, %2#2, %2#3
/// {permutation_map: (d0, d1, d2, d3) -> (d1, d0)} :
/// vector<4x4xf32>, memref<?x?x?x?xf32>,
/// index, index, index, index
/// %3 = affine_apply (d0, d1, d2, d3) -> (d0, d1, d2, d3 + 2)
/// %3 = affine.apply (d0, d1, d2, d3) -> (d0, d1, d2, d3 + 2)
/// (%i0, %i1, %i2, %i3)
/// vector_transfer_write {{.*}}, %0, %3#0, %3#1, %3#2, %3#3
/// {permutation_map: (d0, d1, d2, d3) -> (d1, d0)} :
/// vector<4x4xf32>, memref<?x?x?x?xf32>,
/// index, index, index, index
/// %4 = affine_apply (d0, d1, d2, d3) -> (d0, d1, d2, d3 + 3)
/// %4 = affine.apply (d0, d1, d2, d3) -> (d0, d1, d2, d3 + 3)
/// (%i0, %i1, %i2, %i3)
/// vector_transfer_write {{.*}}, %0, %4#0, %4#1, %4#2, %4#3
/// {permutation_map: (d0, d1, d2, d3) -> (d1, d0)} :

2
mlir/lib/Transforms/MemRefDataFlowOpt.cpp
View File

@ -147,7 +147,7 @@ void MemRefDataFlowOpt::forwardStoreToLoad(OpPointer<LoadOp> loadOp) {
// common surrounding loop. As an example this filters out cases like:
// for %i0
// for %i1
// %idx = affine_apply (d0) -> (d0 + 1) (%i0)
// %idx = affine.apply (d0) -> (d0 + 1) (%i0)
// store %A[%idx]
// load %A[%i0]
//

2
mlir/lib/Transforms/PipelineDataTransfer.cpp
View File

@ -324,7 +324,7 @@ PipelineDataTransfer::runOnAffineForOp(OpPointer<AffineForOp> forOp) {
instShiftMap[sliceOp->getInstruction()] = 0;
}
} else {
// If a slice wasn't created, the reachable affine_apply op's from its
// If a slice wasn't created, the reachable affine.apply op's from its
// operands are the ones that go with it.
SmallVector<Instruction *, 4> affineApplyInsts;
SmallVector<Value *, 4> operands(dmaStartInst->getOperands());

2
mlir/lib/Transforms/Utils/LoopUtils.cpp
View File

@ -113,7 +113,7 @@ bool mlir::promoteIfSingleIteration(OpPointer<AffineForOp> forOp) {
SmallVector<Value *, 4> lbOperands(lb.operand_begin(), lb.operand_end());
FuncBuilder builder(forInst->getBlock(), Block::iterator(forInst));
if (lb.getMap() == builder.getDimIdentityMap()) {
// No need of generating an affine_apply.
// No need of generating an affine.apply.
iv->replaceAllUsesWith(lbOperands[0]);
} else {
auto affineApplyOp = builder.create<AffineApplyOp>(

14
mlir/lib/Transforms/Utils/Utils.cpp
View File

@ -195,25 +195,25 @@ bool mlir::replaceAllMemRefUsesWith(const Value *oldMemRef, Value *newMemRef,
/// Before
///
/// for %i = 0 to #map(%N)
/// %idx = affine_apply (d0) -> (d0 mod 2) (%i)
/// %idx = affine.apply (d0) -> (d0 mod 2) (%i)
/// "send"(%idx, %A, ...)
/// "compute"(%idx)
///
/// After
///
/// for %i = 0 to #map(%N)
/// %idx = affine_apply (d0) -> (d0 mod 2) (%i)
/// %idx = affine.apply (d0) -> (d0 mod 2) (%i)
/// "send"(%idx, %A, ...)
/// %idx_ = affine_apply (d0) -> (d0 mod 2) (%i)
/// %idx_ = affine.apply (d0) -> (d0 mod 2) (%i)
/// "compute"(%idx_)
///
/// This allows applying different transformations on send and compute (for eg.
/// different shifts/delays).
///
/// Returns nullptr either if none of opInst's operands were the result of an
/// affine_apply and thus there was no affine computation slice to create, or if
/// all the affine_apply op's supplying operands to this opInst did not have any
/// uses besides this opInst; otherwise returns the list of affine_apply
/// affine.apply and thus there was no affine computation slice to create, or if
/// all the affine.apply op's supplying operands to this opInst did not have any
/// uses besides this opInst; otherwise returns the list of affine.apply
/// operations created in output argument `sliceOps`.
void mlir::createAffineComputationSlice(
Instruction *opInst, SmallVectorImpl<OpPointer<AffineApplyOp>> *sliceOps) {
@ -255,7 +255,7 @@ void mlir::createAffineComputationSlice(
auto composedMap = builder.getMultiDimIdentityMap(composedOpOperands.size());
fullyComposeAffineMapAndOperands(&composedMap, &composedOpOperands);
// Create an affine_apply for each of the map results.
// Create an affine.apply for each of the map results.
sliceOps->reserve(composedMap.getNumResults());
for (auto resultExpr : composedMap.getResults()) {
auto singleResMap = builder.getAffineMap(

126
mlir/test/AffineOps/canonicalize.mlir
View File

@ -35,39 +35,39 @@ func @compose_affine_maps_1dto2d_no_symbols() {
for %i0 = 0 to 15 {
// Test load[%x, %x]
%x0 = affine_apply (d0) -> (d0 - 1) (%i0)
%x1_0 = affine_apply (d0, d1) -> (d0) (%x0, %x0)
%x1_1 = affine_apply (d0, d1) -> (d1) (%x0, %x0)
%x0 = affine.apply (d0) -> (d0 - 1) (%i0)
%x1_0 = affine.apply (d0, d1) -> (d0) (%x0, %x0)
%x1_1 = affine.apply (d0, d1) -> (d1) (%x0, %x0)
// CHECK: [[I0A:%[0-9]+]] = affine_apply [[MAP0]](%i0)
// CHECK-NEXT: [[I0B:%[0-9]+]] = affine_apply [[MAP0]](%i0)
// CHECK: [[I0A:%[0-9]+]] = affine.apply [[MAP0]](%i0)
// CHECK-NEXT: [[I0B:%[0-9]+]] = affine.apply [[MAP0]](%i0)
// CHECK-NEXT: load %0{{\[}}[[I0A]], [[I0B]]{{\]}}
%v0 = load %0[%x1_0, %x1_1] : memref<4x4xf32>
// Test load[%y, %y]
%y0 = affine_apply (d0) -> (d0 + 1) (%i0)
%y1_0 = affine_apply (d0, d1) -> (d0) (%y0, %y0)
%y1_1 = affine_apply (d0, d1) -> (d1) (%y0, %y0)
%y0 = affine.apply (d0) -> (d0 + 1) (%i0)
%y1_0 = affine.apply (d0, d1) -> (d0) (%y0, %y0)
%y1_1 = affine.apply (d0, d1) -> (d1) (%y0, %y0)
// CHECK-NEXT: [[I1A:%[0-9]+]] = affine_apply [[MAP1]](%i0)
// CHECK-NEXT: [[I1B:%[0-9]+]] = affine_apply [[MAP1]](%i0)
// CHECK-NEXT: [[I1A:%[0-9]+]] = affine.apply [[MAP1]](%i0)
// CHECK-NEXT: [[I1B:%[0-9]+]] = affine.apply [[MAP1]](%i0)
// CHECK-NEXT: load %0{{\[}}[[I1A]], [[I1B]]{{\]}}
%v1 = load %0[%y1_0, %y1_1] : memref<4x4xf32>
// Test load[%x, %y]
%xy_0 = affine_apply (d0, d1) -> (d0) (%x0, %y0)
%xy_1 = affine_apply (d0, d1) -> (d1) (%x0, %y0)
%xy_0 = affine.apply (d0, d1) -> (d0) (%x0, %y0)
%xy_1 = affine.apply (d0, d1) -> (d1) (%x0, %y0)
// CHECK-NEXT: [[I2A:%[0-9]+]] = affine_apply [[MAP0]](%i0)
// CHECK-NEXT: [[I2B:%[0-9]+]] = affine_apply [[MAP1]](%i0)
// CHECK-NEXT: [[I2A:%[0-9]+]] = affine.apply [[MAP0]](%i0)
// CHECK-NEXT: [[I2B:%[0-9]+]] = affine.apply [[MAP1]](%i0)
// CHECK-NEXT: load %0{{\[}}[[I2A]], [[I2B]]{{\]}}
%v2 = load %0[%xy_0, %xy_1] : memref<4x4xf32>
// Test load[%y, %x]
%yx_0 = affine_apply (d0, d1) -> (d0) (%y0, %x0)
%yx_1 = affine_apply (d0, d1) -> (d1) (%y0, %x0)
// CHECK-NEXT: [[I3A:%[0-9]+]] = affine_apply [[MAP1]](%i0)
// CHECK-NEXT: [[I3B:%[0-9]+]] = affine_apply [[MAP0]](%i0)
%yx_0 = affine.apply (d0, d1) -> (d0) (%y0, %x0)
%yx_1 = affine.apply (d0, d1) -> (d1) (%y0, %x0)
// CHECK-NEXT: [[I3A:%[0-9]+]] = affine.apply [[MAP1]](%i0)
// CHECK-NEXT: [[I3B:%[0-9]+]] = affine.apply [[MAP0]](%i0)
// CHECK-NEXT: load %0{{\[}}[[I3A]], [[I3B]]{{\]}}
%v3 = load %0[%yx_0, %yx_1] : memref<4x4xf32>
}
@ -81,30 +81,30 @@ func @compose_affine_maps_1dto2d_with_symbols() {
for %i0 = 0 to 15 {
// Test load[%x0, %x0] with symbol %c4
%c4 = constant 4 : index
%x0 = affine_apply (d0)[s0] -> (d0 - s0) (%i0)[%c4]
%x0 = affine.apply (d0)[s0] -> (d0 - s0) (%i0)[%c4]
// CHECK: [[I0:%[0-9]+]] = affine_apply [[MAP4]](%i0)[%c4]
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP4]](%i0)[%c4]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I0]]{{\]}}
%v0 = load %0[%x0, %x0] : memref<4x4xf32>
// Test load[%x0, %x1] with symbol %c4 captured by '%x0' map.
%x1 = affine_apply (d0) -> (d0 + 1) (%i0)
%y1 = affine_apply (d0, d1) -> (d0+d1) (%x0, %x1)
// CHECK-NEXT: [[I1:%[0-9]+]] = affine_apply [[MAP6]](%i0)[%c4]
%x1 = affine.apply (d0) -> (d0 + 1) (%i0)
%y1 = affine.apply (d0, d1) -> (d0+d1) (%x0, %x1)
// CHECK-NEXT: [[I1:%[0-9]+]] = affine.apply [[MAP6]](%i0)[%c4]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I1]], [[I1]]{{\]}}
%v1 = load %0[%y1, %y1] : memref<4x4xf32>
// Test load[%x1, %x0] with symbol %c4 captured by '%x0' map.
%y2 = affine_apply (d0, d1) -> (d0 + d1) (%x1, %x0)
// CHECK-NEXT: [[I2:%[0-9]+]] = affine_apply [[MAP6]](%i0)[%c4]
%y2 = affine.apply (d0, d1) -> (d0 + d1) (%x1, %x0)
// CHECK-NEXT: [[I2:%[0-9]+]] = affine.apply [[MAP6]](%i0)[%c4]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I2]], [[I2]]{{\]}}
%v2 = load %0[%y2, %y2] : memref<4x4xf32>
// Test load[%x2, %x0] with symbol %c4 from '%x0' and %c5 from '%x2'
%c5 = constant 5 : index
%x2 = affine_apply (d0)[s0] -> (d0 + s0) (%i0)[%c5]
%y3 = affine_apply (d0, d1) -> (d0 + d1) (%x2, %x0)
// CHECK: [[I3:%[0-9]+]] = affine_apply [[MAP7]](%i0)[%c5, %c4]
%x2 = affine.apply (d0)[s0] -> (d0 + s0) (%i0)[%c5]
%y3 = affine.apply (d0, d1) -> (d0 + d1) (%x2, %x0)
// CHECK: [[I3:%[0-9]+]] = affine.apply [[MAP7]](%i0)[%c5, %c4]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I3]], [[I3]]{{\]}}
%v3 = load %0[%y3, %y3] : memref<4x4xf32>
}
@ -120,20 +120,20 @@ func @compose_affine_maps_2d_tile() {
%c8 = constant 8 : index
for %i0 = 0 to 3 {
%x0 = affine_apply (d0)[s0] -> (d0 ceildiv s0) (%i0)[%c4]
%x0 = affine.apply (d0)[s0] -> (d0 ceildiv s0) (%i0)[%c4]
for %i1 = 0 to 3 {
%x1 = affine_apply (d0)[s0] -> (d0 ceildiv s0) (%i1)[%c8]
%x1 = affine.apply (d0)[s0] -> (d0 ceildiv s0) (%i1)[%c8]
for %i2 = 0 to 3 {
%x2 = affine_apply (d0)[s0] -> (d0 mod s0) (%i2)[%c4]
%x2 = affine.apply (d0)[s0] -> (d0 mod s0) (%i2)[%c4]
for %i3 = 0 to 3 {
%x3 = affine_apply (d0)[s0] -> (d0 mod s0) (%i3)[%c8]
%x3 = affine.apply (d0)[s0] -> (d0 mod s0) (%i3)[%c8]
%x40 = affine_apply (d0, d1, d2, d3)[s0, s1] ->
%x40 = affine.apply (d0, d1, d2, d3)[s0, s1] ->
((d0 * s0) + d2) (%x0, %x1, %x2, %x3)[%c4, %c8]
%x41 = affine_apply (d0, d1, d2, d3)[s0, s1] ->
%x41 = affine.apply (d0, d1, d2, d3)[s0, s1] ->
((d1 * s1) + d3) (%x0, %x1, %x2, %x3)[%c4, %c8]
// CHECK: [[I0:%[0-9]+]] = affine_apply [[MAP8]](%i0, %i2)[%c4]
// CHECK: [[I1:%[0-9]+]] = affine_apply [[MAP8]](%i1, %i3)[%c8]
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP8]](%i0, %i2)[%c4]
// CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP8]](%i1, %i3)[%c8]
// CHECK-NEXT: [[L0:%[0-9]+]] = load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
%v0 = load %0[%x40, %x41] : memref<16x32xf32>
@ -157,16 +157,16 @@ func @compose_affine_maps_dependent_loads() {
%c3 = constant 3 : index
%c7 = constant 7 : index
%x00 = affine_apply (d0, d1, d2)[s0, s1] -> (d0 + s0)
%x00 = affine.apply (d0, d1, d2)[s0, s1] -> (d0 + s0)
(%i0, %i1, %i2)[%c3, %c7]
%x01 = affine_apply (d0, d1, d2)[s0, s1] -> (d1 - s1)
%x01 = affine.apply (d0, d1, d2)[s0, s1] -> (d1 - s1)
(%i0, %i1, %i2)[%c3, %c7]
%x02 = affine_apply (d0, d1, d2)[s0, s1] -> (d2 * s0)
%x02 = affine.apply (d0, d1, d2)[s0, s1] -> (d2 * s0)
(%i0, %i1, %i2)[%c3, %c7]
// CHECK: [[I0:%[0-9]+]] = affine_apply [[MAP9]](%i0)[%c3]
// CHECK: [[I1:%[0-9]+]] = affine_apply [[MAP4]](%i1)[%c7]
// CHECK: [[I2:%[0-9]+]] = affine_apply [[MAP10]](%i2)[%c3]
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP9]](%i0)[%c3]
// CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP4]](%i1)[%c7]
// CHECK: [[I2:%[0-9]+]] = affine.apply [[MAP10]](%i2)[%c3]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
%v0 = load %0[%x00, %x01] : memref<16x32xf32>
@ -178,13 +178,13 @@ func @compose_affine_maps_dependent_loads() {
%v2 = load %0[%x01, %x00] : memref<16x32xf32>
// Swizzle %x00, %x01 and %c3, %c7
%x10 = affine_apply (d0, d1)[s0, s1] -> (d0 * s1)
%x10 = affine.apply (d0, d1)[s0, s1] -> (d0 * s1)
(%x01, %x00)[%c7, %c3]
%x11 = affine_apply (d0, d1)[s0, s1] -> (d1 ceildiv s0)
%x11 = affine.apply (d0, d1)[s0, s1] -> (d1 ceildiv s0)
(%x01, %x00)[%c7, %c3]
// CHECK-NEXT: [[I2A:%[0-9]+]] = affine_apply [[MAP12]](%i1)[%c7]
// CHECK-NEXT: [[I2B:%[0-9]+]] = affine_apply [[MAP11]](%i0)[%c3, %c7]
// CHECK-NEXT: [[I2A:%[0-9]+]] = affine.apply [[MAP12]](%i1)[%c7]
// CHECK-NEXT: [[I2B:%[0-9]+]] = affine.apply [[MAP11]](%i0)[%c3, %c7]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I2A]], [[I2B]]{{\]}}
%v3 = load %0[%x10, %x11] : memref<16x32xf32>
}
@ -198,13 +198,13 @@ func @compose_affine_maps_diamond_dependency() {
%0 = alloc() : memref<4x4xf32>
for %i0 = 0 to 15 {
%a = affine_apply (d0) -> (d0 - 1) (%i0)
%b = affine_apply (d0) -> (d0 + 7) (%a)
%c = affine_apply (d0) -> (d0 * 4) (%a)
%d0 = affine_apply (d0, d1) -> (d0 ceildiv 8) (%b, %c)
%d1 = affine_apply (d0, d1) -> (d1 floordiv 3) (%b, %c)
// CHECK: [[I0:%[0-9]+]] = affine_apply [[MAP13A]](%i0)
// CHECK: [[I1:%[0-9]+]] = affine_apply [[MAP13B]](%i0)
%a = affine.apply (d0) -> (d0 - 1) (%i0)
%b = affine.apply (d0) -> (d0 + 7) (%a)
%c = affine.apply (d0) -> (d0 * 4) (%a)
%d0 = affine.apply (d0, d1) -> (d0 ceildiv 8) (%b, %c)
%d1 = affine.apply (d0, d1) -> (d1 floordiv 3) (%b, %c)
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP13A]](%i0)
// CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP13B]](%i0)
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
%v = load %0[%d0, %d1] : memref<4x4xf32>
}
@ -219,11 +219,11 @@ func @arg_used_as_dim_and_symbol(%arg0: memref<100x100xf32>, %arg1: index) {
%2 = alloc() : memref<1xi32>
for %i0 = 0 to 100 {
for %i1 = 0 to 100 {
%3 = affine_apply (d0, d1)[s0, s1] -> (d1 + s0 + s1)
%3 = affine.apply (d0, d1)[s0, s1] -> (d1 + s0 + s1)
(%i0, %i1)[%arg1, %c9]
%4 = affine_apply (d0, d1, d3) -> (d3 - (d0 + d1))
%4 = affine.apply (d0, d1, d3) -> (d3 - (d0 + d1))
(%arg1, %c9, %3)
// CHECK: [[I0:%[0-9]+]] = affine_apply [[MAP14]](%arg1, %c9, %i1)[%arg1, %c9]
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP14]](%arg1, %c9, %i1)[%arg1, %c9]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], %arg1{{\]}}
%5 = load %1[%4, %arg1] : memref<100x100xf32, 1>
}
@ -233,17 +233,17 @@ func @arg_used_as_dim_and_symbol(%arg0: memref<100x100xf32>, %arg1: index) {
// CHECK-LABEL: func @trivial_maps
func @trivial_maps() {
// CHECK-NOT: affine_apply
// CHECK-NOT: affine.apply
%0 = alloc() : memref<10xf32>
%c0 = constant 0 : index
%cst = constant 0.000000e+00 : f32
for %i1 = 0 to 10 {
%1 = affine_apply ()[s0] -> (s0)()[%c0]
%1 = affine.apply ()[s0] -> (s0)()[%c0]
store %cst, %0[%1] : memref<10xf32>
%2 = load %0[%c0] : memref<10xf32>
%3 = affine_apply ()[] -> (0)()[]
%3 = affine.apply ()[] -> (0)()[]
store %cst, %0[%3] : memref<10xf32>
%4 = load %0[%c0] : memref<10xf32>
}
@ -252,11 +252,11 @@ func @trivial_maps() {
// CHECK-LABEL: func @partial_fold_map
func @partial_fold_map(%arg0: memref<index>, %arg1: index, %arg2: index) {
// TODO: Constant fold one index into affine_apply
// TODO: Constant fold one index into affine.apply
%c42 = constant 42 : index
%2 = affine_apply (d0, d1) -> (d0 - d1) (%arg1, %c42)
%2 = affine.apply (d0, d1) -> (d0 - d1) (%arg1, %c42)
store %2, %arg0[] : memref<index>
// CHECK: [[X:%[0-9]+]] = affine_apply [[MAP15]](%arg1, %c42)
// CHECK: [[X:%[0-9]+]] = affine.apply [[MAP15]](%arg1, %c42)
// CHECK-NEXT: store [[X]], %arg0
return
@ -274,7 +274,7 @@ func @constant_fold_bounds(%N : index) {
%c9 = constant 9 : index
%c1 = constant 1 : index
%c2 = constant 2 : index
%c3 = affine_apply (d0, d1) -> (d0 + d1) (%c1, %c2)
%c3 = affine.apply (d0, d1) -> (d0 + d1) (%c1, %c2)
%l = "foo"() : () -> index
// CHECK: for %i0 = 5 to 7 {

2
mlir/test/IR/affine-map.mlir
View File

@ -9,7 +9,7 @@
// CHECK: #map{{[0-9]+}} = () -> (0)
// A map may have 0 inputs.
// However, an affine_apply always takes at least one input.
// However, an affine.apply always takes at least one input.
#map2 = () -> (0)
// All the maps in the following block are equivalent and are unique'd as one

10
mlir/test/IR/core-ops.mlir
View File

@ -207,12 +207,12 @@ func @affine_apply() {
%i = "constant"() {value: 0: index} : () -> index
%j = "constant"() {value: 1: index} : () -> index
// CHECK: affine_apply #map0(%c0)
%a = "affine_apply" (%i) { map: (d0) -> (d0 + 1) } :
// CHECK: affine.apply #map0(%c0)
%a = "affine.apply" (%i) { map: (d0) -> (d0 + 1) } :
(index) -> (index)
// CHECK: affine_apply #map1()[%c0]
%b = affine_apply ()[x] -> (x+1)()[%i]
// CHECK: affine.apply #map1()[%c0]
%b = affine.apply ()[x] -> (x+1)()[%i]
return
}
@ -307,7 +307,7 @@ func @test_dimop(%arg0: tensor<4x4x?xf32>) {
// CHECK: %0 = dim %arg0, 2 : tensor<4x4x?xf32>
%0 = dim %arg0, 2 : tensor<4x4x?xf32>
// use dim as an affine_int to ensure type correctness
%1 = affine_apply (d0) -> (d0)(%0)
%1 = affine.apply (d0) -> (d0)(%0)
return
}

6
mlir/test/IR/invalid-ops.mlir
View File

@ -43,7 +43,7 @@ func @constant_out_of_range() {
func @affine_apply_no_map() {
^bb0:
%i = "constant"() {value: 0} : () -> index
%x = "affine_apply" (%i) { } : (index) -> (index) // expected-error {{'affine_apply' op requires an affine map}}
%x = "affine.apply" (%i) { } : (index) -> (index) // expected-error {{'affine.apply' op requires an affine map}}
return
}
@ -52,7 +52,7 @@ func @affine_apply_no_map() {
func @affine_apply_wrong_operand_count() {
^bb0:
%i = "constant"() {value: 0} : () -> index
%x = "affine_apply" (%i) {map: (d0, d1) -> ((d0 + 1), (d1 + 2))} : (index) -> (index) // expected-error {{'affine_apply' op operand count and affine map dimension and symbol count must match}}
%x = "affine.apply" (%i) {map: (d0, d1) -> ((d0 + 1), (d1 + 2))} : (index) -> (index) // expected-error {{'affine.apply' op operand count and affine map dimension and symbol count must match}}
return
}
@ -62,7 +62,7 @@ func @affine_apply_wrong_result_count() {
^bb0:
%i = "constant"() {value: 0} : () -> index
%j = "constant"() {value: 1} : () -> index
%x = "affine_apply" (%i, %j) {map: (d0, d1) -> ((d0 + 1), (d1 + 2))} : (index,index) -> (index) // expected-error {{'affine_apply' op mapping must produce one value}}
%x = "affine.apply" (%i, %j) {map: (d0, d1) -> ((d0 + 1), (d1 + 2))} : (index,index) -> (index) // expected-error {{'affine.apply' op mapping must produce one value}}
return
}

2
mlir/test/IR/invalid.mlir
View File

@ -816,7 +816,7 @@ func @invalid_tensor_literal() {
func @invalid_affine_structure() {
%c0 = constant 0 : index
%idx = affine_apply (d0, d1) (%c0, %c0) // expected-error {{expected '->' or ':'}}
%idx = affine.apply (d0, d1) (%c0, %c0) // expected-error {{expected '->' or ':'}}
return
}

16
mlir/test/IR/parser.mlir
View File

@ -279,18 +279,18 @@ func @loop_bounds(%N : index) {
for %i = %s to %N {
// CHECK: for %i1 = #map{{[0-9]+}}(%i0) to 0
for %j = (d0)[]->(d0)(%i)[] to 0 step 1 {
// CHECK: %1 = affine_apply #map{{.*}}(%i0, %i1)[%0]
%w1 = affine_apply(d0, d1)[s0] -> (d0+d1) (%i, %j) [%s]
// CHECK: %2 = affine_apply #map{{.*}}(%i0, %i1)[%0]
%w2 = affine_apply(d0, d1)[s0] -> (s0+1) (%i, %j) [%s]
// CHECK: %1 = affine.apply #map{{.*}}(%i0, %i1)[%0]
%w1 = affine.apply(d0, d1)[s0] -> (d0+d1) (%i, %j) [%s]
// CHECK: %2 = affine.apply #map{{.*}}(%i0, %i1)[%0]
%w2 = affine.apply(d0, d1)[s0] -> (s0+1) (%i, %j) [%s]
// CHECK: for %i2 = #map{{.*}}(%1, %i0)[%arg0] to #map{{.*}}(%2, %i1)[%0] {
for %k = #bound_map1 (%w1, %i)[%N] to (i, j)[s] -> (i + j + s) (%w2, %j)[%s] {
// CHECK: "foo"(%i0, %i1, %i2) : (index, index, index) -> ()
"foo"(%i, %j, %k) : (index, index, index)->()
// CHECK: %c30 = constant 30 : index
%c = constant 30 : index
// CHECK: %3 = affine_apply #map{{.*}}(%arg0, %c30)
%u = affine_apply (d0, d1)->(d0+d1) (%N, %c)
// CHECK: %3 = affine.apply #map{{.*}}(%arg0, %c30)
%u = affine.apply (d0, d1)->(d0+d1) (%N, %c)
// CHECK: for %i3 = max #map{{.*}}(%i0)[%3] to min #map{{.*}}(%i2)[%c30] {
for %l = max #bound_map2(%i)[%u] to min #bound_map2(%k)[%c] {
// CHECK: "bar"(%i3) : (index) -> ()
@ -315,8 +315,8 @@ func @ifinst(%N: index) {
if (i)[N] : (i - 2 >= 0, 4 - i >= 0)(%i)[%N] { // CHECK if (#set1(%i0)[%arg0]) {
// CHECK: %c1 = constant 1 : index
%u = constant 1 : index
// CHECK: %2 = affine_apply #map{{.*}}(%i0, %i0)[%c1]
%w = affine_apply (d0,d1)[s0] -> (d0+d1+s0) (%i, %i) [%u]
// CHECK: %2 = affine.apply #map{{.*}}(%i0, %i0)[%c1]
%w = affine.apply (d0,d1)[s0] -> (d0+d1+s0) (%i, %i) [%u]
} else { // CHECK } else {
%v = constant 3 : i32 // %c3_i32 = constant 3 : i32
}

54
mlir/test/Transforms/Vectorize/lower_vector_transfers.mlir
View File

@ -9,11 +9,11 @@ func @materialize_read_1d() {
for %i0 = 0 to 7 step 4 {
for %i1 = 0 to 42 step 4 {
%f1 = vector_transfer_read %A, %i0, %i1 {permutation_map: (d0, d1) -> (d0)} : (memref<7x42xf32>, index, index) -> vector<4xf32>
%ip1 = affine_apply (d0) -> (d0 + 1) (%i1)
%ip1 = affine.apply (d0) -> (d0 + 1) (%i1)
%f2 = vector_transfer_read %A, %i0, %ip1 {permutation_map: (d0, d1) -> (d0)} : (memref<7x42xf32>, index, index) -> vector<4xf32>
%ip2 = affine_apply (d0) -> (d0 + 2) (%i1)
%ip2 = affine.apply (d0) -> (d0 + 2) (%i1)
%f3 = vector_transfer_read %A, %i0, %ip2 {permutation_map: (d0, d1) -> (d0)} : (memref<7x42xf32>, index, index) -> vector<4xf32>
%ip3 = affine_apply (d0) -> (d0 + 3) (%i1)
%ip3 = affine.apply (d0) -> (d0 + 3) (%i1)
%f4 = vector_transfer_read %A, %i0, %ip3 {permutation_map: (d0, d1) -> (d0)} : (memref<7x42xf32>, index, index) -> vector<4xf32>
// Both accesses in the load must be clipped otherwise %i1 + 2 and %i1 + 3 will go out of bounds.
// CHECK: {{.*}} = select
@ -35,7 +35,7 @@ func @materialize_read_1d_partially_specialized(%dyn1 : index, %dyn2 : index, %d
for %i3 = 0 to 42 step 2 {
for %i4 = 0 to %dyn4 {
%f1 = vector_transfer_read %A, %i0, %i1, %i2, %i3, %i4 {permutation_map: (d0, d1, d2, d3, d4) -> (d3)} : ( memref<7x?x?x42x?xf32>, index, index, index, index, index) -> vector<4xf32>
%i3p1 = affine_apply (d0) -> (d0 + 1) (%i3)
%i3p1 = affine.apply (d0) -> (d0 + 1) (%i3)
%f2 = vector_transfer_read %A, %i0, %i1, %i2, %i3p1, %i4 {permutation_map: (d0, d1, d2, d3, d4) -> (d3)} : ( memref<7x?x?x42x?xf32>, index, index, index, index, index) -> vector<4xf32>
}
}
@ -69,30 +69,30 @@ func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
// CHECK-NEXT: for %[[I4:.*]] = 0 to 3 {
// CHECK-NEXT: for %[[I5:.*]] = 0 to 4 {
// CHECK-NEXT: for %[[I6:.*]] = 0 to 5 {
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]]
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]]
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}}, %[[C0]] : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]]
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]]
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}} : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]]
// CHECK-NEXT: {{.*}} = affine_apply #[[SUB]]
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]]
// CHECK-NEXT: {{.*}} = affine.apply #[[SUB]]
// CHECK-NEXT: {{.*}} = select
// CHECK-NEXT: {{.*}} = select
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}} : index
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}} : index
// CHECK-NEXT: {{.*}} = affine_apply #[[SUB]]
// CHECK-NEXT: {{.*}} = affine.apply #[[SUB]]
// CHECK-NEXT: {{.*}} = select
// CHECK-NEXT: {{.*}} = select
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}} : index
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}} : index
// CHECK-NEXT: {{.*}} = affine_apply #[[SUB]]
// CHECK-NEXT: {{.*}} = affine.apply #[[SUB]]
// CHECK-NEXT: {{.*}} = select
// CHECK-NEXT: {{.*}} = select
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]]
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]]
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}}, %[[C0]] : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]]
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]]
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}}, {{.*}} : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]]
// CHECK-NEXT: {{.*}} = affine_apply #[[SUB]]
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]]
// CHECK-NEXT: {{.*}} = affine.apply #[[SUB]]
// CHECK-NEXT: {{.*}} = select {{.*}} : index
// CHECK-NEXT: {{.*}} = select {{.*}} : index
// CHECK-NEXT: {{.*}} = load %0[{{.*}}] : memref<?x?x?x?xf32>
@ -142,33 +142,33 @@ func @materialize_write(%M: index, %N: index, %O: index, %P: index) {
// CHECK-NEXT: for %[[I5:.*]] = 0 to 4 {
// CHECK-NEXT: for %[[I6:.*]] = 0 to 5 {
// CHECK-NEXT: {{.*}} = load {{.*}}[%[[I6]], %[[I5]], %[[I4]]] : memref<5x4x3xf32>
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]](%[[I0]], %[[I4]])
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]](%[[I0]], %[[I4]])
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}}, %[[C0]] : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]](%[[I0]], %[[I4]])
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]](%[[I0]], %[[I4]])
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}}, {{.*}} : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]](%[[I0]], %[[I4]])
// CHECK-NEXT: {{.*}} = affine_apply #[[SUB]]({{.*}}, %[[C1]])
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]](%[[I0]], %[[I4]])
// CHECK-NEXT: {{.*}} = affine.apply #[[SUB]]({{.*}}, %[[C1]])
// CHECK-NEXT: {{.*}} = select {{.*}}, {{.*}}, {{.*}} : index
// CHECK-NEXT: {{.*}} = select {{.*}}, %[[C0]], {{.*}} : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]](%[[I1]], %[[I5]])
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]](%[[I1]], %[[I5]])
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}}, %[[C0]] : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]](%[[I1]], %[[I5]])
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]](%[[I1]], %[[I5]])
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}}, {{.*}} : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]](%[[I1]], %[[I5]])
// CHECK-NEXT: {{.*}} = affine_apply #[[SUB]]({{.*}}, %[[C1]])
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]](%[[I1]], %[[I5]])
// CHECK-NEXT: {{.*}} = affine.apply #[[SUB]]({{.*}}, %[[C1]])
// CHECK-NEXT: {{.*}} = select {{.*}}, {{.*}}, {{.*}} : index
// CHECK-NEXT: {{.*}} = select {{.*}}, %[[C0]], {{.*}} : index
// CHECK-NEXT: {{.*}} = cmpi "slt", %[[I2]], %[[C0]] : index
// CHECK-NEXT: {{.*}} = cmpi "slt", %[[I2]], %3 : index
// CHECK-NEXT: {{.*}} = affine_apply #map{{.*}}(%3, %[[C1]])
// CHECK-NEXT: {{.*}} = affine.apply #map{{.*}}(%3, %[[C1]])
// CHECK-NEXT: {{.*}} = select {{.*}}, %[[I2]], {{.*}} : index
// CHECK-NEXT: {{.*}} = select {{.*}}, %[[C0]], {{.*}} : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]](%[[I3]], %[[I6]])
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]](%[[I3]], %[[I6]])
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}}, %[[C0]] : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]](%[[I3]], %[[I6]])
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]](%[[I3]], %[[I6]])
// CHECK-NEXT: {{.*}} = cmpi "slt", {{.*}}, {{.*}} : index
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]](%[[I3]], %[[I6]])
// CHECK-NEXT: {{.*}} = affine_apply #[[SUB]]({{.*}}, %[[C1]])
// CHECK-NEXT: {{.*}} = affine.apply #[[ADD]](%[[I3]], %[[I6]])
// CHECK-NEXT: {{.*}} = affine.apply #[[SUB]]({{.*}}, %[[C1]])
// CHECK-NEXT: {{.*}} = select {{.*}}, {{.*}}, {{.*}} : index
// CHECK-NEXT: {{.*}} = select {{.*}}, %[[C0]], {{.*}} : index
// CHECK-NEXT: store {{.*}}, {{.*}}[{{.*}}, {{.*}}, {{.*}}, {{.*}}] : memref<?x?x?x?xf32>

80
mlir/test/Transforms/Vectorize/materialize_vectors_1d_to_1d.mlir
View File

@ -21,17 +21,17 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
// CHECK-NEXT: [[CST1:%.*]] = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
// CHECK-NEXT: [[CST2:%.*]] = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
// CHECK-NEXT: [[CST3:%.*]] = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
// CHECK-NEXT: [[VAL00:%.*]] = affine_apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL01:%.*]] = affine_apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL00:%.*]] = affine.apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL01:%.*]] = affine.apply [[ID1]]{{.*}}
// CHECK-NEXT: vector_transfer_write [[CST0]], {{.*}}, [[VAL00]], [[VAL01]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
// CHECK-NEXT: [[VAL10:%.*]] = affine_apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL11:%.*]] = affine_apply [[D0P8]]{{.*}}
// CHECK-NEXT: [[VAL10:%.*]] = affine.apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL11:%.*]] = affine.apply [[D0P8]]{{.*}}
// CHECK-NEXT: vector_transfer_write [[CST1]], {{.*}}, [[VAL10]], [[VAL11]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
// CHECK-NEXT: [[VAL20:%.*]] = affine_apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL21:%.*]] = affine_apply [[D0P16]]{{.*}}
// CHECK-NEXT: [[VAL20:%.*]] = affine.apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL21:%.*]] = affine.apply [[D0P16]]{{.*}}
// CHECK-NEXT: vector_transfer_write [[CST2]], {{.*}}, [[VAL20]], [[VAL21]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
// CHECK-NEXT: [[VAL30:%.*]] = affine_apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL31:%.*]] = affine_apply [[D0P24]]{{.*}}
// CHECK-NEXT: [[VAL30:%.*]] = affine.apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL31:%.*]] = affine.apply [[D0P24]]{{.*}}
// CHECK-NEXT: vector_transfer_write [[CST3]], {{.*}}, [[VAL30]], [[VAL31]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
//
for %i0 = 0 to %M {
@ -47,17 +47,17 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
// CHECK-NEXT: [[CST1:%.*]] = constant splat<vector<8xf32>, 2.000000e+00> : vector<8xf32>
// CHECK-NEXT: [[CST2:%.*]] = constant splat<vector<8xf32>, 2.000000e+00> : vector<8xf32>
// CHECK-NEXT: [[CST3:%.*]] = constant splat<vector<8xf32>, 2.000000e+00> : vector<8xf32>
// CHECK-NEXT: [[VAL00:%.*]] = affine_apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL01:%.*]] = affine_apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL00:%.*]] = affine.apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL01:%.*]] = affine.apply [[ID1]]{{.*}}
// CHECK-NEXT: vector_transfer_write [[CST0]], {{.*}}, [[VAL00]], [[VAL01]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
// CHECK-NEXT: [[VAL10:%.*]] = affine_apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL11:%.*]] = affine_apply [[D0P8]]{{.*}}
// CHECK-NEXT: [[VAL10:%.*]] = affine.apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL11:%.*]] = affine.apply [[D0P8]]{{.*}}
// CHECK-NEXT: vector_transfer_write [[CST1]], {{.*}}, [[VAL10]], [[VAL11]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
// CHECK-NEXT: [[VAL20:%.*]] = affine_apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL21:%.*]] = affine_apply [[D0P16]]{{.*}}
// CHECK-NEXT: [[VAL20:%.*]] = affine.apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL21:%.*]] = affine.apply [[D0P16]]{{.*}}
// CHECK-NEXT: vector_transfer_write [[CST2]], {{.*}}, [[VAL20]], [[VAL21]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
// CHECK-NEXT: [[VAL30:%.*]] = affine_apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL31:%.*]] = affine_apply [[D0P24]]{{.*}}
// CHECK-NEXT: [[VAL30:%.*]] = affine.apply [[ID1]]{{.*}}
// CHECK-NEXT: [[VAL31:%.*]] = affine.apply [[D0P24]]{{.*}}
// CHECK-NEXT: vector_transfer_write [[CST3]], {{.*}}, [[VAL30]], [[VAL31]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
//
for %i2 = 0 to %M {
@ -69,45 +69,45 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
// 4x unroll (jammed by construction).
// CHECK: for %i4 = 0 to %arg0 {
// CHECK-NEXT: for %i5 = 0 to %arg1 step 32 {
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = addf {{.*}} : vector<8xf32>
// CHECK-NEXT: {{.*}} = addf {{.*}} : vector<8xf32>
// CHECK-NEXT: {{.*}} = addf {{.*}} : vector<8xf32>
// CHECK-NEXT: {{.*}} = addf {{.*}} : vector<8xf32>
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
//
for %i4 = 0 to %M {

96
mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_1d.mlir
View File

@ -23,23 +23,23 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
// CHECK-NEXT: {{.*}} = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
// CHECK-NEXT: {{.*}} = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
// CHECK-NEXT: {{.*}} = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
// CHECK-NEXT: [[VAL00:%.*]] = affine_apply [[ID1]](%i0)
// CHECK-NEXT: [[VAL01:%.*]] = affine_apply [[ID1]](%i1)
// CHECK-NEXT: [[VAL00:%.*]] = affine.apply [[ID1]](%i0)
// CHECK-NEXT: [[VAL01:%.*]] = affine.apply [[ID1]](%i1)
// CHECK-NEXT: vector_transfer_write {{.*}}, {{.*}}, [[VAL00]], [[VAL01]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
// CHECK-NEXT: [[VAL10:%.*]] = affine_apply [[ID1]](%i0)
// CHECK-NEXT: [[VAL11:%.*]] = affine_apply [[D0P8]](%i1)
// CHECK-NEXT: [[VAL10:%.*]] = affine.apply [[ID1]](%i0)
// CHECK-NEXT: [[VAL11:%.*]] = affine.apply [[D0P8]](%i1)
// CHECK-NEXT: vector_transfer_write {{.*}}, {{.*}}, [[VAL10]], [[VAL11]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
// CHECK-NEXT: [[VAL20:%.*]] = affine_apply [[D0P1]](%i0)
// CHECK-NEXT: [[VAL21:%.*]] = affine_apply [[ID1]](%i1)
// CHECK-NEXT: [[VAL20:%.*]] = affine.apply [[D0P1]](%i0)
// CHECK-NEXT: [[VAL21:%.*]] = affine.apply [[ID1]](%i1)
// CHECK-NEXT: vector_transfer_write {{.*}}, {{.*}}, [[VAL20]], [[VAL21]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
// CHECK-NEXT: [[VAL30:%.*]] = affine_apply [[D0P1]](%i0)
// CHECK-NEXT: [[VAL31:%.*]] = affine_apply [[D0P8]](%i1)
// CHECK-NEXT: [[VAL30:%.*]] = affine.apply [[D0P1]](%i0)
// CHECK-NEXT: [[VAL31:%.*]] = affine.apply [[D0P8]](%i1)
// CHECK-NEXT: vector_transfer_write {{.*}}, {{.*}}, [[VAL30]], [[VAL31]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
// CHECK-NEXT: [[VAL40:%.*]] = affine_apply [[D0P2]](%i0)
// CHECK-NEXT: [[VAL41:%.*]] = affine_apply [[ID1]](%i1)
// CHECK-NEXT: [[VAL40:%.*]] = affine.apply [[D0P2]](%i0)
// CHECK-NEXT: [[VAL41:%.*]] = affine.apply [[ID1]](%i1)
// CHECK-NEXT: vector_transfer_write {{.*}}, {{.*}}, [[VAL40]], [[VAL41]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
// CHECK-NEXT: [[VAL50:%.*]] = affine_apply [[D0P2]](%i0)
// CHECK-NEXT: [[VAL51:%.*]] = affine_apply [[D0P8]](%i1)
// CHECK-NEXT: [[VAL50:%.*]] = affine.apply [[D0P2]](%i0)
// CHECK-NEXT: [[VAL51:%.*]] = affine.apply [[D0P8]](%i1)
// CHECK-NEXT: vector_transfer_write {{.*}}, {{.*}}, [[VAL50]], [[VAL51]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
for %i0 = 0 to %M {
for %i1 = 0 to %N {
@ -61,41 +61,41 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
// (3x2)x unroll (jammed by construction).
// CHECK: for %i4 = 0 to %arg0 step 3 {
// CHECK-NEXT: for %i5 = 0 to %arg1 step 16 {
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = addf {{.*}} : vector<8xf32>
// CHECK-NEXT: {{.*}} = addf {{.*}} : vector<8xf32>
@ -103,23 +103,23 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
// CHECK-NEXT: {{.*}} = addf {{.*}} : vector<8xf32>
// CHECK-NEXT: {{.*}} = addf {{.*}} : vector<8xf32>
// CHECK-NEXT: {{.*}} = addf {{.*}} : vector<8xf32>
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
//
for %i4 = 0 to %M {

40
mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_2d.mlir
View File

@ -17,11 +17,11 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
// CHECK-NEXT: for %i1 = 0 to %arg1 step 32 {
// CHECK-NEXT: {{.*}} = constant splat<vector<3x16xf32>, 1.000000e+00> : vector<3x16xf32>
// CHECK-NEXT: {{.*}} = constant splat<vector<3x16xf32>, 1.000000e+00> : vector<3x16xf32>
// CHECK-NEXT: [[VAL00:%.*]] = affine_apply [[ID1]](%i0)
// CHECK-NEXT: [[VAL01:%.*]] = affine_apply [[ID1]](%i1)
// CHECK-NEXT: [[VAL00:%.*]] = affine.apply [[ID1]](%i0)
// CHECK-NEXT: [[VAL01:%.*]] = affine.apply [[ID1]](%i1)
// CHECK-NEXT: vector_transfer_write {{.*}}, {{.*}}, [[VAL00]], [[VAL01]] {permutation_map: [[ID2]]} : vector<3x16xf32>
// CHECK-NEXT: [[VAL10:%.*]] = affine_apply [[ID1]](%i0)
// CHECK-NEXT: [[VAL11:%.*]] = affine_apply [[D0P16]](%i1)
// CHECK-NEXT: [[VAL10:%.*]] = affine.apply [[ID1]](%i0)
// CHECK-NEXT: [[VAL11:%.*]] = affine.apply [[D0P16]](%i1)
// CHECK-NEXT: vector_transfer_write {{.*}}, {{.*}}, [[VAL10]], [[VAL11]] {permutation_map: [[ID2]]} : vector<3x16xf32>
//
for %i0 = 0 to %M {
@ -35,11 +35,11 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
// CHECK-NEXT: for %i3 = 0 to %arg1 step 32 {
// CHECK-NEXT: {{.*}} = constant splat<vector<3x16xf32>, 2.000000e+00> : vector<3x16xf32>
// CHECK-NEXT: {{.*}} = constant splat<vector<3x16xf32>, 2.000000e+00> : vector<3x16xf32>
// CHECK-NEXT: [[VAL00:%.*]] = affine_apply [[ID1]](%i2)
// CHECK-NEXT: [[VAL01:%.*]] = affine_apply [[ID1]](%i3)
// CHECK-NEXT: [[VAL00:%.*]] = affine.apply [[ID1]](%i2)
// CHECK-NEXT: [[VAL01:%.*]] = affine.apply [[ID1]](%i3)
// CHECK-NEXT: vector_transfer_write {{.*}}, {{.*}}, [[VAL00]], [[VAL01]] {permutation_map: [[ID2]]} : vector<3x16xf32>
// CHECK-NEXT: [[VAL10:%.*]] = affine_apply [[ID1]](%i2)
// CHECK-NEXT: [[VAL11:%.*]] = affine_apply [[D0P16]](%i3)
// CHECK-NEXT: [[VAL10:%.*]] = affine.apply [[ID1]](%i2)
// CHECK-NEXT: [[VAL11:%.*]] = affine.apply [[D0P16]](%i3)
// CHECK-NEXT: vector_transfer_write {{.*}}, {{.*}}, [[VAL10]], [[VAL11]] {permutation_map: [[ID2]]} : vector<3x16xf32>
//
for %i2 = 0 to %M {
@ -51,25 +51,25 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
// 2x unroll (jammed by construction).
// CHECK: for %i4 = 0 to %arg0 step 3 {
// CHECK-NEXT: for %i5 = 0 to %arg1 step 32 {
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = vector_transfer_read
// CHECK-NEXT: {{.*}} = addf {{.*}} : vector<3x16xf32>
// CHECK-NEXT: {{.*}} = addf {{.*}} : vector<3x16xf32>
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine_apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: {{.*}} = affine.apply
// CHECK-NEXT: vector_transfer_write
//
for %i4 = 0 to %M {

48
mlir/test/Transforms/Vectorize/normalize_maps.mlir
View File

@ -10,49 +10,49 @@
// CHECK-LABEL: func @simple()
func @simple() {
for %i0 = 0 to 7 {
%0 = affine_apply (d0) -> (d0) (%i0)
%1 = affine_apply (d0) -> (d0) (%0)
%2 = affine_apply (d0, d1) -> (d0 + d1) (%0, %0)
%3 = affine_apply (d0, d1) -> (d0 - d1) (%0, %0)
%0 = affine.apply (d0) -> (d0) (%i0)
%1 = affine.apply (d0) -> (d0) (%0)
%2 = affine.apply (d0, d1) -> (d0 + d1) (%0, %0)
%3 = affine.apply (d0, d1) -> (d0 - d1) (%0, %0)
}
// CHECK-NEXT: for %i0 = 0 to 7
// CHECK-NEXT: {{.*}} affine_apply #[[ID1]](%i0)
// CHECK-NEXT: {{.*}} affine_apply #[[D0TIMES2]](%i0)
// CHECK-NEXT: {{.*}} affine_apply #[[ZERO]]()
// CHECK-NEXT: {{.*}} affine.apply #[[ID1]](%i0)
// CHECK-NEXT: {{.*}} affine.apply #[[D0TIMES2]](%i0)
// CHECK-NEXT: {{.*}} affine.apply #[[ZERO]]()
for %i1 = 0 to 7 {
for %i2 = 0 to 42 {
%20 = affine_apply (d0, d1) -> (d1) (%i1, %i2)
%21 = affine_apply (d0, d1) -> (d0) (%i1, %i2)
%22 = affine_apply (d0, d1) -> (d0 + d1) (%20, %21)
%23 = affine_apply (d0, d1) -> (d0 - d1) (%20, %21)
%24 = affine_apply (d0, d1) -> (-d0 + d1) (%20, %21)
%20 = affine.apply (d0, d1) -> (d1) (%i1, %i2)
%21 = affine.apply (d0, d1) -> (d0) (%i1, %i2)
%22 = affine.apply (d0, d1) -> (d0 + d1) (%20, %21)
%23 = affine.apply (d0, d1) -> (d0 - d1) (%20, %21)
%24 = affine.apply (d0, d1) -> (-d0 + d1) (%20, %21)
}
}
// CHECK: for %i1 = 0 to 7
// CHECK-NEXT: for %i2 = 0 to 42
// CHECK-NEXT: {{.*}} affine_apply #[[D0PLUSD1]](%i1, %i2)
// CHECK-NEXT: {{.*}} affine_apply #[[MINSD0PLUSD1]](%i1, %i2)
// CHECK-NEXT: {{.*}} affine_apply #[[D0MINUSD1]](%i1, %i2)
// CHECK-NEXT: {{.*}} affine.apply #[[D0PLUSD1]](%i1, %i2)
// CHECK-NEXT: {{.*}} affine.apply #[[MINSD0PLUSD1]](%i1, %i2)
// CHECK-NEXT: {{.*}} affine.apply #[[D0MINUSD1]](%i1, %i2)
for %i3 = 0 to 16 {
for %i4 = 0 to 47 step 2 {
for %i5 = 0 to 78 step 16 {
%50 = affine_apply (d0) -> (d0) (%i3)
%51 = affine_apply (d0) -> (d0) (%i4)
%52 = affine_apply (d0) -> (d0) (%i5)
%53 = affine_apply (d0, d1, d2) -> (d0) (%50, %51, %52)
%54 = affine_apply (d0, d1, d2) -> (d1) (%50, %51, %52)
%55 = affine_apply (d0, d1, d2) -> (d2) (%50, %51, %52)
%50 = affine.apply (d0) -> (d0) (%i3)
%51 = affine.apply (d0) -> (d0) (%i4)
%52 = affine.apply (d0) -> (d0) (%i5)
%53 = affine.apply (d0, d1, d2) -> (d0) (%50, %51, %52)
%54 = affine.apply (d0, d1, d2) -> (d1) (%50, %51, %52)
%55 = affine.apply (d0, d1, d2) -> (d2) (%50, %51, %52)
}
}
}
// CHECK: for %i3 = 0 to 16
// CHECK-NEXT: for %i4 = 0 to 47 step 2
// CHECK-NEXT: for %i5 = 0 to 78 step 16
// CHECK-NEXT: {{.*}} affine_apply #[[ID1]](%i3)
// CHECK-NEXT: {{.*}} affine_apply #[[ID1]](%i4)
// CHECK-NEXT: {{.*}} affine_apply #[[ID1]](%i5)
// CHECK-NEXT: {{.*}} affine.apply #[[ID1]](%i3)
// CHECK-NEXT: {{.*}} affine.apply #[[ID1]](%i4)
// CHECK-NEXT: {{.*}} affine.apply #[[ID1]](%i5)
return
}

40
mlir/test/Transforms/Vectorize/vectorize_1d.mlir
View File

@ -34,27 +34,27 @@ func @vec1d(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
//
// CHECK: for %i{{[0-9]*}} = 0 to [[ARG_M]] {
for %i2 = 0 to %M { // not vectorized, would vectorize with --test-fastest-varying=1
%r2 = affine_apply (d0) -> (d0) (%i2)
%r2 = affine.apply (d0) -> (d0) (%i2)
%a2 = load %A[%r2#0, %cst0] : memref<?x?xf32>
}
//
// CHECK:for [[IV3:%[a-zA-Z0-9]+]] = 0 to [[ARG_M]] step 128
// CHECK-NEXT: [[APP3:%[a-zA-Z0-9]+]] = affine_apply {{.*}}[[IV3]]
// CHECK-NEXT: [[APP3:%[a-zA-Z0-9]+]] = affine.apply {{.*}}[[IV3]]
// CHECK-NEXT: {{.*}} = vector_transfer_read %arg0, [[C0]], [[APP3]] {permutation_map: #[[map_proj_d0d1_d1]]} : {{.*}} -> vector<128xf32>
for %i3 = 0 to %M { // vectorized
%r3 = affine_apply (d0) -> (d0) (%i3)
%r3 = affine.apply (d0) -> (d0) (%i3)
%a3 = load %A[%cst0, %r3#0] : memref<?x?xf32>
}
//
// CHECK:for [[IV4:%[i0-9]+]] = 0 to [[ARG_M]] step 128 {
// CHECK-NEXT: for [[IV5:%[i0-9]*]] = 0 to [[ARG_N]] {
// CHECK-NEXT: [[APP50:%[0-9]+]] = affine_apply {{.*}}([[IV4]], [[IV5]])
// CHECK-NEXT: [[APP51:%[0-9]+]] = affine_apply {{.*}}([[IV4]], [[IV5]])
// CHECK-NEXT: [[APP50:%[0-9]+]] = affine.apply {{.*}}([[IV4]], [[IV5]])
// CHECK-NEXT: [[APP51:%[0-9]+]] = affine.apply {{.*}}([[IV4]], [[IV5]])
// CHECK-NEXT: {{.*}} = vector_transfer_read %arg0, [[APP50]], [[APP51]] {permutation_map: #[[map_proj_d0d1_d1]]} : {{.*}} -> vector<128xf32>
for %i4 = 0 to %M { // vectorized
for %i5 = 0 to %N { // not vectorized, would vectorize with --test-fastest-varying=1
%r50 = affine_apply (d0, d1) -> (d1) (%i4, %i5)
%r51 = affine_apply (d0, d1) -> (d0) (%i4, %i5)
%r50 = affine.apply (d0, d1) -> (d1) (%i4, %i5)
%r51 = affine.apply (d0, d1) -> (d0) (%i4, %i5)
%a5 = load %A[%r50, %r51] : memref<?x?xf32>
}
}
@ -63,21 +63,21 @@ func @vec1d(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
// CHECK-NEXT: for [[IV7:%[i0-9]*]] = 0 to [[ARG_N]] {
for %i6 = 0 to %M { // not vectorized, would vectorize with --test-fastest-varying=1
for %i7 = 0 to %N { // not vectorized, can never vectorize
%r70 = affine_apply (d0, d1) -> (d1 + d0) (%i6, %i7)
%r71 = affine_apply (d0, d1) -> (d0) (%i6, %i7)
%r70 = affine.apply (d0, d1) -> (d1 + d0) (%i6, %i7)
%r71 = affine.apply (d0, d1) -> (d0) (%i6, %i7)
%a7 = load %A[%r70, %r71] : memref<?x?xf32>
}
}
//
// CHECK:for [[IV8:%[i0-9]+]] = 0 to [[ARG_M]] step 128
// CHECK-NEXT: for [[IV9:%[i0-9]*]] = 0 to [[ARG_N]] {
// CHECK-NEXT: [[APP9_0:%[0-9]+]] = affine_apply {{.*}}([[IV8]], [[IV9]])
// CHECK-NEXT: [[APP9_1:%[0-9]+]] = affine_apply {{.*}}([[IV8]], [[IV9]])
// CHECK-NEXT: [[APP9_0:%[0-9]+]] = affine.apply {{.*}}([[IV8]], [[IV9]])
// CHECK-NEXT: [[APP9_1:%[0-9]+]] = affine.apply {{.*}}([[IV8]], [[IV9]])
// CHECK-NEXT: {{.*}} = vector_transfer_read %arg0, [[APP9_0]], [[APP9_1]] {permutation_map: #[[map_proj_d0d1_d1]]} : {{.*}} -> vector<128xf32>
for %i8 = 0 to %M { // vectorized
for %i9 = 0 to %N {
%r90 = affine_apply (d0, d1) -> (d1) (%i8, %i9)
%r91 = affine_apply (d0, d1) -> (d0 + d1) (%i8, %i9)
%r90 = affine.apply (d0, d1) -> (d1) (%i8, %i9)
%r91 = affine.apply (d0, d1) -> (d0 + d1) (%i8, %i9)
%a9 = load %A[%r90, %r91] : memref<?x?xf32>
}
}
@ -86,11 +86,11 @@ func @vec1d(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
// CHECK: for [[IV11:%[i0-9]*]] = 0 to %{{[0-9]*}} {
for %i10 = 0 to %M { // not vectorized, need per load transposes
for %i11 = 0 to %N { // not vectorized, need per load transposes
%r11_0 = affine_apply (d0, d1) -> (d0) (%i10, %i11)
%r11_1 = affine_apply (d0, d1) -> (d1) (%i10, %i11)
%r11_0 = affine.apply (d0, d1) -> (d0) (%i10, %i11)
%r11_1 = affine.apply (d0, d1) -> (d1) (%i10, %i11)
%a11 = load %A[%r11_0, %r11_1] : memref<?x?xf32>
%r12_0 = affine_apply (d0, d1) -> (d1) (%i10, %i11)
%r12_1 = affine_apply (d0, d1) -> (d0) (%i10, %i11)
%r12_0 = affine.apply (d0, d1) -> (d1) (%i10, %i11)
%r12_1 = affine.apply (d0, d1) -> (d0) (%i10, %i11)
store %a11, %A[%r12_0, %r12_1] : memref<?x?xf32>
}
}
@ -101,9 +101,9 @@ func @vec1d(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
for %i12 = 0 to %M { // not vectorized, can never vectorize
for %i13 = 0 to %N { // not vectorized, can never vectorize
for %i14 = 0 to %P { // vectorized
%r14_0 = affine_apply (d0, d1, d2) -> (d1) (%i12, %i13, %i14)
%r14_1 = affine_apply (d0, d1, d2) -> (d0 + d1) (%i12, %i13, %i14)
%r14_2 = affine_apply (d0, d1, d2) -> (d0 + d2) (%i12, %i13, %i14)
%r14_0 = affine.apply (d0, d1, d2) -> (d1) (%i12, %i13, %i14)
%r14_1 = affine.apply (d0, d1, d2) -> (d0 + d1) (%i12, %i13, %i14)
%r14_2 = affine.apply (d0, d1, d2) -> (d0 + d2) (%i12, %i13, %i14)
%a14 = load %B[%r14_0, %r14_1, %r14_2] : memref<?x?x?xf32>
}
}

4
mlir/test/Transforms/canonicalize.mlir
View File

@ -255,8 +255,8 @@ func @hoist_constant(%arg0: memref<8xi32>) {
func @const_fold_propagate() -> memref<?x?xf32> {
%VT_i = constant 512 : index
%VT_i_s = affine_apply (d0) -> (d0 floordiv 8) (%VT_i)
%VT_k_l = affine_apply (d0) -> (d0 floordiv 16) (%VT_i)
%VT_i_s = affine.apply (d0) -> (d0 floordiv 8) (%VT_i)
%VT_k_l = affine.apply (d0) -> (d0 floordiv 16) (%VT_i)
// CHECK: = alloc() : memref<64x32xf32>
%Av = alloc(%VT_i_s, %VT_k_l) : memref<?x?xf32>

12
mlir/test/Transforms/constant-fold.mlir
View File

@ -121,13 +121,13 @@ func @affine_apply(%variable : index) -> (index, index, index) {
// CHECK: %c1159 = constant 1159 : index
// CHECK: %c1152 = constant 1152 : index
%x0 = affine_apply (d0, d1)[S0] -> ( (d0 + 128 * S0) floordiv 128 + d1 mod 128)
%x0 = affine.apply (d0, d1)[S0] -> ( (d0 + 128 * S0) floordiv 128 + d1 mod 128)
(%c177, %c211)[%N]
%x1 = affine_apply (d0, d1)[S0] -> (128 * (S0 ceildiv 128))
%x1 = affine.apply (d0, d1)[S0] -> (128 * (S0 ceildiv 128))
(%c177, %c211)[%N]
// CHECK: %c42 = constant 42 : index
%y = affine_apply (d0) -> (42) (%variable)
%y = affine.apply (d0) -> (42) (%variable)
// CHECK: return %c1159, %c1152, %c42
return %x0, %x1, %y : index, index, index
@ -321,7 +321,7 @@ func @fold_extract_element(%arg0 : index) -> (f32, f16, f16, i32) {
// --------------------------------------------------------------------------//
// IMPORTANT NOTE: the operations in this test are exactly those produced by
// lowering affine_apply (i) -> (i mod 42) to standard operations. Please only
// lowering affine.apply (i) -> (i mod 42) to standard operations. Please only
// change these operations together with the affine lowering pass tests.
// --------------------------------------------------------------------------//
// CHECK-LABEL: @lowered_affine_mod
@ -347,7 +347,7 @@ func @lowered_affine_mod() -> (index, index) {
// --------------------------------------------------------------------------//
// IMPORTANT NOTE: the operations in this test are exactly those produced by
// lowering affine_apply (i) -> (i mod 42) to standard operations. Please only
// lowering affine.apply (i) -> (i mod 42) to standard operations. Please only
// change these operations together with the affine lowering pass tests.
// --------------------------------------------------------------------------//
// CHECK-LABEL: func @lowered_affine_floordiv
@ -379,7 +379,7 @@ func @lowered_affine_floordiv() -> (index, index) {
// --------------------------------------------------------------------------//
// IMPORTANT NOTE: the operations in this test are exactly those produced by
// lowering affine_apply (i) -> (i mod 42) to standard operations. Please only
// lowering affine.apply (i) -> (i mod 42) to standard operations. Please only
// change these operations together with the affine lowering pass tests.
// --------------------------------------------------------------------------//
// CHECK-LABEL: func @lowered_affine_ceildiv

6
mlir/test/Transforms/cse.mlir
View File

@ -29,9 +29,9 @@ func @basic_ml() -> (index, index) {
%c0 = constant 0 : index
%c1 = constant 0 : index
// CHECK-NEXT: %0 = affine_apply #map0(%c0)
%0 = affine_apply #map0(%c0)
%1 = affine_apply #map0(%c1)
// CHECK-NEXT: %0 = affine.apply #map0(%c0)
%0 = affine.apply #map0(%c0)
%1 = affine.apply #map0(%c1)
// CHECK-NEXT: return %0, %0 : index, index
return %0, %1 : index, index

88
mlir/test/Transforms/dma-generate.mlir
View File

@ -34,8 +34,8 @@ func @loop_nest_1d() {
// CHECK-NEXT: dma_wait %6[%c0], %c256_0 : memref<1xi32>
// CHECK: for %i0 = 0 to 256 {
// CHECK-NEXT: %7 = load %3[%i0] : memref<256xf32, 1>
// CHECK: %8 = affine_apply [[MAP_PLUS_256]](%i0)
// CHECK: %9 = affine_apply [[MAP_MINUS_256]](%8)
// CHECK: %8 = affine.apply [[MAP_PLUS_256]](%i0)
// CHECK: %9 = affine.apply [[MAP_MINUS_256]](%8)
// CHECK-NEXT: %10 = load %5[%9] : memref<256xf32, 1>
// Already in faster memory space.
// CHECK: %11 = load %2[%i0] : memref<256xf32, 1>
@ -43,7 +43,7 @@ func @loop_nest_1d() {
// CHECK-NEXT: return
for %i = 0 to 256 {
load %A[%i] : memref<256 x f32>
%idx = affine_apply (d0) -> (d0 + 256)(%i)
%idx = affine.apply (d0) -> (d0 + 256)(%i)
load %B[%idx] : memref<512 x f32>
load %F[%i] : memref<256 x f32, 1>
}
@ -72,18 +72,18 @@ func @loop_nest_1d() {
// CHECK-NEXT: for %i1 = 0 to 32 {
// CHECK-NEXT: for %i2 = 0 to 32 {
// CHECK-NEXT: for %i3 = 0 to 16 {
// CHECK-NEXT: %7 = affine_apply #map{{[0-9]+}}(%i1, %i3)
// CHECK-NEXT: %7 = affine.apply #map{{[0-9]+}}(%i1, %i3)
// CHECK-NEXT: %8 = load [[BUFB]][%7, %i0] : memref<512x32xf32, 1>
// CHECK-NEXT: "foo"(%8) : (f32) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: for %i4 = 0 to 16 {
// CHECK-NEXT: %9 = affine_apply #map{{[0-9]+}}(%i2, %i4)
// CHECK-NEXT: %9 = affine.apply #map{{[0-9]+}}(%i2, %i4)
// CHECK-NEXT: %10 = load [[BUFA]][%9, %i1] : memref<512x32xf32, 1>
// CHECK-NEXT: "bar"(%10) : (f32) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: for %i5 = 0 to 16 {
// CHECK-NEXT: %11 = "abc_compute"() : () -> f32
// CHECK-NEXT: %12 = affine_apply #map{{[0-9]+}}(%i2, %i5)
// CHECK-NEXT: %12 = affine.apply #map{{[0-9]+}}(%i2, %i5)
// CHECK-NEXT: %13 = load [[BUFC]][%12, %i0] : memref<512x32xf32, 1>
// CHECK-NEXT: %14 = "addf32"(%11, %13) : (f32, f32) -> f32
// CHECK-NEXT: store %14, [[BUFC]][%12, %i0] : memref<512x32xf32, 1>
@ -106,18 +106,18 @@ func @loop_nest_high_d(%A: memref<512 x 32 x f32>,
for %kT = 0 to 32 {
for %iT = 0 to 32 {
for %kk = 0 to 16 { // k intratile
%k = affine_apply (d0, d1) -> (16*d0 + d1) (%kT, %kk)
%k = affine.apply (d0, d1) -> (16*d0 + d1) (%kT, %kk)
%v0 = load %B[%k, %jT] : memref<512 x 32 x f32>
"foo"(%v0) : (f32) -> ()
}
for %ii = 0 to 16 { // i intratile.
%i = affine_apply (d0, d1) -> (16*d0 + d1)(%iT, %ii)
%i = affine.apply (d0, d1) -> (16*d0 + d1)(%iT, %ii)
%v1 = load %A[%i, %kT] : memref<512 x 32 x f32>
"bar"(%v1) : (f32) -> ()
}
for %ii_ = 0 to 16 { // i intratile.
%v2 = "abc_compute"() : () -> f32
%i_ = affine_apply (d0, d1) -> (16*d0 + d1)(%iT, %ii_)
%i_ = affine.apply (d0, d1) -> (16*d0 + d1)(%iT, %ii_)
%v3 = load %C[%i_, %jT] : memref<512 x 32 x f32>
%v4 = "addf32"(%v2, %v3) : (f32, f32) -> (f32)
store %v4, %C[%i_, %jT] : memref<512 x 32 x f32>
@ -135,7 +135,7 @@ func @loop_nest_high_d(%A: memref<512 x 32 x f32>,
// CHECK-LABEL: func @loop_nest_modulo() {
// CHECK: %0 = alloc() : memref<256x8xf32>
// CHECK-NEXT: for %i0 = 0 to 32 step 4 {
// CHECK-NEXT: %1 = affine_apply #map{{[0-9]+}}(%i0)
// CHECK-NEXT: %1 = affine.apply #map{{[0-9]+}}(%i0)
// CHECK-NEXT: %2 = alloc() : memref<1x2xf32, 1>
// CHECK-NEXT: %3 = alloc() : memref<1xi32>
// CHECK-NEXT: dma_start %0[%1, %c0], %2[%c0, %c0], %c2, %3[%c0] : memref<256x8xf32>, memref<1x2xf32, 1>, memref<1xi32>
@ -151,7 +151,7 @@ func @loop_nest_modulo() {
for %i = 0 to 32 step 4 {
// DMAs will be performed at this level (%j is the first unit stride loop)
for %j = 0 to 8 {
%idx = affine_apply (d0) -> (d0 mod 2) (%j)
%idx = affine.apply (d0) -> (d0 mod 2) (%j)
// A buffer of size 32 x 2 will be allocated (original buffer was 256 x 8).
%v = load %A[%i, %idx] : memref<256 x 8 x f32>
}
@ -175,8 +175,8 @@ func @loop_nest_tiled() -> memref<256x1024xf32> {
// CHECK-NEXT: for %i3 = #map
for %i2 = (d0) -> (d0)(%i0) to (d0) -> (d0 + 32)(%i0) {
for %i3 = (d0) -> (d0)(%i1) to (d0) -> (d0 + 32)(%i1) {
// CHECK-NEXT: %5 = affine_apply [[MAP_INDEX_DIFF_EVEN]](%i0, %i1, %i2, %i3)
// CHECK-NEXT: %6 = affine_apply [[MAP_INDEX_DIFF_ODD]](%i0, %i1, %i2, %i3)
// CHECK-NEXT: %5 = affine.apply [[MAP_INDEX_DIFF_EVEN]](%i0, %i1, %i2, %i3)
// CHECK-NEXT: %6 = affine.apply [[MAP_INDEX_DIFF_ODD]](%i0, %i1, %i2, %i3)
// CHECK-NEXT: %7 = load %3[%5, %6] : memref<32x32xf32, 1>
%1 = load %0[%i2, %i3] : memref<256x1024xf32>
} // CHECK-NEXT: }
@ -198,8 +198,8 @@ func @dma_constant_dim_access(%A : memref<100x100xf32>) {
// CHECK-NEXT: dma_wait %1[%c0], %c100 : memref<1xi32>
for %i = 0 to 100 {
for %j = 0 to ()[s0] -> (s0) ()[%N] {
// CHECK: %2 = affine_apply [[MAP_D0_MINUS_ONE]](%c1_0, %i1)
// CHECK: %3 = affine_apply [[MAP_D1]](%c1_0, %i1)
// CHECK: %2 = affine.apply [[MAP_D0_MINUS_ONE]](%c1_0, %i1)
// CHECK: %3 = affine.apply [[MAP_D1]](%c1_0, %i1)
// CHECK-NEXT: %4 = load %0[%2, %3] : memref<1x100xf32, 1>
load %A[%one, %j] : memref<100 x 100 x f32>
}
@ -212,7 +212,7 @@ func @dma_with_symbolic_accesses(%A : memref<100x100xf32>, %M : index) {
%N = constant 9 : index
for %i = 0 to 100 {
for %j = 0 to 100 {
%idy = affine_apply (d0, d1) [s0, s1] -> (d1 + s0 + s1)(%i, %j)[%M, %N]
%idy = affine.apply (d0, d1) [s0, s1] -> (d1 + s0 + s1)(%i, %j)[%M, %N]
load %A[%i, %idy] : memref<100 x 100 x f32>
}
}
@ -223,9 +223,9 @@ func @dma_with_symbolic_accesses(%A : memref<100x100xf32>, %M : index) {
// CHECK-NEXT: dma_wait %2[%c0], %c10000
// CHECK-NEXT: for %i0 = 0 to 100 {
// CHECK-NEXT: for %i1 = 0 to 100 {
// CHECK-NEXT: %3 = affine_apply [[MAP_SYM_SHIFT]](%i0, %i1)[%arg1, %c9]
// CHECK-NEXT: %4 = affine_apply [[MAP_3D_D1]](%arg1, %i0, %3)
// CHECK-NEXT: %5 = affine_apply [[MAP_SUB_OFFSET]](%arg1, %i0, %3)
// CHECK-NEXT: %3 = affine.apply [[MAP_SYM_SHIFT]](%i0, %i1)[%arg1, %c9]
// CHECK-NEXT: %4 = affine.apply [[MAP_3D_D1]](%arg1, %i0, %3)
// CHECK-NEXT: %5 = affine.apply [[MAP_SUB_OFFSET]](%arg1, %i0, %3)
// CHECK-NEXT: %6 = load %1[%4, %5] : memref<100x100xf32, 1>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -243,7 +243,7 @@ func @dma_with_symbolic_loop_bounds(%A : memref<100x100xf32>, %M : index, %N: in
// CHECK-NEXT: dma_wait %1[%c0], %c10000 : memref<1xi32>
for %i = 0 to 100 {
for %j = %M to %N {
%idy = affine_apply (d1) [s0] -> (d1 + s0)(%j)[%K]
%idy = affine.apply (d1) [s0] -> (d1 + s0)(%j)[%K]
load %A[%i, %idy] : memref<100 x 100 x f32>
}
}
@ -275,9 +275,9 @@ func @dma_memref_3d(%arg0: memref<1024x1024x1024xf32>) {
for %i = 0 to 1024 {
for %j = 0 to 1024 {
for %k = 0 to 1024 {
%idx = affine_apply (d0) -> (d0 mod 128)(%i)
%idy = affine_apply (d0) -> (d0 mod 128)(%j)
%idz = affine_apply (d0) -> (d0 mod 128)(%k)
%idx = affine.apply (d0) -> (d0 mod 128)(%i)
%idy = affine.apply (d0) -> (d0 mod 128)(%j)
%idz = affine.apply (d0) -> (d0 mod 128)(%k)
// DMA with nested striding (or emulating with loop around strided DMA)
// not yet implemented.
// CHECK: %5 = load %arg0[%2, %3, %4] : memref<1024x1024x1024xf32>
@ -310,16 +310,16 @@ func @multi_load_store_union() {
%A = alloc() : memref<512 x 512 x f32>
for %i = 0 to 256 {
for %j = 0 to 256 {
%idx = affine_apply (d0) -> (d0 + 64)(%i)
%idy = affine_apply (d0) -> (d0 + 128)(%j)
%ishift = affine_apply (d0) -> (d0 + 2)(%i)
%jshift = affine_apply (d0) -> (d0 + 2)(%j)
%idx = affine.apply (d0) -> (d0 + 64)(%i)
%idy = affine.apply (d0) -> (d0 + 128)(%j)
%ishift = affine.apply (d0) -> (d0 + 2)(%i)
%jshift = affine.apply (d0) -> (d0 + 2)(%j)
%u = load %A[%ishift, %idy] : memref<512 x 512 x f32>
%v = load %A[%idx, %jshift] : memref<512 x 512 x f32>
%sidx = affine_apply (d0) -> (d0 + 128)(%i)
%sidy = affine_apply (d0) -> (d0 + 192)(%j)
%sidx = affine.apply (d0) -> (d0 + 128)(%i)
%sidy = affine.apply (d0) -> (d0 + 192)(%j)
store %u, %A[%ishift, %sidy] : memref<512 x 512 x f32>
store %v, %A[%sidx, %jshift] : memref<512 x 512 x f32>
@ -335,23 +335,23 @@ func @multi_load_store_union() {
// CHECK-NEXT: %3 = alloc() : memref<1xi32>
// CHECK-NEXT: for %i0 = 0 to 256 {
// CHECK-NEXT: for %i1 = 0 to 256 {
// CHECK-NEXT: %4 = affine_apply [[MAP_PLUS_64]](%i0)
// CHECK-NEXT: %5 = affine_apply [[MAP_PLUS_128]](%i1)
// CHECK-NEXT: %6 = affine_apply [[MAP_PLUS_2]](%i0)
// CHECK-NEXT: %7 = affine_apply [[MAP_PLUS_2]](%i1)
// CHECK-NEXT: %8 = affine_apply [[MAP_D0_MINUS_2]](%6, %5)
// CHECK-NEXT: %9 = affine_apply [[MAP_D1_MINUS_2]](%6, %5)
// CHECK-NEXT: %4 = affine.apply [[MAP_PLUS_64]](%i0)
// CHECK-NEXT: %5 = affine.apply [[MAP_PLUS_128]](%i1)
// CHECK-NEXT: %6 = affine.apply [[MAP_PLUS_2]](%i0)
// CHECK-NEXT: %7 = affine.apply [[MAP_PLUS_2]](%i1)
// CHECK-NEXT: %8 = affine.apply [[MAP_D0_MINUS_2]](%6, %5)
// CHECK-NEXT: %9 = affine.apply [[MAP_D1_MINUS_2]](%6, %5)
// CHECK-NEXT: %10 = load %1[%8, %9] : memref<382x446xf32, 1>
// CHECK-NEXT: %11 = affine_apply [[MAP_D0_MINUS_2]](%4, %7)
// CHECK-NEXT: %12 = affine_apply [[MAP_D1_MINUS_2]](%4, %7)
// CHECK-NEXT: %11 = affine.apply [[MAP_D0_MINUS_2]](%4, %7)
// CHECK-NEXT: %12 = affine.apply [[MAP_D1_MINUS_2]](%4, %7)
// CHECK-NEXT: %13 = load %1[%11, %12] : memref<382x446xf32, 1>
// CHECK-NEXT: %14 = affine_apply [[MAP_PLUS_128]](%i0)
// CHECK-NEXT: %15 = affine_apply [[MAP_PLUS_192]](%i1)
// CHECK-NEXT: %16 = affine_apply [[MAP_D0_MINUS_2]](%6, %15)
// CHECK-NEXT: %17 = affine_apply [[MAP_D1_MINUS_2]](%6, %15)
// CHECK-NEXT: %14 = affine.apply [[MAP_PLUS_128]](%i0)
// CHECK-NEXT: %15 = affine.apply [[MAP_PLUS_192]](%i1)
// CHECK-NEXT: %16 = affine.apply [[MAP_D0_MINUS_2]](%6, %15)
// CHECK-NEXT: %17 = affine.apply [[MAP_D1_MINUS_2]](%6, %15)
// CHECK-NEXT: store %10, %1[%16, %17] : memref<382x446xf32, 1>
// CHECK-NEXT: %18 = affine_apply [[MAP_D0_MINUS_2]](%14, %7)
// CHECK-NEXT: %19 = affine_apply [[MAP_D1_MINUS_2]](%14, %7)
// CHECK-NEXT: %18 = affine.apply [[MAP_D0_MINUS_2]](%14, %7)
// CHECK-NEXT: %19 = affine.apply [[MAP_D1_MINUS_2]](%14, %7)
// CHECK-NEXT: store %13, %1[%18, %19] : memref<382x446xf32, 1>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -390,7 +390,7 @@ func @dma_loop_straightline_interspersed() {
// CHECK-NEXT: dma_start %0[%c1_0], %4[%c0], %c254, %5[%c0] : memref<256xf32>, memref<254xf32, 1>, memref<1xi32>
// CHECK-NEXT: dma_wait %5[%c0], %c254 : memref<1xi32>
// CHECK-NEXT: for %i0 = 1 to 255 {
// CHECK-NEXT: %6 = affine_apply [[MAP_MINUS_ONE]](%i0)
// CHECK-NEXT: %6 = affine.apply [[MAP_MINUS_ONE]](%i0)
// CHECK-NEXT: %7 = load %4[%6] : memref<254xf32, 1>
// CHECK-NEXT: }
// CHECK-NEXT: %8 = alloc() : memref<256xf32, 1>

308
mlir/test/Transforms/loop-fusion.mlir
View File

@ -23,9 +23,9 @@ func @should_fuse_raw_dep_for_locality() {
%v0 = load %m[%i1] : memref<10xf32>
}
// CHECK: for %i0 = 0 to 10 {
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %1 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %cst, %0[%1] : memref<1xf32>
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %2 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %3 = load %0[%2] : memref<1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -61,14 +61,14 @@ func @should_fuse_reduction_to_pointwise() {
// is not used in the access function of the store/load on %b.
// CHECK: for %i0 = 0 to 10 {
// CHECK-NEXT: for %i1 = 0 to 10 {
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %4 = load %0[%3] : memref<1xf32>
// CHECK-NEXT: %5 = load %1[%i0, %i1] : memref<10x10xf32>
// CHECK-NEXT: %6 = addf %4, %5 : f32
// CHECK-NEXT: %7 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %7 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %6, %0[%7] : memref<1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: %8 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %8 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %9 = load %0[%8] : memref<1xf32>
// CHECK-NEXT: store %9, %2[%i0] : memref<10xf32>
// CHECK-NEXT: }
@ -90,8 +90,8 @@ func @should_fuse_loop_nests_with_shifts() {
for %i0 = 0 to 9 {
for %i1 = 0 to 9 {
%idx = affine_apply (d0) -> (d0 + 1) (%i0)
%idy = affine_apply (d0) -> (d0 + 1) (%i1)
%idx = affine.apply (d0) -> (d0 + 1) (%i0)
%idy = affine.apply (d0) -> (d0 + 1) (%i1)
store %cf7, %a[%idx, %idy] : memref<10x10xf32>
}
}
@ -111,15 +111,15 @@ func @should_fuse_loop_nests_with_shifts() {
// NOTE: Should create a private memref with reduced shape 9x9xf32.
// CHECK: for %i0 = 1 to 10 {
// CHECK-NEXT: for %i1 = 1 to 10 {
// CHECK-NEXT: %1 = affine_apply [[MAP_SHIFT_MINUS_ONE_R1]](%i0)
// CHECK-NEXT: %2 = affine_apply [[MAP_SHIFT_MINUS_ONE_R1]](%i1)
// CHECK-NEXT: %3 = affine_apply [[MAP_SHIFT_BY_ONE]](%1)
// CHECK-NEXT: %4 = affine_apply [[MAP_SHIFT_BY_ONE]](%2)
// CHECK-NEXT: %5 = affine_apply [[MAP_SHIFT_MINUS_IV_R2_EVEN]](%i0, %i1, %3, %4)
// CHECK-NEXT: %6 = affine_apply [[MAP_SHIFT_MINUS_IV_R2_ODD]](%i0, %i1, %3, %4)
// CHECK-NEXT: %1 = affine.apply [[MAP_SHIFT_MINUS_ONE_R1]](%i0)
// CHECK-NEXT: %2 = affine.apply [[MAP_SHIFT_MINUS_ONE_R1]](%i1)
// CHECK-NEXT: %3 = affine.apply [[MAP_SHIFT_BY_ONE]](%1)
// CHECK-NEXT: %4 = affine.apply [[MAP_SHIFT_BY_ONE]](%2)
// CHECK-NEXT: %5 = affine.apply [[MAP_SHIFT_MINUS_IV_R2_EVEN]](%i0, %i1, %3, %4)
// CHECK-NEXT: %6 = affine.apply [[MAP_SHIFT_MINUS_IV_R2_ODD]](%i0, %i1, %3, %4)
// CHECK-NEXT: store %cst, %0[%5, %6] : memref<1x1xf32>
// CHECK-NEXT: %7 = affine_apply [[MAP_SHIFT_MINUS_IV_R2_EVEN]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %8 = affine_apply [[MAP_SHIFT_MINUS_IV_R2_ODD]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %7 = affine.apply [[MAP_SHIFT_MINUS_IV_R2_EVEN]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %8 = affine.apply [[MAP_SHIFT_MINUS_IV_R2_ODD]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %9 = load %0[%7, %8] : memref<1x1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -159,17 +159,17 @@ func @should_fuse_loop_nest() {
// CHECK-DAG: [[NEWB:%[0-9]+]] = alloc() : memref<1x1xf32>
// CHECK: for %i0 = 0 to 10 {
// CHECK-NEXT: for %i1 = 0 to 10 {
// CHECK-NEXT: %2 = affine_apply [[MAP_D2_D0_DIFF]](%i1, %i0, %i1, %i0)
// CHECK-NEXT: %3 = affine_apply [[MAP_D3_D1_DIFF]](%i1, %i0, %i1, %i0)
// CHECK-NEXT: %2 = affine.apply [[MAP_D2_D0_DIFF]](%i1, %i0, %i1, %i0)
// CHECK-NEXT: %3 = affine.apply [[MAP_D3_D1_DIFF]](%i1, %i0, %i1, %i0)
// CHECK-NEXT: store %cst, [[NEWA]][%2, %3] : memref<1x1xf32>
// CHECK-NEXT: %4 = affine_apply [[MAP_D2_D0_DIFF]](%i1, %i0, %i1, %i0)
// CHECK-NEXT: %5 = affine_apply [[MAP_D3_D1_DIFF]](%i1, %i0, %i1, %i0)
// CHECK-NEXT: %4 = affine.apply [[MAP_D2_D0_DIFF]](%i1, %i0, %i1, %i0)
// CHECK-NEXT: %5 = affine.apply [[MAP_D3_D1_DIFF]](%i1, %i0, %i1, %i0)
// CHECK-NEXT: %6 = load [[NEWA]][%4, %5] : memref<1x1xf32>
// CHECK-NEXT: %7 = affine_apply [[MAP_D2_D0_DIFF]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %8 = affine_apply [[MAP_D3_D1_DIFF]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %7 = affine.apply [[MAP_D2_D0_DIFF]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %8 = affine.apply [[MAP_D3_D1_DIFF]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: store %6, [[NEWB]][%7, %8] : memref<1x1xf32>
// CHECK-NEXT: %9 = affine_apply [[MAP_D2_D0_DIFF]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %10 = affine_apply [[MAP_D3_D1_DIFF]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %9 = affine.apply [[MAP_D2_D0_DIFF]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %10 = affine.apply [[MAP_D3_D1_DIFF]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %11 = load [[NEWB]][%9, %10] : memref<1x1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -207,9 +207,9 @@ func @should_fuse_across_intermediate_loop_with_no_deps() {
// CHECK-NEXT: }
// CHECK: for %i1 = 0 to 10 {
// CHECK-NEXT: %3 = load %1[%i1] : memref<10xf32>
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %4 = affine.apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: store %3, %0[%4] : memref<1xf32>
// CHECK-NEXT: %5 = affine_apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %5 = affine.apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %6 = load %0[%5] : memref<1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -243,13 +243,13 @@ func @should_fuse_all_loops() {
// CHECK-DAG: [[NEWA:%[0-9]+]] = alloc() : memref<1xf32>
// CHECK-DAG: [[NEWB:%[0-9]+]] = alloc() : memref<1xf32>
// CHECK: for %i0 = 0 to 10 {
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %2 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %cst, [[NEWA]][%2] : memref<1xf32>
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %cst, [[NEWB]][%3] : memref<1xf32>
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %4 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %5 = load [[NEWA]][%4] : memref<1xf32>
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %6 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %7 = load [[NEWB]][%6] : memref<1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -282,9 +282,9 @@ func @should_fuse_first_and_second_loops() {
// Should fuse first loop into the second (last loop should not be fused).
// Should create private memref '%2' for fused loop.
// CHECK: for %i0 = 0 to 10 {
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %cst, %0[%3] : memref<1xf32>
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %4 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %5 = load %0[%4] : memref<1xf32>
// CHECK-NEXT: store %cst, %1[%i0] : memref<10xf32>
// CHECK-NEXT: }
@ -394,9 +394,9 @@ func @should_fuse_and_move_to_preserve_war_dep() {
// the WAR dependence from load '%a' in '%i0' to the store '%a' in loop '%i1'.
// CHECK: for %i0 = 0 to 10 {
// CHECK-NEXT: %2 = load %1[%i0] : memref<10xf32>
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %2, %0[%3] : memref<1xf32>
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %4 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %5 = load %0[%4] : memref<1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: for %i1 = 0 to 10 {
@ -429,9 +429,9 @@ func @should_fuse_with_private_memref_if_top_level_access() {
// CHECK-NEXT: store %cst, %1[%i0] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: for %i1 = 0 to 10 {
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %2 = affine.apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: store %cst, %0[%2] : memref<1xf32>
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %4 = load %0[%3] : memref<1xf32>
// CHECK-NEXT: }
return
@ -453,9 +453,9 @@ func @should_fuse_no_top_level_access() {
%v0 = load %m[%i1] : memref<10xf32>
}
// CHECK: for %i0 = 0 to 10 {
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %1 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %cst, %0[%1] : memref<1xf32>
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %2 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %3 = load %0[%2] : memref<1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -550,13 +550,13 @@ func @permute_and_fuse() {
// CHECK: for %i0 = 0 to 30 {
// CHECK-NEXT: for %i1 = 0 to 10 {
// CHECK-NEXT: for %i2 = 0 to 20 {
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: %2 = affine_apply [[MAP1]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: %3 = affine_apply [[MAP2]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: %1 = affine.apply [[MAP0]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: %2 = affine.apply [[MAP1]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: %3 = affine.apply [[MAP2]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: store %cst, %0[%1, %2, %3] : memref<1x1x1xf32>
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: %5 = affine_apply [[MAP1]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: %6 = affine_apply [[MAP2]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: %4 = affine.apply [[MAP0]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: %5 = affine.apply [[MAP1]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: %6 = affine.apply [[MAP2]](%i1, %i2, %i0, %i1, %i2, %i0)
// CHECK-NEXT: %7 = load %0[%4, %5, %6] : memref<1x1x1xf32>
// CHECK-NEXT: "foo"(%7) : (f32) -> ()
// CHECK-NEXT: }
@ -580,8 +580,8 @@ func @fuse_reshape_64_16_4(%in : memref<64xf32>) {
for %i0 = 0 to 64 {
%v = load %in[%i0] : memref<64xf32>
%idx = affine_apply (d0) -> (d0 floordiv 4) (%i0)
%idy = affine_apply (d0) -> (d0 mod 4) (%i0)
%idx = affine.apply (d0) -> (d0 floordiv 4) (%i0)
%idy = affine.apply (d0) -> (d0 mod 4) (%i0)
store %v, %out[%idx, %idy] : memref<16x4xf32>
}
@ -615,7 +615,7 @@ func @fuse_reshape_16_4_64() {
for %i0 = 0 to 16 {
for %i1 = 0 to 4 {
%v = load %in[%i0, %i1] : memref<16x4xf32>
%idx = affine_apply (d0, d1) -> (4*d0 + d1) (%i0, %i1)
%idx = affine.apply (d0, d1) -> (4*d0 + d1) (%i0, %i1)
store %v, %out[%idx] : memref<64xf32>
}
}
@ -625,13 +625,13 @@ func @fuse_reshape_16_4_64() {
"foo"(%w) : (f32) -> ()
}
// CHECK: for %i0 = 0 to 64 {
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i0)
// CHECK-NEXT: %3 = affine_apply [[MAP1]](%i0)
// CHECK-NEXT: %2 = affine.apply [[MAP0]](%i0)
// CHECK-NEXT: %3 = affine.apply [[MAP1]](%i0)
// CHECK-NEXT: %4 = load %1[%2, %3] : memref<16x4xf32>
// CHECK-NEXT: %5 = affine_apply [[MAP2]](%2, %3)
// CHECK-NEXT: %6 = affine_apply [[MAP3]](%i0, %5)
// CHECK-NEXT: %5 = affine.apply [[MAP2]](%2, %3)
// CHECK-NEXT: %6 = affine.apply [[MAP3]](%i0, %5)
// CHECK-NEXT: store %4, %0[%6] : memref<1xf32>
// CHECK-NEXT: %7 = affine_apply [[MAP3]](%i0, %i0)
// CHECK-NEXT: %7 = affine.apply [[MAP3]](%i0, %i0)
// CHECK-NEXT: %8 = load %0[%7] : memref<1xf32>
// CHECK-NEXT: "foo"(%8) : (f32) -> ()
// CHECK-NEXT: }
@ -668,13 +668,13 @@ func @R6_to_R2_reshape_square() -> memref<64x9xi32> {
for %ii = 0 to 64 {
for %jj = 0 to 9 {
// Convert output coordinates to linear index.
%a0 = affine_apply (d0, d1) -> (d0 * 9 + d1) (%ii, %jj)
%0 = affine_apply (d0) -> (d0 floordiv (2 * 3 * 3 * 16 * 1))(%a0)
%1 = affine_apply (d0) -> ((d0 mod 288) floordiv (3 * 3 * 16 * 1))(%a0)
%2 = affine_apply (d0) -> (((d0 mod 288) mod 144) floordiv (3 * 16 * 1))(%a0)
%3 = affine_apply (d0) -> ((((d0 mod 288) mod 144) mod 48) floordiv (16 * 1))(%a0)
%4 = affine_apply (d0) -> ((((d0 mod 288) mod 144) mod 48) mod 16)(%a0)
%5 = affine_apply (d0) -> (((((d0 mod 144) mod 144) mod 48) mod 16) mod 1)(%a0)
%a0 = affine.apply (d0, d1) -> (d0 * 9 + d1) (%ii, %jj)
%0 = affine.apply (d0) -> (d0 floordiv (2 * 3 * 3 * 16 * 1))(%a0)
%1 = affine.apply (d0) -> ((d0 mod 288) floordiv (3 * 3 * 16 * 1))(%a0)
%2 = affine.apply (d0) -> (((d0 mod 288) mod 144) floordiv (3 * 16 * 1))(%a0)
%3 = affine.apply (d0) -> ((((d0 mod 288) mod 144) mod 48) floordiv (16 * 1))(%a0)
%4 = affine.apply (d0) -> ((((d0 mod 288) mod 144) mod 48) mod 16)(%a0)
%5 = affine.apply (d0) -> (((((d0 mod 144) mod 144) mod 48) mod 16) mod 1)(%a0)
%v = load %in[%0, %1, %2, %3, %4, %5] : memref<2x2x3x3x16x1xi32>
store %v, %out[%ii, %jj] : memref<64x9xi32>
}
@ -719,38 +719,38 @@ func @R6_to_R2_reshape_square() -> memref<64x9xi32> {
// CHECK: %2 = alloc() : memref<64x9xi32>
// CHECK-NEXT: for %i0 = 0 to 64 {
// CHECK-NEXT: for %i1 = 0 to 9 {
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i1)
// CHECK-NEXT: %4 = affine_apply [[MAP1]](%i0, %i1)
// CHECK-NEXT: %5 = affine_apply [[MAP2]](%i0, %i1)
// CHECK-NEXT: %6 = affine_apply [[MAP3]](%i0, %i1)
// CHECK-NEXT: %7 = affine_apply [[MAP4]](%i0, %i1)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%i0, %i1)
// CHECK-NEXT: %4 = affine.apply [[MAP1]](%i0, %i1)
// CHECK-NEXT: %5 = affine.apply [[MAP2]](%i0, %i1)
// CHECK-NEXT: %6 = affine.apply [[MAP3]](%i0, %i1)
// CHECK-NEXT: %7 = affine.apply [[MAP4]](%i0, %i1)
// CHECK-NEXT: %8 = "foo"(%3, %4, %5, %6, %7, %c0) : (index, index, index, index, index, index) -> i32
// CHECK-NEXT: %9 = affine_apply [[MAP5]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: %10 = affine_apply [[MAP6]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: %11 = affine_apply [[MAP7]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: %12 = affine_apply [[MAP8]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: %13 = affine_apply [[MAP9]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: %14 = affine_apply [[MAP10]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: %9 = affine.apply [[MAP5]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: %10 = affine.apply [[MAP6]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: %11 = affine.apply [[MAP7]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: %12 = affine.apply [[MAP8]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: %13 = affine.apply [[MAP9]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: %14 = affine.apply [[MAP10]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
// CHECK-NEXT: store %8, %0[%9, %10, %11, %12, %13, %14] : memref<1x2x3x3x16x1xi32>
// CHECK-NEXT: %15 = affine_apply [[MAP11]](%i0, %i1)
// CHECK-NEXT: %16 = affine_apply [[MAP12]](%15)
// CHECK-NEXT: %17 = affine_apply [[MAP13]](%15)
// CHECK-NEXT: %18 = affine_apply [[MAP14]](%15)
// CHECK-NEXT: %19 = affine_apply [[MAP15]](%15)
// CHECK-NEXT: %20 = affine_apply [[MAP16]](%15)
// CHECK-NEXT: %21 = affine_apply [[MAP17]](%15)
// CHECK-NEXT: %22 = affine_apply [[MAP5]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %23 = affine_apply [[MAP6]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %24 = affine_apply [[MAP7]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %25 = affine_apply [[MAP8]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %26 = affine_apply [[MAP9]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %27 = affine_apply [[MAP10]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %15 = affine.apply [[MAP11]](%i0, %i1)
// CHECK-NEXT: %16 = affine.apply [[MAP12]](%15)
// CHECK-NEXT: %17 = affine.apply [[MAP13]](%15)
// CHECK-NEXT: %18 = affine.apply [[MAP14]](%15)
// CHECK-NEXT: %19 = affine.apply [[MAP15]](%15)
// CHECK-NEXT: %20 = affine.apply [[MAP16]](%15)
// CHECK-NEXT: %21 = affine.apply [[MAP17]](%15)
// CHECK-NEXT: %22 = affine.apply [[MAP5]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %23 = affine.apply [[MAP6]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %24 = affine.apply [[MAP7]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %25 = affine.apply [[MAP8]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %26 = affine.apply [[MAP9]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %27 = affine.apply [[MAP10]](%i0, %i1, %16, %17, %18, %19, %20, %21)
// CHECK-NEXT: %28 = load %0[%22, %23, %24, %25, %26, %27] : memref<1x2x3x3x16x1xi32>
// CHECK-NEXT: %29 = affine_apply [[MAP18]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %30 = affine_apply [[MAP19]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %29 = affine.apply [[MAP18]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %30 = affine.apply [[MAP19]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: store %28, %1[%29, %30] : memref<1x1xi32>
// CHECK-NEXT: %31 = affine_apply [[MAP18]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %32 = affine_apply [[MAP19]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %31 = affine.apply [[MAP18]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %32 = affine.apply [[MAP19]](%i0, %i1, %i0, %i1)
// CHECK-NEXT: %33 = load %1[%31, %32] : memref<1x1xi32>
// CHECK-NEXT: %34 = muli %33, %33 : i32
// CHECK-NEXT: store %34, %2[%i0, %i1] : memref<64x9xi32>
@ -762,7 +762,7 @@ func @R6_to_R2_reshape_square() -> memref<64x9xi32> {
// CHECK-LABEL: func @fuse_symbolic_bounds
func @fuse_symbolic_bounds(%M : index, %N : index) {
%N_plus_5 = affine_apply (d0) -> (d0 + 5)(%N)
%N_plus_5 = affine.apply (d0) -> (d0 + 5)(%N)
%m = alloc(%M, %N_plus_5) : memref<? x ? x f32>
%c0 = constant 0.0 : f32
@ -776,7 +776,7 @@ func @fuse_symbolic_bounds(%M : index, %N : index) {
for %i2 = 0 to %M {
for %i3 = 0 to %N {
%idy = affine_apply (d0)[s0] -> (d0 + s0) (%i3)[%s]
%idy = affine.apply (d0)[s0] -> (d0 + s0) (%i3)[%s]
%v = load %m[%i2, %idy] : memref<? x ? x f32>
}
}
@ -814,19 +814,19 @@ func @should_fuse_reduction_at_depth1() {
// memory space.
// CHECK: for %i0 = 0 to 10 {
// CHECK-NEXT: for %i1 = 0 to 100 {
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %2 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %3 = load %0[%2] : memref<1xf32>
// CHECK-NEXT: %4 = load %1[%i0, %i1] : memref<10x100xf32>
// CHECK-NEXT: %5 = "maxf"(%3, %4) : (f32, f32) -> f32
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %6 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %5, %0[%6] : memref<1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: for %i2 = 0 to 100 {
// CHECK-NEXT: %7 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %7 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %8 = load %0[%7] : memref<1xf32>
// CHECK-NEXT: %9 = load %1[%i0, %i2] : memref<10x100xf32>
// CHECK-NEXT: %10 = subf %9, %8 : f32
// CHECK-NEXT: %11 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %11 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %10, %0[%11] : memref<1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -872,13 +872,13 @@ func @should_fuse_at_src_depth1_and_dst_depth1() {
// CHECK-NEXT: }
// CHECK-NEXT: for %i2 = 0 to 16 {
// CHECK-NEXT: %3 = "op1"() : () -> f32
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i0, %i0, %i2)
// CHECK-NEXT: %5 = affine_apply [[MAP1]](%i0, %i0, %i2)
// CHECK-NEXT: %4 = affine.apply [[MAP0]](%i0, %i0, %i2)
// CHECK-NEXT: %5 = affine.apply [[MAP1]](%i0, %i0, %i2)
// CHECK-NEXT: store %3, %0[%4, %5] : memref<1x16xf32>
// CHECK-NEXT: }
// CHECK-NEXT: for %i3 = 0 to 16 {
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%i0, %i0, %i3)
// CHECK-NEXT: %7 = affine_apply [[MAP1]](%i0, %i0, %i3)
// CHECK-NEXT: %6 = affine.apply [[MAP0]](%i0, %i0, %i3)
// CHECK-NEXT: %7 = affine.apply [[MAP1]](%i0, %i0, %i3)
// CHECK-NEXT: %8 = load %0[%6, %7] : memref<1x16xf32>
// CHECK-NEXT: "op2"(%8) : (f32) -> ()
// CHECK-NEXT: }
@ -902,7 +902,7 @@ func @should_fuse_src_depth1_at_dst_depth2() {
for %i1 = 0 to 10 {
for %i2 = 0 to 10 {
%a0 = affine_apply (d0, d1) -> (d0 * 10 + d1) (%i1, %i2)
%a0 = affine.apply (d0, d1) -> (d0 * 10 + d1) (%i1, %i2)
%v0 = load %a[%a0] : memref<100xf32>
}
}
@ -910,11 +910,11 @@ func @should_fuse_src_depth1_at_dst_depth2() {
// loop IVs, so we should slice at depth 1 and insert the slice at depth 2.
// CHECK: for %i0 = 0 to 10 {
// CHECK-NEXT: for %i1 = 0 to 10 {
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%i0, %i1)
// CHECK-NEXT: %2 = affine_apply [[MAP1]](%i0, %i1, %1)
// CHECK-NEXT: %1 = affine.apply [[MAP0]](%i0, %i1)
// CHECK-NEXT: %2 = affine.apply [[MAP1]](%i0, %i1, %1)
// CHECK-NEXT: store %cst, %0[%2] : memref<1xf32>
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i1)
// CHECK-NEXT: %4 = affine_apply [[MAP1]](%i0, %i1, %3)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%i0, %i1)
// CHECK-NEXT: %4 = affine.apply [[MAP1]](%i0, %i1, %3)
// CHECK-NEXT: %5 = load %0[%4] : memref<1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -940,7 +940,7 @@ func @fusion_at_depth0_not_currently_supported() {
// nest, and make the store in the slice store to the same element.
// CHECK-DAG: %0 = alloc() : memref<1xf32>
// CHECK: for %i0 = 0 to 10 {
// CHECK-NEXT: %1 = affine_apply [[MAP0]]()[%c0]
// CHECK-NEXT: %1 = affine.apply [[MAP0]]()[%c0]
// CHECK-NEXT: store %cst, %0[%1] : memref<1xf32>
// CHECK-NEXT: %2 = load %0[%c0] : memref<1xf32>
// CHECK-NEXT: }
@ -1032,12 +1032,12 @@ func @should_fuse_deep_loop_nests() {
// CHECK-NEXT: }
// CHECK-NEXT: for %i8 = 0 to 16 {
// CHECK-NEXT: for %i9 = 0 to 10 {
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: %5 = affine_apply [[MAP1]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: %6 = affine_apply [[MAP2]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: %7 = affine_apply [[MAP3]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: %8 = affine_apply [[MAP4]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: %9 = affine_apply [[MAP5]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: %4 = affine.apply [[MAP0]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: %5 = affine.apply [[MAP1]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: %6 = affine.apply [[MAP2]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: %7 = affine.apply [[MAP3]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: %8 = affine.apply [[MAP4]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: %9 = affine.apply [[MAP5]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
// CHECK-NEXT: store %cst, %0[%4, %5, %6, %7, %8, %9] : memref<1x1x1x1x16x10xf32, 2>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -1050,12 +1050,12 @@ func @should_fuse_deep_loop_nests() {
// CHECK-NEXT: }
// CHECK-NEXT: for %i14 = 0 to 16 {
// CHECK-NEXT: for %i15 = 0 to 10 {
// CHECK-NEXT: %11 = affine_apply [[MAP0]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %12 = affine_apply [[MAP1]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %13 = affine_apply [[MAP2]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %14 = affine_apply [[MAP3]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %15 = affine_apply [[MAP4]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %16 = affine_apply [[MAP5]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %11 = affine.apply [[MAP0]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %12 = affine.apply [[MAP1]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %13 = affine.apply [[MAP2]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %14 = affine.apply [[MAP3]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %15 = affine.apply [[MAP4]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %16 = affine.apply [[MAP5]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
// CHECK-NEXT: %17 = load %0[%11, %12, %13, %14, %15, %16] : memref<1x1x1x1x16x10xf32, 2>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -1112,13 +1112,13 @@ func @should_fuse_at_depth1_and_reduce_slice_trip_count() {
// CHECK-NEXT: %2 = load %1[%i0, %i1] : memref<4x256xf32>
// CHECK-NEXT: }
// CHECK-NEXT: for %i2 = 0 to 16 {
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i0, %i2)
// CHECK-NEXT: %4 = affine_apply [[MAP1]](%i0, %i0, %i2)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%i0, %i0, %i2)
// CHECK-NEXT: %4 = affine.apply [[MAP1]](%i0, %i0, %i2)
// CHECK-NEXT: store %cst, %0[%3, %4] : memref<1x16xf32>
// CHECK-NEXT: }
// CHECK-NEXT: for %i3 = 0 to 16 {
// CHECK-NEXT: %5 = affine_apply [[MAP0]](%i0, %i0, %i3)
// CHECK-NEXT: %6 = affine_apply [[MAP1]](%i0, %i0, %i3)
// CHECK-NEXT: %5 = affine.apply [[MAP0]](%i0, %i0, %i3)
// CHECK-NEXT: %6 = affine.apply [[MAP1]](%i0, %i0, %i3)
// CHECK-NEXT: %7 = load %0[%5, %6] : memref<1x16xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -1231,15 +1231,15 @@ func @should_fuse_with_private_memrefs_with_diff_shapes() {
// CHECK-DAG: %0 = alloc() : memref<1xf32>
// CHECK-DAG: %1 = alloc() : memref<1xf32>
// CHECK: for %i0 = 0 to 82 {
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %2 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %cst, %1[%2] : memref<1xf32>
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %4 = load %1[%3] : memref<1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: for %i1 = 0 to 17 {
// CHECK-NEXT: %5 = affine_apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %5 = affine.apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: store %cst, %0[%5] : memref<1xf32>
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %6 = affine.apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %7 = load %0[%6] : memref<1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -1314,8 +1314,8 @@ func @R3_to_R2_reshape() {
for %ii = 0 to 32 {
for %jj = 0 to 3 {
%a0 = affine_apply (d0, d1) -> (d0 * 3 + d1) (%ii, %jj)
%idx = affine_apply (d0) -> (d0 floordiv (3 * 16)) (%a0)
%a0 = affine.apply (d0, d1) -> (d0 * 3 + d1) (%ii, %jj)
%idx = affine.apply (d0) -> (d0 floordiv (3 * 16)) (%a0)
%v = load %in[%idx, %jj, %c0]
: memref<2x3x16xi32>
}
@ -1334,18 +1334,18 @@ func @R3_to_R2_reshape() {
// CHECK-DAG: %0 = alloc() : memref<1x1x1xi32>
// CHECK: for %i0 = 0 to 32 {
// CHECK-NEXT: for %i1 = 0 to 3 {
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%i0, %i1)
// CHECK-NEXT: %2 = affine_apply [[MAP1]]()[%c0]
// CHECK-NEXT: %1 = affine.apply [[MAP0]](%i0, %i1)
// CHECK-NEXT: %2 = affine.apply [[MAP1]]()[%c0]
// CHECK-NEXT: %3 = "foo"(%1, %i1, %2) : (index, index, index) -> i32
// CHECK-NEXT: %4 = affine_apply [[MAP2]](%i0, %i1, %1, %i1, %2)
// CHECK-NEXT: %5 = affine_apply [[MAP3]](%i0, %i1, %1, %i1, %2)
// CHECK-NEXT: %6 = affine_apply [[MAP4]](%i0, %i1, %1, %i1, %2)
// CHECK-NEXT: %4 = affine.apply [[MAP2]](%i0, %i1, %1, %i1, %2)
// CHECK-NEXT: %5 = affine.apply [[MAP3]](%i0, %i1, %1, %i1, %2)
// CHECK-NEXT: %6 = affine.apply [[MAP4]](%i0, %i1, %1, %i1, %2)
// CHECK-NEXT: store %3, %0[%4, %5, %6] : memref<1x1x1xi32>
// CHECK-NEXT: %7 = affine_apply [[MAP5]](%i0, %i1)
// CHECK-NEXT: %8 = affine_apply [[MAP6]](%7)
// CHECK-NEXT: %9 = affine_apply [[MAP2]](%i0, %i1, %8, %i1, %c0)
// CHECK-NEXT: %10 = affine_apply [[MAP3]](%i0, %i1, %8, %i1, %c0)
// CHECK-NEXT: %11 = affine_apply [[MAP4]](%i0, %i1, %8, %i1, %c0)
// CHECK-NEXT: %7 = affine.apply [[MAP5]](%i0, %i1)
// CHECK-NEXT: %8 = affine.apply [[MAP6]](%7)
// CHECK-NEXT: %9 = affine.apply [[MAP2]](%i0, %i1, %8, %i1, %c0)
// CHECK-NEXT: %10 = affine.apply [[MAP3]](%i0, %i1, %8, %i1, %c0)
// CHECK-NEXT: %11 = affine.apply [[MAP4]](%i0, %i1, %8, %i1, %c0)
// CHECK-NEXT: %12 = load %0[%9, %10, %11] : memref<1x1x1xi32>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -1466,9 +1466,9 @@ func @should_fuse_and_move_to_preserve_war_dep() {
// CHECK-NEXT: }
// CHECK-NEXT: for %i1 = 0 to 10 {
// CHECK-NEXT: %4 = load %1[%i1] : memref<10xf32>
// CHECK-NEXT: %5 = affine_apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %5 = affine.apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: store %4, %0[%5] : memref<1xf32>
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %6 = affine.apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %7 = load %0[%6] : memref<1xf32>
// CHECK-NEXT: store %cst, %2[%i1] : memref<10xf32>
// CHECK-NEXT: }
@ -1551,9 +1551,9 @@ func @should_fuse_and_preserve_dep_on_constant() {
// CHECK: %cst_0 = constant 1.100000e+01 : f32
// CHECK-NEXT: for %i0 = 0 to 10 {
// CHECK-NEXT: %3 = load %1[%i0] : memref<10xf32>
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %4 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %cst, %0[%4] : memref<1xf32>
// CHECK-NEXT: %5 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %5 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %6 = load %0[%5] : memref<1xf32>
// CHECK-NEXT: store %cst_0, %2[%i0] : memref<10xf32>
// CHECK-NEXT: }
@ -1583,19 +1583,19 @@ func @should_fuse_at_depth_above_loop_carried_dependence(%arg0: memref<64x4xf32>
for %i2 = 0 to 4 {
for %i3 = 0 to 4 {
for %i4 = 0 to 16 {
%1 = affine_apply (d0, d1) -> (d0 * 16 - d1 + 15)(%i3, %i4)
%1 = affine.apply (d0, d1) -> (d0 * 16 - d1 + 15)(%i3, %i4)
%2 = load %arg1[%1, %i2] : memref<64x4xf32>
"op0"(%2) : (f32) -> ()
}
for %i5 = 0 to 4 {
for %i6 = 0 to 16 {
%3 = affine_apply (d0, d1) -> (d0 * 16 - d1 + 15)(%i5, %i6)
%3 = affine.apply (d0, d1) -> (d0 * 16 - d1 + 15)(%i5, %i6)
%4 = load %arg0[%3, %i3] : memref<64x4xf32>
"op1"(%4) : (f32) -> ()
}
for %i7 = 0 to 16 {
%5 = "op2"() : () -> (f32)
%6 = affine_apply (d0, d1) -> (d0 * 16 + d1)(%i5, %i7)
%6 = affine.apply (d0, d1) -> (d0 * 16 + d1)(%i5, %i7)
%7 = load %out[%6, %i2] : memref<64x4xf32>
%8 = addf %7, %5 : f32
store %8, %out[%6, %i2] : memref<64x4xf32>
@ -1615,31 +1615,31 @@ func @should_fuse_at_depth_above_loop_carried_dependence(%arg0: memref<64x4xf32>
// CHECK: %0 = alloc() : memref<64x1xf32>
// CHECK: for %i0 = 0 to 4 {
// CHECK-NEXT: for %i1 = 0 to 64 {
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%i0, %i1, %i0)
// CHECK-NEXT: %2 = affine_apply [[MAP1]](%i0, %i1, %i0)
// CHECK-NEXT: %1 = affine.apply [[MAP0]](%i0, %i1, %i0)
// CHECK-NEXT: %2 = affine.apply [[MAP1]](%i0, %i1, %i0)
// CHECK-NEXT: store %cst, %0[%1, %2] : memref<64x1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: for %i2 = 0 to 4 {
// CHECK-NEXT: for %i3 = 0 to 16 {
// CHECK-NEXT: %3 = affine_apply [[MAP2]](%i2, %i3)
// CHECK-NEXT: %3 = affine.apply [[MAP2]](%i2, %i3)
// CHECK-NEXT: %4 = load %arg1[%3, %i0] : memref<64x4xf32>
// CHECK-NEXT: "op0"(%4) : (f32) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: for %i4 = 0 to 4 {
// CHECK-NEXT: for %i5 = 0 to 16 {
// CHECK-NEXT: %5 = affine_apply [[MAP2]](%i4, %i5)
// CHECK-NEXT: %5 = affine.apply [[MAP2]](%i4, %i5)
// CHECK-NEXT: %6 = load %arg0[%5, %i2] : memref<64x4xf32>
// CHECK-NEXT: "op1"(%6) : (f32) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: for %i6 = 0 to 16 {
// CHECK-NEXT: %7 = "op2"() : () -> f32
// CHECK-NEXT: %8 = affine_apply [[MAP3]](%i4, %i6)
// CHECK-NEXT: %9 = affine_apply [[MAP0]](%i0, %8, %i0)
// CHECK-NEXT: %10 = affine_apply [[MAP1]](%i0, %8, %i0)
// CHECK-NEXT: %8 = affine.apply [[MAP3]](%i4, %i6)
// CHECK-NEXT: %9 = affine.apply [[MAP0]](%i0, %8, %i0)
// CHECK-NEXT: %10 = affine.apply [[MAP1]](%i0, %8, %i0)
// CHECK-NEXT: %11 = load %0[%9, %10] : memref<64x1xf32>
// CHECK-NEXT: %12 = addf %11, %7 : f32
// CHECK-NEXT: %13 = affine_apply [[MAP0]](%i0, %8, %i0)
// CHECK-NEXT: %14 = affine_apply [[MAP1]](%i0, %8, %i0)
// CHECK-NEXT: %13 = affine.apply [[MAP0]](%i0, %8, %i0)
// CHECK-NEXT: %14 = affine.apply [[MAP1]](%i0, %8, %i0)
// CHECK-NEXT: store %12, %0[%13, %14] : memref<64x1xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -1679,16 +1679,16 @@ func @should_fuse_after_private_memref_creation() {
// longer exists, so '%i0' can now be fused into '%i2'.
// CHECK: for %i0 = 0 to 10 {
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: store %cst, %1[%3] : memref<1xf32>
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %4 = affine.apply [[MAP0]](%i0, %i0)
// CHECK-NEXT: %5 = load %1[%4] : memref<1xf32>
// CHECK-NEXT: store %5, %2[%i0] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: for %i1 = 0 to 10 {
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %6 = affine.apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: store %cst, %0[%6] : memref<1xf32>
// CHECK-NEXT: %7 = affine_apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %7 = affine.apply [[MAP0]](%i1, %i1)
// CHECK-NEXT: %8 = load %0[%7] : memref<1xf32>
// CHECK-NEXT: store %8, %2[%i1] : memref<10xf32>
// CHECK-NEXT: }

4
mlir/test/Transforms/loop-tiling.mlir
View File

@ -59,12 +59,12 @@ func @loop_tiling() {
func @loop_max_min_bound(%A : memref<? x i32>, %L : index, %U : index) {
%M = dim %A, 0 : memref<? x i32>
for %iTT = max #lb()[%L] to min #ub()[%M, %U] {
%out = affine_apply (d0) -> (d0) (%iTT)
%out = affine.apply (d0) -> (d0) (%iTT)
}
return
// CHECK: for %i0 = max [[LB]]()[%arg1] to min [[UB]]()[%0, %arg2] step 32 {
// CHECK-NEXT: for %i1 = [[IDENTITY]](%i0) to min [[UB_INTRA_TILE]](%0, %arg2, %i0) {
// CHECK-NEXT: %1 = affine_apply [[IDENTITY]](%i1)
// CHECK-NEXT: %1 = affine.apply [[IDENTITY]](%i1)
// CHECK-NEXT: }
// CHECK-NEXT: }
}

26
mlir/test/Transforms/lower-affine.mlir
View File

@ -506,20 +506,20 @@ func @min_reduction_tree(%v : index) {
func @affine_applies() {
^bb0:
// CHECK: %c0 = constant 0 : index
%zero = affine_apply #map0()
%zero = affine.apply #map0()
// Identity maps are just discarded.
// CHECK-NEXT: %c101 = constant 101 : index
%101 = constant 101 : index
%symbZero = affine_apply #map1()[%zero]
%symbZero = affine.apply #map1()[%zero]
// CHECK-NEXT: %c102 = constant 102 : index
%102 = constant 102 : index
%copy = affine_apply #map2(%zero)
%copy = affine.apply #map2(%zero)
// CHECK-NEXT: %0 = addi %c0, %c0 : index
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %1 = addi %0, %c1 : index
%one = affine_apply #map3(%symbZero)[%zero]
%one = affine.apply #map3(%symbZero)[%zero]
// CHECK-NEXT: %c103 = constant 103 : index
// CHECK-NEXT: %c104 = constant 104 : index
@ -553,7 +553,7 @@ func @affine_applies() {
// CHECK-NEXT: %c7 = constant 7 : index
// CHECK-NEXT: %12 = muli %c109, %c7 : index
// CHECK-NEXT: %13 = addi %11, %12 : index
%four = affine_apply #map4(%103,%104,%105,%106)[%107,%108,%109]
%four = affine.apply #map4(%103,%104,%105,%106)[%107,%108,%109]
return
}
@ -561,8 +561,8 @@ func @affine_applies() {
func @args_ret_affine_apply(index, index) -> (index, index) {
^bb0(%0 : index, %1 : index):
// CHECK-NEXT: return %arg0, %arg1 : index, index
%00 = affine_apply #map2 (%0)
%11 = affine_apply #map1 ()[%1]
%00 = affine.apply #map2 (%0)
%11 = affine.apply #map1 ()[%1]
return %00, %11 : index, index
}
@ -578,7 +578,7 @@ func @args_ret_affine_apply(index, index) -> (index, index) {
// --------------------------------------------------------------------------//
// IMPORTANT NOTE: if you change this test, also change the @lowered_affine_mod
// test in the "constant-fold.mlir" test to reflect the expected output of
// affine_apply lowering.
// affine.apply lowering.
// --------------------------------------------------------------------------//
// CHECK-LABEL: func @affine_apply_mod
func @affine_apply_mod(%arg0 : index) -> (index) {
@ -588,7 +588,7 @@ func @affine_apply_mod(%arg0 : index) -> (index) {
// CHECK-NEXT: %1 = cmpi "slt", %0, %c0 : index
// CHECK-NEXT: %2 = addi %0, %c42 : index
// CHECK-NEXT: %3 = select %1, %2, %0 : index
%0 = affine_apply #mapmod (%arg0)
%0 = affine.apply #mapmod (%arg0)
return %0 : index
}
@ -597,7 +597,7 @@ func @affine_apply_mod(%arg0 : index) -> (index) {
// --------------------------------------------------------------------------//
// IMPORTANT NOTE: if you change this test, also change the @lowered_affine_mod
// test in the "constant-fold.mlir" test to reflect the expected output of
// affine_apply lowering.
// affine.apply lowering.
// --------------------------------------------------------------------------//
// CHECK-LABEL: func @affine_apply_floordiv
func @affine_apply_floordiv(%arg0 : index) -> (index) {
@ -610,7 +610,7 @@ func @affine_apply_floordiv(%arg0 : index) -> (index) {
// CHECK-NEXT: %3 = divis %2, %c42 : index
// CHECK-NEXT: %4 = subi %c-1, %3 : index
// CHECK-NEXT: %5 = select %0, %4, %3 : index
%0 = affine_apply #mapfloordiv (%arg0)
%0 = affine.apply #mapfloordiv (%arg0)
return %0 : index
}
@ -619,7 +619,7 @@ func @affine_apply_floordiv(%arg0 : index) -> (index) {
// --------------------------------------------------------------------------//
// IMPORTANT NOTE: if you change this test, also change the @lowered_affine_mod
// test in the "constant-fold.mlir" test to reflect the expected output of
// affine_apply lowering.
// affine.apply lowering.
// --------------------------------------------------------------------------//
// CHECK-LABEL: func @affine_apply_ceildiv
func @affine_apply_ceildiv(%arg0 : index) -> (index) {
@ -634,6 +634,6 @@ func @affine_apply_ceildiv(%arg0 : index) -> (index) {
// CHECK-NEXT: %5 = subi %c0, %4 : index
// CHECK-NEXT: %6 = addi %4, %c1 : index
// CHECK-NEXT: %7 = select %0, %5, %6 : index
%0 = affine_apply #mapceildiv (%arg0)
%0 = affine.apply #mapceildiv (%arg0)
return %0 : index
}

64
mlir/test/Transforms/memref-bound-check.mlir
View File

@ -13,8 +13,8 @@ func @test() {
for %i = -1 to 10 {
for %j = -1 to 10 {
%idx0 = affine_apply (d0, d1) -> (d0)(%i, %j)
%idx1 = affine_apply (d0, d1) -> (d1)(%i, %j)
%idx0 = affine.apply (d0, d1) -> (d0)(%i, %j)
%idx1 = affine.apply (d0, d1) -> (d1)(%i, %j)
// Out of bound access.
%x = load %A[%idx0, %idx1] : memref<9 x 9 x i32>
// expected-error@-1 {{'load' op memref out of upper bound access along dimension #1}}
@ -22,7 +22,7 @@ func @test() {
// expected-error@-3 {{'load' op memref out of upper bound access along dimension #2}}
// expected-error@-4 {{'load' op memref out of lower bound access along dimension #2}}
// This will access 0 to 110 - hence an overflow.
%idy = affine_apply (d0, d1) -> (10*d0 - d1 + 19)(%i, %j)
%idy = affine.apply (d0, d1) -> (10*d0 - d1 + 19)(%i, %j)
%y = load %B[%idy] : memref<111 x i32>
}
}
@ -45,16 +45,16 @@ func @test_mod_floordiv_ceildiv() {
for %i = 0 to 256 {
for %j = 0 to 256 {
%idx0 = affine_apply (d0, d1, d2) -> (d0 mod 128 + 1)(%i, %j, %j)
%idx1 = affine_apply (d0, d1, d2) -> (d1 floordiv 4 + 1)(%i, %j, %j)
%idx2 = affine_apply (d0, d1, d2) -> (d2 ceildiv 4)(%i, %j, %j)
%idx0 = affine.apply (d0, d1, d2) -> (d0 mod 128 + 1)(%i, %j, %j)
%idx1 = affine.apply (d0, d1, d2) -> (d1 floordiv 4 + 1)(%i, %j, %j)
%idx2 = affine.apply (d0, d1, d2) -> (d2 ceildiv 4)(%i, %j, %j)
%x = load %A[%idx0, %idx1, %idx2] : memref<128 x 64 x 64 x i32>
// expected-error@-1 {{'load' op memref out of upper bound access along dimension #1}}
// expected-error@-2 {{'load' op memref out of upper bound access along dimension #2}}
// expected-error@-3 {{'load' op memref out of upper bound access along dimension #3}}
%idy0 = affine_apply (d0, d1, d2) -> (d0 mod 128)(%i, %j, %j)
%idy1 = affine_apply (d0, d1, d2) -> (d1 floordiv 4)(%i, %j, %j)
%idy2 = affine_apply (d0, d1, d2) -> (d2 ceildiv 4 - 1)(%i, %j, %j)
%idy0 = affine.apply (d0, d1, d2) -> (d0 mod 128)(%i, %j, %j)
%idy1 = affine.apply (d0, d1, d2) -> (d1 floordiv 4)(%i, %j, %j)
%idy2 = affine.apply (d0, d1, d2) -> (d2 ceildiv 4 - 1)(%i, %j, %j)
store %x, %A[%idy0, %idy1, %idy2] : memref<128 x 64 x 64 x i32> // expected-error {{'store' op memref out of lower bound access along dimension #3}}
// CHECK-EMPTY
} // CHECK }
@ -72,16 +72,16 @@ func @test_no_out_of_bounds() {
for %i = 0 to 256 {
for %j = 0 to 256 {
// All of these accesses are in bound; check that no errors are emitted.
// CHECK: %3 = affine_apply {{#map.*}}(%i0, %i1)
// CHECK: %3 = affine.apply {{#map.*}}(%i0, %i1)
// CHECK-NEXT: %4 = load %0[%3, %c0] : memref<257x256xi32>
// CHECK-NEXT: %5 = affine_apply {{#map.*}}(%i0, %i0)
// CHECK-NEXT: %5 = affine.apply {{#map.*}}(%i0, %i0)
// CHECK-NEXT: %6 = load %2[%5] : memref<1xi32>
%idx0 = affine_apply (d0, d1) -> ( 64 * (d0 ceildiv 64))(%i, %j)
%idx0 = affine.apply (d0, d1) -> ( 64 * (d0 ceildiv 64))(%i, %j)
// Without GCDTightenInequalities(), the upper bound on the region
// accessed along first memref dimension would have come out as d0 <= 318
// (instead of d0 <= 256), and led to a false positive out of bounds.
%x = load %A[%idx0, %zero] : memref<257 x 256 x i32>
%idy = affine_apply (d0, d1) -> (d0 floordiv 256)(%i, %i)
%idy = affine.apply (d0, d1) -> (d0 floordiv 256)(%i, %i)
%y = load %B[%idy] : memref<1 x i32>
} // CHECK-NEXT }
}
@ -95,16 +95,16 @@ func @mod_div() {
for %i = 0 to 256 {
for %j = 0 to 256 {
%idx0 = affine_apply (d0, d1, d2) -> (d0 mod 128 + 1)(%i, %j, %j)
%idx1 = affine_apply (d0, d1, d2) -> (d1 floordiv 4 + 1)(%i, %j, %j)
%idx2 = affine_apply (d0, d1, d2) -> (d2 ceildiv 4)(%i, %j, %j)
%idx0 = affine.apply (d0, d1, d2) -> (d0 mod 128 + 1)(%i, %j, %j)
%idx1 = affine.apply (d0, d1, d2) -> (d1 floordiv 4 + 1)(%i, %j, %j)
%idx2 = affine.apply (d0, d1, d2) -> (d2 ceildiv 4)(%i, %j, %j)
%x = load %A[%idx0, %idx1, %idx2] : memref<128 x 64 x 64 x i32>
// expected-error@-1 {{'load' op memref out of upper bound access along dimension #1}}
// expected-error@-2 {{'load' op memref out of upper bound access along dimension #2}}
// expected-error@-3 {{'load' op memref out of upper bound access along dimension #3}}
%idy0 = affine_apply (d0, d1, d2) -> (d0 mod 128)(%i, %j, %j)
%idy1 = affine_apply (d0, d1, d2) -> (d1 floordiv 4)(%i, %j, %j)
%idy2 = affine_apply (d0, d1, d2) -> (d2 ceildiv 4 - 1)(%i, %j, %j)
%idy0 = affine.apply (d0, d1, d2) -> (d0 mod 128)(%i, %j, %j)
%idy1 = affine.apply (d0, d1, d2) -> (d1 floordiv 4)(%i, %j, %j)
%idy2 = affine.apply (d0, d1, d2) -> (d2 ceildiv 4 - 1)(%i, %j, %j)
store %x, %A[%idy0, %idy1, %idy2] : memref<128 x 64 x 64 x i32> // expected-error {{'store' op memref out of lower bound access along dimension #3}}
}
}
@ -117,8 +117,8 @@ func @mod_floordiv_nested() {
%A = alloc() : memref<256 x 256 x i32>
for %i = 0 to 256 {
for %j = 0 to 256 {
%idx0 = affine_apply (d0, d1) -> ((d0 mod 1024) floordiv 4)(%i, %j)
%idx1 = affine_apply (d0, d1) -> ((((d1 mod 128) mod 32) ceildiv 4) * 32)(%i, %j)
%idx0 = affine.apply (d0, d1) -> ((d0 mod 1024) floordiv 4)(%i, %j)
%idx1 = affine.apply (d0, d1) -> ((((d1 mod 128) mod 32) ceildiv 4) * 32)(%i, %j)
load %A[%idx0, %idx1] : memref<256 x 256 x i32> // expected-error {{'load' op memref out of upper bound access along dimension #2}}
}
}
@ -129,7 +129,7 @@ func @mod_floordiv_nested() {
func @test_semi_affine_bailout(%N : index) {
%B = alloc() : memref<10 x i32>
for %i = 0 to 10 {
%idx = affine_apply (d0)[s0] -> (d0 * s0)(%i)[%N]
%idx = affine.apply (d0)[s0] -> (d0 * s0)(%i)[%N]
%y = load %B[%idx] : memref<10 x i32>
}
return
@ -139,8 +139,8 @@ func @test_semi_affine_bailout(%N : index) {
func @multi_mod_floordiv() {
%A = alloc() : memref<2x2xi32>
for %ii = 0 to 64 {
%idx0 = affine_apply (d0) -> ((d0 mod 147456) floordiv 1152) (%ii)
%idx1 = affine_apply (d0) -> (((d0 mod 147456) mod 1152) floordiv 384) (%ii)
%idx0 = affine.apply (d0) -> ((d0 mod 147456) floordiv 1152) (%ii)
%idx1 = affine.apply (d0) -> (((d0 mod 147456) mod 1152) floordiv 384) (%ii)
%v = load %A[%idx0, %idx1] : memref<2x2xi32>
}
return
@ -155,18 +155,18 @@ func @delinearize_mod_floordiv() {
// Reshape '%in' into '%out'.
for %ii = 0 to 64 {
for %jj = 0 to 9 {
%a0 = affine_apply (d0, d1) -> (d0 * (9 * 1024) + d1 * 128) (%ii, %jj)
%a10 = affine_apply (d0) ->
%a0 = affine.apply (d0, d1) -> (d0 * (9 * 1024) + d1 * 128) (%ii, %jj)
%a10 = affine.apply (d0) ->
(d0 floordiv (2 * 3 * 3 * 128 * 128)) (%a0)
%a11 = affine_apply (d0) ->
%a11 = affine.apply (d0) ->
((d0 mod 294912) floordiv (3 * 3 * 128 * 128)) (%a0)
%a12 = affine_apply (d0) ->
%a12 = affine.apply (d0) ->
((((d0 mod 294912) mod 147456) floordiv 1152) floordiv 8) (%a0)
%a13 = affine_apply (d0) ->
%a13 = affine.apply (d0) ->
((((d0 mod 294912) mod 147456) mod 1152) floordiv 384) (%a0)
%a14 = affine_apply (d0) ->
%a14 = affine.apply (d0) ->
(((((d0 mod 294912) mod 147456) mod 1152) mod 384) floordiv 128) (%a0)
%a15 = affine_apply (d0) ->
%a15 = affine.apply (d0) ->
((((((d0 mod 294912) mod 147456) mod 1152) mod 384) mod 128)
floordiv 128) (%a0)
%v0 = load %in[%a10, %a11, %a13, %a14, %a12, %a15]
@ -190,7 +190,7 @@ func @out_of_bounds() {
%c9 = constant 9 : i32
for %i0 = 10 to 11 {
%idy = affine_apply (d0) -> (100 * d0 floordiv 1000) (%i0)
%idy = affine.apply (d0) -> (100 * d0 floordiv 1000) (%i0)
store %c9, %in[%idy] : memref<1xi32> // expected-error {{'store' op memref out of upper bound access along dimension #1}}
}
return

20
mlir/test/Transforms/memref-dataflow-opt.mlir
View File

@ -61,10 +61,10 @@ func @store_load_affine_apply() -> memref<10x10xf32> {
%m = alloc() : memref<10x10xf32>
for %i0 = 0 to 10 {
for %i1 = 0 to 10 {
%t0 = affine_apply (d0, d1) -> (d1 + 1)(%i0, %i1)
%t1 = affine_apply (d0, d1) -> (d0)(%i0, %i1)
%idx0 = affine_apply (d0, d1) -> (d1) (%t0, %t1)
%idx1 = affine_apply (d0, d1) -> (d0 - 1) (%t0, %t1)
%t0 = affine.apply (d0, d1) -> (d1 + 1)(%i0, %i1)
%t1 = affine.apply (d0, d1) -> (d0)(%i0, %i1)
%idx0 = affine.apply (d0, d1) -> (d1) (%t0, %t1)
%idx1 = affine.apply (d0, d1) -> (d0 - 1) (%t0, %t1)
store %cf7, %m[%idx0, %idx1] : memref<10x10xf32>
// CHECK-NOT: load %{{[0-9]+}}
%v0 = load %m[%i0, %i1] : memref<10x10xf32>
@ -77,10 +77,10 @@ func @store_load_affine_apply() -> memref<10x10xf32> {
// CHECK-NEXT: %0 = alloc() : memref<10x10xf32>
// CHECK-NEXT: for %i0 = 0 to 10 {
// CHECK-NEXT: for %i1 = 0 to 10 {
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%i0, %i1)
// CHECK-NEXT: %2 = affine_apply [[MAP1]](%i0, %i1)
// CHECK-NEXT: %3 = affine_apply [[MAP2]](%1, %2)
// CHECK-NEXT: %4 = affine_apply [[MAP3]](%1, %2)
// CHECK-NEXT: %1 = affine.apply [[MAP0]](%i0, %i1)
// CHECK-NEXT: %2 = affine.apply [[MAP1]](%i0, %i1)
// CHECK-NEXT: %3 = affine.apply [[MAP2]](%1, %2)
// CHECK-NEXT: %4 = affine.apply [[MAP3]](%1, %2)
// CHECK-NEXT: store %cst, %0[%3, %4] : memref<10x10xf32>
// CHECK-NEXT: %5 = addf %cst, %cst : f32
// CHECK-NEXT: }
@ -228,7 +228,7 @@ func @store_load_store_nested_fwd(%N : index) -> f32 {
for %i1 = 0 to %N {
%v0 = load %m[%i0] : memref<10xf32>
%v1 = addf %v0, %v0 : f32
%idx = affine_apply (d0) -> (d0 + 1) (%i0)
%idx = affine.apply (d0) -> (d0 + 1) (%i0)
store %cf9, %m[%idx] : memref<10xf32>
}
}
@ -240,7 +240,7 @@ func @store_load_store_nested_fwd(%N : index) -> f32 {
// CHECK-NEXT: store %cst, %0[%i0] : memref<10xf32>
// CHECK-NEXT: for %i1 = 0 to %arg0 {
// CHECK-NEXT: %1 = addf %cst, %cst : f32
// CHECK-NEXT: %2 = affine_apply [[MAP4]](%i0)
// CHECK-NEXT: %2 = affine.apply [[MAP4]](%i0)
// CHECK-NEXT: store %cst_0, %0[%2] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }

122
mlir/test/Transforms/memref-dependence-check.mlir
View File

@ -164,11 +164,11 @@ func @store_load_diff_element_affine_apply_const() {
%m = alloc() : memref<100xf32>
%c1 = constant 1 : index
%c8 = constant 8.0 : f32
%a0 = affine_apply (d0) -> (d0) (%c1)
%a0 = affine.apply (d0) -> (d0) (%c1)
store %c8, %m[%a0] : memref<100xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 1 at depth 1 = false}}
%a1 = affine_apply (d0) -> (d0 + 1) (%c1)
%a1 = affine.apply (d0) -> (d0 + 1) (%c1)
%v0 = load %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
@ -182,11 +182,11 @@ func @store_load_same_element_affine_apply_const() {
%c7 = constant 7.0 : f32
%c9 = constant 9 : index
%c11 = constant 11 : index
%a0 = affine_apply (d0) -> (d0 + 1) (%c9)
%a0 = affine.apply (d0) -> (d0 + 1) (%c9)
store %c7, %m[%a0] : memref<100xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 1 at depth 1 = true}}
%a1 = affine_apply (d0) -> (d0 - 1) (%c11)
%a1 = affine.apply (d0) -> (d0 - 1) (%c11)
%v0 = load %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
@ -198,11 +198,11 @@ func @store_load_same_element_affine_apply_const() {
func @store_load_affine_apply_symbol(%arg0: index) {
%m = alloc() : memref<100xf32>
%c7 = constant 7.0 : f32
%a0 = affine_apply (d0) -> (d0) (%arg0)
%a0 = affine.apply (d0) -> (d0) (%arg0)
store %c7, %m[%a0] : memref<100xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 1 at depth 1 = true}}
%a1 = affine_apply (d0) -> (d0) (%arg0)
%a1 = affine.apply (d0) -> (d0) (%arg0)
%v0 = load %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
@ -214,11 +214,11 @@ func @store_load_affine_apply_symbol(%arg0: index) {
func @store_load_affine_apply_symbol_offset(%arg0: index) {
%m = alloc() : memref<100xf32>
%c7 = constant 7.0 : f32
%a0 = affine_apply (d0) -> (d0) (%arg0)
%a0 = affine.apply (d0) -> (d0) (%arg0)
store %c7, %m[%a0] : memref<100xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 1 at depth 1 = false}}
%a1 = affine_apply (d0) -> (d0 + 1) (%arg0)
%a1 = affine.apply (d0) -> (d0 + 1) (%arg0)
%v0 = load %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
@ -232,13 +232,13 @@ func @store_range_load_after_range() {
%c7 = constant 7.0 : f32
%c10 = constant 10 : index
for %i0 = 0 to 10 {
%a0 = affine_apply (d0) -> (d0) (%i0)
%a0 = affine.apply (d0) -> (d0) (%i0)
store %c7, %m[%a0] : memref<100xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
// expected-note@-3 {{dependence from 0 to 1 at depth 1 = false}}
// expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
%a1 = affine_apply (d0) -> (d0) (%c10)
%a1 = affine.apply (d0) -> (d0) (%c10)
%v0 = load %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -255,13 +255,13 @@ func @store_load_func_symbol(%arg0: index, %arg1: index) {
%c7 = constant 7.0 : f32
%c10 = constant 10 : index
for %i0 = 0 to %arg1 {
%a0 = affine_apply (d0) -> (d0) (%arg0)
%a0 = affine.apply (d0) -> (d0) (%arg0)
store %c7, %m[%a0] : memref<100xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = [1, +inf]}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
// expected-note@-3 {{dependence from 0 to 1 at depth 1 = [1, +inf]}}
// expected-note@-4 {{dependence from 0 to 1 at depth 2 = true}}
%a1 = affine_apply (d0) -> (d0) (%arg0)
%a1 = affine.apply (d0) -> (d0) (%arg0)
%v0 = load %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = [1, +inf]}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -278,7 +278,7 @@ func @store_range_load_last_in_range() {
%c7 = constant 7.0 : f32
%c10 = constant 10 : index
for %i0 = 0 to 10 {
%a0 = affine_apply (d0) -> (d0) (%i0)
%a0 = affine.apply (d0) -> (d0) (%i0)
// For dependence from 0 to 1, we do not have a loop carried dependence
// because only the final write in the loop accesses the same element as the
// load, so this dependence appears only at depth 2 (loop independent).
@ -287,7 +287,7 @@ func @store_range_load_last_in_range() {
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
// expected-note@-3 {{dependence from 0 to 1 at depth 1 = false}}
// expected-note@-4 {{dependence from 0 to 1 at depth 2 = true}}
%a1 = affine_apply (d0) -> (d0 - 1) (%c10)
%a1 = affine.apply (d0) -> (d0 - 1) (%c10)
// For dependence from 1 to 0, we have write-after-read (WAR) dependences
// for all loads in the loop to the store on the last iteration.
%v0 = load %m[%a1] : memref<100xf32>
@ -306,13 +306,13 @@ func @store_range_load_before_range() {
%c7 = constant 7.0 : f32
%c0 = constant 0 : index
for %i0 = 1 to 11 {
%a0 = affine_apply (d0) -> (d0) (%i0)
%a0 = affine.apply (d0) -> (d0) (%i0)
store %c7, %m[%a0] : memref<100xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
// expected-note@-3 {{dependence from 0 to 1 at depth 1 = false}}
// expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
%a1 = affine_apply (d0) -> (d0) (%c0)
%a1 = affine.apply (d0) -> (d0) (%c0)
%v0 = load %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -329,7 +329,7 @@ func @store_range_load_first_in_range() {
%c7 = constant 7.0 : f32
%c0 = constant 0 : index
for %i0 = 1 to 11 {
%a0 = affine_apply (d0) -> (d0) (%i0)
%a0 = affine.apply (d0) -> (d0) (%i0)
// Dependence from 0 to 1 at depth 1 is a range because all loads at
// constant index zero are reads after first store at index zero during
// first iteration of the loop.
@ -338,7 +338,7 @@ func @store_range_load_first_in_range() {
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
// expected-note@-3 {{dependence from 0 to 1 at depth 1 = [1, 9]}}
// expected-note@-4 {{dependence from 0 to 1 at depth 2 = true}}
%a1 = affine_apply (d0) -> (d0 + 1) (%c0)
%a1 = affine.apply (d0) -> (d0 + 1) (%c0)
%v0 = load %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -354,13 +354,13 @@ func @store_plus_3() {
%m = alloc() : memref<100xf32>
%c7 = constant 7.0 : f32
for %i0 = 1 to 11 {
%a0 = affine_apply (d0) -> (d0 + 3) (%i0)
%a0 = affine.apply (d0) -> (d0 + 3) (%i0)
store %c7, %m[%a0] : memref<100xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
// expected-note@-3 {{dependence from 0 to 1 at depth 1 = [3, 3]}}
// expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
%a1 = affine_apply (d0) -> (d0) (%i0)
%a1 = affine.apply (d0) -> (d0) (%i0)
%v0 = load %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -376,13 +376,13 @@ func @load_minus_2() {
%m = alloc() : memref<100xf32>
%c7 = constant 7.0 : f32
for %i0 = 2 to 11 {
%a0 = affine_apply (d0) -> (d0) (%i0)
%a0 = affine.apply (d0) -> (d0) (%i0)
store %c7, %m[%a0] : memref<100xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
// expected-note@-3 {{dependence from 0 to 1 at depth 1 = [2, 2]}}
// expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
%a1 = affine_apply (d0) -> (d0 - 2) (%i0)
%a1 = affine.apply (d0) -> (d0 - 2) (%i0)
%v0 = load %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -400,8 +400,8 @@ func @perfectly_nested_loops_loop_independent() {
for %i0 = 0 to 11 {
for %i1 = 0 to 11 {
// Dependence from access 0 to 1 is loop independent at depth = 3.
%a00 = affine_apply (d0, d1) -> (d0) (%i0, %i1)
%a01 = affine_apply (d0, d1) -> (d1) (%i0, %i1)
%a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
%a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
store %c7, %m[%a00, %a01] : memref<10x10xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
@ -409,8 +409,8 @@ func @perfectly_nested_loops_loop_independent() {
// expected-note@-4 {{dependence from 0 to 1 at depth 1 = false}}
// expected-note@-5 {{dependence from 0 to 1 at depth 2 = false}}
// expected-note@-6 {{dependence from 0 to 1 at depth 3 = true}}
%a10 = affine_apply (d0, d1) -> (d0) (%i0, %i1)
%a11 = affine_apply (d0, d1) -> (d1) (%i0, %i1)
%a10 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
%a11 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
%v0 = load %m[%a10, %a11] : memref<10x10xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -431,8 +431,8 @@ func @perfectly_nested_loops_loop_carried_at_depth1() {
for %i0 = 0 to 9 {
for %i1 = 0 to 9 {
// Dependence from access 0 to 1 is loop carried at depth 1.
%a00 = affine_apply (d0, d1) -> (d0) (%i0, %i1)
%a01 = affine_apply (d0, d1) -> (d1) (%i0, %i1)
%a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
%a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
store %c7, %m[%a00, %a01] : memref<10x10xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
@ -440,8 +440,8 @@ func @perfectly_nested_loops_loop_carried_at_depth1() {
// expected-note@-4 {{dependence from 0 to 1 at depth 1 = [2, 2][0, 0]}}
// expected-note@-5 {{dependence from 0 to 1 at depth 2 = false}}
// expected-note@-6 {{dependence from 0 to 1 at depth 3 = false}}
%a10 = affine_apply (d0, d1) -> (d0 - 2) (%i0, %i1)
%a11 = affine_apply (d0, d1) -> (d1) (%i0, %i1)
%a10 = affine.apply (d0, d1) -> (d0 - 2) (%i0, %i1)
%a11 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
%v0 = load %m[%a10, %a11] : memref<10x10xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -462,8 +462,8 @@ func @perfectly_nested_loops_loop_carried_at_depth2() {
for %i0 = 0 to 10 {
for %i1 = 0 to 10 {
// Dependence from access 0 to 1 is loop carried at depth 2.
%a00 = affine_apply (d0, d1) -> (d0) (%i0, %i1)
%a01 = affine_apply (d0, d1) -> (d1) (%i0, %i1)
%a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
%a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
store %c7, %m[%a00, %a01] : memref<10x10xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
@ -471,8 +471,8 @@ func @perfectly_nested_loops_loop_carried_at_depth2() {
// expected-note@-4 {{dependence from 0 to 1 at depth 1 = false}}
// expected-note@-5 {{dependence from 0 to 1 at depth 2 = [0, 0][3, 3]}}
// expected-note@-6 {{dependence from 0 to 1 at depth 3 = false}}
%a10 = affine_apply (d0, d1) -> (d0) (%i0, %i1)
%a11 = affine_apply (d0, d1) -> (d1 - 3) (%i0, %i1)
%a10 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
%a11 = affine.apply (d0, d1) -> (d1 - 3) (%i0, %i1)
%v0 = load %m[%a10, %a11] : memref<10x10xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -493,8 +493,8 @@ func @one_common_loop() {
// There is a loop-independent dependence from access 0 to 1 at depth 2.
for %i0 = 0 to 10 {
for %i1 = 0 to 10 {
%a00 = affine_apply (d0, d1) -> (d0) (%i0, %i1)
%a01 = affine_apply (d0, d1) -> (d1) (%i0, %i1)
%a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
%a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
store %c7, %m[%a00, %a01] : memref<10x10xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
@ -503,8 +503,8 @@ func @one_common_loop() {
// expected-note@-5 {{dependence from 0 to 1 at depth 2 = true}}
}
for %i2 = 0 to 9 {
%a10 = affine_apply (d0, d1) -> (d0) (%i0, %i2)
%a11 = affine_apply (d0, d1) -> (d1) (%i0, %i2)
%a10 = affine.apply (d0, d1) -> (d0) (%i0, %i2)
%a11 = affine.apply (d0, d1) -> (d1) (%i0, %i2)
%v0 = load %m[%a10, %a11] : memref<10x10xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -526,7 +526,7 @@ func @dependence_cycle() {
// *) loop-independent dependence from access 1 to 2 at depth 2.
// *) loop-carried dependence from access 3 to 0 at depth 1.
for %i0 = 0 to 9 {
%a0 = affine_apply (d0) -> (d0) (%i0)
%a0 = affine.apply (d0) -> (d0) (%i0)
%v0 = load %m.a[%a0] : memref<100xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
@ -536,7 +536,7 @@ func @dependence_cycle() {
// expected-note@-6 {{dependence from 0 to 2 at depth 2 = false}}
// expected-note@-7 {{dependence from 0 to 3 at depth 1 = false}}
// expected-note@-8 {{dependence from 0 to 3 at depth 2 = false}}
%a1 = affine_apply (d0) -> (d0) (%i0)
%a1 = affine.apply (d0) -> (d0) (%i0)
store %v0, %m.b[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -546,7 +546,7 @@ func @dependence_cycle() {
// expected-note@-6 {{dependence from 1 to 2 at depth 2 = true}}
// expected-note@-7 {{dependence from 1 to 3 at depth 1 = false}}
// expected-note@-8 {{dependence from 1 to 3 at depth 2 = false}}
%a2 = affine_apply (d0) -> (d0) (%i0)
%a2 = affine.apply (d0) -> (d0) (%i0)
%v1 = load %m.b[%a2] : memref<100xf32>
// expected-note@-1 {{dependence from 2 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 2 to 0 at depth 2 = false}}
@ -556,7 +556,7 @@ func @dependence_cycle() {
// expected-note@-6 {{dependence from 2 to 2 at depth 2 = false}}
// expected-note@-7 {{dependence from 2 to 3 at depth 1 = false}}
// expected-note@-8 {{dependence from 2 to 3 at depth 2 = false}}
%a3 = affine_apply (d0) -> (d0 + 1) (%i0)
%a3 = affine.apply (d0) -> (d0 + 1) (%i0)
store %v1, %m.a[%a3] : memref<100xf32>
// expected-note@-1 {{dependence from 3 to 0 at depth 1 = [1, 1]}}
// expected-note@-2 {{dependence from 3 to 0 at depth 2 = false}}
@ -577,8 +577,8 @@ func @negative_and_positive_direction_vectors(%arg0: index, %arg1: index) {
%c7 = constant 7.0 : f32
for %i0 = 0 to %arg0 {
for %i1 = 0 to %arg1 {
%a00 = affine_apply (d0, d1) -> (d0 - 1) (%i0, %i1)
%a01 = affine_apply (d0, d1) -> (d1 + 1) (%i0, %i1)
%a00 = affine.apply (d0, d1) -> (d0 - 1) (%i0, %i1)
%a01 = affine.apply (d0, d1) -> (d1 + 1) (%i0, %i1)
%v0 = load %m[%a00, %a01] : memref<10x10xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
@ -586,8 +586,8 @@ func @negative_and_positive_direction_vectors(%arg0: index, %arg1: index) {
// expected-note@-4 {{dependence from 0 to 1 at depth 1 = false}}
// expected-note@-5 {{dependence from 0 to 1 at depth 2 = false}}
// expected-note@-6 {{dependence from 0 to 1 at depth 3 = false}}
%a10 = affine_apply (d0, d1) -> (d0) (%i0, %i1)
%a11 = affine_apply (d0, d1) -> (d1) (%i0, %i1)
%a10 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
%a11 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
store %c7, %m[%a10, %a11] : memref<10x10xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = [1, 1][-1, -1]}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -607,7 +607,7 @@ func @war_raw_waw_deps() {
%c7 = constant 7.0 : f32
for %i0 = 0 to 10 {
for %i1 = 0 to 10 {
%a0 = affine_apply (d0) -> (d0 + 1) (%i1)
%a0 = affine.apply (d0) -> (d0 + 1) (%i1)
%v0 = load %m[%a0] : memref<100xf32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
@ -615,7 +615,7 @@ func @war_raw_waw_deps() {
// expected-note@-4 {{dependence from 0 to 1 at depth 1 = [1, 9][1, 1]}}
// expected-note@-5 {{dependence from 0 to 1 at depth 2 = [0, 0][1, 1]}}
// expected-note@-6 {{dependence from 0 to 1 at depth 3 = false}}
%a1 = affine_apply (d0) -> (d0) (%i1)
%a1 = affine.apply (d0) -> (d0) (%i1)
store %c7, %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = [1, 9][-1, -1]}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -634,7 +634,7 @@ func @mod_deps() {
%m = alloc() : memref<100xf32>
%c7 = constant 7.0 : f32
for %i0 = 0 to 10 {
%a0 = affine_apply (d0) -> (d0 mod 2) (%i0)
%a0 = affine.apply (d0) -> (d0 mod 2) (%i0)
// Results are conservative here since we currently don't have a way to
// represent strided sets in FlatAffineConstraints.
%v0 = load %m[%a0] : memref<100xf32>
@ -642,7 +642,7 @@ func @mod_deps() {
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
// expected-note@-3 {{dependence from 0 to 1 at depth 1 = [1, 9]}}
// expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
%a1 = affine_apply (d0) -> ( (d0 + 1) mod 2) (%i0)
%a1 = affine.apply (d0) -> ( (d0 + 1) mod 2) (%i0)
store %c7, %m[%a1] : memref<100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = [1, 9]}}
// expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
@ -671,7 +671,7 @@ func @loop_nest_depth() {
for %i3 = 0 to 8 {
for %i4 = 0 to 8 {
for %i5 = 0 to 16 {
%8 = affine_apply (d0, d1) -> (d0 * 16 + d1)(%i4, %i5)
%8 = affine.apply (d0, d1) -> (d0 * 16 + d1)(%i4, %i5)
%9 = load %0[%8, %i3] : memref<100x100xf32>
// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
// expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
@ -696,9 +696,9 @@ func @mod_div_3d() {
for %i0 = 0 to 8 {
for %i1 = 0 to 8 {
for %i2 = 0 to 8 {
%idx0 = affine_apply (d0, d1, d2) -> (d0 floordiv 4) (%i0, %i1, %i2)
%idx1 = affine_apply (d0, d1, d2) -> (d1 mod 2) (%i0, %i1, %i2)
%idx2 = affine_apply (d0, d1, d2) -> (d2 floordiv 4) (%i0, %i1, %i2)
%idx0 = affine.apply (d0, d1, d2) -> (d0 floordiv 4) (%i0, %i1, %i2)
%idx1 = affine.apply (d0, d1, d2) -> (d1 mod 2) (%i0, %i1, %i2)
%idx2 = affine.apply (d0, d1, d2) -> (d2 floordiv 4) (%i0, %i1, %i2)
store %c0, %M[%idx0, %idx1, %idx2] : memref<2 x 2 x 2 x i32>
// expected-note@-1 {{dependence from 0 to 0 at depth 1 = [1, 3][-7, 7][-3, 3]}}
// expected-note@-2 {{dependence from 0 to 0 at depth 2 = [0, 0][2, 7][-3, 3]}}
@ -744,18 +744,18 @@ func @delinearize_mod_floordiv() {
for %ii = 0 to 64 {
for %jj = 0 to 9 {
%a0 = affine_apply (d0, d1) -> (d0 * (9 * 1024) + d1 * 128) (%ii, %jj)
%a10 = affine_apply (d0) ->
%a0 = affine.apply (d0, d1) -> (d0 * (9 * 1024) + d1 * 128) (%ii, %jj)
%a10 = affine.apply (d0) ->
(d0 floordiv (2 * 3 * 3 * 128 * 128)) (%a0)
%a11 = affine_apply (d0) ->
%a11 = affine.apply (d0) ->
((d0 mod 294912) floordiv (3 * 3 * 128 * 128)) (%a0)
%a12 = affine_apply (d0) ->
%a12 = affine.apply (d0) ->
((((d0 mod 294912) mod 147456) floordiv 1152) floordiv 8) (%a0)
%a13 = affine_apply (d0) ->
%a13 = affine.apply (d0) ->
((((d0 mod 294912) mod 147456) mod 1152) floordiv 384) (%a0)
%a14 = affine_apply (d0) ->
%a14 = affine.apply (d0) ->
(((((d0 mod 294912) mod 147456) mod 1152) mod 384) floordiv 128) (%a0)
%a15 = affine_apply (d0) ->
%a15 = affine.apply (d0) ->
((((((d0 mod 294912) mod 147456) mod 1152) mod 384) mod 128)
floordiv 128) (%a0)
%v0 = load %in[%a10, %a11, %a13, %a14, %a12, %a15] : memref<2x2x3x3x16x1xi32>

52
mlir/test/Transforms/pipeline-data-transfer.mlir
View File

@ -31,16 +31,16 @@ func @loop_nest_dma() {
// CHECK: %0 = alloc() : memref<256xf32>
// CHECK: %1 = alloc() : memref<2x32xf32, 1>
// CHECK-NEXT: %2 = alloc() : memref<2x1xf32>
// CHECK-NEXT: %3 = affine_apply [[MOD_2]](%c0)
// CHECK-NEXT: %4 = affine_apply [[MOD_2]](%c0)
// CHECK-NEXT: %3 = affine.apply [[MOD_2]](%c0)
// CHECK-NEXT: %4 = affine.apply [[MOD_2]](%c0)
// CHECK-NEXT: dma_start %0[%c0], %1[%3, %c0], %c128, %2[%4, %c0_0] : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32>
// CHECK-NEXT: for %i0 = 1 to 8 {
// CHECK-NEXT: %5 = affine_apply [[MOD_2]](%i0)
// CHECK-NEXT: %6 = affine_apply [[MOD_2]](%i0)
// CHECK-NEXT: %5 = affine.apply [[MOD_2]](%i0)
// CHECK-NEXT: %6 = affine.apply [[MOD_2]](%i0)
// CHECK-NEXT: dma_start %0[%i0], %1[%5, %i0], %c128, %2[%6, %c0_0] : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32>
// CHECK-NEXT: %7 = affine_apply [[MAP_MINUS_1]](%i0)
// CHECK-NEXT: %8 = affine_apply [[MOD_2]](%7)
// CHECK-NEXT: %9 = affine_apply [[MOD_2]](%7)
// CHECK-NEXT: %7 = affine.apply [[MAP_MINUS_1]](%i0)
// CHECK-NEXT: %8 = affine.apply [[MOD_2]](%7)
// CHECK-NEXT: %9 = affine.apply [[MOD_2]](%7)
// CHECK-NEXT: dma_wait %2[%8, %c0_0], %c128 : memref<2x1xf32>
// CHECK-NEXT: %10 = load %1[%9, %7] : memref<2x32xf32, 1>
// CHECK-NEXT: %11 = "compute"(%10) : (f32) -> f32
@ -49,9 +49,9 @@ func @loop_nest_dma() {
// CHECK-NEXT: "do_more_compute"(%7, %i1) : (index, index) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: %12 = affine_apply [[MAP_MINUS_1]](%c8)
// CHECK-NEXT: %13 = affine_apply [[MOD_2]](%12)
// CHECK-NEXT: %14 = affine_apply [[MOD_2]](%12)
// CHECK-NEXT: %12 = affine.apply [[MAP_MINUS_1]](%c8)
// CHECK-NEXT: %13 = affine.apply [[MOD_2]](%12)
// CHECK-NEXT: %14 = affine.apply [[MOD_2]](%12)
// CHECK-NEXT: dma_wait %2[%13, %c0_0], %c128 : memref<2x1xf32>
// CHECK-NEXT: %15 = load %1[%14, %12] : memref<2x32xf32, 1>
// CHECK-NEXT: %16 = "compute"(%15) : (f32) -> f32
@ -79,20 +79,20 @@ func @loop_step(%arg0: memref<512xf32>,
return
}
// CHECK: [[TAG:%[0-9]+]] = alloc() : memref<2x1xi32>
// CHECK: %2 = affine_apply [[FLOOR_MOD_2]](%c0)
// CHECK: %3 = affine_apply [[FLOOR_MOD_2]](%c0)
// CHECK: %2 = affine.apply [[FLOOR_MOD_2]](%c0)
// CHECK: %3 = affine.apply [[FLOOR_MOD_2]](%c0)
// CHECK-NEXT: dma_start %arg0[%c0], %0[%2, %c0_0], %c4, [[TAG]][%3, %c0_0] : memref<512xf32>, memref<2x4xf32, 1>, memref<2x1xi32>
// CHECK-NEXT: for %i0 = 4 to 512 step 4 {
// CHECK-NEXT: %4 = affine_apply [[FLOOR_MOD_2]](%i0)
// CHECK-NEXT: %5 = affine_apply [[FLOOR_MOD_2]](%i0)
// CHECK-NEXT: %4 = affine.apply [[FLOOR_MOD_2]](%i0)
// CHECK-NEXT: %5 = affine.apply [[FLOOR_MOD_2]](%i0)
// CHECK-NEXT: dma_start %arg0[%i0], %0[%4, %c0_0], %c4, [[TAG]][%5, %c0_0] : memref<512xf32>, memref<2x4xf32, 1>, memref<2x1xi32>
// CHECK-NEXT: %6 = affine_apply [[REMAP_SHIFT_MINUS_4]](%i0)
// CHECK-NEXT: %7 = affine_apply [[FLOOR_MOD_2]](%6)
// CHECK-NEXT: %6 = affine.apply [[REMAP_SHIFT_MINUS_4]](%i0)
// CHECK-NEXT: %7 = affine.apply [[FLOOR_MOD_2]](%6)
// CHECK: dma_wait [[TAG]][%7, %c0_0], %c4 : memref<2x1xi32>
// CHECK-NEXT: "compute"(%6) : (index) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: [[SHIFTED:%[0-9]+]] = affine_apply [[REMAP_SHIFT_MINUS_4]](%c512)
// CHECK-NEXT: %10 = affine_apply [[FLOOR_MOD_2]]([[SHIFTED]])
// CHECK-NEXT: [[SHIFTED:%[0-9]+]] = affine.apply [[REMAP_SHIFT_MINUS_4]](%c512)
// CHECK-NEXT: %10 = affine.apply [[FLOOR_MOD_2]]([[SHIFTED]])
// CHECK: dma_wait [[TAG]][%10, %c0_0], %c4 : memref<2x1xi32>
// CHECK-NEXT: "compute"(%9) : (index) -> ()
// CHECK-NEXT: return
@ -116,7 +116,7 @@ func @loop_dma_nested(%arg0: memref<512x32xvector<8xf32>, #map0>, %arg1: memref<
// CHECK: dma_start %arg2[
// CHECK: for %i0 = 1 to 8 {
for %i0 = 0 to 8 {
%6 = affine_apply #map2(%i0)
%6 = affine.apply #map2(%i0)
dma_start %arg2[%6, %c0], %2[%c0, %c0], %num_elts, %5[%c0] : memref<512x32xvector<8xf32>, #map0>, memref<64x4xvector<8xf32>, #map0, 2>, memref<2xi32>
dma_wait %5[%c0], %num_elts : memref<2xi32>
// Steady state for DMA overlap on arg2
@ -129,8 +129,8 @@ func @loop_dma_nested(%arg0: memref<512x32xvector<8xf32>, #map0>, %arg1: memref<
// CHECK: dma_start %arg1[
// CHECK-NEXT for %i1 = 1 to 8 {
for %i1 = 0 to 8 {
%7 = affine_apply #map1(%i0, %i1)
%8 = affine_apply #map2(%i1)
%7 = affine.apply #map1(%i0, %i1)
%8 = affine.apply #map2(%i1)
dma_start %arg0[%7, %c0], %0[%c0, %c0], %num_elts, %3[%c0] : memref<512x32xvector<8xf32>, #map0>, memref<64x4xvector<8xf32>, #map0, 2>, memref<2xi32>
dma_start %arg1[%8, %c0], %1[%c0, %c0], %num_elts, %4[%c0] : memref<512x32xvector<8xf32>, #map0>, memref<64x4xvector<8xf32>, #map0, 2>, memref<2xi32>
dma_wait %3[%c0], %num_elts : memref<2xi32>
@ -187,7 +187,7 @@ func @loop_dma_dependent(%arg2: memref<512x32xvector<8xf32>>) {
// CHECK-NOT: dma_start
// CHECK: for %i0 = 0 to 8 {
for %i0 = 0 to 8 {
%6 = affine_apply #map2(%i0)
%6 = affine.apply #map2(%i0)
dma_start %arg2[%6, %c0], %2[%c0, %c0], %num_elts, %5[%c0] : memref<512x32xvector<8xf32>>, memref<64x4xvector<8xf32>, 2>, memref<2xi32>
dma_wait %5[%c0], %num_elts : memref<2xi32>
@ -258,8 +258,8 @@ func @dynamic_shape_dma_buffer(%arg0: memref<512 x 32 x f32>) {
// CHECK-NEXT: %1 = dim %0, 0 : memref<?x?xf32, 2>
// CHECK-NEXT: %2 = dim %0, 1 : memref<?x?xf32, 2>
// CHECK-NEXT: %3 = alloc(%1, %2) : memref<2x?x?xf32, 2>
// CHECK: %5 = affine_apply [[MOD_2]](%c0)
// CHECK: %6 = affine_apply [[MOD_2]](%c0)
// CHECK: %5 = affine.apply [[MOD_2]](%c0)
// CHECK: %6 = affine.apply [[MOD_2]](%c0)
// CHECK: dma_start %arg0[%c0_0, %c0_0], %3[%5, %c0_0, %c0_0], %c512, %4[%6, %c0_0]
for %kTT = 0 to 16 {
dma_start %arg0[%zero, %zero], %Av[%zero, %zero], %num_elt, %tag[%zero] :
@ -269,8 +269,8 @@ func @dynamic_shape_dma_buffer(%arg0: memref<512 x 32 x f32>) {
}
return
// CHECK-NEXT: for %i0 = 1 to 16 {
// CHECK: %7 = affine_apply [[MOD_2]](%i0)
// CHECK: %8 = affine_apply [[MOD_2]](%i0)
// CHECK: %7 = affine.apply [[MOD_2]](%i0)
// CHECK: %8 = affine.apply [[MOD_2]](%i0)
// CHECK: dma_start %arg0[%c0_0, %c0_0], %3[%7, %c0_0, %c0_0], %c512, %4[%8, %c0_0]
// CHECK: dma_wait %4[%10, %c0_0], %c512 : memref<2x1xi32>
// CHECK: }

14
mlir/test/Transforms/unroll-jam.mlir
View File

@ -10,20 +10,20 @@ func @unroll_jam_imperfect_nest() {
// CHECK-NEXT: for %i0 = 0 to 99 step 2 {
for %i = 0 to 101 {
// CHECK: %0 = "addi32"(%i0, %i0) : (index, index) -> i32
// CHECK-NEXT: %1 = affine_apply [[MAP_PLUS_1]](%i0)
// CHECK-NEXT: %1 = affine.apply [[MAP_PLUS_1]](%i0)
// CHECK-NEXT: %2 = "addi32"(%1, %1) : (index, index) -> i32
%x = "addi32"(%i, %i) : (index, index) -> i32
for %j = 0 to 17 {
// CHECK: %3 = "addi32"(%i0, %i0) : (index, index) -> i32
// CHECK-NEXT: %4 = "addi32"(%3, %3) : (i32, i32) -> i32
// CHECK-NEXT: %5 = affine_apply [[MAP_PLUS_1]](%i0)
// CHECK-NEXT: %5 = affine.apply [[MAP_PLUS_1]](%i0)
// CHECK-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> i32
// CHECK-NEXT: %7 = "addi32"(%6, %6) : (i32, i32) -> i32
%y = "addi32"(%i, %i) : (index, index) -> i32
%z = "addi32"(%y, %y) : (i32, i32) -> i32
}
// CHECK: %8 = "addi32"(%i0, %i0) : (index, index) -> i32
// CHECK-NEXT: %9 = affine_apply [[MAP_PLUS_1]](%i0)
// CHECK-NEXT: %9 = affine.apply [[MAP_PLUS_1]](%i0)
// CHECK-NEXT: %10 = "addi32"(%9, %9) : (index, index) -> i32
%w = "addi32"(%i, %i) : (index, index) -> i32
} // CHECK }
@ -67,16 +67,16 @@ func @loop_nest_unknown_count_2(%arg : index) {
// UNROLL-BY-4-NEXT: for %i0 = %arg0 to #map{{[0-9]+}}()[%arg0] step 4 {
// UNROLL-BY-4-NEXT: for %i1 = 1 to 100 {
// UNROLL-BY-4-NEXT: %0 = "foo"(%i0) : (index) -> i32
// UNROLL-BY-4-NEXT: %1 = affine_apply #map{{[0-9]+}}(%i0)
// UNROLL-BY-4-NEXT: %1 = affine.apply #map{{[0-9]+}}(%i0)
// UNROLL-BY-4-NEXT: %2 = "foo"(%1) : (index) -> i32
// UNROLL-BY-4-NEXT: %3 = affine_apply #map{{[0-9]+}}(%i0)
// UNROLL-BY-4-NEXT: %3 = affine.apply #map{{[0-9]+}}(%i0)
// UNROLL-BY-4-NEXT: %4 = "foo"(%3) : (index) -> i32
// UNROLL-BY-4-NEXT: %5 = affine_apply #map{{[0-9]+}}(%i0)
// UNROLL-BY-4-NEXT: %5 = affine.apply #map{{[0-9]+}}(%i0)
// UNROLL-BY-4-NEXT: %6 = "foo"(%5) : (index) -> i32
// UNROLL-BY-4-NEXT: }
// UNROLL-BY-4-NEXT: }
// The cleanup loop is a single iteration one and is promoted.
// UNROLL-BY-4-NEXT: %7 = affine_apply [[M1:#map{{[0-9]+}}]]()[%arg0]
// UNROLL-BY-4-NEXT: %7 = affine.apply [[M1:#map{{[0-9]+}}]]()[%arg0]
// UNROLL-BY-4-NEXT: for %i3 = 1 to 100 {
// UNROLL-BY-4-NEXT: %8 = "foo"() : () -> i32
// UNROLL-BY-4_NEXT: }

150
mlir/test/Transforms/unroll.mlir
View File

@ -65,11 +65,11 @@ func @loop_nest_simple_iv_use() {
// CHECK-NEXT: for %i0 = 0 to 100 step 2 {
for %i = 0 to 100 step 2 {
// CHECK: %0 = "addi32"(%c0, %c0) : (index, index) -> i32
// CHECK: %1 = affine_apply [[MAP0]](%c0)
// CHECK: %1 = affine.apply [[MAP0]](%c0)
// CHECK-NEXT: %2 = "addi32"(%1, %1) : (index, index) -> i32
// CHECK: %3 = affine_apply [[MAP1]](%c0)
// CHECK: %3 = affine.apply [[MAP1]](%c0)
// CHECK-NEXT: %4 = "addi32"(%3, %3) : (index, index) -> i32
// CHECK: %5 = affine_apply [[MAP2]](%c0)
// CHECK: %5 = affine.apply [[MAP2]](%c0)
// CHECK-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> i32
for %j = 0 to 4 {
%x = "addi32"(%j, %j) : (index, index) -> i32
@ -86,19 +86,19 @@ func @loop_nest_body_def_use() {
for %i = 0 to 100 step 2 {
// CHECK: %c0_0 = constant 0 : index
%c0 = constant 0 : index
// CHECK: %0 = affine_apply [[MAP0]](%c0)
// CHECK: %0 = affine.apply [[MAP0]](%c0)
// CHECK-NEXT: %1 = "addi32"(%0, %c0_0) : (index, index) -> index
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%c0)
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%2)
// CHECK-NEXT: %2 = affine.apply [[MAP0]](%c0)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%2)
// CHECK-NEXT: %4 = "addi32"(%3, %c0_0) : (index, index) -> index
// CHECK-NEXT: %5 = affine_apply [[MAP1]](%c0)
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%5)
// CHECK-NEXT: %5 = affine.apply [[MAP1]](%c0)
// CHECK-NEXT: %6 = affine.apply [[MAP0]](%5)
// CHECK-NEXT: %7 = "addi32"(%6, %c0_0) : (index, index) -> index
// CHECK-NEXT: %8 = affine_apply [[MAP2]](%c0)
// CHECK-NEXT: %9 = affine_apply [[MAP0]](%8)
// CHECK-NEXT: %8 = affine.apply [[MAP2]](%c0)
// CHECK-NEXT: %9 = affine.apply [[MAP0]](%8)
// CHECK-NEXT: %10 = "addi32"(%9, %c0_0) : (index, index) -> index
for %j = 0 to 4 {
%x = "affine_apply" (%j) { map: (d0) -> (d0 + 1) } :
%x = "affine.apply" (%j) { map: (d0) -> (d0 + 1) } :
(index) -> (index)
%y = "addi32"(%x, %c0) : (index, index) -> index
}
@ -112,26 +112,26 @@ func @loop_nest_strided() {
// CHECK-NEXT: %c2_0 = constant 2 : index
// CHECK-NEXT: for %i0 = 0 to 100 {
for %i = 0 to 100 {
// CHECK: %0 = affine_apply [[MAP0]](%c2_0)
// CHECK: %0 = affine.apply [[MAP0]](%c2_0)
// CHECK-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
// CHECK-NEXT: %2 = affine_apply [[MAP1]](%c2_0)
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%2)
// CHECK-NEXT: %2 = affine.apply [[MAP1]](%c2_0)
// CHECK-NEXT: %3 = affine.apply [[MAP0]](%2)
// CHECK-NEXT: %4 = "addi32"(%3, %3) : (index, index) -> index
for %j = 2 to 6 step 2 {
%x = "affine_apply" (%j) { map: (d0) -> (d0 + 1) } :
%x = "affine.apply" (%j) { map: (d0) -> (d0 + 1) } :
(index) -> (index)
%y = "addi32"(%x, %x) : (index, index) -> index
}
// CHECK: %5 = affine_apply [[MAP0]](%c2)
// CHECK: %5 = affine.apply [[MAP0]](%c2)
// CHECK-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> index
// CHECK-NEXT: %7 = affine_apply [[MAP1]](%c2)
// CHECK-NEXT: %8 = affine_apply [[MAP0]](%7)
// CHECK-NEXT: %7 = affine.apply [[MAP1]](%c2)
// CHECK-NEXT: %8 = affine.apply [[MAP0]](%7)
// CHECK-NEXT: %9 = "addi32"(%8, %8) : (index, index) -> index
// CHECK-NEXT: %10 = affine_apply [[MAP3]](%c2)
// CHECK-NEXT: %11 = affine_apply [[MAP0]](%10)
// CHECK-NEXT: %10 = affine.apply [[MAP3]](%c2)
// CHECK-NEXT: %11 = affine.apply [[MAP0]](%10)
// CHECK-NEXT: %12 = "addi32"(%11, %11) : (index, index) -> index
for %k = 2 to 7 step 2 {
%z = "affine_apply" (%k) { map: (d0) -> (d0 + 1) } :
%z = "affine.apply" (%k) { map: (d0) -> (d0 + 1) } :
(index) -> (index)
%w = "addi32"(%z, %z) : (index, index) -> index
}
@ -144,19 +144,19 @@ func @loop_nest_multiple_results() {
// CHECK: %c0 = constant 0 : index
// CHECK-NEXT: for %i0 = 0 to 100 {
for %i = 0 to 100 {
// CHECK: %0 = affine_apply [[MAP4]](%i0, %c0)
// CHECK: %0 = affine.apply [[MAP4]](%i0, %c0)
// CHECK-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
// CHECK-NEXT: %2 = affine_apply #map{{.*}}(%i0, %c0)
// CHECK-NEXT: %2 = affine.apply #map{{.*}}(%i0, %c0)
// CHECK-NEXT: %3 = "fma"(%2, %0, %0) : (index, index, index) -> (index, index)
// CHECK-NEXT: %4 = affine_apply #map{{.*}}(%c0)
// CHECK-NEXT: %5 = affine_apply #map{{.*}}(%i0, %4)
// CHECK-NEXT: %4 = affine.apply #map{{.*}}(%c0)
// CHECK-NEXT: %5 = affine.apply #map{{.*}}(%i0, %4)
// CHECK-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> index
// CHECK-NEXT: %7 = affine_apply #map{{.*}}(%i0, %4)
// CHECK-NEXT: %7 = affine.apply #map{{.*}}(%i0, %4)
// CHECK-NEXT: %8 = "fma"(%7, %5, %5) : (index, index, index) -> (index, index)
for %j = 0 to 2 step 1 {
%x = affine_apply (d0, d1) -> (d0 + 1) (%i, %j)
%x = affine.apply (d0, d1) -> (d0 + 1) (%i, %j)
%y = "addi32"(%x, %x) : (index, index) -> index
%z = affine_apply (d0, d1) -> (d0 + 3) (%i, %j)
%z = affine.apply (d0, d1) -> (d0 + 3) (%i, %j)
%w = "fma"(%z, %x, %x) : (index, index, index) -> (index, index)
}
} // CHECK: }
@ -174,23 +174,23 @@ func @loop_nest_seq_imperfect(%a : memref<128x128xf32>) {
for %i = 0 to 100 {
// CHECK: %0 = "vld"(%i0) : (index) -> i32
%ld = "vld"(%i) : (index) -> i32
// CHECK: %1 = affine_apply [[MAP0]](%c0)
// CHECK: %1 = affine.apply [[MAP0]](%c0)
// CHECK-NEXT: %2 = "vmulf"(%c0, %1) : (index, index) -> index
// CHECK-NEXT: %3 = "vaddf"(%2, %2) : (index, index) -> index
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%c0)
// CHECK-NEXT: %5 = affine_apply [[MAP0]](%4)
// CHECK-NEXT: %4 = affine.apply [[MAP0]](%c0)
// CHECK-NEXT: %5 = affine.apply [[MAP0]](%4)
// CHECK-NEXT: %6 = "vmulf"(%4, %5) : (index, index) -> index
// CHECK-NEXT: %7 = "vaddf"(%6, %6) : (index, index) -> index
// CHECK-NEXT: %8 = affine_apply [[MAP1]](%c0)
// CHECK-NEXT: %9 = affine_apply [[MAP0]](%8)
// CHECK-NEXT: %8 = affine.apply [[MAP1]](%c0)
// CHECK-NEXT: %9 = affine.apply [[MAP0]](%8)
// CHECK-NEXT: %10 = "vmulf"(%8, %9) : (index, index) -> index
// CHECK-NEXT: %11 = "vaddf"(%10, %10) : (index, index) -> index
// CHECK-NEXT: %12 = affine_apply [[MAP2]](%c0)
// CHECK-NEXT: %13 = affine_apply [[MAP0]](%12)
// CHECK-NEXT: %12 = affine.apply [[MAP2]](%c0)
// CHECK-NEXT: %13 = affine.apply [[MAP0]](%12)
// CHECK-NEXT: %14 = "vmulf"(%12, %13) : (index, index) -> index
// CHECK-NEXT: %15 = "vaddf"(%14, %14) : (index, index) -> index
for %j = 0 to 4 {
%x = "affine_apply" (%j) { map: (d0) -> (d0 + 1) } :
%x = "affine.apply" (%j) { map: (d0) -> (d0 + 1) } :
(index) -> (index)
%y = "vmulf"(%j, %x) : (index, index) -> index
%z = "vaddf"(%y, %y) : (index, index) -> index
@ -207,19 +207,19 @@ func @loop_nest_seq_imperfect(%a : memref<128x128xf32>) {
func @loop_nest_seq_multiple() {
// CHECK: c0 = constant 0 : index
// CHECK-NEXT: %c0_0 = constant 0 : index
// CHECK-NEXT: %0 = affine_apply [[MAP0]](%c0_0)
// CHECK-NEXT: %0 = affine.apply [[MAP0]](%c0_0)
// CHECK-NEXT: "mul"(%0, %0) : (index, index) -> ()
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%c0_0)
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%1)
// CHECK-NEXT: %1 = affine.apply [[MAP0]](%c0_0)
// CHECK-NEXT: %2 = affine.apply [[MAP0]](%1)
// CHECK-NEXT: "mul"(%2, %2) : (index, index) -> ()
// CHECK-NEXT: %3 = affine_apply [[MAP1]](%c0_0)
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%3)
// CHECK-NEXT: %3 = affine.apply [[MAP1]](%c0_0)
// CHECK-NEXT: %4 = affine.apply [[MAP0]](%3)
// CHECK-NEXT: "mul"(%4, %4) : (index, index) -> ()
// CHECK-NEXT: %5 = affine_apply [[MAP2]](%c0_0)
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%5)
// CHECK-NEXT: %5 = affine.apply [[MAP2]](%c0_0)
// CHECK-NEXT: %6 = affine.apply [[MAP0]](%5)
// CHECK-NEXT: "mul"(%6, %6) : (index, index) -> ()
for %j = 0 to 4 {
%x = "affine_apply" (%j) { map: (d0) -> (d0 + 1) } :
%x = "affine.apply" (%j) { map: (d0) -> (d0 + 1) } :
(index) -> (index)
"mul"(%x, %x) : (index, index) -> ()
}
@ -228,21 +228,21 @@ func @loop_nest_seq_multiple() {
%k = "constant"(){value: 99} : () -> index
// CHECK: for %i0 = 0 to 100 step 2 {
for %m = 0 to 100 step 2 {
// CHECK: %7 = affine_apply [[MAP0]](%c0)
// CHECK-NEXT: %8 = affine_apply [[MAP6]](%c0)[%c99]
// CHECK-NEXT: %9 = affine_apply [[MAP0]](%c0)
// CHECK-NEXT: %10 = affine_apply [[MAP0]](%9)
// CHECK-NEXT: %11 = affine_apply [[MAP6]](%9)[%c99]
// CHECK-NEXT: %12 = affine_apply [[MAP1]](%c0)
// CHECK-NEXT: %13 = affine_apply [[MAP0]](%12)
// CHECK-NEXT: %14 = affine_apply [[MAP6]](%12)[%c99]
// CHECK-NEXT: %15 = affine_apply [[MAP2]](%c0)
// CHECK-NEXT: %16 = affine_apply [[MAP0]](%15)
// CHECK-NEXT: %17 = affine_apply [[MAP6]](%15)[%c99]
// CHECK: %7 = affine.apply [[MAP0]](%c0)
// CHECK-NEXT: %8 = affine.apply [[MAP6]](%c0)[%c99]
// CHECK-NEXT: %9 = affine.apply [[MAP0]](%c0)
// CHECK-NEXT: %10 = affine.apply [[MAP0]](%9)
// CHECK-NEXT: %11 = affine.apply [[MAP6]](%9)[%c99]
// CHECK-NEXT: %12 = affine.apply [[MAP1]](%c0)
// CHECK-NEXT: %13 = affine.apply [[MAP0]](%12)
// CHECK-NEXT: %14 = affine.apply [[MAP6]](%12)[%c99]
// CHECK-NEXT: %15 = affine.apply [[MAP2]](%c0)
// CHECK-NEXT: %16 = affine.apply [[MAP0]](%15)
// CHECK-NEXT: %17 = affine.apply [[MAP6]](%15)[%c99]
for %n = 0 to 4 {
%y = "affine_apply" (%n) { map: (d0) -> (d0 + 1) } :
%y = "affine.apply" (%n) { map: (d0) -> (d0 + 1) } :
(index) -> (index)
%z = "affine_apply" (%n, %k) { map: (d0) [s0] -> (d0 + s0 + 1) } :
%z = "affine.apply" (%n, %k) { map: (d0) [s0] -> (d0 + s0 + 1) } :
(index, index) -> (index)
} // CHECK }
} // CHECK }
@ -252,16 +252,16 @@ func @loop_nest_seq_multiple() {
// SHORT-LABEL: func @loop_nest_outer_unroll() {
func @loop_nest_outer_unroll() {
// SHORT: for %i0 = 0 to 4 {
// SHORT-NEXT: %0 = affine_apply [[MAP0]](%i0)
// SHORT-NEXT: %0 = affine.apply [[MAP0]](%i0)
// SHORT-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
// SHORT-NEXT: }
// SHORT-NEXT: for %i1 = 0 to 4 {
// SHORT-NEXT: %2 = affine_apply [[MAP0]](%i1)
// SHORT-NEXT: %2 = affine.apply [[MAP0]](%i1)
// SHORT-NEXT: %3 = "addi32"(%2, %2) : (index, index) -> index
// SHORT-NEXT: }
for %i = 0 to 2 {
for %j = 0 to 4 {
%x = "affine_apply" (%j) { map: (d0) -> (d0 + 1) } :
%x = "affine.apply" (%j) { map: (d0) -> (d0 + 1) } :
(index) -> (index)
%y = "addi32"(%x, %x) : (index, index) -> index
}
@ -295,19 +295,19 @@ func @loop_nest_seq_long() -> i32 {
for %i0 = 0 to 2 {
for %i1 = 0 to 2 {
for %i2 = 0 to 8 {
%b2 = "affine_apply" (%i1, %i2) {map: (d0, d1) -> (16*d0 + d1)} : (index, index) -> index
%b2 = "affine.apply" (%i1, %i2) {map: (d0, d1) -> (16*d0 + d1)} : (index, index) -> index
%x = load %B[%i0, %b2] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
"op1"(%x) : (i32) -> ()
}
for %j1 = 0 to 8 {
for %j2 = 0 to 8 {
%a2 = "affine_apply" (%i1, %j2) {map: (d0, d1) -> (16*d0 + d1)} : (index, index) -> index
%a2 = "affine.apply" (%i1, %j2) {map: (d0, d1) -> (16*d0 + d1)} : (index, index) -> index
%v203 = load %A[%j1, %a2] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
"op2"(%v203) : (i32) -> ()
}
for %k2 = 0 to 8 {
%s0 = "op3"() : () -> i32
%c2 = "affine_apply" (%i0, %k2) {map: (d0, d1) -> (16*d0 + d1)} : (index, index) -> index
%c2 = "affine.apply" (%i0, %k2) {map: (d0, d1) -> (16*d0 + d1)} : (index, index) -> index
%s1 = load %C[%j1, %c2] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
%s2 = "addi32"(%s0, %s1) : (i32, i32) -> i32
store %s2, %C[%j1, %c2] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
@ -327,13 +327,13 @@ func @unroll_unit_stride_no_cleanup() {
// UNROLL-BY-4: for [[L1:%i[0-9]+]] = 0 to 8 step 4 {
// UNROLL-BY-4-NEXT: %0 = "addi32"([[L1]], [[L1]]) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %1 = "addi32"(%0, %0) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %2 = affine_apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %2 = affine.apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %3 = "addi32"(%2, %2) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %4 = "addi32"(%3, %3) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %5 = affine_apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %5 = affine.apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %7 = "addi32"(%6, %6) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %8 = affine_apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %8 = affine.apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %9 = "addi32"(%8, %8) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %10 = "addi32"(%9, %9) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: }
@ -356,13 +356,13 @@ func @unroll_unit_stride_cleanup() {
// UNROLL-BY-4: for [[L1:%i[0-9]+]] = 0 to 7 step 4 {
// UNROLL-BY-4-NEXT: %0 = "addi32"([[L1]], [[L1]]) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %1 = "addi32"(%0, %0) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %2 = affine_apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %2 = affine.apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %3 = "addi32"(%2, %2) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %4 = "addi32"(%3, %3) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %5 = affine_apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %5 = affine.apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %7 = "addi32"(%6, %6) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %8 = affine_apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %8 = affine.apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %9 = "addi32"(%8, %8) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %10 = "addi32"(%9, %9) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: }
@ -385,13 +385,13 @@ func @unroll_non_unit_stride_cleanup() {
// UNROLL-BY-4: for [[L1:%i[0-9]+]] = 2 to 37 step 20 {
// UNROLL-BY-4-NEXT: %0 = "addi32"([[L1]], [[L1]]) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %1 = "addi32"(%0, %0) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %2 = affine_apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %2 = affine.apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %3 = "addi32"(%2, %2) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %4 = "addi32"(%3, %3) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %5 = affine_apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %5 = affine.apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %7 = "addi32"(%6, %6) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %8 = affine_apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %8 = affine.apply #map{{[0-9]+}}([[L1]])
// UNROLL-BY-4-NEXT: %9 = "addi32"(%8, %8) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %10 = "addi32"(%9, %9) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: }
@ -414,11 +414,11 @@ func @loop_nest_single_iteration_after_unroll(%N: index) {
// UNROLL-BY-4: for %i0 = 0 to %arg0 {
for %i = 0 to %N {
// UNROLL-BY-4: %0 = "addi32"(%c0, %c0) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %1 = affine_apply [[MAP0]](%c0)
// UNROLL-BY-4-NEXT: %1 = affine.apply [[MAP0]](%c0)
// UNROLL-BY-4-NEXT: %2 = "addi32"(%1, %1) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %3 = affine_apply [[MAP1]](%c0)
// UNROLL-BY-4-NEXT: %3 = affine.apply [[MAP1]](%c0)
// UNROLL-BY-4-NEXT: %4 = "addi32"(%3, %3) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %5 = affine_apply [[MAP2]](%c0)
// UNROLL-BY-4-NEXT: %5 = affine.apply [[MAP2]](%c0)
// UNROLL-BY-4-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %7 = "addi32"(%c4, %c4) : (index, index) -> i32
// UNROLL-BY-4-NOT: for

2
mlir/utils/vim/mlir.vim
View File

@ -12,7 +12,7 @@ syn keyword mlirType memref tensor vector
syntax keyword mlirKeywords extfunc cfgfunc mlfunc for to step return
syntax keyword mlirConditional if else
syntax keyword mlirCoreOps dim addf addi subf subi mulf muli cmpi select constant affine_apply call call_indirect extract_element getTensor memref_cast tensor_cast load store alloc dealloc dma_start dma_wait
syntax keyword mlirCoreOps dim addf addi subf subi mulf muli cmpi select constant affine.apply call call_indirect extract_element getTensor memref_cast tensor_cast load store alloc dealloc dma_start dma_wait
syn match mlirInt "-\=\<\d\+\>"
syn match mlirFloat "-\=\<\d\+\.\d\+\>"