diff --git a/mlir/docs/Dialects/Affine.md b/mlir/docs/Dialects/Affine.md --- a/mlir/docs/Dialects/Affine.md +++ b/mlir/docs/Dialects/Affine.md @@ -22,7 +22,7 @@ ```mlir // A 2d to 3d affine mapping. // d0/d1 are dimensions, s0 is a symbol -#affine_map2to3 = affine_map<(d0, d1)[s0] -> (d0, d1 + s0, d1 - s0)> +#affine_map2to3 = affine_map<(d0, d1) [s0] -> (d0, d1 + s0, d1 - s0)> ``` Dimensional identifiers correspond to the dimensions of the underlying structure @@ -52,7 +52,7 @@ Example: ```mlir -#affine_map2to3 = affine_map<(d0, d1)[s0] -> (d0, d1 + s0, d1 - s0)> +#affine_map2to3 = affine_map<(d0, d1) [s0] -> (d0, d1 + s0, d1 - s0)> // Binds %N to the s0 symbol in affine_map2to3. %x = alloc()[%N] : memref<40x50xf32, #affine_map2to3> ``` @@ -188,14 +188,14 @@ ```mlir // Affine map out-of-line definition and usage example. -#affine_map42 = affine_map<(d0, d1)[s0] -> (d0, d0 + d1 + s0 floordiv 2)> +#affine_map42 = affine_map<(d0, d1) [s0] -> (d0, d0 + d1 + s0 floordiv 2)> // Use an affine mapping definition in an alloc operation, binding the // SSA value %N to the symbol s0. %a = alloc()[%N] : memref<4x4xf32, #affine_map42> // Same thing with an inline affine mapping definition. -%b = alloc()[%N] : memref<4x4xf32, affine_map<(d0, d1)[s0] -> (d0, d0 + d1 + s0 floordiv 2)>> +%b = alloc()[%N] : memref<4x4xf32, affine_map<(d0, d1) [s0] -> (d0, d0 + d1 + s0 floordiv 2)>> ``` ### Semi-affine maps @@ -295,7 +295,7 @@ : (d0 >= 0, -d0 + s0 - 1 >= 0, d1 >= 0, -d1 + s1 - 1 >= 0)> // Inside a Region -affine.if #set42(%i, %j)[%M, %N] { +affine.if #set42(%i, %j) [%M, %N] { ... } ``` diff --git a/mlir/docs/Dialects/Linalg.md b/mlir/docs/Dialects/Linalg.md --- a/mlir/docs/Dialects/Linalg.md +++ b/mlir/docs/Dialects/Linalg.md @@ -371,7 +371,7 @@ // Note that we lower the Linalg dialect directly to the Standard dialect. // See this doc: https://mlir.llvm.org/docs/Dialects/Standard/ -#map0 = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +#map0 = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> func @example(%arg0: memref, %arg1: memref, %arg2: memref) { %0 = memref_cast %arg0 : memref to memref diff --git a/mlir/docs/LangRef.md b/mlir/docs/LangRef.md --- a/mlir/docs/LangRef.md +++ b/mlir/docs/LangRef.md @@ -1027,7 +1027,7 @@ #tiled_2d_128x256 = affine_map<(d0, d1) -> (d0 div 128, d1 div 256, d0 mod 128, d1 mod 256)> // A tiled data layout with non-constant tile sizes. -#tiled_dynamic = affine_map<(d0, d1)[s0, s1] -> (d0 floordiv s0, d1 floordiv s1, +#tiled_dynamic = affine_map<(d0, d1) [s0, s1] -> (d0 floordiv s0, d1 floordiv s1, d0 mod s0, d1 mod s1)> // A layout that yields a padding on two at either end of the minor dimension. diff --git a/mlir/include/mlir/Conversion/Passes.td b/mlir/include/mlir/Conversion/Passes.td --- a/mlir/include/mlir/Conversion/Passes.td +++ b/mlir/include/mlir/Conversion/Passes.td @@ -31,8 +31,8 @@ type. Consequently, named maps and sets thare are no longer in use may be removed from the module. - For example, `%r = affine.apply affine_map<(d0, d1)[s0] -> (d0 + 2*d1 + - s0)>(%d0, %d1)[%s0]` + For example, `%r = affine.apply affine_map<(d0, d1) [s0] -> (d0 + 2*d1 + + s0)>(%d0, %d1) [%s0]` can be converted into: ```mlir diff --git a/mlir/include/mlir/Conversion/VectorToSCF/VectorToSCF.h b/mlir/include/mlir/Conversion/VectorToSCF/VectorToSCF.h --- a/mlir/include/mlir/Conversion/VectorToSCF/VectorToSCF.h +++ b/mlir/include/mlir/Conversion/VectorToSCF/VectorToSCF.h @@ -59,9 +59,9 @@ /// ``` /// %0 = vector.extract %arg2[0] : vector<3x15xf32> /// vector.transfer_write %0, %arg0[%arg1, %arg1] : vector<15xf32>, -/// memref %1 = affine.apply #map1()[%arg1] %2 = vector.extract +/// memref %1 = affine.apply #map1() [%arg1] %2 = vector.extract /// %arg2[1] : vector<3x15xf32> vector.transfer_write %2, %arg0[%1, %arg1] : -/// vector<15xf32>, memref %3 = affine.apply #map2()[%arg1] %4 = +/// vector<15xf32>, memref %3 = affine.apply #map2() [%arg1] %4 = /// vector.extract %arg2[2] : vector<3x15xf32> vector.transfer_write %4, /// %arg0[%3, %arg1] : vector<15xf32>, memref /// ``` diff --git a/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td b/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td --- a/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td +++ b/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td @@ -62,7 +62,7 @@ %1 = affine.apply #map10 (%s, %t) // Inline example. - %2 = affine.apply affine_map<(i)[s0] -> (i+s0)> (%42)[%n] + %2 = affine.apply affine_map<(i) [s0] -> (i+s0)> (%42) [%n] ``` }]; let arguments = (ins AffineMapAttr:$map, Variadic:$mapOperands); @@ -159,13 +159,13 @@ Example showing reverse iteration of the inner loop: ```mlir - #map57 = affine_map<(d0)[s0] -> (s0 - d0 - 1)> + #map57 = affine_map<(d0) [s0] -> (s0 - d0 - 1)> func @simple_example(%A: memref, %B: memref) { %N = dim %A, 0 : memref affine.for %i = 0 to %N step 1 { affine.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, index, index)->(f32) call @F2(%tmp, %B, %i, %0) : (f32, memref, index, index)->() } @@ -374,7 +374,7 @@ affine.for %j = 0 to %N { %0 = affine.apply #map42(%j) %tmp = call @S1(%X, %i, %0) - affine.if #set(%i, %j)[%N] { + affine.if #set(%i, %j) [%N] { %1 = affine.apply #map43(%i, %j) call @S2(%tmp, %A, %i, %1) } @@ -570,7 +570,7 @@ Example: ```mlir - %0 = affine.min affine_map<(d0)[s0] -> (1000, d0 + 512, s0)> (%arg0)[%arg1] + %0 = affine.min affine_map<(d0) [s0] -> (1000, d0 + 512, s0)> (%arg0) [%arg1] ``` }]; } diff --git a/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td b/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td --- a/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td +++ b/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td @@ -637,9 +637,9 @@ Example of 1D convolution with symbols: ```mlir #conv_1d_accesses = [ - affine_map<(m, n)[dimN] -> (m + n - dimN floordiv 2)>, // in - affine_map<(m, n)[dimN] -> (n)>, // filter - affine_map<(m, n)[dimN] -> (m)> // out + affine_map<(m, n) [dimN] -> (m + n - dimN floordiv 2)>, // in + affine_map<(m, n) [dimN] -> (n)>, // filter + affine_map<(m, n) [dimN] -> (m)> // out ] #conv_1d_trait = { @@ -810,9 +810,9 @@ Example of 1D convolution with symbols: ```mlir #conv_1d_accesses = [ - affine_map<(m, n)[dimN] -> (m + n - dimN floordiv 2)>, // in - affine_map<(m, n)[dimN] -> (n)>, // filter - affine_map<(m, n)[dimN] -> (m)> // out + affine_map<(m, n) [dimN] -> (m + n - dimN floordiv 2)>, // in + affine_map<(m, n) [dimN] -> (n)>, // filter + affine_map<(m, n) [dimN] -> (m)> // out ] #conv_1d_trait = { diff --git a/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h b/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h --- a/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h +++ b/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h @@ -95,7 +95,7 @@ /// need to be computed before they can be used for the second matmul. The /// second matmul is further tiled (similar to normal tiling). /// -/// #map0 = affine_map<(d0, d1)[s0] -> (d0 * 32 + s0 + d1)> +/// #map0 = affine_map<(d0, d1) [s0] -> (d0 * 32 + s0 + d1)> /// #map1 = affine_map<(d0, d1) -> (d0 * 32 + d1)> /// scf.parallel (%arg5) = (%c0) to (%c256) step (%c16) { /// %0 = subview %arg2[%arg5, 0] [16, 32] [1, 1] diff --git a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.h b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.h --- a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.h +++ b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.h @@ -313,16 +313,6 @@ computeRankReductionMask(ArrayRef originalShape, ArrayRef reducedShape); -/// Prints dimension and symbol list. -void printDimAndSymbolList(Operation::operand_iterator begin, - Operation::operand_iterator end, unsigned numDims, - OpAsmPrinter &p); - -/// Parses dimension and symbol list and returns true if parsing failed. -ParseResult parseDimAndSymbolList(OpAsmParser &parser, - SmallVectorImpl &operands, - unsigned &numDims); - /// Determines whether MemRefCastOp casts to a more dynamic version of the /// source memref. This is useful to to fold a memref_cast into a consuming op /// and implement canonicalization patterns for ops in different dialects that diff --git a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td --- a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td +++ b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td @@ -157,20 +157,38 @@ class AllocLikeOp traits = []> : - Std_Op]>], traits)> { - - let arguments = (ins Variadic:$value, + Std_Op]>, + AttrSizedOperandSegments + ], traits)> { + + let arguments = (ins Variadic:$dynamicSizes, + // The symbolic operands (the ones in square brackets) bind + // to the symbols of the memref's layout map. + Variadic:$symbolOperands, Confined, [IntMinValue<0>]>:$alignment); - let results = (outs Res]>); + let results = (outs Res]>:$memref); let builders = [ - OpBuilderDAG<(ins "MemRefType":$memrefType), [{ - $_state.types.push_back(memrefType); + OpBuilderDAG<(ins "MemRefType":$memrefType, + CArg<"IntegerAttr", "IntegerAttr()">:$alignment), [{ + return build($_builder, $_state, memrefType, {}, alignment); }]>, - OpBuilderDAG<(ins "MemRefType":$memrefType, "ValueRange":$operands, - CArg<"IntegerAttr", "IntegerAttr()">:$alignment), [{ - $_state.addOperands(operands); + OpBuilderDAG<(ins "MemRefType":$memrefType, "ValueRange":$dynamicSizes, + CArg<"IntegerAttr", "IntegerAttr()">:$alignment), [{ + return build($_builder, $_state, memrefType, dynamicSizes, {}, alignment); + }]>, + OpBuilderDAG<(ins "MemRefType":$memrefType, "ValueRange":$dynamicSizes, + "ValueRange":$symbolOperands, + CArg<"IntegerAttr", "{}">:$alignment), [{ $_state.types.push_back(memrefType); + $_state.addOperands(dynamicSizes); + $_state.addOperands(symbolOperands); + $_state.addAttribute(getOperandSegmentSizeAttr(), + $_builder.getI32VectorAttr({ + static_cast(dynamicSizes.size()), + static_cast(symbolOperands.size())})); if (alignment) $_state.addAttribute(getAlignmentAttrName(), alignment); }]>]; @@ -180,23 +198,13 @@ MemRefType getType() { return getResult().getType().cast(); } - /// Returns the number of symbolic operands (the ones in square brackets), - /// which bind to the symbols of the memref's layout map. - unsigned getNumSymbolicOperands() { - return getNumOperands() - getType().getNumDynamicDims(); - } - - /// Returns the symbolic operands (the ones in square brackets), which bind - /// to the symbols of the memref's layout map. - operand_range getSymbolicOperands() { - return {operand_begin() + getType().getNumDynamicDims(), operand_end()}; - } - /// Returns the dynamic sizes for this alloc operation if specified. - operand_range getDynamicSizes() { return getOperands(); } + operand_range getDynamicSizes() { return dynamicSizes(); } }]; - let parser = [{ return ::parseAllocLikeOp(parser, result); }]; + let assemblyFormat = [{ + `(`$dynamicSizes`)` (`[` $symbolOperands^ `]`)? attr-dict `:` type($memref) + }]; let hasCanonicalizer = 1; } @@ -543,7 +551,7 @@ ```mlir %0 = alloc()[%s] : memref<8x64xf32, - affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1> + affine_map<(d0, d1) [s0] -> ((d0 + s0), d1)>, 1> ``` This operation returns a single ssa value of memref type, which can be used @@ -555,7 +563,7 @@ ```mlir %0 = alloc()[%s] {alignment = 8} : - memref<8x64xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1> + memref<8x64xf32, affine_map<(d0, d1) [s0] -> ((d0 + s0), d1)>, 1> ``` }]; } @@ -592,7 +600,7 @@ ```mlir %0 = alloca()[%s] : memref<8x64xf32, - affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>> + affine_map<(d0, d1) [s0] -> ((d0 + s0), d1)>> ``` This operation returns a single SSA value of memref type, which can be used @@ -3766,7 +3774,7 @@ Example: ```mlir - %1 = transpose %0 (i, j) -> (j, i) : memref to memref (d1 * s0 + d0)>> + %1 = transpose %0 (i, j) -> (j, i) : memref to memref (d1 * s0 + d0)>> ``` }]; diff --git a/mlir/lib/Dialect/Affine/IR/AffineOps.cpp b/mlir/lib/Dialect/Affine/IR/AffineOps.cpp --- a/mlir/lib/Dialect/Affine/IR/AffineOps.cpp +++ b/mlir/lib/Dialect/Affine/IR/AffineOps.cpp @@ -297,6 +297,33 @@ return isValidDim(value, region) || isValidSymbol(value, region); } +/// Prints dimension and symbol list. +static void printDimAndSymbolList(Operation::operand_iterator begin, + Operation::operand_iterator end, + unsigned numDims, OpAsmPrinter &printer) { + OperandRange operands(begin, end); + printer << '(' << operands.take_front(numDims) << ')'; + if (operands.size() > numDims) + printer << " [" << operands.drop_front(numDims) << ']'; +} + +/// Parses dimension and symbol list and returns true if parsing failed. +static ParseResult parseDimAndSymbolList(OpAsmParser &parser, + SmallVectorImpl &operands, + unsigned &numDims) { + SmallVector opInfos; + if (parser.parseOperandList(opInfos, OpAsmParser::Delimiter::Paren)) + return failure(); + // Store number of dimensions for validation by caller. + numDims = opInfos.size(); + + // Parse the optional symbol operands. + auto indexTy = parser.getBuilder().getIndexType(); + return failure(parser.parseOperandList( + opInfos, OpAsmParser::Delimiter::OptionalSquare) || + parser.resolveOperands(opInfos, indexTy, operands)); +} + /// Utility function to verify that a set of operands are valid dimension and /// symbol identifiers. The operands should be laid out such that the dimension /// operands are before the symbol operands. This function returns failure if @@ -2265,7 +2292,7 @@ p << '(' << operands.take_front(numDims) << ')'; if (operands.size() != numDims) - p << '[' << operands.drop_front(numDims) << ']'; + p << " [" << operands.drop_front(numDims) << ']'; p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{T::getMapAttrName()}); } diff --git a/mlir/lib/Dialect/StandardOps/IR/Ops.cpp b/mlir/lib/Dialect/StandardOps/IR/Ops.cpp --- a/mlir/lib/Dialect/StandardOps/IR/Ops.cpp +++ b/mlir/lib/Dialect/StandardOps/IR/Ops.cpp @@ -169,36 +169,6 @@ return builder.create(loc, type, value); } -void mlir::printDimAndSymbolList(Operation::operand_iterator begin, - Operation::operand_iterator end, - unsigned numDims, OpAsmPrinter &p) { - Operation::operand_range operands(begin, end); - p << '(' << operands.take_front(numDims) << ')'; - if (operands.size() != numDims) - p << '[' << operands.drop_front(numDims) << ']'; -} - -// Parses dimension and symbol list, and sets 'numDims' to the number of -// dimension operands parsed. -// Returns 'false' on success and 'true' on error. -ParseResult mlir::parseDimAndSymbolList(OpAsmParser &parser, - SmallVectorImpl &operands, - unsigned &numDims) { - SmallVector opInfos; - if (parser.parseOperandList(opInfos, OpAsmParser::Delimiter::Paren)) - return failure(); - // Store number of dimensions for validation by caller. - numDims = opInfos.size(); - - // Parse the optional symbol operands. - auto indexTy = parser.getBuilder().getIndexType(); - if (parser.parseOperandList(opInfos, - OpAsmParser::Delimiter::OptionalSquare) || - parser.resolveOperands(opInfos, indexTy, operands)) - return failure(); - return success(); -} - /// Matches a ConstantIndexOp. /// TODO: This should probably just be a general matcher that uses m_Constant /// and checks the operation for an index type. @@ -404,90 +374,37 @@ //===----------------------------------------------------------------------===// template -static void printAllocLikeOp(OpAsmPrinter &p, AllocLikeOp op, StringRef name) { - static_assert(llvm::is_one_of::value, - "applies to only alloc or alloca"); - p << name; - - // Print dynamic dimension operands. - MemRefType type = op.getType(); - printDimAndSymbolList(op.operand_begin(), op.operand_end(), - type.getNumDynamicDims(), p); - p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{"map"}); - p << " : " << type; -} - -static void print(OpAsmPrinter &p, AllocOp op) { - printAllocLikeOp(p, op, "alloc"); -} - -static void print(OpAsmPrinter &p, AllocaOp op) { - printAllocLikeOp(p, op, "alloca"); -} - -static ParseResult parseAllocLikeOp(OpAsmParser &parser, - OperationState &result) { - MemRefType type; - - // Parse the dimension operands and optional symbol operands, followed by a - // memref type. - unsigned numDimOperands; - if (parseDimAndSymbolList(parser, result.operands, numDimOperands) || - parser.parseOptionalAttrDict(result.attributes) || - parser.parseColonType(type)) - return failure(); - - // Check numDynamicDims against number of question marks in memref type. - // Note: this check remains here (instead of in verify()), because the - // partition between dim operands and symbol operands is lost after parsing. - // Verification still checks that the total number of operands matches - // the number of symbols in the affine map, plus the number of dynamic - // dimensions in the memref. - if (numDimOperands != type.getNumDynamicDims()) - return parser.emitError(parser.getNameLoc()) - << "dimension operand count does not equal memref dynamic dimension " - "count"; - result.types.push_back(type); - return success(); -} - -template -static LogicalResult verify(AllocLikeOp op) { +static LogicalResult verifyAllocLikeOp(AllocLikeOp op) { static_assert(llvm::is_one_of::value, "applies to only alloc or alloca"); auto memRefType = op.getResult().getType().template dyn_cast(); if (!memRefType) return op.emitOpError("result must be a memref"); - unsigned numSymbols = 0; - if (!memRefType.getAffineMaps().empty()) { - // Store number of symbols used in affine map (used in subsequent check). - AffineMap affineMap = memRefType.getAffineMaps()[0]; - numSymbols = affineMap.getNumSymbols(); - } + if (static_cast(op.dynamicSizes().size()) != + memRefType.getNumDynamicDims()) + return op.emitOpError("dimension operand count does not equal memref " + "dynamic dimension count"); - // Check that the total number of operands matches the number of symbols in - // the affine map, plus the number of dynamic dimensions specified in the - // memref type. - unsigned numDynamicDims = memRefType.getNumDynamicDims(); - if (op.getNumOperands() != numDynamicDims + numSymbols) + unsigned numSymbols = 0; + if (!memRefType.getAffineMaps().empty()) + numSymbols = memRefType.getAffineMaps().front().getNumSymbols(); + if (op.symbolOperands().size() != numSymbols) return op.emitOpError( - "operand count does not equal dimension plus symbol operand count"); + "symbol operand count does not equal memref symbol count"); - // Verify that all operands are of type Index. - for (auto operandType : op.getOperandTypes()) - if (!operandType.isIndex()) - return op.emitOpError("requires operands to be of type Index"); + return success(); +} - if (std::is_same::value) - return success(); +static LogicalResult verify(AllocOp op) { return verifyAllocLikeOp(op); } +static LogicalResult verify(AllocaOp op) { // An alloca op needs to have an ancestor with an allocation scope trait. - if (!op.template getParentWithTrait()) + if (!op.getParentWithTrait()) return op.emitOpError( "requires an ancestor op with AutomaticAllocationScope trait"); - return success(); + return verifyAllocLikeOp(op); } namespace { diff --git a/mlir/lib/IR/AsmPrinter.cpp b/mlir/lib/IR/AsmPrinter.cpp --- a/mlir/lib/IR/AsmPrinter.cpp +++ b/mlir/lib/IR/AsmPrinter.cpp @@ -1938,7 +1938,7 @@ // Symbolic identifiers. if (map.getNumSymbols() != 0) { - os << '['; + os << " ["; for (unsigned i = 0; i < map.getNumSymbols() - 1; ++i) os << 's' << i << ", "; if (map.getNumSymbols() >= 1) diff --git a/mlir/lib/Transforms/Utils/LoopUtils.cpp b/mlir/lib/Transforms/Utils/LoopUtils.cpp --- a/mlir/lib/Transforms/Utils/LoopUtils.cpp +++ b/mlir/lib/Transforms/Utils/LoopUtils.cpp @@ -761,8 +761,8 @@ // new loop bounds here will be like ()[s0, s1] -> ((s0 - 5) ceildiv s1 + 5) // where 's0' is the original upper bound and 's1' is the tiling // parameter. 2.) When ubMap has more than one result expression. For e.g. - // #map0 = affine_map<()[s0, s1] -> (s0, s1) - // affine.for %i = 5 to min #map0()[%s0, %s1] + // #map0 = affine_map<() [s0, s1] -> (s0, s1) + // affine.for %i = 5 to min #map0() [%s0, %s1] // // A symbol operand is added which represents the tiling parameter. The // new loop bounds will be like ()[s0, s1, s2] -> ((s0 - 5) ceildiv s2 + 5, diff --git a/mlir/lib/Transforms/Utils/Utils.cpp b/mlir/lib/Transforms/Utils/Utils.cpp --- a/mlir/lib/Transforms/Utils/Utils.cpp +++ b/mlir/lib/Transforms/Utils/Utils.cpp @@ -401,7 +401,7 @@ // Fetch a new memref type after normalizing the old memref to have an // identity map layout. MemRefType newMemRefType = - normalizeMemRefType(memrefType, b, allocOp.getNumSymbolicOperands()); + normalizeMemRefType(memrefType, b, allocOp.symbolOperands().size()); if (newMemRefType == memrefType) // Either memrefType already had an identity map or the map couldn't be // transformed to an identity map. @@ -409,9 +409,9 @@ Value oldMemRef = allocOp.getResult(); - SmallVector symbolOperands(allocOp.getSymbolicOperands()); + SmallVector symbolOperands(allocOp.symbolOperands()); AllocOp newAlloc = b.create(allocOp.getLoc(), newMemRefType, - llvm::None, allocOp.alignmentAttr()); + allocOp.alignmentAttr()); AffineMap layoutMap = memrefType.getAffineMaps().front(); // Replace all uses of the old memref. if (failed(replaceAllMemRefUsesWith(oldMemRef, /*newMemRef=*/newAlloc, diff --git a/mlir/test/CAPI/ir.c b/mlir/test/CAPI/ir.c --- a/mlir/test/CAPI/ir.c +++ b/mlir/test/CAPI/ir.c @@ -960,7 +960,7 @@ mlirAffineMapDump(permutationAffineMap); // CHECK-LABEL: @affineMap // CHECK: () -> () - // CHECK: (d0, d1, d2)[s0, s1] -> () + // CHECK: (d0, d1, d2) [s0, s1] -> () // CHECK: () -> (2) // CHECK: (d0, d1, d2) -> (d0, d1, d2) // CHECK: (d0, d1, d2) -> (d1, d2) diff --git a/mlir/test/Conversion/AffineToStandard/lower-affine.mlir b/mlir/test/Conversion/AffineToStandard/lower-affine.mlir --- a/mlir/test/Conversion/AffineToStandard/lower-affine.mlir +++ b/mlir/test/Conversion/AffineToStandard/lower-affine.mlir @@ -114,7 +114,7 @@ // CHECK-NEXT: } func @affine_apply_loops_shorthand(%N : index) { affine.for %i = 0 to %N { - affine.for %j = affine_map<(d0)[]->(d0)>(%i)[] to 42 { + affine.for %j = affine_map<(d0) []->(d0)>(%i) [] to 42 { call @body2(%i, %j) : (index, index) -> () } } @@ -251,7 +251,7 @@ // CHECK-NEXT: } func @multi_cond(%N : index, %M : index, %K : index, %L : index) { %i = call @get_idx() : () -> (index) - affine.if #setN(%i)[%N,%M,%K,%L] { + affine.if #setN(%i) [%N,%M,%K,%L] { call @body(%i) : (index) -> () } else { call @mid(%i) : (index) -> () @@ -311,8 +311,8 @@ return } -#lbMultiMap = affine_map<(d0)[s0] -> (d0, s0 - d0)> -#ubMultiMap = affine_map<(d0)[s0] -> (s0, d0 + 10)> +#lbMultiMap = affine_map<(d0) [s0] -> (d0, s0 - d0)> +#ubMultiMap = affine_map<(d0) [s0] -> (s0, d0 + 10)> // CHECK-LABEL: func @loop_min_max // CHECK-NEXT: %[[c0:.*]] = constant 0 : index @@ -337,7 +337,7 @@ // CHECK-NEXT: } func @loop_min_max(%N : index) { affine.for %i = 0 to 42 { - affine.for %j = max #lbMultiMap(%i)[%N] to min #ubMultiMap(%i)[%N] { + affine.for %j = max #lbMultiMap(%i) [%N] to min #ubMultiMap(%i) [%N] { call @body2(%i, %j) : (index, index) -> () } } @@ -370,7 +370,7 @@ // CHECK-NEXT: return // CHECK-NEXT: } func @min_reduction_tree(%v1 : index, %v2 : index, %v3 : index, %v4 : index, %v5 : index, %v6 : index, %v7 : index) { - affine.for %i = 0 to min #map_7_values(%v1, %v2, %v3, %v4, %v5, %v6, %v7)[] { + affine.for %i = 0 to min #map_7_values(%v1, %v2, %v3, %v4, %v5, %v6, %v7) [] { call @body(%i) : (index) -> () } return @@ -379,10 +379,10 @@ ///////////////////////////////////////////////////////////////////// #map0 = affine_map<() -> (0)> -#map1 = affine_map<()[s0] -> (s0)> +#map1 = affine_map<() [s0] -> (s0)> #map2 = affine_map<(d0) -> (d0)> -#map3 = affine_map<(d0)[s0] -> (d0 + s0 + 1)> -#map4 = affine_map<(d0,d1,d2,d3)[s0,s1,s2] -> (d0 + 2*d1 + 3*d2 + 4*d3 + 5*s0 + 6*s1 + 7*s2)> +#map3 = affine_map<(d0) [s0] -> (d0 + s0 + 1)> +#map4 = affine_map<(d0,d1,d2,d3) [s0,s1,s2] -> (d0 + 2*d1 + 3*d2 + 4*d3 + 5*s0 + 6*s1 + 7*s2)> #map5 = affine_map<(d0,d1,d2) -> (d0,d1,d2)> #map6 = affine_map<(d0,d1,d2) -> (d0 + d1 + d2)> @@ -394,7 +394,7 @@ // 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) @@ -402,7 +402,7 @@ // CHECK-NEXT: %[[v0:.*]] = addi %[[c0]], %[[c0]] : index // CHECK-NEXT: %[[c1:.*]] = constant 1 : index // CHECK-NEXT: %[[v1:.*]] = addi %[[v0]], %[[c1]] : index - %one = affine.apply #map3(%symbZero)[%zero] + %one = affine.apply #map3(%symbZero) [%zero] // CHECK-NEXT: %[[c2:.*]] = constant 2 : index // CHECK-NEXT: %[[v2:.*]] = muli %arg0, %[[c2]] : index @@ -422,7 +422,7 @@ // CHECK-NEXT: %[[c7:.*]] = constant 7 : index // CHECK-NEXT: %[[v12:.*]] = muli %arg0, %[[c7]] : index // CHECK-NEXT: %[[v13:.*]] = addi %[[v11]], %[[v12]] : index - %four = affine.apply #map4(%arg0, %arg0, %arg0, %arg0)[%arg0, %arg0, %arg0] + %four = affine.apply #map4(%arg0, %arg0, %arg0, %arg0) [%arg0, %arg0, %arg0] return } @@ -431,7 +431,7 @@ ^bb0(%0 : index, %1 : index): // CHECK-NEXT: return %{{.*}}, %{{.*}} : index, index %00 = affine.apply #map2 (%0) - %11 = affine.apply #map1 ()[%1] + %11 = affine.apply #map1 () [%1] return %00, %11 : index, index } diff --git a/mlir/test/Conversion/LinalgToVector/linalg-to-vector.mlir b/mlir/test/Conversion/LinalgToVector/linalg-to-vector.mlir --- a/mlir/test/Conversion/LinalgToVector/linalg-to-vector.mlir +++ b/mlir/test/Conversion/LinalgToVector/linalg-to-vector.mlir @@ -1,10 +1,10 @@ // RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,3" --cse | FileCheck %s -// CHECK-DAG: #[[$map0:.*]] = affine_map<(d0)[s0] -> (1, -d0 + s0)> -// CHECK-DAG: #[[$map1:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> +// CHECK-DAG: #[[$map0:.*]] = affine_map<(d0) [s0] -> (1, -d0 + s0)> +// CHECK-DAG: #[[$map1:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> // CHECK-DAG: #[[$map2:.*]] = affine_map<(d0, d1) -> (d0 + d1)> -// CHECK-DAG: #[[$map3:.*]] = affine_map<(d0, d1)[s0] -> (3, -d0 - d1 + s0)> -// CHECK-DAG: #[[$map4:.*]] = affine_map<(d0)[s0] -> (3, -d0 + s0)> +// CHECK-DAG: #[[$map3:.*]] = affine_map<(d0, d1) [s0] -> (3, -d0 - d1 + s0)> +// CHECK-DAG: #[[$map4:.*]] = affine_map<(d0) [s0] -> (3, -d0 + s0)> // CHECK-DAG: #[[$map5:.*]] = affine_map<(d0) -> (d0)> func @conv_1d(%arg0: memref, %arg1: memref, %arg2: memref) { @@ -33,14 +33,14 @@ // CHECK: %[[v7:.*]] = std.view %[[v4]][%[[c0]]][] : memref to memref<3xf32> // CHECK: %[[v8:.*]] = std.view %[[v5]][%[[c0]]][] : memref to memref<1xf32> // CHECK: scf.for %[[arg3:.*]] = %[[c0]] to %[[v1]] step %[[c1]] { -// CHECK: %[[v9:.*]] = affine.min #[[$map0]](%[[arg3]])[%[[v1]]] +// CHECK: %[[v9:.*]] = affine.min #[[$map0]](%[[arg3]]) [%[[v1]]] // CHECK: %[[v10:.*]] = subview %[[arg2]][%[[arg3]]] [%[[v9]]] [1] : memref to memref // CHECK: %[[v11:.*]] = subview %[[v8]][0] [%[[v9]]] [1] : memref<1xf32> to memref // CHECK: scf.for %[[arg4:.*]] = %[[c0]] to %[[v0]] step %[[c3]] { // CHECK: %[[v12:.*]] = affine.apply #[[$map2]](%[[arg3]], %[[arg4]]) -// CHECK: %[[v13:.*]] = affine.min #[[$map3]](%[[arg3]], %[[arg4]])[%[[v2]]] +// CHECK: %[[v13:.*]] = affine.min #[[$map3]](%[[arg3]], %[[arg4]]) [%[[v2]]] // CHECK: %[[v14:.*]] = subview %arg0[%12] [%13] [1] : memref to memref -// CHECK: %[[v15:.*]] = affine.min #[[$map4]](%arg4)[%0] +// CHECK: %[[v15:.*]] = affine.min #[[$map4]](%arg4) [%0] // CHECK: %[[v16:.*]] = subview %[[arg1]][%[[arg4]]] [%[[v15]]] [1] : memref to memref // CHECK: %[[v17:.*]] = subview %[[v6]][0] [%[[v13]]] [1] : memref<3xf32> to memref // CHECK: %[[v19:.*]] = vector.transfer_read %[[v6]][%[[c0]]], %[[cst]] {masked = [false]} : memref<3xf32>, vector<3xf32> diff --git a/mlir/test/Conversion/SCFToGPU/parallel_loop.mlir b/mlir/test/Conversion/SCFToGPU/parallel_loop.mlir --- a/mlir/test/Conversion/SCFToGPU/parallel_loop.mlir +++ b/mlir/test/Conversion/SCFToGPU/parallel_loop.mlir @@ -15,19 +15,19 @@ return } -// CHECK: #[[$MAP0:.*]] = affine_map<(d0)[s0, s1] -> ((d0 - s0) ceildiv s1)> -// CHECK: #[[$MAP1:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s0 + s1)> +// CHECK: #[[$MAP0:.*]] = affine_map<(d0) [s0, s1] -> ((d0 - s0) ceildiv s1)> +// CHECK: #[[$MAP1:.*]] = affine_map<(d0) [s0, s1] -> (d0 * s0 + s1)> // CHECK: module { // CHECK-LABEL: func @parallel_loop_bidy_bidx( // CHECK-SAME: [[VAL_0:%.*]]: index, [[VAL_1:%.*]]: index, [[VAL_2:%.*]]: index, [[VAL_3:%.*]]: index, [[VAL_4:%.*]]: index, [[VAL_5:%.*]]: memref, [[VAL_6:%.*]]: memref) { // CHECK: [[VAL_7:%.*]] = constant 2 : index // CHECK: [[VAL_8:%.*]] = constant 1 : index -// CHECK: [[VAL_9:%.*]] = affine.apply #[[$MAP0]]([[VAL_2]]){{\[}}[[VAL_0]], [[VAL_4]]] -// CHECK: [[VAL_10:%.*]] = affine.apply #[[$MAP0]]([[VAL_3]]){{\[}}[[VAL_1]], [[VAL_7]]] +// CHECK: [[VAL_9:%.*]] = affine.apply #[[$MAP0]]([[VAL_2]]) {{\[}}[[VAL_0]], [[VAL_4]]] +// CHECK: [[VAL_10:%.*]] = affine.apply #[[$MAP0]]([[VAL_3]]) {{\[}}[[VAL_1]], [[VAL_7]]] // CHECK: gpu.launch blocks([[VAL_11:%.*]], [[VAL_12:%.*]], [[VAL_13:%.*]]) in ([[VAL_14:%.*]] = [[VAL_10]], [[VAL_15:%.*]] = [[VAL_9]], [[VAL_16:%.*]] = [[VAL_8]]) threads([[VAL_17:%.*]], [[VAL_18:%.*]], [[VAL_19:%.*]]) in ([[VAL_20:%.*]] = [[VAL_8]], [[VAL_21:%.*]] = [[VAL_8]], [[VAL_22:%.*]] = [[VAL_8]]) { -// CHECK: [[VAL_23:%.*]] = affine.apply #[[$MAP1]]([[VAL_12]]){{\[}}[[VAL_4]], [[VAL_0]]] -// CHECK: [[VAL_24:%.*]] = affine.apply #[[$MAP1]]([[VAL_11]]){{\[}}[[VAL_7]], [[VAL_1]]] +// CHECK: [[VAL_23:%.*]] = affine.apply #[[$MAP1]]([[VAL_12]]) {{\[}}[[VAL_4]], [[VAL_0]]] +// CHECK: [[VAL_24:%.*]] = affine.apply #[[$MAP1]]([[VAL_11]]) {{\[}}[[VAL_7]], [[VAL_1]]] // CHECK: [[VAL_25:%.*]] = load [[VAL_5]]{{\[}}[[VAL_23]], [[VAL_24]]] : memref // CHECK: store [[VAL_25]], [[VAL_6]]{{\[}}[[VAL_24]], [[VAL_23]]] : memref // CHECK: gpu.terminator @@ -66,8 +66,8 @@ return } -// CHECK: #[[$MAP0:.*]] = affine_map<(d0)[s0, s1] -> ((d0 - s0) ceildiv s1)> -// CHECK: #[[$MAP1:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s0 + s1)> +// CHECK: #[[$MAP0:.*]] = affine_map<(d0) [s0, s1] -> ((d0 - s0) ceildiv s1)> +// CHECK: #[[$MAP1:.*]] = affine_map<(d0) [s0, s1] -> (d0 * s0 + s1)> // CHECK: module { // CHECK-LABEL: func @parallel_loop_tiled( @@ -76,15 +76,15 @@ // CHECK: [[VAL_33:%.*]] = constant 1 : index // CHECK: [[VAL_34:%.*]] = constant 4 : index // CHECK: [[VAL_35:%.*]] = constant 1 : index -// CHECK: [[VAL_36:%.*]] = affine.apply #[[$MAP0]]([[VAL_28]]){{\[}}[[VAL_26]], [[VAL_34]]] -// CHECK: [[VAL_37:%.*]] = affine.apply #[[$MAP0]]([[VAL_29]]){{\[}}[[VAL_27]], [[VAL_34]]] -// CHECK: [[VAL_38:%.*]] = affine.apply #[[$MAP0]]([[VAL_34]]){{\[}}[[VAL_32]], [[VAL_33]]] -// CHECK: [[VAL_39:%.*]] = affine.apply #[[$MAP0]]([[VAL_34]]){{\[}}[[VAL_32]], [[VAL_33]]] +// CHECK: [[VAL_36:%.*]] = affine.apply #[[$MAP0]]([[VAL_28]]) {{\[}}[[VAL_26]], [[VAL_34]]] +// CHECK: [[VAL_37:%.*]] = affine.apply #[[$MAP0]]([[VAL_29]]) {{\[}}[[VAL_27]], [[VAL_34]]] +// CHECK: [[VAL_38:%.*]] = affine.apply #[[$MAP0]]([[VAL_34]]) {{\[}}[[VAL_32]], [[VAL_33]]] +// CHECK: [[VAL_39:%.*]] = affine.apply #[[$MAP0]]([[VAL_34]]) {{\[}}[[VAL_32]], [[VAL_33]]] // CHECK: gpu.launch blocks([[VAL_40:%.*]], [[VAL_41:%.*]], [[VAL_42:%.*]]) in ([[VAL_43:%.*]] = [[VAL_37]], [[VAL_44:%.*]] = [[VAL_36]], [[VAL_45:%.*]] = [[VAL_35]]) threads([[VAL_46:%.*]], [[VAL_47:%.*]], [[VAL_48:%.*]]) in ([[VAL_49:%.*]] = [[VAL_39]], [[VAL_50:%.*]] = [[VAL_38]], [[VAL_51:%.*]] = [[VAL_35]]) { -// CHECK: [[VAL_52:%.*]] = affine.apply #[[$MAP1]]([[VAL_41]]){{\[}}[[VAL_34]], [[VAL_26]]] -// CHECK: [[VAL_53:%.*]] = affine.apply #[[$MAP1]]([[VAL_40]]){{\[}}[[VAL_34]], [[VAL_27]]] -// CHECK: [[VAL_54:%.*]] = affine.apply #[[$MAP1]]([[VAL_47]]){{\[}}[[VAL_33]], [[VAL_32]]] -// CHECK: [[VAL_55:%.*]] = affine.apply #[[$MAP1]]([[VAL_46]]){{\[}}[[VAL_33]], [[VAL_32]]] +// CHECK: [[VAL_52:%.*]] = affine.apply #[[$MAP1]]([[VAL_41]]) {{\[}}[[VAL_34]], [[VAL_26]]] +// CHECK: [[VAL_53:%.*]] = affine.apply #[[$MAP1]]([[VAL_40]]) {{\[}}[[VAL_34]], [[VAL_27]]] +// CHECK: [[VAL_54:%.*]] = affine.apply #[[$MAP1]]([[VAL_47]]) {{\[}}[[VAL_33]], [[VAL_32]]] +// CHECK: [[VAL_55:%.*]] = affine.apply #[[$MAP1]]([[VAL_46]]) {{\[}}[[VAL_33]], [[VAL_32]]] // CHECK: [[VAL_56:%.*]] = addi [[VAL_52]], [[VAL_54]] : index // CHECK: [[VAL_57:%.*]] = addi [[VAL_53]], [[VAL_55]] : index // CHECK: [[VAL_58:%.*]] = load [[VAL_30]]{{\[}}[[VAL_56]], [[VAL_57]]] : memref @@ -115,17 +115,17 @@ return } -// CHECK: #[[$MAP0:.*]] = affine_map<(d0)[s0, s1] -> ((d0 - s0) ceildiv s1)> -// CHECK: #[[$MAP1:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s0 + s1)> +// CHECK: #[[$MAP0:.*]] = affine_map<(d0) [s0, s1] -> ((d0 - s0) ceildiv s1)> +// CHECK: #[[$MAP1:.*]] = affine_map<(d0) [s0, s1] -> (d0 * s0 + s1)> // CHECK: module { // CHECK-LABEL: func @parallel_loop_bidy_seq( // CHECK-SAME: [[VAL_59:%.*]]: index, [[VAL_60:%.*]]: index, [[VAL_61:%.*]]: index, [[VAL_62:%.*]]: index, [[VAL_63:%.*]]: index, [[VAL_64:%.*]]: memref, [[VAL_65:%.*]]: memref) { // CHECK: [[VAL_66:%.*]] = constant 2 : index // CHECK: [[VAL_67:%.*]] = constant 1 : index -// CHECK: [[VAL_68:%.*]] = affine.apply #[[$MAP0]]([[VAL_61]]){{\[}}[[VAL_59]], [[VAL_63]]] +// CHECK: [[VAL_68:%.*]] = affine.apply #[[$MAP0]]([[VAL_61]]) {{\[}}[[VAL_59]], [[VAL_63]]] // CHECK: gpu.launch blocks([[VAL_69:%.*]], [[VAL_70:%.*]], [[VAL_71:%.*]]) in ([[VAL_72:%.*]] = [[VAL_67]], [[VAL_73:%.*]] = [[VAL_68]], [[VAL_74:%.*]] = [[VAL_67]]) threads([[VAL_75:%.*]], [[VAL_76:%.*]], [[VAL_77:%.*]]) in ([[VAL_78:%.*]] = [[VAL_67]], [[VAL_79:%.*]] = [[VAL_67]], [[VAL_80:%.*]] = [[VAL_67]]) { -// CHECK: [[VAL_81:%.*]] = affine.apply #[[$MAP1]]([[VAL_70]]){{\[}}[[VAL_63]], [[VAL_59]]] +// CHECK: [[VAL_81:%.*]] = affine.apply #[[$MAP1]]([[VAL_70]]) {{\[}}[[VAL_63]], [[VAL_59]]] // CHECK: scf.for [[VAL_82:%.*]] = [[VAL_60]] to [[VAL_62]] step [[VAL_66]] { // CHECK: [[VAL_83:%.*]] = load [[VAL_64]]{{\[}}[[VAL_81]], [[VAL_82]]] : memref // CHECK: store [[VAL_83]], [[VAL_65]]{{\[}}[[VAL_82]], [[VAL_81]]] : memref @@ -166,8 +166,8 @@ return } -// CHECK: #[[$MAP0:.*]] = affine_map<(d0)[s0, s1] -> ((d0 - s0) ceildiv s1)> -// CHECK: #[[$MAP1:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s0 + s1)> +// CHECK: #[[$MAP0:.*]] = affine_map<(d0) [s0, s1] -> ((d0 - s0) ceildiv s1)> +// CHECK: #[[$MAP1:.*]] = affine_map<(d0) [s0, s1] -> (d0 * s0 + s1)> // CHECK: module { // CHECK-LABEL: func @parallel_loop_tiled_seq( @@ -176,12 +176,12 @@ // CHECK: [[VAL_91:%.*]] = constant 1 : index // CHECK: [[VAL_92:%.*]] = constant 4 : index // CHECK: [[VAL_93:%.*]] = constant 1 : index -// CHECK: [[VAL_94:%.*]] = affine.apply #[[$MAP0]]([[VAL_86]]){{\[}}[[VAL_84]], [[VAL_92]]] -// CHECK: [[VAL_95:%.*]] = affine.apply #[[$MAP0]]([[VAL_92]]){{\[}}[[VAL_90]], [[VAL_91]]] +// CHECK: [[VAL_94:%.*]] = affine.apply #[[$MAP0]]([[VAL_86]]) {{\[}}[[VAL_84]], [[VAL_92]]] +// CHECK: [[VAL_95:%.*]] = affine.apply #[[$MAP0]]([[VAL_92]]) {{\[}}[[VAL_90]], [[VAL_91]]] // CHECK: gpu.launch blocks([[VAL_96:%.*]], [[VAL_97:%.*]], [[VAL_98:%.*]]) in ([[VAL_99:%.*]] = [[VAL_93]], [[VAL_100:%.*]] = [[VAL_94]], [[VAL_101:%.*]] = [[VAL_93]]) threads([[VAL_102:%.*]], [[VAL_103:%.*]], [[VAL_104:%.*]]) in ([[VAL_105:%.*]] = [[VAL_93]], [[VAL_106:%.*]] = [[VAL_95]], [[VAL_107:%.*]] = [[VAL_93]]) { -// CHECK: [[VAL_108:%.*]] = affine.apply #[[$MAP1]]([[VAL_97]]){{\[}}[[VAL_92]], [[VAL_84]]] +// CHECK: [[VAL_108:%.*]] = affine.apply #[[$MAP1]]([[VAL_97]]) {{\[}}[[VAL_92]], [[VAL_84]]] // CHECK: scf.for [[VAL_109:%.*]] = [[VAL_85]] to [[VAL_87]] step [[VAL_92]] { -// CHECK: [[VAL_110:%.*]] = affine.apply #[[$MAP1]]([[VAL_103]]){{\[}}[[VAL_91]], [[VAL_90]]] +// CHECK: [[VAL_110:%.*]] = affine.apply #[[$MAP1]]([[VAL_103]]) {{\[}}[[VAL_91]], [[VAL_90]]] // CHECK: scf.for [[VAL_111:%.*]] = [[VAL_90]] to [[VAL_92]] step [[VAL_91]] { // CHECK: [[VAL_112:%.*]] = addi [[VAL_108]], [[VAL_110]] : index // CHECK: [[VAL_113:%.*]] = addi [[VAL_109]], [[VAL_111]] : index @@ -197,10 +197,10 @@ // ----- -#map0 = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -#map1 = affine_map<(d0)[s0] -> (2, -d0 + s0)> -#map2 = affine_map<(d0)[s0] -> (3, -d0 + s0)> -#map3 = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +#map0 = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +#map1 = affine_map<(d0) [s0] -> (2, -d0 + s0)> +#map2 = affine_map<(d0) [s0] -> (3, -d0 + s0)> +#map3 = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> module { func @sum(%arg0: memref, %arg1: memref, %arg2: memref) { @@ -212,20 +212,20 @@ %1 = dim %arg0, %c1 : memref scf.parallel (%arg3, %arg4) = (%c0, %c0) to (%0, %1) step (%c2, %c3) { %2 = dim %arg0, %c0 : memref - %3 = affine.min #map1(%arg3)[%2] + %3 = affine.min #map1(%arg3) [%2] %squared_min = muli %3, %3 : index %4 = dim %arg0, %c1 : memref - %5 = affine.min #map2(%arg4)[%4] + %5 = affine.min #map2(%arg4) [%4] %6 = std.subview %arg0[%arg3, %arg4][%squared_min, %5][%c1, %c1] : memref to memref %7 = dim %arg1, %c0 : memref - %8 = affine.min #map1(%arg3)[%7] + %8 = affine.min #map1(%arg3) [%7] %9 = dim %arg1, %c1 : memref - %10 = affine.min #map2(%arg4)[%9] + %10 = affine.min #map2(%arg4) [%9] %11 = std.subview %arg1[%arg3, %arg4][%8, %10][%c1, %c1] : memref to memref %12 = dim %arg2, %c0 : memref - %13 = affine.min #map1(%arg3)[%12] + %13 = affine.min #map1(%arg3) [%12] %14 = dim %arg2, %c1 : memref - %15 = affine.min #map2(%arg4)[%14] + %15 = affine.min #map2(%arg4) [%14] %16 = std.subview %arg2[%arg3, %arg4][%13, %15][%c1, %c1] : memref to memref scf.parallel (%arg5, %arg6) = (%c0, %c0) to (%squared_min, %5) step (%c1, %c1) { %17 = load %6[%arg5, %arg6] : memref @@ -241,12 +241,12 @@ } } -// CHECK: #[[$MAP0:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECK: #[[$MAP1:.*]] = affine_map<(d0)[s0, s1] -> ((d0 - s0) ceildiv s1)> -// CHECK: #[[$MAP2:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s0 + s1)> -// CHECK: #[[$MAP3:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)> -// CHECK: #[[$MAP4:.*]] = affine_map<(d0)[s0] -> (3, -d0 + s0)> -// CHECK: #[[$MAP5:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +// CHECK: #[[$MAP0:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK: #[[$MAP1:.*]] = affine_map<(d0) [s0, s1] -> ((d0 - s0) ceildiv s1)> +// CHECK: #[[$MAP2:.*]] = affine_map<(d0) [s0, s1] -> (d0 * s0 + s1)> +// CHECK: #[[$MAP3:.*]] = affine_map<(d0) [s0] -> (2, -d0 + s0)> +// CHECK: #[[$MAP4:.*]] = affine_map<(d0) [s0] -> (3, -d0 + s0)> +// CHECK: #[[$MAP5:.*]] = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> // CHECK: module { // CHECK-LABEL: func @sum( @@ -258,35 +258,35 @@ // CHECK: [[VAL_7:%.*]] = dim [[VAL_0]], %[[C0]] : memref // CHECK: [[VAL_8:%.*]] = dim [[VAL_0]], %[[C1]] : memref // CHECK: [[VAL_9:%.*]] = constant 1 : index -// CHECK: [[VAL_10:%.*]] = affine.apply #[[$MAP1]]([[VAL_7]]){{\[}}%[[C0]], %[[C2]]] -// CHECK: [[VAL_11:%.*]] = affine.apply #[[$MAP1]]([[VAL_8]]){{\[}}%[[C0]], %[[C3]]] +// CHECK: [[VAL_10:%.*]] = affine.apply #[[$MAP1]]([[VAL_7]]) {{\[}}%[[C0]], %[[C2]]] +// CHECK: [[VAL_11:%.*]] = affine.apply #[[$MAP1]]([[VAL_8]]) {{\[}}%[[C0]], %[[C3]]] // CHECK: [[VAL_12:%.*]] = constant 4 : index -// CHECK: [[VAL_13:%.*]] = affine.apply #[[$MAP1]]([[VAL_12]]){{\[}}%[[C0]], %[[C1]]] +// CHECK: [[VAL_13:%.*]] = affine.apply #[[$MAP1]]([[VAL_12]]) {{\[}}%[[C0]], %[[C1]]] // CHECK: [[VAL_14:%.*]] = constant 3 : index -// CHECK: [[VAL_15:%.*]] = affine.apply #[[$MAP1]]([[VAL_14]]){{\[}}%[[C0]], %[[C1]]] +// CHECK: [[VAL_15:%.*]] = affine.apply #[[$MAP1]]([[VAL_14]]) {{\[}}%[[C0]], %[[C1]]] // CHECK: gpu.launch blocks([[VAL_16:%.*]], [[VAL_17:%.*]], [[VAL_18:%.*]]) in ([[VAL_19:%.*]] = [[VAL_10]], [[VAL_20:%.*]] = [[VAL_11]], [[VAL_21:%.*]] = [[VAL_9]]) threads([[VAL_22:%.*]], [[VAL_23:%.*]], [[VAL_24:%.*]]) in ([[VAL_25:%.*]] = [[VAL_13]], [[VAL_26:%.*]] = [[VAL_15]], [[VAL_27:%.*]] = [[VAL_9]]) { -// CHECK: [[VAL_28:%.*]] = affine.apply #[[$MAP2]]([[VAL_16]]){{\[}}%[[C2]], %[[C0]]] -// CHECK: [[VAL_29:%.*]] = affine.apply #[[$MAP2]]([[VAL_17]]){{\[}}%[[C3]], %[[C0]]] +// CHECK: [[VAL_28:%.*]] = affine.apply #[[$MAP2]]([[VAL_16]]) {{\[}}%[[C2]], %[[C0]]] +// CHECK: [[VAL_29:%.*]] = affine.apply #[[$MAP2]]([[VAL_17]]) {{\[}}%[[C3]], %[[C0]]] // CHECK: [[VAL_30:%.*]] = dim [[VAL_0]], %[[C0]] : memref -// CHECK: [[VAL_31:%.*]] = affine.min #[[$MAP3]]([[VAL_28]]){{\[}}[[VAL_30]]] +// CHECK: [[VAL_31:%.*]] = affine.min #[[$MAP3]]([[VAL_28]]) {{\[}}[[VAL_30]]] // CHECK: [[VAL_31_SQUARED:%.*]] = muli [[VAL_31]], [[VAL_31]] : index // CHECK: [[VAL_32:%.*]] = dim [[VAL_0]], %[[C1]] : memref -// CHECK: [[VAL_33:%.*]] = affine.min #[[$MAP4]]([[VAL_29]]){{\[}}[[VAL_32]]] +// CHECK: [[VAL_33:%.*]] = affine.min #[[$MAP4]]([[VAL_29]]) {{\[}}[[VAL_32]]] // CHECK: [[VAL_34:%.*]] = subview [[VAL_0]]{{\[}}[[VAL_28]], [[VAL_29]]] {{\[}}[[VAL_31_SQUARED]], [[VAL_33]]] {{\[}}%[[C1]], %[[C1]]] : memref to memref // CHECK: [[VAL_35:%.*]] = dim [[VAL_1]], %[[C0]] : memref -// CHECK: [[VAL_36:%.*]] = affine.min #[[$MAP3]]([[VAL_28]]){{\[}}[[VAL_35]]] +// CHECK: [[VAL_36:%.*]] = affine.min #[[$MAP3]]([[VAL_28]]) {{\[}}[[VAL_35]]] // CHECK: [[VAL_37:%.*]] = dim [[VAL_1]], %[[C1]] : memref -// CHECK: [[VAL_38:%.*]] = affine.min #[[$MAP4]]([[VAL_29]]){{\[}}[[VAL_37]]] +// CHECK: [[VAL_38:%.*]] = affine.min #[[$MAP4]]([[VAL_29]]) {{\[}}[[VAL_37]]] // CHECK: [[VAL_39:%.*]] = subview [[VAL_1]]{{\[}}[[VAL_28]], [[VAL_29]]] {{\[}}[[VAL_36]], [[VAL_38]]] {{\[}}%[[C1]], %[[C1]]] : memref to memref // CHECK: [[VAL_40:%.*]] = dim [[VAL_2]], %[[C0]] : memref -// CHECK: [[VAL_41:%.*]] = affine.min #[[$MAP3]]([[VAL_28]]){{\[}}[[VAL_40]]] +// CHECK: [[VAL_41:%.*]] = affine.min #[[$MAP3]]([[VAL_28]]) {{\[}}[[VAL_40]]] // CHECK: [[VAL_42:%.*]] = dim [[VAL_2]], %[[C1]] : memref -// CHECK: [[VAL_43:%.*]] = affine.min #[[$MAP4]]([[VAL_29]]){{\[}}[[VAL_42]]] +// CHECK: [[VAL_43:%.*]] = affine.min #[[$MAP4]]([[VAL_29]]) {{\[}}[[VAL_42]]] // CHECK: [[VAL_44:%.*]] = subview [[VAL_2]]{{\[}}[[VAL_28]], [[VAL_29]]] {{\[}}[[VAL_41]], [[VAL_43]]] {{\[}}%[[C1]], %[[C1]]] : memref to memref -// CHECK: [[VAL_45:%.*]] = affine.apply #[[$MAP2]]([[VAL_22]]){{\[}}%[[C1]], %[[C0]]] +// CHECK: [[VAL_45:%.*]] = affine.apply #[[$MAP2]]([[VAL_22]]) {{\[}}%[[C1]], %[[C0]]] // CHECK: [[VAL_46:%.*]] = cmpi "slt", [[VAL_45]], [[VAL_31_SQUARED]] : index // CHECK: scf.if [[VAL_46]] { -// CHECK: [[VAL_47:%.*]] = affine.apply #[[$MAP2]]([[VAL_23]]){{\[}}%[[C1]], %[[C0]]] +// CHECK: [[VAL_47:%.*]] = affine.apply #[[$MAP2]]([[VAL_23]]) {{\[}}%[[C1]], %[[C0]]] // CHECK: [[VAL_48:%.*]] = cmpi "slt", [[VAL_47]], [[VAL_33]] : index // CHECK: scf.if [[VAL_48]] { // CHECK: [[VAL_49:%.*]] = load [[VAL_34]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref diff --git a/mlir/test/Conversion/StandardToLLVM/convert-dynamic-memref-ops.mlir b/mlir/test/Conversion/StandardToLLVM/convert-dynamic-memref-ops.mlir --- a/mlir/test/Conversion/StandardToLLVM/convert-dynamic-memref-ops.mlir +++ b/mlir/test/Conversion/StandardToLLVM/convert-dynamic-memref-ops.mlir @@ -9,8 +9,8 @@ // CHECK-COUNT-2: !llvm.ptr // CHECK-COUNT-5: !llvm.i64 func @check_strided_memref_arguments(%static: memref<10x20xf32, affine_map<(i,j)->(20 * i + j + 1)>>, - %dynamic : memref(M * i + j + 1)>>, - %mixed : memref<10x?xf32, affine_map<(i,j)[M]->(M * i + j + 1)>>) { + %dynamic : memref(M * i + j + 1)>>, + %mixed : memref<10x?xf32, affine_map<(i,j) [M]->(M * i + j + 1)>>) { return } diff --git a/mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir b/mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir --- a/mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir +++ b/mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir @@ -12,7 +12,7 @@ // CHECK-LABEL: func @strided_memref( func @strided_memref(%ind: index) { - %0 = alloc()[%ind] : memref<32x64xf32, affine_map<(i, j)[M] -> (32 + M * i + j)>> + %0 = alloc()[%ind] : memref<32x64xf32, affine_map<(i, j) [M] -> (32 + M * i + j)>> std.return } @@ -128,6 +128,6 @@ // CHECK: llvm.extractvalue {{.*}}[3, 2] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.insertvalue {{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> func @transpose(%arg0: memref) { - %0 = transpose %arg0 (i, j, k) -> (k, i, j) : memref to memref (d2 * s1 + s0 + d0 * s2 + d1)>> + %0 = transpose %arg0 (i, j, k) -> (k, i, j) : memref to memref (d2 * s1 + s0 + d0 * s2 + d1)>> return } diff --git a/mlir/test/Conversion/VectorToSCF/vector-to-loops.mlir b/mlir/test/Conversion/VectorToSCF/vector-to-loops.mlir --- a/mlir/test/Conversion/VectorToSCF/vector-to-loops.mlir +++ b/mlir/test/Conversion/VectorToSCF/vector-to-loops.mlir @@ -173,12 +173,12 @@ // ----- -// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> +// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> // CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1) -> (d1)> // FULL-UNROLL-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1) -> (d1)> -// FULL-UNROLL-DAG: #[[$MAP1:.*]] = affine_map<()[s0] -> (s0 + 1)> -// FULL-UNROLL-DAG: #[[$MAP2:.*]] = affine_map<()[s0] -> (s0 + 2)> +// FULL-UNROLL-DAG: #[[$MAP1:.*]] = affine_map<() [s0] -> (s0 + 1)> +// FULL-UNROLL-DAG: #[[$MAP2:.*]] = affine_map<() [s0] -> (s0 + 2)> // CHECK-LABEL: transfer_read_progressive( @@ -198,7 +198,7 @@ // CHECK-DAG: %[[C0:.*]] = constant 0 : index // CHECK-DAG: %[[dim:.*]] = dim %[[A]], %[[C0]] : memref // CHECK: affine.for %[[I:.*]] = 0 to 3 { - // CHECK: %[[add:.*]] = affine.apply #[[$MAP0]](%[[I]])[%[[base]]] + // CHECK: %[[add:.*]] = affine.apply #[[$MAP0]](%[[I]]) [%[[base]]] // CHECK: %[[cond1:.*]] = cmpi "slt", %[[add]], %[[dim]] : index // CHECK: scf.if %[[cond1]] { // CHECK: %[[vec_1d:.*]] = vector.transfer_read %[[A]][%[[add]], %[[base]]], %[[cst]] : memref, vector<15xf32> @@ -223,7 +223,7 @@ // FULL-UNROLL: vector.insert %{{.*}}, %[[VEC0]] [0] : vector<15xf32> into vector<3x15xf32> // FULL-UNROLL: scf.yield %{{.*}} : vector<3x15xf32> // FULL-UNROLL: } - // FULL-UNROLL: affine.apply #[[$MAP1]]()[%[[base]]] + // FULL-UNROLL: affine.apply #[[$MAP1]]() [%[[base]]] // FULL-UNROLL: cmpi "slt", %{{.*}}, %[[DIM]] : index // FULL-UNROLL: %[[VEC2:.*]] = scf.if %{{.*}} -> (vector<3x15xf32>) { // FULL-UNROLL: vector.transfer_read %[[A]][%{{.*}}, %[[base]]], %[[pad]] : memref, vector<15xf32> @@ -233,7 +233,7 @@ // FULL-UNROLL: vector.insert %{{.*}}, %[[VEC1]] [1] : vector<15xf32> into vector<3x15xf32> // FULL-UNROLL: scf.yield %{{.*}} : vector<3x15xf32> // FULL-UNROLL: } - // FULL-UNROLL: affine.apply #[[$MAP2]]()[%[[base]]] + // FULL-UNROLL: affine.apply #[[$MAP2]]() [%[[base]]] // FULL-UNROLL: cmpi "slt", %{{.*}}, %[[DIM]] : index // FULL-UNROLL: %[[VEC3:.*]] = scf.if %{{.*}} -> (vector<3x15xf32>) { // FULL-UNROLL: vector.transfer_read %[[A]][%{{.*}}, %[[base]]], %[[pad]] : memref, vector<15xf32> @@ -252,12 +252,12 @@ // ----- -// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> +// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> // CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1) -> (d1)> // FULL-UNROLL-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1) -> (d1)> -// FULL-UNROLL-DAG: #[[$MAP1:.*]] = affine_map<()[s0] -> (s0 + 1)> -// FULL-UNROLL-DAG: #[[$MAP2:.*]] = affine_map<()[s0] -> (s0 + 2)> +// FULL-UNROLL-DAG: #[[$MAP1:.*]] = affine_map<() [s0] -> (s0 + 1)> +// FULL-UNROLL-DAG: #[[$MAP2:.*]] = affine_map<() [s0] -> (s0 + 2)> // CHECK-LABEL: transfer_write_progressive( // CHECK-SAME: %[[A:[a-zA-Z0-9]+]]: memref, @@ -274,7 +274,7 @@ // CHECK: store %[[vec]], %[[vmemref]][] : memref> // CHECK: %[[dim:.*]] = dim %[[A]], %[[C0]] : memref // CHECK: affine.for %[[I:.*]] = 0 to 3 { - // CHECK: %[[add:.*]] = affine.apply #[[$MAP0]](%[[I]])[%[[base]]] + // CHECK: %[[add:.*]] = affine.apply #[[$MAP0]](%[[I]]) [%[[base]]] // CHECK: %[[cmp:.*]] = cmpi "slt", %[[add]], %[[dim]] : index // CHECK: scf.if %[[cmp]] { // CHECK: %[[vec_1d:.*]] = load %0[%[[I]]] : memref<3xvector<15xf32>> @@ -288,13 +288,13 @@ // FULL-UNROLL: %[[V0:.*]] = vector.extract %[[vec]][0] : vector<3x15xf32> // FULL-UNROLL: vector.transfer_write %[[V0]], %[[A]][%[[base]], %[[base]]] : vector<15xf32>, memref // FULL-UNROLL: } - // FULL-UNROLL: %[[I1:.*]] = affine.apply #[[$MAP1]]()[%[[base]]] + // FULL-UNROLL: %[[I1:.*]] = affine.apply #[[$MAP1]]() [%[[base]]] // FULL-UNROLL: %[[CMP1:.*]] = cmpi "slt", %[[I1]], %[[DIM]] : index // FULL-UNROLL: scf.if %[[CMP1]] { // FULL-UNROLL: %[[V1:.*]] = vector.extract %[[vec]][1] : vector<3x15xf32> // FULL-UNROLL: vector.transfer_write %[[V1]], %[[A]][%[[I1]], %[[base]]] : vector<15xf32>, memref // FULL-UNROLL: } - // FULL-UNROLL: %[[I2:.*]] = affine.apply #[[$MAP2]]()[%[[base]]] + // FULL-UNROLL: %[[I2:.*]] = affine.apply #[[$MAP2]]() [%[[base]]] // FULL-UNROLL: %[[CMP2:.*]] = cmpi "slt", %[[I2]], %[[DIM]] : index // FULL-UNROLL: scf.if %[[CMP2]] { // FULL-UNROLL: %[[V2:.*]] = vector.extract %[[vec]][2] : vector<3x15xf32> @@ -308,12 +308,12 @@ // ----- -// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> +// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> // CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1) -> (d1)> // FULL-UNROLL-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1) -> (d1)> -// FULL-UNROLL-DAG: #[[$MAP1:.*]] = affine_map<()[s0] -> (s0 + 1)> -// FULL-UNROLL-DAG: #[[$MAP2:.*]] = affine_map<()[s0] -> (s0 + 2)> +// FULL-UNROLL-DAG: #[[$MAP1:.*]] = affine_map<() [s0] -> (s0 + 1)> +// FULL-UNROLL-DAG: #[[$MAP2:.*]] = affine_map<() [s0] -> (s0 + 2)> // CHECK-LABEL: transfer_write_progressive_unmasked( // CHECK-SAME: %[[A:[a-zA-Z0-9]+]]: memref, @@ -329,16 +329,16 @@ // CHECK-NEXT: %[[vmemref:.*]] = vector.type_cast %[[alloc]] : memref<3xvector<15xf32>> to memref> // CHECK-NEXT: store %[[vec]], %[[vmemref]][] : memref> // CHECK-NEXT: affine.for %[[I:.*]] = 0 to 3 { - // CHECK-NEXT: %[[add:.*]] = affine.apply #[[$MAP0]](%[[I]])[%[[base]]] + // CHECK-NEXT: %[[add:.*]] = affine.apply #[[$MAP0]](%[[I]]) [%[[base]]] // CHECK-NEXT: %[[vec_1d:.*]] = load %0[%[[I]]] : memref<3xvector<15xf32>> // CHECK-NEXT: vector.transfer_write %[[vec_1d]], %[[A]][%[[add]], %[[base]]] {masked = [false]} : vector<15xf32>, memref // FULL-UNROLL: %[[VEC0:.*]] = vector.extract %[[vec]][0] : vector<3x15xf32> // FULL-UNROLL: vector.transfer_write %[[VEC0]], %[[A]][%[[base]], %[[base]]] {masked = [false]} : vector<15xf32>, memref - // FULL-UNROLL: %[[I1:.*]] = affine.apply #[[$MAP1]]()[%[[base]]] + // FULL-UNROLL: %[[I1:.*]] = affine.apply #[[$MAP1]]() [%[[base]]] // FULL-UNROLL: %[[VEC1:.*]] = vector.extract %[[vec]][1] : vector<3x15xf32> // FULL-UNROLL: vector.transfer_write %2, %[[A]][%[[I1]], %[[base]]] {masked = [false]} : vector<15xf32>, memref - // FULL-UNROLL: %[[I2:.*]] = affine.apply #[[$MAP2]]()[%[[base]]] + // FULL-UNROLL: %[[I2:.*]] = affine.apply #[[$MAP2]]() [%[[base]]] // FULL-UNROLL: %[[VEC2:.*]] = vector.extract %[[vec]][2] : vector<3x15xf32> // FULL-UNROLL: vector.transfer_write %[[VEC2:.*]], %[[A]][%[[I2]], %[[base]]] {masked = [false]} : vector<15xf32>, memref vector.transfer_write %vec, %A[%base, %base] {masked = [false, false]} : diff --git a/mlir/test/Dialect/Affine/SuperVectorize/compose_maps.mlir b/mlir/test/Dialect/Affine/SuperVectorize/compose_maps.mlir --- a/mlir/test/Dialect/Affine/SuperVectorize/compose_maps.mlir +++ b/mlir/test/Dialect/Affine/SuperVectorize/compose_maps.mlir @@ -17,36 +17,36 @@ } func @simple2() { - // CHECK: Composed map: (d0)[s0, s1] -> (d0 - s0 + s1) - "test_affine_map"() { affine_map = affine_map<(d0)[s0] -> (d0 + s0 - 1)> } : () -> () - "test_affine_map"() { affine_map = affine_map<(d0)[s0] -> (d0 - s0 + 1)> } : () -> () + // CHECK: Composed map: (d0) [s0, s1] -> (d0 - s0 + s1) + "test_affine_map"() { affine_map = affine_map<(d0) [s0] -> (d0 + s0 - 1)> } : () -> () + "test_affine_map"() { affine_map = affine_map<(d0) [s0] -> (d0 - s0 + 1)> } : () -> () return } func @simple3a() { - // CHECK: Composed map: (d0, d1)[s0, s1, s2, s3] -> ((d0 ceildiv s2) * s0, (d1 ceildiv s3) * s1) - "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> (d0 ceildiv s0, d1 ceildiv s1)> } : () -> () - "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> (d0 * s0, d1 * s1)> } : () -> () + // CHECK: Composed map: (d0, d1) [s0, s1, s2, s3] -> ((d0 ceildiv s2) * s0, (d1 ceildiv s3) * s1) + "test_affine_map"() { affine_map = affine_map<(d0, d1) [s0, s1] -> (d0 ceildiv s0, d1 ceildiv s1)> } : () -> () + "test_affine_map"() { affine_map = affine_map<(d0, d1) [s0, s1] -> (d0 * s0, d1 * s1)> } : () -> () return } func @simple3b() { - // CHECK: Composed map: (d0, d1)[s0, s1] -> (d0 mod s0, d1 mod s1) - "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> (d0 mod s0, d1 mod s1)> } : () -> () + // CHECK: Composed map: (d0, d1) [s0, s1] -> (d0 mod s0, d1 mod s1) + "test_affine_map"() { affine_map = affine_map<(d0, d1) [s0, s1] -> (d0 mod s0, d1 mod s1)> } : () -> () return } func @simple3c() { - // CHECK: Composed map: (d0, d1)[s0, s1, s2, s3, s4, s5] -> ((d0 ceildiv s4) * s4 + d0 mod s2, (d1 ceildiv s5) * s5 + d1 mod s3) - "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> ((d0 ceildiv s0) * s0, (d1 ceildiv s1) * s1, d0, d1)> } : () -> () - "test_affine_map"() { affine_map = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 + d2 mod s2, d1 + d3 mod s3)> } : () -> () + // CHECK: Composed map: (d0, d1) [s0, s1, s2, s3, s4, s5] -> ((d0 ceildiv s4) * s4 + d0 mod s2, (d1 ceildiv s5) * s5 + d1 mod s3) + "test_affine_map"() { affine_map = affine_map<(d0, d1) [s0, s1] -> ((d0 ceildiv s0) * s0, (d1 ceildiv s1) * s1, d0, d1)> } : () -> () + "test_affine_map"() { affine_map = affine_map<(d0, d1, d2, d3) [s0, s1, s2, s3] -> (d0 + d2 mod s2, d1 + d3 mod s3)> } : () -> () return } func @simple4() { - // CHECK: Composed map: (d0, d1)[s0, s1] -> (d1 * s1, d0 ceildiv s0) + // CHECK: Composed map: (d0, d1) [s0, s1] -> (d1 * s1, d0 ceildiv s0) "test_affine_map"() { affine_map = affine_map<(d0, d1) -> (d1, d0)> } : () -> () - "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> (d0 * s1, d1 ceildiv s0)> } : () -> () + "test_affine_map"() { affine_map = affine_map<(d0, d1) [s0, s1] -> (d0 * s1, d1 ceildiv s0)> } : () -> () return } @@ -110,22 +110,22 @@ } func @symbols1() { - // CHECK: Composed map: (d0)[s0] -> (d0 + s0 + 1, d0 - s0 - 1) - "test_affine_map"() { affine_map = affine_map<(d0)[s0] -> (d0 + s0, d0 - s0)> } : () -> () + // CHECK: Composed map: (d0) [s0] -> (d0 + s0 + 1, d0 - s0 - 1) + "test_affine_map"() { affine_map = affine_map<(d0) [s0] -> (d0 + s0, d0 - s0)> } : () -> () "test_affine_map"() { affine_map = affine_map<(d0, d1) -> (d0 + 1, d1 - 1)> } : () -> () return } func @drop() { - // CHECK: Composed map: (d0, d1, d2)[s0, s1] -> (d0 * 2 + d1 + d2 + s1) - "test_affine_map"() { affine_map = affine_map<(d0, d1, d2)[s0, s1] -> (d0 + s1, d1 + s0, d0 + d1 + d2)> } : () -> () + // CHECK: Composed map: (d0, d1, d2) [s0, s1] -> (d0 * 2 + d1 + d2 + s1) + "test_affine_map"() { affine_map = affine_map<(d0, d1, d2) [s0, s1] -> (d0 + s1, d1 + s0, d0 + d1 + d2)> } : () -> () "test_affine_map"() { affine_map = affine_map<(d0, d1, d2) -> (d0 + d2)> } : () -> () return } func @multi_symbols() { - // CHECK: Composed map: (d0)[s0, s1, s2] -> (d0 + s1 + s2 + 1, d0 - s0 - s2 - 1) - "test_affine_map"() { affine_map = affine_map<(d0)[s0] -> (d0 + s0, d0 - s0)> } : () -> () - "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> (d0 + 1 + s1, d1 - 1 - s0)> } : () -> () + // CHECK: Composed map: (d0) [s0, s1, s2] -> (d0 + s1 + s2 + 1, d0 - s0 - s2 - 1) + "test_affine_map"() { affine_map = affine_map<(d0) [s0] -> (d0 + s0, d0 - s0)> } : () -> () + "test_affine_map"() { affine_map = affine_map<(d0, d1) [s0, s1] -> (d0 + 1 + s1, d1 - 1 - s0)> } : () -> () return } diff --git a/mlir/test/Dialect/Affine/affine-data-copy.mlir b/mlir/test/Dialect/Affine/affine-data-copy.mlir --- a/mlir/test/Dialect/Affine/affine-data-copy.mlir +++ b/mlir/test/Dialect/Affine/affine-data-copy.mlir @@ -239,18 +239,18 @@ // with multi-level tiling when the tile sizes used don't divide loop trip // counts. -#lb = affine_map<()[s0, s1] -> (s0 * 512, s1 * 6)> -#ub = affine_map<()[s0, s1] -> (s0 * 512 + 512, s1 * 6 + 6)> +#lb = affine_map<() [s0, s1] -> (s0 * 512, s1 * 6)> +#ub = affine_map<() [s0, s1] -> (s0 * 512 + 512, s1 * 6 + 6)> -// CHECK-DAG: #[[$LB:.*]] = affine_map<()[s0, s1] -> (s0 * 512, s1 * 6)> -// CHECK-DAG: #[[$UB:.*]] = affine_map<()[s0, s1] -> (s0 * 512 + 512, s1 * 6 + 6)> +// CHECK-DAG: #[[$LB:.*]] = affine_map<() [s0, s1] -> (s0 * 512, s1 * 6)> +// CHECK-DAG: #[[$UB:.*]] = affine_map<() [s0, s1] -> (s0 * 512 + 512, s1 * 6 + 6)> // CHECK-LABEL: max_lower_bound(%{{.*}}: memref<2048x516xf64>, // CHECK-SAME: [[i:arg[0-9]+]] // CHECK-SAME: [[j:arg[0-9]+]] func @max_lower_bound(%M: memref<2048x516xf64>, %i : index, %j : index) { affine.for %ii = 0 to 2048 { - affine.for %jj = max #lb()[%i, %j] to min #ub()[%i, %j] { + affine.for %jj = max #lb() [%i, %j] to min #ub() [%i, %j] { affine.load %M[%ii, %jj] : memref<2048x516xf64> } } @@ -259,13 +259,13 @@ // CHECK: %[[BUF:.*]] = alloc() : memref<2048x6xf64> // CHECK-NEXT: affine.for %[[ii:.*]] = 0 to 2048 { -// CHECK-NEXT: affine.for %[[jj:.*]] = max #[[$LB]]()[%[[i]], %[[j]]] to min #[[$UB]]()[%[[i]], %[[j]]] { +// CHECK-NEXT: affine.for %[[jj:.*]] = max #[[$LB]]() [%[[i]], %[[j]]] to min #[[$UB]]() [%[[i]], %[[j]]] { // CHECK-NEXT: affine.load %{{.*}}[%[[ii]], %[[jj]]] : memref<2048x516xf64> // CHECK-NEXT: affine.store %{{.*}}, %[[BUF]][%[[ii]], %[[jj]] - symbol(%[[j]]) * 6] : memref<2048x6xf64> // CHECK-NEXT: } // CHECK-NEXT: } // CHECK-NEXT: affine.for %[[ii_:.*]] = 0 to 2048 { -// CHECK-NEXT: affine.for %[[jj_:.*]] = max #[[$LB]]()[%{{.*}}, %{{.*}}] to min #[[$UB]]()[%{{.*}}, %{{.*}}] { +// CHECK-NEXT: affine.for %[[jj_:.*]] = max #[[$LB]]() [%{{.*}}, %{{.*}}] to min #[[$UB]]() [%{{.*}}, %{{.*}}] { // CHECK-NEXT: affine.load %[[BUF]][%[[ii_]], %[[jj_]] - symbol(%[[j]]) * 6] : memref<2048x6xf64> // CHECK-NEXT: } // CHECK-NEXT: } diff --git a/mlir/test/Dialect/Affine/canonicalize.mlir b/mlir/test/Dialect/Affine/canonicalize.mlir --- a/mlir/test/Dialect/Affine/canonicalize.mlir +++ b/mlir/test/Dialect/Affine/canonicalize.mlir @@ -25,22 +25,22 @@ // CHECK-DAG: [[$MAP13B:#map[0-9]+]] = affine_map<(d0) -> ((d0 * 4 - 4) floordiv 3)> // Affine maps for test case: partial_fold_map -// CHECK-DAG: [[$MAP15:#map[0-9]+]] = affine_map<()[s0] -> (s0 - 42)> +// CHECK-DAG: [[$MAP15:#map[0-9]+]] = affine_map<() [s0] -> (s0 - 42)> // Affine maps for test cases: symbolic_composition_* -// CHECK-DAG: [[$MAP_symbolic_composition_a:#map[0-9]+]] = affine_map<()[s0] -> (s0 * 512)> -// CHECK-DAG: [[$MAP_symbolic_composition_b:#map[0-9]+]] = affine_map<()[s0] -> (s0 * 4)> -// CHECK-DAG: [[$MAP_symbolic_composition_c:#map[0-9]+]] = affine_map<()[s0, s1] -> (s0 * 3 + s1)> -// CHECK-DAG: [[$MAP_symbolic_composition_d:#map[0-9]+]] = affine_map<()[s0, s1] -> (s1 * 3 + s0)> +// CHECK-DAG: [[$MAP_symbolic_composition_a:#map[0-9]+]] = affine_map<() [s0] -> (s0 * 512)> +// CHECK-DAG: [[$MAP_symbolic_composition_b:#map[0-9]+]] = affine_map<() [s0] -> (s0 * 4)> +// CHECK-DAG: [[$MAP_symbolic_composition_c:#map[0-9]+]] = affine_map<() [s0, s1] -> (s0 * 3 + s1)> +// CHECK-DAG: [[$MAP_symbolic_composition_d:#map[0-9]+]] = affine_map<() [s0, s1] -> (s1 * 3 + s0)> // Affine maps for test cases: map_mix_dims_and_symbols_* -// CHECK-DAG: [[$MAP_mix_dims_and_symbols_b:#map[0-9]+]] = affine_map<()[s0, s1] -> (s1 + s0 * 42 + 6)> -// CHECK-DAG: [[$MAP_mix_dims_and_symbols_c:#map[0-9]+]] = affine_map<()[s0, s1] -> (s1 * 4 + s0 * 168 - 4)> -// CHECK-DAG: [[$MAP_mix_dims_and_symbols_d:#map[0-9]+]] = affine_map<()[s0, s1] -> ((s1 + s0 * 42 + 6) ceildiv 8)> -// CHECK-DAG: [[$MAP_mix_dims_and_symbols_e:#map[0-9]+]] = affine_map<()[s0, s1] -> ((s1 * 4 + s0 * 168 - 4) floordiv 3)> +// CHECK-DAG: [[$MAP_mix_dims_and_symbols_b:#map[0-9]+]] = affine_map<() [s0, s1] -> (s1 + s0 * 42 + 6)> +// CHECK-DAG: [[$MAP_mix_dims_and_symbols_c:#map[0-9]+]] = affine_map<() [s0, s1] -> (s1 * 4 + s0 * 168 - 4)> +// CHECK-DAG: [[$MAP_mix_dims_and_symbols_d:#map[0-9]+]] = affine_map<() [s0, s1] -> ((s1 + s0 * 42 + 6) ceildiv 8)> +// CHECK-DAG: [[$MAP_mix_dims_and_symbols_e:#map[0-9]+]] = affine_map<() [s0, s1] -> ((s1 * 4 + s0 * 168 - 4) floordiv 3)> // Affine maps for test case: $symbolic_semi_affine -// CHECK-DAG: [[$symbolic_semi_affine:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 floordiv (s0 + 1))> +// CHECK-DAG: [[$symbolic_semi_affine:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 floordiv (s0 + 1))> // CHECK-LABEL: func @compose_affine_maps_1dto2d_no_symbols() { func @compose_affine_maps_1dto2d_no_symbols() { @@ -89,7 +89,7 @@ affine.for %i0 = 0 to 15 { // Test load[%x0, %x0] with symbol %c4 %c4 = constant 4 : index - %x0 = affine.apply affine_map<(d0)[s0] -> (d0 - s0)> (%i0)[%c4] + %x0 = affine.apply affine_map<(d0) [s0] -> (d0 - s0)> (%i0) [%c4] // CHECK: [[I0:%[0-9]+]] = affine.apply [[$MAP4]](%{{.*}}) // CHECK-NEXT: [[V0:%[0-9]+]] = load %{{[0-9]+}}{{\[}}[[I0]], [[I0]]{{\]}} @@ -110,7 +110,7 @@ // Test store[%x2, %x0] with symbol %c4 from '%x0' and %c5 from '%x2' %c5 = constant 5 : index - %x2 = affine.apply affine_map<(d0)[s0] -> (d0 + s0)> (%i0)[%c5] + %x2 = affine.apply affine_map<(d0) [s0] -> (d0 + s0)> (%i0) [%c5] %y3 = affine.apply affine_map<(d0, d1) -> (d0 + d1)> (%x2, %x0) // CHECK: [[I3:%[0-9]+]] = affine.apply [[$MAP7a]](%{{.*}}) // CHECK-NEXT: store [[V0]], %{{[0-9]+}}{{\[}}[[I3]], [[I3]]{{\]}} @@ -128,18 +128,18 @@ %c8 = constant 8 : index affine.for %i0 = 0 to 3 { - %x0 = affine.apply affine_map<(d0)[s0] -> (d0 ceildiv s0)> (%i0)[%c4] + %x0 = affine.apply affine_map<(d0) [s0] -> (d0 ceildiv s0)> (%i0) [%c4] affine.for %i1 = 0 to 3 { - %x1 = affine.apply affine_map<(d0)[s0] -> (d0 ceildiv s0)> (%i1)[%c8] + %x1 = affine.apply affine_map<(d0) [s0] -> (d0 ceildiv s0)> (%i1) [%c8] affine.for %i2 = 0 to 3 { - %x2 = affine.apply affine_map<(d0)[s0] -> (d0 mod s0)> (%i2)[%c4] + %x2 = affine.apply affine_map<(d0) [s0] -> (d0 mod s0)> (%i2) [%c4] affine.for %i3 = 0 to 3 { - %x3 = affine.apply affine_map<(d0)[s0] -> (d0 mod s0)> (%i3)[%c8] + %x3 = affine.apply affine_map<(d0) [s0] -> (d0 mod s0)> (%i3) [%c8] - %x40 = affine.apply affine_map<(d0, d1, d2, d3)[s0, s1] -> - ((d0 * s0) + d2)> (%x0, %x1, %x2, %x3)[%c4, %c8] - %x41 = affine.apply affine_map<(d0, d1, d2, d3)[s0, s1] -> - ((d1 * s1) + d3)> (%x0, %x1, %x2, %x3)[%c4, %c8] + %x40 = affine.apply affine_map<(d0, d1, d2, d3) [s0, s1] -> + ((d0 * s0) + d2)> (%x0, %x1, %x2, %x3) [%c4, %c8] + %x41 = affine.apply affine_map<(d0, d1, d2, d3) [s0, s1] -> + ((d1 * s1) + d3)> (%x0, %x1, %x2, %x3) [%c4, %c8] // CHECK: [[I0:%[0-9]+]] = affine.apply [[$MAP8]](%{{.*}}, %{{.*}}) // CHECK: [[I1:%[0-9]+]] = affine.apply [[$MAP8a]](%{{.*}}, %{{.*}}) // CHECK-NEXT: [[L0:%[0-9]+]] = load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}} @@ -165,12 +165,12 @@ %c3 = constant 3 : index %c7 = constant 7 : index - %x00 = affine.apply affine_map<(d0, d1, d2)[s0, s1] -> (d0 + s0)> - (%i0, %i1, %i2)[%c3, %c7] - %x01 = affine.apply affine_map<(d0, d1, d2)[s0, s1] -> (d1 - s1)> - (%i0, %i1, %i2)[%c3, %c7] - %x02 = affine.apply affine_map<(d0, d1, d2)[s0, s1] -> (d2 * s0)> - (%i0, %i1, %i2)[%c3, %c7] + %x00 = affine.apply affine_map<(d0, d1, d2) [s0, s1] -> (d0 + s0)> + (%i0, %i1, %i2) [%c3, %c7] + %x01 = affine.apply affine_map<(d0, d1, d2) [s0, s1] -> (d1 - s1)> + (%i0, %i1, %i2) [%c3, %c7] + %x02 = affine.apply affine_map<(d0, d1, d2) [s0, s1] -> (d2 * s0)> + (%i0, %i1, %i2) [%c3, %c7] // CHECK: [[I0:%[0-9]+]] = affine.apply [[$MAP9]](%{{.*}}) // CHECK: [[I1:%[0-9]+]] = affine.apply [[$MAP4b]](%{{.*}}) @@ -186,10 +186,10 @@ store %v0, %0[%x01, %x00] : memref<16x32xf32> // Swizzle %x00, %x01 and %c3, %c7 - %x10 = affine.apply affine_map<(d0, d1)[s0, s1] -> (d0 * s1)> - (%x01, %x00)[%c3, %c7] - %x11 = affine.apply affine_map<(d0, d1)[s0, s1] -> (d1 ceildiv s0)> - (%x01, %x00)[%c3, %c7] + %x10 = affine.apply affine_map<(d0, d1) [s0, s1] -> (d0 * s1)> + (%x01, %x00) [%c3, %c7] + %x11 = affine.apply affine_map<(d0, d1) [s0, s1] -> (d1 ceildiv s0)> + (%x01, %x00) [%c3, %c7] // CHECK-NEXT: [[I2A:%[0-9]+]] = affine.apply [[$MAP12]](%{{.*}}) // CHECK-NEXT: [[I2B:%[0-9]+]] = affine.apply [[$MAP11]](%{{.*}}) @@ -225,8 +225,8 @@ %2 = alloc() : memref<1xi32> affine.for %i0 = 0 to 100 { affine.for %i1 = 0 to 100 { - %3 = affine.apply affine_map<(d0, d1)[s0, s1] -> (d1 + s0 + s1)> - (%i0, %i1)[%arg1, %c9] + %3 = affine.apply affine_map<(d0, d1) [s0, s1] -> (d1 + s0 + s1)> + (%i0, %i1) [%arg1, %c9] %4 = affine.apply affine_map<(d0, d1, d3) -> (d3 - (d0 + d1))> (%arg1, %c9, %3) // CHECK: store %arg2, %{{[0-9]+}}{{\[}}%{{.*}}, %{{.*}}{{\]}} @@ -244,11 +244,11 @@ %c0 = constant 0 : index %cst = constant 0.000000e+00 : f32 affine.for %i1 = 0 to 10 { - %1 = affine.apply affine_map<()[s0] -> (s0)>()[%c0] + %1 = affine.apply affine_map<() [s0] -> (s0)>() [%c0] store %cst, %0[%1] : memref<10xf32> %2 = load %0[%c0] : memref<10xf32> - %3 = affine.apply affine_map<()[] -> (0)>()[] + %3 = affine.apply affine_map<() [] -> (0)>() [] store %cst, %0[%3] : memref<10xf32> store %2, %0[%c0] : memref<10xf32> } @@ -260,24 +260,24 @@ // TODO: Constant fold one index into affine.apply %c42 = constant 42 : index %2 = affine.apply affine_map<(d0, d1) -> (d0 - d1)> (%arg1, %c42) - // CHECK: [[X:%[0-9]+]] = affine.apply [[$MAP15]]()[%{{.*}}] + // CHECK: [[X:%[0-9]+]] = affine.apply [[$MAP15]]() [%{{.*}}] return %2 : index } // CHECK-LABEL: func @symbolic_composition_a(%{{.*}}: index, %{{.*}}: index) -> index { func @symbolic_composition_a(%arg0: index, %arg1: index) -> index { %0 = affine.apply affine_map<(d0) -> (d0 * 4)>(%arg0) - %1 = affine.apply affine_map<()[s0, s1] -> (8 * s0)>()[%0, %arg0] - %2 = affine.apply affine_map<()[s0, s1] -> (16 * s1)>()[%arg1, %1] - // CHECK: %{{.*}} = affine.apply [[$MAP_symbolic_composition_a]]()[%{{.*}}] + %1 = affine.apply affine_map<() [s0, s1] -> (8 * s0)>() [%0, %arg0] + %2 = affine.apply affine_map<() [s0, s1] -> (16 * s1)>() [%arg1, %1] + // CHECK: %{{.*}} = affine.apply [[$MAP_symbolic_composition_a]]() [%{{.*}}] return %2 : index } // CHECK-LABEL: func @symbolic_composition_b(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index { func @symbolic_composition_b(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index { %0 = affine.apply affine_map<(d0) -> (d0)>(%arg0) - %1 = affine.apply affine_map<()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)>()[%0, %0, %0, %0] - // CHECK: %{{.*}} = affine.apply [[$MAP_symbolic_composition_b]]()[%{{.*}}] + %1 = affine.apply affine_map<() [s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)>() [%0, %0, %0, %0] + // CHECK: %{{.*}} = affine.apply [[$MAP_symbolic_composition_b]]() [%{{.*}}] return %1 : index } @@ -285,68 +285,68 @@ func @symbolic_composition_c(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index { %0 = affine.apply affine_map<(d0) -> (d0)>(%arg0) %1 = affine.apply affine_map<(d0) -> (d0)>(%arg1) - %2 = affine.apply affine_map<()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)>()[%0, %0, %0, %1] - // CHECK: %{{.*}} = affine.apply [[$MAP_symbolic_composition_c]]()[%{{.*}}, %{{.*}}] + %2 = affine.apply affine_map<() [s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)>() [%0, %0, %0, %1] + // CHECK: %{{.*}} = affine.apply [[$MAP_symbolic_composition_c]]() [%{{.*}}, %{{.*}}] return %2 : index } // CHECK-LABEL: func @symbolic_composition_d(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index { func @symbolic_composition_d(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index { %0 = affine.apply affine_map<(d0) -> (d0)>(%arg0) - %1 = affine.apply affine_map<()[s0] -> (s0)>()[%arg1] - %2 = affine.apply affine_map<()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)>()[%0, %0, %0, %1] - // CHECK: %{{.*}} = affine.apply [[$MAP_symbolic_composition_d]]()[%{{.*}}, %{{.*}}] + %1 = affine.apply affine_map<() [s0] -> (s0)>() [%arg1] + %2 = affine.apply affine_map<() [s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)>() [%0, %0, %0, %1] + // CHECK: %{{.*}} = affine.apply [[$MAP_symbolic_composition_d]]() [%{{.*}}, %{{.*}}] return %2 : index } // CHECK-LABEL: func @mix_dims_and_symbols_b(%arg0: index, %arg1: index) -> index { func @mix_dims_and_symbols_b(%arg0: index, %arg1: index) -> index { - %a = affine.apply affine_map<(d0)[s0] -> (d0 - 1 + 42 * s0)> (%arg0)[%arg1] + %a = affine.apply affine_map<(d0) [s0] -> (d0 - 1 + 42 * s0)> (%arg0) [%arg1] %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a) - // CHECK: {{.*}} = affine.apply [[$MAP_mix_dims_and_symbols_b]]()[%{{.*}}, %{{.*}}] + // CHECK: {{.*}} = affine.apply [[$MAP_mix_dims_and_symbols_b]]() [%{{.*}}, %{{.*}}] return %b : index } // CHECK-LABEL: func @mix_dims_and_symbols_c(%arg0: index, %arg1: index) -> index { func @mix_dims_and_symbols_c(%arg0: index, %arg1: index) -> index { - %a = affine.apply affine_map<(d0)[s0] -> (d0 - 1 + 42 * s0)> (%arg0)[%arg1] + %a = affine.apply affine_map<(d0) [s0] -> (d0 - 1 + 42 * s0)> (%arg0) [%arg1] %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a) %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a) - // CHECK: {{.*}} = affine.apply [[$MAP_mix_dims_and_symbols_c]]()[%{{.*}}, %{{.*}}] + // CHECK: {{.*}} = affine.apply [[$MAP_mix_dims_and_symbols_c]]() [%{{.*}}, %{{.*}}] return %c : index } // CHECK-LABEL: func @mix_dims_and_symbols_d(%arg0: index, %arg1: index) -> index { func @mix_dims_and_symbols_d(%arg0: index, %arg1: index) -> index { - %a = affine.apply affine_map<(d0)[s0] -> (d0 - 1 + 42 * s0)> (%arg0)[%arg1] + %a = affine.apply affine_map<(d0) [s0] -> (d0 - 1 + 42 * s0)> (%arg0) [%arg1] %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a) %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a) - %d = affine.apply affine_map<()[s0] -> (s0 ceildiv 8)> ()[%b] - // CHECK: {{.*}} = affine.apply [[$MAP_mix_dims_and_symbols_d]]()[%{{.*}}, %{{.*}}] + %d = affine.apply affine_map<() [s0] -> (s0 ceildiv 8)> () [%b] + // CHECK: {{.*}} = affine.apply [[$MAP_mix_dims_and_symbols_d]]() [%{{.*}}, %{{.*}}] return %d : index } // CHECK-LABEL: func @mix_dims_and_symbols_e(%arg0: index, %arg1: index) -> index { func @mix_dims_and_symbols_e(%arg0: index, %arg1: index) -> index { - %a = affine.apply affine_map<(d0)[s0] -> (d0 - 1 + 42 * s0)> (%arg0)[%arg1] + %a = affine.apply affine_map<(d0) [s0] -> (d0 - 1 + 42 * s0)> (%arg0) [%arg1] %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a) %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a) - %d = affine.apply affine_map<()[s0] -> (s0 ceildiv 8)> ()[%b] + %d = affine.apply affine_map<() [s0] -> (s0 ceildiv 8)> () [%b] %e = affine.apply affine_map<(d0) -> (d0 floordiv 3)> (%c) - // CHECK: {{.*}} = affine.apply [[$MAP_mix_dims_and_symbols_e]]()[%{{.*}}, %{{.*}}] + // CHECK: {{.*}} = affine.apply [[$MAP_mix_dims_and_symbols_e]]() [%{{.*}}, %{{.*}}] return %e : index } // CHECK-LABEL: func @mix_dims_and_symbols_f(%arg0: index, %arg1: index) -> index { func @mix_dims_and_symbols_f(%arg0: index, %arg1: index) -> index { - %a = affine.apply affine_map<(d0)[s0] -> (d0 - 1 + 42 * s0)> (%arg0)[%arg1] + %a = affine.apply affine_map<(d0) [s0] -> (d0 - 1 + 42 * s0)> (%arg0) [%arg1] %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a) %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a) - %d = affine.apply affine_map<()[s0] -> (s0 ceildiv 8)> ()[%b] + %d = affine.apply affine_map<() [s0] -> (s0 ceildiv 8)> () [%b] %e = affine.apply affine_map<(d0) -> (d0 floordiv 3)> (%c) - %f = affine.apply affine_map<(d0, d1)[s0, s1] -> (d0 - s1 + d1 - s0)> (%d, %e)[%e, %d] + %f = affine.apply affine_map<(d0, d1) [s0, s1] -> (d0 - s1 + d1 - s0)> (%d, %e) [%e, %d] // CHECK: {{.*}} = constant 0 : index return %f : index @@ -355,12 +355,12 @@ // CHECK-LABEL: func @mix_dims_and_symbols_g(%arg0: index, %arg1: index) -> (index, index, index) { func @mix_dims_and_symbols_g(%M: index, %N: index) -> (index, index, index) { %K = affine.apply affine_map<(d0) -> (4*d0)> (%M) - %res1 = affine.apply affine_map<()[s0, s1] -> (4 * s0)>()[%N, %K] - %res2 = affine.apply affine_map<()[s0, s1] -> (s1)>()[%N, %K] - %res3 = affine.apply affine_map<()[s0, s1] -> (1024)>()[%N, %K] + %res1 = affine.apply affine_map<() [s0, s1] -> (4 * s0)>() [%N, %K] + %res2 = affine.apply affine_map<() [s0, s1] -> (s1)>() [%N, %K] + %res3 = affine.apply affine_map<() [s0, s1] -> (1024)>() [%N, %K] // CHECK-DAG: {{.*}} = constant 1024 : index - // CHECK-DAG: {{.*}} = affine.apply [[$MAP_symbolic_composition_b]]()[%{{.*}}] - // CHECK-DAG: {{.*}} = affine.apply [[$MAP_symbolic_composition_b]]()[%{{.*}}] + // CHECK-DAG: {{.*}} = affine.apply [[$MAP_symbolic_composition_b]]() [%{{.*}}] + // CHECK-DAG: {{.*}} = affine.apply [[$MAP_symbolic_composition_b]]() [%{{.*}}] return %res1, %res2, %res3 : index, index, index } @@ -368,9 +368,9 @@ func @symbolic_semi_affine(%M: index, %N: index, %A: memref) { %f1 = constant 1.0 : f32 affine.for %i0 = 1 to 100 { - %1 = affine.apply affine_map<()[s0] -> (s0 + 1)> ()[%M] - %2 = affine.apply affine_map<(d0)[s0] -> (d0 floordiv s0)> (%i0)[%1] - // CHECK-DAG: {{.*}} = affine.apply [[$symbolic_semi_affine]](%{{.*}})[%{{.*}}] + %1 = affine.apply affine_map<() [s0] -> (s0 + 1)> () [%M] + %2 = affine.apply affine_map<(d0) [s0] -> (d0 floordiv s0)> (%i0) [%1] + // CHECK-DAG: {{.*}} = affine.apply [[$symbolic_semi_affine]](%{{.*}}) [%{{.*}}] store %f1, %A[%2] : memref } return @@ -378,8 +378,8 @@ // ----- -// CHECK: [[$MAP0:#map[0-9]+]] = affine_map<()[s0] -> (0, s0)> -// CHECK: [[$MAP1:#map[0-9]+]] = affine_map<()[s0] -> (100, s0)> +// CHECK: [[$MAP0:#map[0-9]+]] = affine_map<() [s0] -> (0, s0)> +// CHECK: [[$MAP1:#map[0-9]+]] = affine_map<() [s0] -> (100, s0)> // CHECK-LABEL: func @constant_fold_bounds(%arg0: index) { func @constant_fold_bounds(%N : index) { @@ -403,8 +403,8 @@ } // None of the bounds can be folded. - // CHECK: affine.for %{{.*}} = max [[$MAP0]]()[%{{.*}}] to min [[$MAP1]]()[%{{.*}}] { - affine.for %k = max affine_map<()[s0] -> (0, s0)> ()[%l] to min affine_map<()[s0] -> (100, s0)> ()[%N] { + // CHECK: affine.for %{{.*}} = max [[$MAP0]]() [%{{.*}}] to min [[$MAP1]]() [%{{.*}}] { + affine.for %k = max affine_map<() [s0] -> (0, s0)> () [%l] to min affine_map<() [s0] -> (100, s0)> () [%N] { "foo"(%k, %c3) : (index, index) -> () } return @@ -433,8 +433,8 @@ // Drop unused operand %M, propagate %c1022, and promote %N to symbolic. affine.for %i = 0 to 1024 { affine.for %j = 0 to %N { - // CHECK: affine.if [[$SET]](%{{.*}}, %{{.*}}){{\[}}[[N]]{{\]}} - affine.if affine_set<(d0, d1, d2, d3)[s0] : (d1 >= 0, d0 - d1 >= 0, d2 >= 0, d3 - d2 - 2 >= 0)> (%c1022, %i, %j, %N)[%M] { + // CHECK: affine.if [[$SET]](%{{.*}}, %{{.*}}) {{\[}}[[N]]{{\]}} + affine.if affine_set<(d0, d1, d2, d3) [s0] : (d1 >= 0, d0 - d1 >= 0, d2 >= 0, d3 - d2 - 2 >= 0)> (%c1022, %i, %j, %N) [%M] { "foo"() : () -> () } "bar"() : () -> () @@ -445,8 +445,8 @@ // ----- -// CHECK-DAG: [[$LBMAP:#map[0-9]+]] = affine_map<()[s0] -> (0, s0)> -// CHECK-DAG: [[$UBMAP:#map[0-9]+]] = affine_map<()[s0] -> (1024, s0 * 2)> +// CHECK-DAG: [[$LBMAP:#map[0-9]+]] = affine_map<() [s0] -> (0, s0)> +// CHECK-DAG: [[$UBMAP:#map[0-9]+]] = affine_map<() [s0] -> (1024, s0 * 2)> // CHECK-LABEL: func @canonicalize_bounds // CHECK-SAME: [[M:%.*]]: index, @@ -456,17 +456,17 @@ %c1024 = constant 1024 : index // Drop unused operand %N, drop duplicate operand %M, propagate %c1024, and // promote %M to a symbolic one. - // CHECK: affine.for %{{.*}} = 0 to min [[$UBMAP]](){{\[}}[[M]]{{\]}} + // CHECK: affine.for %{{.*}} = 0 to min [[$UBMAP]]() {{\[}}[[M]]{{\]}} affine.for %i = 0 to min affine_map<(d0, d1, d2, d3) -> (d0, d1 + d2)> (%c1024, %M, %M, %N) { "foo"() : () -> () } // Promote %M to symbolic position. - // CHECK: affine.for %{{.*}} = 0 to #map{{[0-9]+}}(){{\[}}[[M]]{{\]}} + // CHECK: affine.for %{{.*}} = 0 to #map{{[0-9]+}}() {{\[}}[[M]]{{\]}} affine.for %i = 0 to affine_map<(d0) -> (4 * d0)> (%M) { "foo"() : () -> () } // Lower bound canonicalize. - // CHECK: affine.for %{{.*}} = max [[$LBMAP]](){{\[}}[[N]]{{\]}} to [[M]] + // CHECK: affine.for %{{.*}} = max [[$LBMAP]]() {{\[}}[[N]]{{\]}} to [[M]] affine.for %i = max affine_map<(d0, d1) -> (d0, d1)> (%c0, %N) to %M { "foo"() : () -> () } @@ -504,7 +504,7 @@ func @affine_min(%arg0 : index, %arg1 : index, %arg2 : index) { %c511 = constant 511 : index %c1 = constant 0 : index - %0 = affine.min affine_map<(d0)[s0] -> (1000, d0 + 512, s0 + 1)> (%c1)[%c511] + %0 = affine.min affine_map<(d0) [s0] -> (1000, d0 + 512, s0 + 1)> (%c1) [%c511] "op0"(%0) : (index) -> () // CHECK: %[[CST:.*]] = constant 512 : index // CHECK-NEXT: "op0"(%[[CST]]) : (index) -> () @@ -517,7 +517,7 @@ func @affine_min(%arg0 : index, %arg1 : index, %arg2 : index) { %c3 = constant 3 : index %c20 = constant 20 : index - %0 = affine.min affine_map<(d0)[s0] -> (1000, d0 floordiv 4, (s0 mod 5) + 1)> (%c20)[%c3] + %0 = affine.min affine_map<(d0) [s0] -> (1000, d0 floordiv 4, (s0 mod 5) + 1)> (%c20) [%c3] "op0"(%0) : (index) -> () // CHECK: %[[CST:.*]] = constant 4 : index // CHECK-NEXT: "op0"(%[[CST]]) : (index) -> () @@ -530,7 +530,7 @@ func @affine_max(%arg0 : index, %arg1 : index, %arg2 : index) { %c511 = constant 511 : index %c1 = constant 0 : index - %0 = affine.max affine_map<(d0)[s0] -> (1000, d0 + 512, s0 + 1)> (%c1)[%c511] + %0 = affine.max affine_map<(d0) [s0] -> (1000, d0 + 512, s0 + 1)> (%c1) [%c511] "op0"(%0) : (index) -> () // CHECK: %[[CST:.*]] = constant 1000 : index // CHECK-NEXT: "op0"(%[[CST]]) : (index) -> () @@ -543,7 +543,7 @@ func @affine_max(%arg0 : index, %arg1 : index, %arg2 : index) { %c3 = constant 3 : index %c20 = constant 20 : index - %0 = affine.max affine_map<(d0)[s0] -> (1000, d0 floordiv 4, (s0 mod 5) + 1)> (%c20)[%c3] + %0 = affine.max affine_map<(d0) [s0] -> (1000, d0 floordiv 4, (s0 mod 5) + 1)> (%c20) [%c3] "op0"(%0) : (index) -> () // CHECK: %[[CST:.*]] = constant 1000 : index // CHECK-NEXT: "op0"(%[[CST]]) : (index) -> () @@ -575,10 +575,10 @@ // it is composed with, e.g. A.compose(B) will first have all symbols of A, // then all symbols of B. -#map1 = affine_map<(d0)[s0, s1] -> (d0 * s0 + s1)> -#map2 = affine_map<(d0)[s0] -> (1024, -d0 + s0)> +#map1 = affine_map<(d0) [s0, s1] -> (d0 * s0 + s1)> +#map2 = affine_map<(d0) [s0] -> (1024, -d0 + s0)> -// CHECK: #[[$MAP:.*]] = affine_map<()[s0, s1] -> (1024, s1 * -1024 + s0)> +// CHECK: #[[$MAP:.*]] = affine_map<() [s0, s1] -> (1024, s1 * -1024 + s0)> // CHECK: func @rep(%[[ARG0:.*]]: index, %[[ARG1:.*]]: index) func @rep(%arg0 : index, %arg1 : index) -> index { @@ -586,16 +586,16 @@ %c0 = constant 0 : index %c1024 = constant 1024 : index // CHECK-NOT: affine.apply - %0 = affine.apply #map1(%arg0)[%c1024, %c0] + %0 = affine.apply #map1(%arg0) [%c1024, %c0] - // CHECK: affine.min #[[$MAP]]()[%[[ARG1]], %[[ARG0]]] - %1 = affine.min #map2(%0)[%arg1] + // CHECK: affine.min #[[$MAP]]() [%[[ARG1]], %[[ARG0]]] + %1 = affine.min #map2(%0) [%arg1] return %1 : index } // ----- -// CHECK-DAG: #[[lb:.*]] = affine_map<()[s0] -> (s0)> -// CHECK-DAG: #[[ub:.*]] = affine_map<()[s0] -> (s0 + 2)> +// CHECK-DAG: #[[lb:.*]] = affine_map<() [s0] -> (s0)> +// CHECK-DAG: #[[ub:.*]] = affine_map<() [s0] -> (s0 + 2)> func @drop_duplicate_bounds(%N : index) { // affine.for %i = max #lb(%arg0) to min #ub(%arg0) diff --git a/mlir/test/Dialect/Affine/constant-fold.mlir b/mlir/test/Dialect/Affine/constant-fold.mlir --- a/mlir/test/Dialect/Affine/constant-fold.mlir +++ b/mlir/test/Dialect/Affine/constant-fold.mlir @@ -8,10 +8,10 @@ // CHECK:[[C1159:%.+]] = constant 1159 : index // CHECK:[[C1152:%.+]] = constant 1152 : index - %x0 = affine.apply affine_map<(d0, d1)[S0] -> ( (d0 + 128 * S0) floordiv 128 + d1 mod 128)> - (%c177, %c211)[%N] - %x1 = affine.apply affine_map<(d0, d1)[S0] -> (128 * (S0 ceildiv 128))> - (%c177, %c211)[%N] + %x0 = affine.apply affine_map<(d0, d1) [S0] -> ( (d0 + 128 * S0) floordiv 128 + d1 mod 128)> + (%c177, %c211) [%N] + %x1 = affine.apply affine_map<(d0, d1) [S0] -> (128 * (S0 ceildiv 128))> + (%c177, %c211) [%N] // CHECK:[[C42:%.+]] = constant 42 : index %y = affine.apply affine_map<(d0) -> (42)> (%variable) diff --git a/mlir/test/Dialect/Affine/dma-generate.mlir b/mlir/test/Dialect/Affine/dma-generate.mlir --- a/mlir/test/Dialect/Affine/dma-generate.mlir +++ b/mlir/test/Dialect/Affine/dma-generate.mlir @@ -215,7 +215,7 @@ // CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<1x100xf32, 2>, // CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32> affine.for %i = 0 to 100 { - affine.for %j = 0 to affine_map<()[s0] -> (s0)> ()[%N] { + affine.for %j = 0 to affine_map<() [s0] -> (s0)> () [%N] { // CHECK: affine.load %{{.*}}[0, %{{.*}}] : memref<1x100xf32, 2> affine.load %A[%one, %j] : memref<100 x 100 x f32> } @@ -230,7 +230,7 @@ %N = constant 9 : index affine.for %i = 0 to 100 { affine.for %j = 0 to 100 { - %idy = affine.apply affine_map<(d0, d1) [s0, s1] -> (d1 + s0 + s1)>(%i, %j)[%M, %N] + %idy = affine.apply affine_map<(d0, d1) [s0, s1] -> (d1 + s0 + s1)>(%i, %j) [%M, %N] affine.load %A[%i, %idy] : memref<100 x 100 x f32> } } @@ -260,7 +260,7 @@ // CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32> affine.for %i = 0 to 100 { affine.for %j = %M to %N { - %idy = affine.apply affine_map<(d1) [s0] -> (d1 + s0)>(%j)[%K] + %idy = affine.apply affine_map<(d1) [s0] -> (d1 + s0)>(%j) [%K] affine.load %A[%i, %idy] : memref<100 x 100 x f32> } } diff --git a/mlir/test/Dialect/Affine/dma.mlir b/mlir/test/Dialect/Affine/dma.mlir --- a/mlir/test/Dialect/Affine/dma.mlir +++ b/mlir/test/Dialect/Affine/dma.mlir @@ -75,8 +75,8 @@ // ----- -// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0, d1 + s0 + 7)> -// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 + s0, d1)> +// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) [s0] -> (d0, d1 + s0 + 7)> +// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) [s0] -> (d0 + s0, d1)> // CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + d1 + 11)> // Test with loop IVs and symbols (with symbol keyword). @@ -102,8 +102,8 @@ // ----- -// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0, (d1 + s0) mod 9 + 7)> -// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> ((d0 + s0) floordiv 3, d1)> +// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) [s0] -> (d0, (d1 + s0) mod 9 + 7)> +// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) [s0] -> ((d0 + s0) floordiv 3, d1)> // CHECK: [[MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + d1 + 11)> // Test with loop IVs, symbols and constants in nested affine expressions. diff --git a/mlir/test/Dialect/Affine/inlining.mlir b/mlir/test/Dialect/Affine/inlining.mlir --- a/mlir/test/Dialect/Affine/inlining.mlir +++ b/mlir/test/Dialect/Affine/inlining.mlir @@ -4,8 +4,8 @@ func @func_with_affine_ops(%N: index) { %c = constant 200 : index affine.for %i = 1 to 10 { - affine.if affine_set<(i)[N] : (i - 2 >= 0, 4 - i >= 0)>(%i)[%c] { - %w = affine.apply affine_map<(d0,d1)[s0] -> (d0+d1+s0)> (%i, %i) [%N] + affine.if affine_set<(i)[ N] : (i - 2 >= 0, 4 - i >= 0)>(%i) [%c] { + %w = affine.apply affine_map<(d0,d1) [s0] -> (d0+d1+s0)> (%i, %i) [%N] } } return diff --git a/mlir/test/Dialect/Affine/invalid.mlir b/mlir/test/Dialect/Affine/invalid.mlir --- a/mlir/test/Dialect/Affine/invalid.mlir +++ b/mlir/test/Dialect/Affine/invalid.mlir @@ -22,14 +22,14 @@ // ----- -#map = affine_map<(d0)[s0] -> (d0 + s0)> +#map = affine_map<(d0) [s0] -> (d0 + s0)> func @affine_for_lower_bound_invalid_dim(%arg : index) { affine.for %n0 = 0 to 7 { %dim = addi %arg, %arg : index // expected-error@+1 {{operand cannot be used as a dimension id}} - affine.for %n1 = 0 to #map(%dim)[%arg] { + affine.for %n1 = 0 to #map(%dim) [%arg] { } } return @@ -37,14 +37,14 @@ // ----- -#map = affine_map<(d0)[s0] -> (d0 + s0)> +#map = affine_map<(d0) [s0] -> (d0 + s0)> func @affine_for_upper_bound_invalid_dim(%arg : index) { affine.for %n0 = 0 to 7 { %dim = addi %arg, %arg : index // expected-error@+1 {{operand cannot be used as a dimension id}} - affine.for %n1 = #map(%dim)[%arg] to 7 { + affine.for %n1 = #map(%dim) [%arg] to 7 { } } return @@ -65,12 +65,12 @@ // ----- -#map0 = affine_map<(d0)[s0] -> (d0 + s0)> +#map0 = affine_map<(d0) [s0] -> (d0 + s0)> func @affine_for_lower_bound_invalid_sym() { affine.for %i0 = 0 to 7 { // expected-error@+1 {{operand cannot be used as a symbol}} - affine.for %n0 = #map0(%i0)[%i0] to 7 { + affine.for %n0 = #map0(%i0) [%i0] to 7 { } } return @@ -78,12 +78,12 @@ // ----- -#map0 = affine_map<(d0)[s0] -> (d0 + s0)> +#map0 = affine_map<(d0) [s0] -> (d0 + s0)> func @affine_for_upper_bound_invalid_sym() { affine.for %i0 = 0 to 7 { // expected-error@+1 {{operand cannot be used as a symbol}} - affine.for %n0 = 0 to #map0(%i0)[%i0] { + affine.for %n0 = 0 to #map0(%i0) [%i0] { } } return @@ -98,7 +98,7 @@ %dim = addi %arg, %arg : index // expected-error@+1 {{operand cannot be used as a dimension id}} - affine.if #set0(%dim)[%n0] {} + affine.if #set0(%dim) [%n0] {} } return } @@ -110,7 +110,7 @@ func @affine_if_invalid_sym() { affine.for %i0 = 0 to 7 { // expected-error@+1 {{operand cannot be used as a symbol}} - affine.if #set0(%i0)[%i0] {} + affine.if #set0(%i0) [%i0] {} } return } @@ -126,7 +126,7 @@ %dim = dim %0, %c0 : memref // expected-error@+1 {{operand cannot be used as a symbol}} - affine.if #set0(%dim)[%n0] {} + affine.if #set0(%dim) [%n0] {} } return } @@ -153,7 +153,7 @@ func @affine_min(%arg0 : index, %arg1 : index, %arg2 : index) { // expected-error@+1 {{operand count and affine map dimension and symbol count must match}} - %0 = affine.min affine_map<()[s0] -> (s0)> (%arg0, %arg1) + %0 = affine.min affine_map<() [s0] -> (s0)> (%arg0, %arg1) return } @@ -180,7 +180,7 @@ func @affine_max(%arg0 : index, %arg1 : index, %arg2 : index) { // expected-error@+1 {{operand count and affine map dimension and symbol count must match}} - %0 = affine.max affine_map<()[s0] -> (s0)> (%arg0, %arg1) + %0 = affine.max affine_map<() [s0] -> (s0)> (%arg0, %arg1) return } @@ -338,9 +338,9 @@ %c = constant 200 : index %i = constant 20: index // expected-error@+1 {{affine.if' op region #0 should have no arguments}} - affine.if affine_set<(i)[N] : (i - 2 >= 0, 4 - i >= 0)>(%i)[%c] { + affine.if affine_set<(i) [N] : (i - 2 >= 0, 4 - i >= 0)>(%i) [%c] { ^bb0(%arg:i32): - %w = affine.apply affine_map<(d0,d1)[s0] -> (d0+d1+s0)> (%i, %i) [%N] + %w = affine.apply affine_map<(d0,d1) [s0] -> (d0+d1+s0)> (%i, %i) [%N] } return } @@ -351,11 +351,11 @@ %c = constant 200 : index %i = constant 20: index // expected-error@+1 {{affine.if' op region #1 should have no arguments}} - affine.if affine_set<(i)[N] : (i - 2 >= 0, 4 - i >= 0)>(%i)[%c] { - %w = affine.apply affine_map<(d0,d1)[s0] -> (d0+d1+s0)> (%i, %i) [%N] + affine.if affine_set<(i) [N] : (i - 2 >= 0, 4 - i >= 0)>(%i) [%c] { + %w = affine.apply affine_map<(d0,d1) [s0] -> (d0+d1+s0)> (%i, %i) [%N] } else { ^bb0(%arg:i32): - %w = affine.apply affine_map<(d0,d1)[s0] -> (d0-d1+s0)> (%i, %i) [%N] + %w = affine.apply affine_map<(d0,d1) [s0] -> (d0-d1+s0)> (%i, %i) [%N] } return } diff --git a/mlir/test/Dialect/Affine/load-store.mlir b/mlir/test/Dialect/Affine/load-store.mlir --- a/mlir/test/Dialect/Affine/load-store.mlir +++ b/mlir/test/Dialect/Affine/load-store.mlir @@ -55,7 +55,7 @@ // ----- -// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d0 + s0, d1 + s1)> +// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) [s0, s1] -> (d0 + s0, d1 + s1)> // Test with loop IVs and function args with 'symbol' keyword (should // be parsed as symbol identifiers). @@ -76,7 +76,7 @@ // ----- -// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> ((d0 + s0) floordiv 3 + 11, (d1 + s1) mod 4 + 7)> +// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) [s0, s1] -> ((d0 + s0) floordiv 3 + 11, (d1 + s1) mod 4 + 7)> // Test with loop IVs, symbols and constants in nested affine expressions. func @test4(%arg0 : index, %arg1 : index) { @@ -140,7 +140,7 @@ // ----- -// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1] -> (d0 + s0, d1 + d2, d2 + s0 + s1)> +// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2) [s0, s1] -> (d0 + s0, d1 + d2, d2 + s0 + s1)> // Test with swizzled loop IVs, duplicate args, and function args used as syms. // Dim and symbol identifiers are assigned in parse order: diff --git a/mlir/test/Dialect/Affine/loop-tiling-parametric.mlir b/mlir/test/Dialect/Affine/loop-tiling-parametric.mlir --- a/mlir/test/Dialect/Affine/loop-tiling-parametric.mlir +++ b/mlir/test/Dialect/Affine/loop-tiling-parametric.mlir @@ -7,13 +7,13 @@ // ----- -// CHECK-DAG: [[LBI:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0)> -// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0 + s0, 256)> -// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0 + s0, 512)> -// CHECK-DAG: [[UBI2:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0 + s0, 1024)> -// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<()[s0] -> (256 ceildiv s0)> -// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<()[s0] -> (512 ceildiv s0)> -// CHECK-DAG: [[UBO2:#map[0-9]+]] = affine_map<()[s0] -> (1024 ceildiv s0)> +// CHECK-DAG: [[LBI:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0)> +// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0 + s0, 256)> +// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0 + s0, 512)> +// CHECK-DAG: [[UBI2:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0 + s0, 1024)> +// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<() [s0] -> (256 ceildiv s0)> +// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<() [s0] -> (512 ceildiv s0)> +// CHECK-DAG: [[UBO2:#map[0-9]+]] = affine_map<() [s0] -> (1024 ceildiv s0)> // CHECK: func @loop_tiling_3d([[ARG0:%arg[0-9]+]]: index, [[ARG1:%arg[0-9]+]]: index, [[ARG2:%arg[0-9]+]]: index) // CHECK-NEXT: affine.for [[ARG3:%arg[0-9]+]] = 0 to [[UBO0]](){{.*}}[[ARG0]] @@ -36,13 +36,13 @@ // ----- -// CHECK-DAG: [[LBI:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0)> -// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0 + s0 * 4, 256)> -// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0 + s0 * 3, 512)> -// CHECK-DAG: [[UBI2:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0 + s0 * 2, 1024)> -// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<()[s0] -> (256 ceildiv s0)> -// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<()[s0] -> (512 ceildiv s0)> -// CHECK-DAG: [[UBO2:#map[0-9]+]] = affine_map<()[s0] -> (1024 ceildiv s0)> +// CHECK-DAG: [[LBI:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0)> +// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0 + s0 * 4, 256)> +// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0 + s0 * 3, 512)> +// CHECK-DAG: [[UBI2:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0 + s0 * 2, 1024)> +// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<() [s0] -> (256 ceildiv s0)> +// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<() [s0] -> (512 ceildiv s0)> +// CHECK-DAG: [[UBO2:#map[0-9]+]] = affine_map<() [s0] -> (1024 ceildiv s0)> // CHECK: func @loop_tiling_non_unit_step([[ARG0:%arg[0-9]+]]: index, [[ARG1:%arg[0-9]+]]: index, [[ARG2:%arg[0-9]+]]: index) // CHECK-NEXT: affine.for [[ARG3:%arg[0-9]+]] = 0 to [[UBO0]](){{.*}}[[ARG0]]{{.*}}step 4 @@ -65,52 +65,52 @@ // ----- -// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0)> -// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0)[s0, s1, s2] -> (d0 * s2 + s2, s0, 4096 floordiv s1)> -// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<()[s0, s1, s2] -> (s0 ceildiv s2, (4096 floordiv s1) ceildiv s2)> +// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0)> +// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0) [s0, s1, s2] -> (d0 * s2 + s2, s0, 4096 floordiv s1)> +// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<() [s0, s1, s2] -> (s0 ceildiv s2, (4096 floordiv s1) ceildiv s2)> // CHECK: func @tile_loop_with_div_in_upper_bound([[ARG0:%arg[0-9]+]]: index, %{{.*}}: memref, %{{.*}}: index, %{{.*}}: index) -#ub = affine_map<()[s0, s1] -> (s0, 4096 floordiv s1)> +#ub = affine_map<() [s0, s1] -> (s0, 4096 floordiv s1)> func @tile_loop_with_div_in_upper_bound(%t5 : index, %A : memref, %L : index, %U : index) { %c0 = constant 0 : index %M = dim %A, %c0 : memref - affine.for %i = 0 to min #ub()[%M, %U] { + affine.for %i = 0 to min #ub() [%M, %U] { addi %i, %i : index } - // CHECK: affine.for [[ARG1:%arg[0-9]+]] = 0 to min [[UBO0]]()[%{{.*}}, %{{.*}}, [[ARG0]]] - // CHECK-NEXT: affine.for %[[I:.*]] = [[LBI0]]([[ARG1]]){{.*}}[[ARG0]]{{.*}} to min [[UBI0]]({{.*}})[{{.*}}, {{.*}}, [[ARG0]]] + // CHECK: affine.for [[ARG1:%arg[0-9]+]] = 0 to min [[UBO0]]() [%{{.*}}, %{{.*}}, [[ARG0]]] + // CHECK-NEXT: affine.for %[[I:.*]] = [[LBI0]]([[ARG1]]){{.*}}[[ARG0]]{{.*}} to min [[UBI0]]({{.*}}) [{{.*}}, {{.*}}, [[ARG0]]] // CHECK-NEXT: addi %[[I]], %[[I]] return } // ----- -// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0)> -// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0)[s0, s1, s2] -> (d0 * s2 + s2 * 4, s0, 4096 floordiv s1)> -// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<()[s0, s1, s2] -> (s0 ceildiv s2, (4096 floordiv s1) ceildiv s2)> +// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0)> +// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0) [s0, s1, s2] -> (d0 * s2 + s2 * 4, s0, 4096 floordiv s1)> +// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<() [s0, s1, s2] -> (s0 ceildiv s2, (4096 floordiv s1) ceildiv s2)> // CHECK: func @tile_loop_with_div_in_upper_bound_non_unit_step([[ARG0:%arg[0-9]+]]: index, %{{.*}}: memref, %{{.*}}: index, %{{.*}}: index) -#ub = affine_map<()[s0, s1] -> (s0, 4096 floordiv s1)> +#ub = affine_map<() [s0, s1] -> (s0, 4096 floordiv s1)> func @tile_loop_with_div_in_upper_bound_non_unit_step(%t5 : index, %A : memref, %L : index, %U : index) { %c0 = constant 0 : index %M = dim %A, %c0 : memref - affine.for %i = 0 to min #ub()[%M, %U] step 4 { + affine.for %i = 0 to min #ub() [%M, %U] step 4 { addi %i, %i : index } - // CHECK: affine.for [[ARG1:%arg[0-9]+]] = 0 to min [[UBO0]]()[%{{.*}}, %{{.*}}, [[ARG0]]]{{.*}} step 4{{.*}} - // CHECK-NEXT: affine.for %[[I:.*]] = [[LBI0]]([[ARG1]]){{.*}}[[ARG0]]{{.*}} to min [[UBI0]]({{.*}})[{{.*}}, {{.*}}, [[ARG0]]]{{.*}} step 4{{.*}} + // CHECK: affine.for [[ARG1:%arg[0-9]+]] = 0 to min [[UBO0]]() [%{{.*}}, %{{.*}}, [[ARG0]]]{{.*}} step 4{{.*}} + // CHECK-NEXT: affine.for %[[I:.*]] = [[LBI0]]([[ARG1]]){{.*}}[[ARG0]]{{.*}} to min [[UBI0]]({{.*}}) [{{.*}}, {{.*}}, [[ARG0]]]{{.*}} step 4{{.*}} // CHECK-NEXT: addi %[[I]], %[[I]] return } // ----- -// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> ((d0 - 8) * s0 + 8)> -// CHECK-DAG: [[UBI2:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> ((d0 - 8) * s1 + s1 * 4 + 8, s0 + 16)> -// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> ((d0 - 8) * s1 + s1 + 8, s0 + 16)> -// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> ((d0 - 8) * s0 + s0 + 8, 256)> -// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<()[s0, s1] -> ((s0 + 8) ceildiv s1 + 8)> -// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<()[s0] -> (248 ceildiv s0 + 8)> +// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0) [s0] -> ((d0 - 8) * s0 + 8)> +// CHECK-DAG: [[UBI2:#map[0-9]+]] = affine_map<(d0) [s0, s1] -> ((d0 - 8) * s1 + s1 * 4 + 8, s0 + 16)> +// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0) [s0, s1] -> ((d0 - 8) * s1 + s1 + 8, s0 + 16)> +// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0) [s0] -> ((d0 - 8) * s0 + s0 + 8, 256)> +// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<() [s0, s1] -> ((s0 + 8) ceildiv s1 + 8)> +// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<() [s0] -> (248 ceildiv s0 + 8)> // CHECK: func @tile_loop_with_non_zero_lb([[ARG0:%arg[0-9]+]]: index, [[ARG1:%arg[0-9]+]]: index, [[ARG2:%arg[0-9]+]]: index, %{{.*}}: index) // CHECK-NEXT: affine.for [[ARG3:%arg[0-9+]]] = 8 to [[UBO0]]{{.*}}[[ARG0]]{{.*}} @@ -120,11 +120,11 @@ // CHECK-NEXT: affine.for %[[J:.*]] = [[LBI0]]([[ARG4]]){{.*}}[[ARG1]]{{.*}} to min [[UBI1]]([[ARG4]]){{.*}}[[ARG1]]{{.*}} // CHECK-NEXT: affine.for %[[K:.*]] = [[LBI0]]([[ARG5]]){{.*}}[[ARG2]]{{.*}} to min [[UBI2]]([[ARG5]]){{.*}}[[ARG2]]{{.*}}step 4{{.*}} // CHECK-NEXT: "test.foo"(%[[I]], %[[J]], %[[K]]) : (index, index, index) -> () -#ubi = affine_map<()[s0] -> (s0 + 16)> +#ubi = affine_map<() [s0] -> (s0 + 16)> func @tile_loop_with_non_zero_lb(%t0: index, %t1: index, %t2: index, %U: index){ affine.for %i = 8 to 256 { - affine.for %j = 8 to #ubi()[%U] { - affine.for %k = 8 to #ubi()[%U] step 4 { + affine.for %j = 8 to #ubi() [%U] { + affine.for %k = 8 to #ubi() [%U] step 4 { "test.foo"(%i, %j, %k) : (index, index, index) -> () } } @@ -134,11 +134,11 @@ // ----- -// CHECK-DAG: [[LBI:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0)> -// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0 + s0, 256)> -// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0 + s0, 250)> -// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<()[s0] -> (256 ceildiv s0)> -// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<()[s0] -> (250 ceildiv s0)> +// CHECK-DAG: [[LBI:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0)> +// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0 + s0, 256)> +// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0 + s0, 250)> +// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<() [s0] -> (256 ceildiv s0)> +// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<() [s0] -> (250 ceildiv s0)> // CHECK: func @simple_matmul([[ARG0:%arg[0-9]+]]: index, [[ARG1:%arg[0-9]+]]: index, [[ARG2:%arg[0-9]+]]: index{{.*}}) // CHECK-NEXT: affine.for [[ARG3:%arg[0-9]+]] = 0 to [[UBO0]](){{.*}}[[ARG0]]{{.*}} @@ -171,9 +171,9 @@ // ----- -// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0)> -// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s1, s0)> -// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<()[s0, s1] -> (s0 ceildiv s1)> +// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0)> +// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0) [s0, s1] -> (d0 * s1 + s1, s0)> +// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<() [s0, s1] -> (s0 ceildiv s1)> // CHECK: func @tile_with_symbolic_loop_upper_bounds([[ARG0:%arg[0-9]+]]: index, [[ARG1:%arg[0-9]+]]: index{{.*}}){{.*}} // CHECK: affine.for [[ARG2:%arg[0-9]+]] = 0 to [[UBO0]](){{.*}}[[ARG0]]{{.*}} @@ -210,31 +210,31 @@ // ----- -// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0)> -// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0)[s0, s1, s2] -> (d0 * s2 + s2, s0 + s1)> -// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<()[s0, s1, s2] -> ((s0 + s1) ceildiv s2)> +// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0)> +// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0) [s0, s1, s2] -> (d0 * s2 + s2, s0 + s1)> +// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<() [s0, s1, s2] -> ((s0 + s1) ceildiv s2)> // CHECK: func @tile_with_loop_upper_bounds_in_two_symbols([[ARG0:%arg[0-9]+]]: index{{.*}}){{.*}} func @tile_with_loop_upper_bounds_in_two_symbols(%t11 : index, %arg0: memref, %limit: index) { %c0 = constant 0 : index %dim0 = dim %arg0, %c0 : memref - affine.for %i0 = 0 to affine_map<()[s0, s1] -> (s0 + s1)> ()[%dim0, %limit] { + affine.for %i0 = 0 to affine_map<() [s0, s1] -> (s0 + s1)> () [%dim0, %limit] { %v0 = affine.load %arg0[%i0] : memref } - // CHECK: affine.for [[ARG1:%arg[0-9]+]] = 0 to [[UBO0]]()[%{{.*}}, %{{.*}}, [[ARG0]]] - // CHECK-NEXT: affine.for %[[I:.*]] = [[LBI0]]([[ARG1]]){{.*}}[[ARG0]]{{.*}} to min [[UBI0]]([[ARG1]])[{{.*}}, {{.*}}, [[ARG0]]] + // CHECK: affine.for [[ARG1:%arg[0-9]+]] = 0 to [[UBO0]]() [%{{.*}}, %{{.*}}, [[ARG0]]] + // CHECK-NEXT: affine.for %[[I:.*]] = [[LBI0]]([[ARG1]]){{.*}}[[ARG0]]{{.*}} to min [[UBI0]]([[ARG1]]) [{{.*}}, {{.*}}, [[ARG0]]] // CHECK-NEXT: affine.load %{{.*}}[%[[I]]] return } // ----- -// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0)> -// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d1 * s1 + s1, d0 + s0 + 4)> -// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d1 * s1 + s1, d0 + s0 + 2)> +// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0)> +// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0, d1) [s0, s1] -> (d1 * s1 + s1, d0 + s0 + 4)> +// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0, d1) [s0, s1] -> (d1 * s1 + s1, d0 + s0 + 2)> // CHECK-DAG: [[LBO0:#map[0-9]+]] = affine_map<() -> (0)> -// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> ((d0 + s0 + 4) ceildiv s1)> -// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> ((d0 + s0 + 2) ceildiv s1)> +// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<(d0) [s0, s1] -> ((d0 + s0 + 4) ceildiv s1)> +// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<(d0) [s0, s1] -> ((d0 + s0 + 2) ceildiv s1)> // CHECK: func @tile_with_upper_bounds_in_dimensions_and_symbols([[ARG0:%arg[0-9]+]]: index, [[ARG1:%arg[0-9]+]]: index, [[ARG2:%arg[0-9]+]]: index, [[ARG3:%arg[0-9]+]]: index{{.*}}){{.*}} // CHECK-NEXT: affine.for [[ARG4:%arg[0-9]+]] = 0 to [[UBO0]]({{.*}}){{.*}}[[ARG0]] @@ -242,8 +242,8 @@ // CHECK-NEXT: affine.for {{.*}} = [[LBI0]]([[ARG4]]){{.*}}[[ARG0]]{{.*}} to min [[UBI0]]({{.*}}, [[ARG4]]){{.*}}[[ARG0]]{{.*}} // CHECK-NEXT: affine.for {{.*}} = [[LBI0]]([[ARG5]]){{.*}}[[ARG1]]{{.*}} to min [[UBI1]]({{.*}}, [[ARG5]]){{.*}}[[ARG1]]{{.*}} func @tile_with_upper_bounds_in_dimensions_and_symbols(%t12 : index, %t13 :index, %M: index, %N: index, %K: index) { - affine.for %i = 0 to affine_map<(d0)[s0] -> (d0 + s0 + 2)>(%M)[%K] { - affine.for %j = 0 to affine_map<(d0)[s0] -> (d0 + s0 + 4)>(%N)[%K] { + affine.for %i = 0 to affine_map<(d0) [s0] -> (d0 + s0 + 2)>(%M) [%K] { + affine.for %j = 0 to affine_map<(d0) [s0] -> (d0 + s0 + 4)>(%N) [%K] { "test.foo" () : () -> () } } @@ -252,12 +252,12 @@ // ----- -// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0)> -// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d1 * s1 + s1 * 4, d0 + s0 + 4)> -// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d1 * s1 + s1 * 2, d0 + s0 + 2)> +// CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 * s0)> +// CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0, d1) [s0, s1] -> (d1 * s1 + s1 * 4, d0 + s0 + 4)> +// CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0, d1) [s0, s1] -> (d1 * s1 + s1 * 2, d0 + s0 + 2)> // CHECK-DAG: [[LBO0:#map[0-9]+]] = affine_map<() -> (0)> -// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> ((d0 + s0 + 4) ceildiv s1)> -// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> ((d0 + s0 + 2) ceildiv s1)> +// CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<(d0) [s0, s1] -> ((d0 + s0 + 4) ceildiv s1)> +// CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<(d0) [s0, s1] -> ((d0 + s0 + 2) ceildiv s1)> // CHECK: func @tile_with_upper_bounds_in_dimensions_and_symbols_non_unit_steps // CHECK-SAME: ([[ARG0:%arg[0-9]+]]: index, [[ARG1:%arg[0-9]+]]: index, [[ARG2:%arg[0-9]+]]: index, [[ARG3:%arg[0-9]+]]: index{{.*}}){{.*}} @@ -266,8 +266,8 @@ // CHECK-NEXT: affine.for {{.*}} = [[LBI0]]([[ARG4]]){{.*}}[[ARG0]]{{.*}} to min [[UBI0]]({{.*}}, [[ARG4]]){{.*}}[[ARG0]]{{.*}} step 2{{.*}} // CHECK-NEXT: affine.for {{.*}} = [[LBI0]]([[ARG5]]){{.*}}[[ARG1]]{{.*}} to min [[UBI1]]({{.*}}, [[ARG5]]){{.*}}[[ARG1]]{{.*}} step 4{{.*}} func @tile_with_upper_bounds_in_dimensions_and_symbols_non_unit_steps(%t12 : index, %t13 :index, %M: index, %N : index, %K: index) { - affine.for %i = 0 to affine_map<(d0)[s0] -> (d0 + s0 + 2)>(%M)[%K] step 2 { - affine.for %j = 0 to affine_map<(d0)[s0] -> (d0 + s0 + 4)>(%N)[%K] step 4 { + affine.for %i = 0 to affine_map<(d0) [s0] -> (d0 + s0 + 2)>(%M) [%K] step 2 { + affine.for %j = 0 to affine_map<(d0) [s0] -> (d0 + s0 + 4)>(%N) [%K] step 4 { "test.foo" () : () -> () } } diff --git a/mlir/test/Dialect/Affine/loop-tiling-unsupported.mlir b/mlir/test/Dialect/Affine/loop-tiling-unsupported.mlir --- a/mlir/test/Dialect/Affine/loop-tiling-unsupported.mlir +++ b/mlir/test/Dialect/Affine/loop-tiling-unsupported.mlir @@ -2,12 +2,12 @@ // ----- -#ub = affine_map<(d0)[s0] -> (d0, s0)> +#ub = affine_map<(d0) [s0] -> (d0, s0)> func @non_hyperrect_loop() { %N = constant 128 : index // expected-error@+1 {{tiled code generation unimplemented for the non-hyperrectangular case}} affine.for %i = 0 to %N { - affine.for %j = 0 to min #ub(%i)[%N] { + affine.for %j = 0 to min #ub(%i) [%N] { affine.yield } } diff --git a/mlir/test/Dialect/Affine/loop-tiling.mlir b/mlir/test/Dialect/Affine/loop-tiling.mlir --- a/mlir/test/Dialect/Affine/loop-tiling.mlir +++ b/mlir/test/Dialect/Affine/loop-tiling.mlir @@ -58,22 +58,22 @@ // ----- // CHECK-DAG: [[$IDENTITY:#map[0-9]+]] = affine_map<(d0) -> (d0)> -// CHECK-DAG: [[$LB:#map[0-9]+]] = affine_map<()[s0] -> (0, s0)> -// CHECK-DAG: [[$UB:#map[0-9]+]] = affine_map<()[s0, s1] -> (s0, 4096 floordiv s1)> -// CHECK-DAG: [[$UB_INTRA_TILE:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> (d0 + 32, s0, 4096 floordiv s1)> +// CHECK-DAG: [[$LB:#map[0-9]+]] = affine_map<() [s0] -> (0, s0)> +// CHECK-DAG: [[$UB:#map[0-9]+]] = affine_map<() [s0, s1] -> (s0, 4096 floordiv s1)> +// CHECK-DAG: [[$UB_INTRA_TILE:#map[0-9]+]] = affine_map<(d0) [s0, s1] -> (d0 + 32, s0, 4096 floordiv s1)> -#lb = affine_map<()[s0] -> (0, s0)> -#ub = affine_map<()[s0, s1] -> (s0, 4096 floordiv s1)> +#lb = affine_map<() [s0] -> (0, s0)> +#ub = affine_map<() [s0, s1] -> (s0, 4096 floordiv s1)> // CHECK-LABEL: func @loop_max_min_bound(%{{.*}}: memref, %{{.*}}: index, %{{.*}}: index) { func @loop_max_min_bound(%A : memref, %L : index, %U : index) { %c0 = constant 0 : index %M = dim %A, %c0 : memref - affine.for %i = max #lb()[%L] to min #ub()[%M, %U] { + affine.for %i = max #lb() [%L] to min #ub() [%M, %U] { addi %i, %i : index } return -// CHECK: affine.for %{{.*}} = max [[$LB]]()[%{{.*}}] to min [[$UB]]()[%{{.*}}, %{{.*}}] step 32 { -// CHECK-NEXT: affine.for %[[I:.*]] = [[$IDENTITY]](%{{.*}}) to min [[$UB_INTRA_TILE]](%{{.*}})[%{{.*}}, %{{.*}}] { +// CHECK: affine.for %{{.*}} = max [[$LB]]() [%{{.*}}] to min [[$UB]]() [%{{.*}}, %{{.*}}] step 32 { +// CHECK-NEXT: affine.for %[[I:.*]] = [[$IDENTITY]](%{{.*}}) to min [[$UB_INTRA_TILE]](%{{.*}}) [%{{.*}}, %{{.*}}] { // CHECK-NEXT: addi %[[I]], %[[I]] // CHECK-NEXT: } // CHECK-NEXT: } @@ -108,7 +108,7 @@ // ----- -// CHECK-DAG: [[$UBMAP:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 + 32, s0)> +// CHECK-DAG: [[$UBMAP:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 + 32, s0)> func @tile_with_symbolic_loop_upper_bounds(%arg0: memref, %arg1: memref, %arg2: memref) { %cst = constant 0.000000e+00 : f32 @@ -133,8 +133,8 @@ // CHECK: dim %{{.*}}, %c0 : memref // CHECK-NEXT: affine.for %{{.*}} = 0 to %{{.*}} step 32 { // CHECK-NEXT: affine.for %{{.*}} = 0 to %{{.*}} step 32 { -// CHECK-NEXT: affine.for %{{.*}} = #map3(%{{.*}}) to min [[$UBMAP]](%{{.*}})[%{{.*}}] { -// CHECK-NEXT: affine.for %{{.*}} = #map3(%{{.*}}) to min [[$UBMAP]](%{{.*}})[%{{.*}}] { +// CHECK-NEXT: affine.for %{{.*}} = #map3(%{{.*}}) to min [[$UBMAP]](%{{.*}}) [%{{.*}}] { +// CHECK-NEXT: affine.for %{{.*}} = #map3(%{{.*}}) to min [[$UBMAP]](%{{.*}}) [%{{.*}}] { // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref // CHECK-NEXT: affine.for %{{.*}} = 0 to %{{.*}} { // CHECK-NEXT: affine.load @@ -153,21 +153,21 @@ // ----- // CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0)> -// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<()[s0, s1] -> (s0 + s1)> -// CHECK-DAG: [[$UBMAP:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> (d0 + 32, s0 + s1)> +// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<() [s0, s1] -> (s0 + s1)> +// CHECK-DAG: [[$UBMAP:#map[0-9]+]] = affine_map<(d0) [s0, s1] -> (d0 + 32, s0 + s1)> func @tile_with_loop_upper_bounds_in_two_symbols(%arg0: memref, %limit: index) { %c0 = constant 0 : index %dim0 = dim %arg0, %c0 : memref - affine.for %i0 = 0 to affine_map<()[s0, s1] -> (s0 + s1)> ()[%dim0, %limit] { + affine.for %i0 = 0 to affine_map<() [s0, s1] -> (s0 + s1)> () [%dim0, %limit] { %v0 = affine.load %arg0[%i0] : memref } return } // CHECK: dim %{{.*}}, %c0 : memref -// CHECK-NEXT: affine.for %{{.*}} = 0 to [[MAP1]]()[%{{.*}}, %{{.*}}] step 32 { -// CHECK-NEXT: affine.for %{{.*}} = [[MAP0]](%{{.*}}) to min [[$UBMAP]](%{{.*}})[%{{.*}}, %{{.*}}] { +// CHECK-NEXT: affine.for %{{.*}} = 0 to [[MAP1]]() [%{{.*}}, %{{.*}}] step 32 { +// CHECK-NEXT: affine.for %{{.*}} = [[MAP0]](%{{.*}}) to min [[$UBMAP]](%{{.*}}) [%{{.*}}, %{{.*}}] { // CHECK-NEXT: affine.load // CHECK-NEXT: } // CHECK-NEXT: } @@ -225,22 +225,22 @@ // SEPARATE-DAG: #[[$SEP_COND:.*]] = affine_set<(d0, d1)[s0, s1] : (-d0 + s0 - 32 >= 0, -d1 + s1 - 32 >= 0)> // SEPARATE-DAG: #[[$LB:.*]] = affine_map<(d0) -> (d0)> // SEPARATE-DAG: #[[$FULL_TILE_UB:.*]] = affine_map<(d0) -> (d0 + 32)> -// SEPARATE-DAG: #[[$PART_TILE_UB:.*]] = affine_map<(d0)[s0] -> (d0 + 32, s0)> +// SEPARATE-DAG: #[[$PART_TILE_UB:.*]] = affine_map<(d0) [s0] -> (d0 + 32, s0)> // SEPARATE-LABEL: func @separate_full_tile_2d( // SEPARATE: %[[M:.*]]: index, %[[N:.*]]: index // SEPARATE: affine.for %[[I:.*]] = // SEPARATE-NEXT: affine.for %[[J:.*]] = -// SEPARATE-NEXT: affine.if #[[$SEP_COND]](%arg2, %arg3)[%arg0, %arg1] { +// SEPARATE-NEXT: affine.if #[[$SEP_COND]](%arg2, %arg3) [%arg0, %arg1] { // SEPARATE-NEXT: affine.for %{{.*}} = #[[$LB]](%[[I]]) to #[[$FULL_TILE_UB]](%[[I]]) { // SEPARATE-NEXT: affine.for %{{.*}} = #[[$LB]](%[[J]]) to #[[$FULL_TILE_UB]](%[[J]]) { // SEPARATE-NEXT: "test.foo" // SEPARATE-NEXT: } // SEPARATE-NEXT: } // SEPARATE-NEXT: } else { -// SEPARATE-NEXT: affine.for %{{.*}} = #[[$LB]](%[[I]]) to min #[[$PART_TILE_UB]](%[[I]])[%[[M]]] { -// SEPARATE-NEXT: affine.for %{{.*}} = #[[$LB]](%[[J]]) to min #[[$PART_TILE_UB]](%[[J]])[%[[N]]] { +// SEPARATE-NEXT: affine.for %{{.*}} = #[[$LB]](%[[I]]) to min #[[$PART_TILE_UB]](%[[I]]) [%[[M]]] { +// SEPARATE-NEXT: affine.for %{{.*}} = #[[$LB]](%[[J]]) to min #[[$PART_TILE_UB]](%[[J]]) [%[[N]]] { // SEPARATE-NEXT: "test.foo" // SEPARATE-NEXT: } // SEPARATE-NEXT: } @@ -263,7 +263,7 @@ // SEPARATE-DAG: #[[PARTIAL_TILE_UB:.*]] = affine_map<(d0, d1, d2) -> (d2 + 32, d0, d1)> // SEPARATE: affine.for %arg4 -// SEPARATE-NEXT: affine.if #[[$SEP_COND]](%arg4)[%arg2, %arg3] { +// SEPARATE-NEXT: affine.if #[[$SEP_COND]](%arg4) [%arg2, %arg3] { // SEPARATE-NEXT: affine.for %arg5 = #[[TILE_LB]](%arg4) to #[[$FULL_TILE_UB]](%arg4) { // SEPARATE-NEXT: } // SEPARATE-NEXT: } else { diff --git a/mlir/test/Dialect/Affine/loop-unswitch.mlir b/mlir/test/Dialect/Affine/loop-unswitch.mlir --- a/mlir/test/Dialect/Affine/loop-unswitch.mlir +++ b/mlir/test/Dialect/Affine/loop-unswitch.mlir @@ -172,30 +172,30 @@ #fub1 = affine_map<(d0) -> (d0 * 3 + 3)> #flb0 = affine_map<(d0) -> (d0 * 16)> #fub0 = affine_map<(d0) -> (d0 * 16 + 16)> -#pub1 = affine_map<(d0)[s0] -> (s0, d0 * 3 + 3)> -#pub0 = affine_map<(d0)[s0] -> (s0, d0 * 16 + 16)> +#pub1 = affine_map<(d0) [s0] -> (s0, d0 * 3 + 3)> +#pub0 = affine_map<(d0) [s0] -> (s0, d0 * 16 + 16)> #lb1 = affine_map<(d0) -> (d0 * 480)> -#ub1 = affine_map<(d0)[s0] -> (s0, d0 * 480 + 480)> +#ub1 = affine_map<(d0) [s0] -> (s0, d0 * 480 + 480)> #lb0 = affine_map<(d0) -> (d0 * 110)> -#ub0 = affine_map<(d0)[s0] -> (d0 * 110 + 110, s0 floordiv 3)> +#ub0 = affine_map<(d0) [s0] -> (d0 * 110 + 110, s0 floordiv 3)> #set0 = affine_set<(d0, d1)[s0, s1] : (d0 * -16 + s0 - 16 >= 0, d1 * -3 + s1 - 3 >= 0)> // CHECK-LABEL: func @perfect_if_else func @perfect_if_else(%arg0 : memref, %arg1 : memref, %v : f64, %arg4 : index, %arg5 : index, %arg6 : index, %sym : index) { - affine.for %arg7 = #lb0(%arg5) to min #ub0(%arg5)[%sym] { + affine.for %arg7 = #lb0(%arg5) to min #ub0(%arg5) [%sym] { affine.parallel (%i0, %j0) = (0, 0) to (symbol(%sym), 100) step (10, 10) { - affine.for %arg8 = #lb1(%arg4) to min #ub1(%arg4)[%sym] { - affine.if #set0(%arg6, %arg7)[%sym, %sym] { + affine.for %arg8 = #lb1(%arg4) to min #ub1(%arg4) [%sym] { + affine.if #set0(%arg6, %arg7) [%sym, %sym] { affine.for %arg9 = #flb0(%arg6) to #fub0(%arg6) { affine.for %arg10 = #flb1(%arg7) to #fub1(%arg7) { affine.store %v, %arg0[0, 0] : memref } } } else { - affine.for %arg9 = #lb0(%arg6) to min #pub0(%arg6)[%sym] { - affine.for %arg10 = #lb1(%arg7) to min #pub1(%arg7)[%sym] { + affine.for %arg9 = #lb0(%arg6) to min #pub0(%arg6) [%sym] { + affine.for %arg10 = #lb1(%arg7) to min #pub1(%arg7) [%sym] { affine.store %v, %arg0[0, 0] : memref } } @@ -239,7 +239,7 @@ call @external() : () -> () } affine.for %i = 0 to 100 { - affine.if affine_set<()[s0] : (s0 >= 0)>()[%N] { + affine.if affine_set<() [s0] : (s0 >= 0)>() [%N] { call @external() : () -> () } } diff --git a/mlir/test/Dialect/Affine/memref-stride-calculation.mlir b/mlir/test/Dialect/Affine/memref-stride-calculation.mlir --- a/mlir/test/Dialect/Affine/memref-stride-calculation.mlir +++ b/mlir/test/Dialect/Affine/memref-stride-calculation.mlir @@ -30,37 +30,37 @@ %16 = alloc(%0, %0, %0) : memref(i, j, k)>> // CHECK: MemRefType offset: 0 strides: ?, ?, 1 - %21 = alloc()[%0] : memref<3x4x5xf32, affine_map<(i, j, k)[M]->(32 * i + 16 * j + M * k + 1)>> + %21 = alloc()[%0] : memref<3x4x5xf32, affine_map<(i, j, k) [M]->(32 * i + 16 * j + M * k + 1)>> // CHECK: MemRefType offset: 1 strides: 32, 16, ? - %22 = alloc()[%0] : memref<3x4x5xf32, affine_map<(i, j, k)[M]->(32 * i + M * j + 16 * k + 3)>> + %22 = alloc()[%0] : memref<3x4x5xf32, affine_map<(i, j, k) [M]->(32 * i + M * j + 16 * k + 3)>> // CHECK: MemRefType offset: 3 strides: 32, ?, 16 %b22 = alloc(%0)[%0, %0] : memref<3x4x?xf32, offset: 0, strides: [?, ?, 1]> // CHECK: MemRefType offset: 0 strides: ?, ?, 1 - %23 = alloc(%0)[%0] : memref<3x?x5xf32, affine_map<(i, j, k)[M]->(M * i + 32 * j + 16 * k + 7)>> + %23 = alloc(%0)[%0] : memref<3x?x5xf32, affine_map<(i, j, k) [M]->(M * i + 32 * j + 16 * k + 7)>> // CHECK: MemRefType offset: 7 strides: ?, 32, 16 %b23 = alloc(%0)[%0] : memref<3x?x5xf32, offset: 0, strides: [?, 5, 1]> // CHECK: MemRefType offset: 0 strides: ?, 5, 1 - %24 = alloc(%0)[%0] : memref<3x?x5xf32, affine_map<(i, j, k)[M]->(M * i + 32 * j + 16 * k + M)>> + %24 = alloc(%0)[%0] : memref<3x?x5xf32, affine_map<(i, j, k) [M]->(M * i + 32 * j + 16 * k + M)>> // CHECK: MemRefType offset: ? strides: ?, 32, 16 %b24 = alloc(%0)[%0, %0] : memref<3x?x5xf32, offset: ?, strides: [?, 32, 16]> // CHECK: MemRefType offset: ? strides: ?, 32, 16 - %25 = alloc(%0, %0)[%0, %0] : memref(M * i + N * j + k + 1)>> + %25 = alloc(%0, %0)[%0, %0] : memref(M * i + N * j + k + 1)>> // CHECK: MemRefType offset: 1 strides: ?, ?, 1 %b25 = alloc(%0, %0)[%0, %0] : memref // CHECK: MemRefType offset: 1 strides: ?, ?, 1 - %26 = alloc(%0)[] : memref(i)>> + %26 = alloc(%0)[] : memref(i)>> // CHECK: MemRefType offset: 0 strides: 1 - %27 = alloc()[%0] : memref<5xf32, affine_map<(i)[M]->(M)>> -// CHECK: MemRefType memref<5xf32, affine_map<(d0)[s0] -> (s0)>> cannot be converted to strided form - %28 = alloc()[%0] : memref<5xf32, affine_map<(i)[M]->(123)>> -// CHECK: MemRefType memref<5xf32, affine_map<(d0)[s0] -> (123)>> cannot be converted to strided form - %29 = alloc()[%0] : memref(M)>> + %27 = alloc()[%0] : memref<5xf32, affine_map<(i) [M]->(M)>> +// CHECK: MemRefType memref<5xf32, affine_map<(d0) [s0] -> (s0)>> cannot be converted to strided form + %28 = alloc()[%0] : memref<5xf32, affine_map<(i) [M]->(123)>> +// CHECK: MemRefType memref<5xf32, affine_map<(d0) [s0] -> (123)>> cannot be converted to strided form + %29 = alloc()[%0] : memref(M)>> // CHECK: MemRefType offset: ? strides: - %30 = alloc()[%0] : memref(123)>> + %30 = alloc()[%0] : memref(123)>> // CHECK: MemRefType offset: 123 strides: - %100 = alloc(%0, %0)[%0, %0] : memref(i + j, j, k)>, affine_map<(i, j, k)[M, N]->(M * i + N * j + k + 1)>> -// CHECK: MemRefType memref (d0 + d1, d1, d2)>, affine_map<(d0, d1, d2)[s0, s1] -> (d0 * s0 + d1 * s1 + d2 + 1)>> cannot be converted to strided form + %100 = alloc(%0, %0)[%0, %0] : memref(i + j, j, k)>, affine_map<(i, j, k) [M, N]->(M * i + N * j + k + 1)>> +// CHECK: MemRefType memref (d0 + d1, d1, d2)>, affine_map<(d0, d1, d2) [s0, s1] -> (d0 * s0 + d1 * s1 + d2 + 1)>> cannot be converted to strided form %101 = alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i floordiv 4 + j + k)>> // CHECK: MemRefType memref<3x4x5xf32, affine_map<(d0, d1, d2) -> (d0 floordiv 4 + d1 + d2)>> cannot be converted to strided form %102 = alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i ceildiv 4 + j + k)>> @@ -68,13 +68,13 @@ %103 = alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i mod 4 + j + k)>> // CHECK: MemRefType memref<3x4x5xf32, affine_map<(d0, d1, d2) -> (d0 mod 4 + d1 + d2)>> cannot be converted to strided form - %200 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * i + N * i + N * j + K * k - (M + N - 20)* i)>> + %200 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k) [M, N, K]->(M * i + N * i + N * j + K * k - (M + N - 20)* i)>> // CHECK: MemRefType offset: 0 strides: 20, ?, ? - %201 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * i + N * i + N * K * j + K * K * k - (M + N - 20) * (i + 1))>> + %201 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k) [M, N, K]->(M * i + N * i + N * K * j + K * K * k - (M + N - 20) * (i + 1))>> // CHECK: MemRefType offset: ? strides: 20, ?, ? - %202 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * (i + 1) + j + k - M)>> + %202 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k) [M, N, K]->(M * (i + 1) + j + k - M)>> // CHECK: MemRefType offset: 0 strides: ?, 1, 1 - %203 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M + M * (i + N * (j + K * k)))>> + %203 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k) [M, N, K]->(M + M * (i + N * (j + K * k)))>> // CHECK: MemRefType offset: ? strides: ?, ?, ? return diff --git a/mlir/test/Dialect/Affine/ops.mlir b/mlir/test/Dialect/Affine/ops.mlir --- a/mlir/test/Dialect/Affine/ops.mlir +++ b/mlir/test/Dialect/Affine/ops.mlir @@ -61,34 +61,34 @@ // ----- -// CHECK-DAG: #[[$MAP0:map[0-9]+]] = affine_map<(d0)[s0] -> (1000, d0 + 512, s0)> -// CHECK-DAG: #[[$MAP1:map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 - d1, s0 + 512)> -// CHECK-DAG: #[[$MAP2:map[0-9]+]] = affine_map<()[s0, s1] -> (s0 - s1, 11)> +// CHECK-DAG: #[[$MAP0:map[0-9]+]] = affine_map<(d0) [s0] -> (1000, d0 + 512, s0)> +// CHECK-DAG: #[[$MAP1:map[0-9]+]] = affine_map<(d0, d1) [s0] -> (d0 - d1, s0 + 512)> +// CHECK-DAG: #[[$MAP2:map[0-9]+]] = affine_map<() [s0, s1] -> (s0 - s1, 11)> // CHECK-DAG: #[[$MAP3:map[0-9]+]] = affine_map<() -> (77, 78, 79)> // CHECK-LABEL: @affine_min func @affine_min(%arg0 : index, %arg1 : index, %arg2 : index) { - // CHECK: affine.min #[[$MAP0]](%arg0)[%arg1] - %0 = affine.min affine_map<(d0)[s0] -> (1000, d0 + 512, s0)> (%arg0)[%arg1] - // CHECK: affine.min #[[$MAP1]](%arg0, %arg1)[%arg2] - %1 = affine.min affine_map<(d0, d1)[s0] -> (d0 - d1, s0 + 512)> (%arg0, %arg1)[%arg2] - // CHECK: affine.min #[[$MAP2]]()[%arg1, %arg2] - %2 = affine.min affine_map<()[s0, s1] -> (s0 - s1, 11)> ()[%arg1, %arg2] + // CHECK: affine.min #[[$MAP0]](%arg0) [%arg1] + %0 = affine.min affine_map<(d0) [s0] -> (1000, d0 + 512, s0)> (%arg0) [%arg1] + // CHECK: affine.min #[[$MAP1]](%arg0, %arg1) [%arg2] + %1 = affine.min affine_map<(d0, d1) [s0] -> (d0 - d1, s0 + 512)> (%arg0, %arg1) [%arg2] + // CHECK: affine.min #[[$MAP2]]() [%arg1, %arg2] + %2 = affine.min affine_map<() [s0, s1] -> (s0 - s1, 11)> () [%arg1, %arg2] // CHECK: affine.min #[[$MAP3]]() - %3 = affine.min affine_map<()[] -> (77, 78, 79)> ()[] + %3 = affine.min affine_map<() [] -> (77, 78, 79)> () [] return } // CHECK-LABEL: @affine_max func @affine_max(%arg0 : index, %arg1 : index, %arg2 : index) { - // CHECK: affine.max #[[$MAP0]](%arg0)[%arg1] - %0 = affine.max affine_map<(d0)[s0] -> (1000, d0 + 512, s0)> (%arg0)[%arg1] - // CHECK: affine.max #[[$MAP1]](%arg0, %arg1)[%arg2] - %1 = affine.max affine_map<(d0, d1)[s0] -> (d0 - d1, s0 + 512)> (%arg0, %arg1)[%arg2] - // CHECK: affine.max #[[$MAP2]]()[%arg1, %arg2] - %2 = affine.max affine_map<()[s0, s1] -> (s0 - s1, 11)> ()[%arg1, %arg2] + // CHECK: affine.max #[[$MAP0]](%arg0) [%arg1] + %0 = affine.max affine_map<(d0) [s0] -> (1000, d0 + 512, s0)> (%arg0)[%arg1] + // CHECK: affine.max #[[$MAP1]](%arg0, %arg1) [%arg2] + %1 = affine.max affine_map<(d0, d1) [s0] -> (d0 - d1, s0 + 512)> (%arg0, %arg1)[%arg2] + // CHECK: affine.max #[[$MAP2]]() [%arg1, %arg2] + %2 = affine.max affine_map<() [s0, s1] -> (s0 - s1, 11)> ()[%arg1, %arg2] // CHECK: affine.max #[[$MAP3]]() - %3 = affine.max affine_map<()[] -> (77, 78, 79)> ()[] + %3 = affine.max affine_map<() [] -> (77, 78, 79)> ()[] return } diff --git a/mlir/test/Dialect/Affine/simplify-affine-structures.mlir b/mlir/test/Dialect/Affine/simplify-affine-structures.mlir --- a/mlir/test/Dialect/Affine/simplify-affine-structures.mlir +++ b/mlir/test/Dialect/Affine/simplify-affine-structures.mlir @@ -53,7 +53,7 @@ affine.for %arg0 = 1 to 10 { affine.for %arg1 = 1 to 100 { // CHECK: #[[$SET_EMPTY]]() - affine.if affine_set<(d0, d1)[s0, s1] : (d0 - s0 == 0, d0 + s0 == 0, s0 - 1 == 0)>(%arg0, %arg1)[%c7, %c11] { + affine.if affine_set<(d0, d1) [s0, s1] : (d0 - s0 == 0, d0 + s0 == 0, s0 - 1 == 0)>(%arg0, %arg1) [%c7, %c11] { call @external() : () -> () } } @@ -74,7 +74,7 @@ affine.for %arg0 = 1 to 10 { affine.for %arg1 = 1 to 100 { // CHECK: #[[$SET_7_11]](%arg0, %arg1) - affine.if #set_2d_non_empty(%arg0, %arg1)[%c7, %c11] { + affine.if #set_2d_non_empty(%arg0, %arg1) [%c7, %c11] { call @external() : () -> () } } @@ -96,7 +96,7 @@ affine.for %arg0 = 1 to 10 { affine.for %arg1 = 1 to 100 { // CHECK: #[[$SET_EMPTY]]() - affine.if #set_2d_empty(%arg0, %arg1)[%c7, %c11] { + affine.if #set_2d_empty(%arg0, %arg1) [%c7, %c11] { call @external() : () -> () } } @@ -175,7 +175,7 @@ "foo"() : () -> () } // CHECK: affine.if #[[$SET_EMPTY]]() - affine.if affine_set<(d0)[s0, s1] : (d0 >= 0, -d0 + s0 - 1 >= 0, -s0 >= 0)>(%i)[%N, %N] { + affine.if affine_set<(d0) [s0, s1] : (d0 >= 0, -d0 + s0 - 1 >= 0, -s0 >= 0)>(%i) [%N, %N] { "bar"() : () -> () } // CHECK: affine.if #[[$SET_EMPTY]]() @@ -267,7 +267,7 @@ func @affine.apply(%N : index) { %v = affine.apply affine_map<(d0, d1) -> (d0 + d1 + 1)>(%N, %N) addi %v, %v : index - // CHECK: affine.apply #map{{.*}}()[%arg0] + // CHECK: affine.apply #map{{.*}}() [%arg0] // CHECK-NEXT: addi return } @@ -285,13 +285,13 @@ // ----- // Tests the simplification of a semi-affine expression in various cases. -// CHECK-DAG: #[[$map0:.*]] = affine_map<()[s0, s1] -> (-(s1 floordiv s0) + 2)> -// CHECK-DAG: #[[$map1:.*]] = affine_map<()[s0, s1] -> (-(s1 floordiv s0) + 42)> +// CHECK-DAG: #[[$map0:.*]] = affine_map<() [s0, s1] -> (-(s1 floordiv s0) + 2)> +// CHECK-DAG: #[[$map1:.*]] = affine_map<() [s0, s1] -> (-(s1 floordiv s0) + 42)> // Tests the simplification of a semi-affine expression with a modulo operation on a floordiv and multiplication. // CHECK-LABEL: func @semiaffine_mod func @semiaffine_mod(%arg0: index, %arg1: index) -> index { - %a = affine.apply affine_map<(d0)[s0] ->((-((d0 floordiv s0) * s0) + s0 * s0) mod s0)> (%arg0)[%arg1] + %a = affine.apply affine_map<(d0) [s0] ->((-((d0 floordiv s0) * s0) + s0 * s0) mod s0)> (%arg0) [%arg1] // CHECK: %[[CST:.*]] = constant 0 return %a : index } @@ -299,23 +299,23 @@ // Tests the simplification of a semi-affine expression with a nested floordiv and a floordiv on modulo operation. // CHECK-LABEL: func @semiaffine_floordiv func @semiaffine_floordiv(%arg0: index, %arg1: index) -> index { - %a = affine.apply affine_map<(d0)[s0] ->((-((d0 floordiv s0) * s0) + ((2 * s0) mod (3 * s0))) floordiv s0)> (%arg0)[%arg1] - // CHECK: affine.apply #[[$map0]]()[%arg1, %arg0] + %a = affine.apply affine_map<(d0) [s0] ->((-((d0 floordiv s0) * s0) + ((2 * s0) mod (3 * s0))) floordiv s0)> (%arg0) [%arg1] + // CHECK: affine.apply #[[$map0]]() [%arg1, %arg0] return %a : index } // Tests the simplification of a semi-affine expression with a ceildiv operation and a division of constant 0 by a symbol. // CHECK-LABEL: func @semiaffine_ceildiv func @semiaffine_ceildiv(%arg0: index, %arg1: index) -> index { - %a = affine.apply affine_map<(d0)[s0] ->((-((d0 floordiv s0) * s0) + s0 * 42 + ((5-5) floordiv s0)) ceildiv s0)> (%arg0)[%arg1] - // CHECK: affine.apply #[[$map1]]()[%arg1, %arg0] + %a = affine.apply affine_map<(d0) [s0] ->((-((d0 floordiv s0) * s0) + s0 * 42 + ((5-5) floordiv s0)) ceildiv s0)> (%arg0) [%arg1] + // CHECK: affine.apply #[[$map1]]() [%arg1, %arg0] return %a : index } // Tests the simplification of a semi-affine expression with a nested ceildiv operation and further simplifications after performing ceildiv. // CHECK-LABEL: func @semiaffine_composite_floor func @semiaffine_composite_floor(%arg0: index, %arg1: index) -> index { - %a = affine.apply affine_map<(d0)[s0] ->(((((s0 * 2) ceildiv 4) * 5) + s0 * 42) ceildiv s0)> (%arg0)[%arg1] + %a = affine.apply affine_map<(d0) [s0] ->(((((s0 * 2) ceildiv 4) * 5) + s0 * 42) ceildiv s0)> (%arg0) [%arg1] // CHECK: %[[CST:.*]] = constant 47 return %a : index } @@ -323,7 +323,7 @@ // Tests the simplification of a semi-affine expression with a modulo operation with a second operand that simplifies to symbol. // CHECK-LABEL: func @semiaffine_unsimplified_symbol func @semiaffine_unsimplified_symbol(%arg0: index, %arg1: index) -> index { - %a = affine.apply affine_map<(d0)[s0] ->(s0 mod (2 * s0 - s0))> (%arg0)[%arg1] + %a = affine.apply affine_map<(d0) [s0] ->(s0 mod (2 * s0 - s0))> (%arg0) [%arg1] // CHECK: %[[CST:.*]] = constant 0 return %a : index } diff --git a/mlir/test/Dialect/Affine/slicing-utils.mlir b/mlir/test/Dialect/Affine/slicing-utils.mlir --- a/mlir/test/Dialect/Affine/slicing-utils.mlir +++ b/mlir/test/Dialect/Affine/slicing-utils.mlir @@ -225,7 +225,7 @@ %c2 = constant 2 : index %c16 = constant 16 : index affine.for %i0 = %c0 to %c16 { - affine.for %i1 = affine_map<(i)[] -> (i)>(%i0) to 10 { + affine.for %i1 = affine_map<(i) [] -> (i)>(%i0) to 10 { // BWD: matched: %[[b:.*]] {{.*}} backward static slice: // BWD: affine.for {{.*}} diff --git a/mlir/test/Dialect/Affine/unroll-jam.mlir b/mlir/test/Dialect/Affine/unroll-jam.mlir --- a/mlir/test/Dialect/Affine/unroll-jam.mlir +++ b/mlir/test/Dialect/Affine/unroll-jam.mlir @@ -2,11 +2,11 @@ // RUN: mlir-opt -allow-unregistered-dialect %s -affine-loop-unroll-jam="unroll-jam-factor=4" | FileCheck --check-prefix=UJAM-FOUR %s // CHECK-DAG: [[$MAP_PLUS_1:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)> -// CHECK-DAG: [[$MAP_DIV_OFFSET:#map[0-9]+]] = affine_map<()[s0] -> (((s0 - 1) floordiv 2) * 2 + 1)> -// CHECK-DAG: [[$MAP_MULTI_RES:#map[0-9]+]] = affine_map<()[s0, s1] -> ((s0 floordiv 2) * 2, (s1 floordiv 2) * 2, 1024)> -// CHECK-DAG: [[$MAP_SYM_UB:#map[0-9]+]] = affine_map<()[s0, s1] -> (s0, s1, 1024)> +// CHECK-DAG: [[$MAP_DIV_OFFSET:#map[0-9]+]] = affine_map<() [s0] -> (((s0 - 1) floordiv 2) * 2 + 1)> +// CHECK-DAG: [[$MAP_MULTI_RES:#map[0-9]+]] = affine_map<() [s0, s1] -> ((s0 floordiv 2) * 2, (s1 floordiv 2) * 2, 1024)> +// CHECK-DAG: [[$MAP_SYM_UB:#map[0-9]+]] = affine_map<() [s0, s1] -> (s0, s1, 1024)> -// UJAM-FOUR-DAG: [[$UBMAP:#map[0-9]+]] = affine_map<()[s0] -> (s0 + 8)> +// UJAM-FOUR-DAG: [[$UBMAP:#map[0-9]+]] = affine_map<() [s0] -> (s0 + 8)> // UJAM-FOUR-DAG: [[$MAP_PLUS_1:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)> // UJAM-FOUR-DAG: [[$MAP_PLUS_2:#map[0-9]+]] = affine_map<(d0) -> (d0 + 2)> // UJAM-FOUR-DAG: [[$MAP_PLUS_3:#map[0-9]+]] = affine_map<(d0) -> (d0 + 3)> @@ -50,14 +50,14 @@ // CHECK-LABEL: func @loop_nest_unknown_count_1 // CHECK-SAME: [[N:arg[0-9]+]]: index func @loop_nest_unknown_count_1(%N : index) { - // CHECK-NEXT: affine.for %{{.*}} = 1 to [[$MAP_DIV_OFFSET]]()[%[[N]]] step 2 { + // CHECK-NEXT: affine.for %{{.*}} = 1 to [[$MAP_DIV_OFFSET]]() [%[[N]]] step 2 { // CHECK-NEXT: affine.for %{{.*}} = 1 to 100 { // CHECK-NEXT: "foo"() : () -> i32 // CHECK-NEXT: "foo"() : () -> i32 // CHECK-NEXT: } // CHECK-NEXT: } // A cleanup loop should be generated here. - // CHECK-NEXT: affine.for %{{.*}} = [[$MAP_DIV_OFFSET]]()[%[[N]]] to %[[N]] { + // CHECK-NEXT: affine.for %{{.*}} = [[$MAP_DIV_OFFSET]]() [%[[N]]] to %[[N]] { // CHECK-NEXT: affine.for %{{.*}} = 1 to 100 { // CHECK-NEXT: "foo"() : () -> i32 // CHECK-NEXT: } @@ -73,7 +73,7 @@ // UJAM-FOUR-LABEL: func @loop_nest_unknown_count_2 // UJAM-FOUR-SAME: %[[N:arg[0-9]+]]: index func @loop_nest_unknown_count_2(%N : index) { - // UJAM-FOUR-NEXT: affine.for [[IV0:%arg[0-9]+]] = %[[N]] to [[$UBMAP]]()[%[[N]]] step 4 { + // UJAM-FOUR-NEXT: affine.for [[IV0:%arg[0-9]+]] = %[[N]] to [[$UBMAP]]() [%[[N]]] step 4 { // UJAM-FOUR-NEXT: affine.for [[IV1:%arg[0-9]+]] = 1 to 100 { // UJAM-FOUR-NEXT: "foo"([[IV0]]) // UJAM-FOUR-NEXT: [[IV_PLUS_1:%[0-9]+]] = affine.apply [[$MAP_PLUS_1]]([[IV0]]) @@ -85,11 +85,11 @@ // UJAM-FOUR-NEXT: } // UJAM-FOUR-NEXT: } // The cleanup loop is a single iteration one and is promoted. - // UJAM-FOUR-NEXT: [[RES:%[0-9]+]] = affine.apply [[$UBMAP]]()[%[[N]]] + // UJAM-FOUR-NEXT: [[RES:%[0-9]+]] = affine.apply [[$UBMAP]]() [%[[N]]] // UJAM-FOUR-NEXT: affine.for [[IV0]] = 1 to 100 { // UJAM-FOUR-NEXT: "foo"([[RES]]) // UJAM-FOUR-NEXT: } - affine.for %i = %N to affine_map<()[s0] -> (s0+9)> ()[%N] { + affine.for %i = %N to affine_map<() [s0] -> (s0+9)> () [%N] { affine.for %j = 1 to 100 { "foo"(%i) : (index) -> () } @@ -102,21 +102,21 @@ // CHECK-SAME: [[N:arg[0-9]+]]: index // CHECK-SAME: [[K:arg[0-9]+]]: index func @loop_nest_symbolic_and_min_upper_bound(%M : index, %N : index, %K : index) { - affine.for %i = 0 to min affine_map<()[s0, s1] -> (s0, s1, 1024)>()[%M, %N] { + affine.for %i = 0 to min affine_map<() [s0, s1] -> (s0, s1, 1024)>() [%M, %N] { affine.for %j = 0 to %K { "foo"(%i, %j) : (index, index) -> () } } return } -// CHECK-NEXT: affine.for [[IV0:%arg[0-9]+]] = 0 to min [[$MAP_MULTI_RES]]()[%[[M]], %[[N]]] step 2 { +// CHECK-NEXT: affine.for [[IV0:%arg[0-9]+]] = 0 to min [[$MAP_MULTI_RES]]() [%[[M]], %[[N]]] step 2 { // CHECK-NEXT: affine.for [[IV1:%arg[0-9]+]] = 0 to %[[K]] { // CHECK-NEXT: "foo"([[IV0]], [[IV1]]) // CHECK-NEXT: [[RES:%[0-9]+]] = affine.apply [[$MAP_PLUS_1]]([[IV0]]) // CHECK-NEXT: "foo"([[RES]], [[IV1]]) // CHECK-NEXT: } // CHECK-NEXT: } -// CHECK-NEXT: affine.for [[IV0]] = max [[$MAP_MULTI_RES]]()[%[[M]], %[[N]]] to min [[$MAP_SYM_UB]]()[%[[M]], %[[N]]] { +// CHECK-NEXT: affine.for [[IV0]] = max [[$MAP_MULTI_RES]]() [%[[M]], %[[N]]] to min [[$MAP_SYM_UB]]() [%[[M]], %[[N]]] { // CHECK-NEXT: affine.for [[IV1]] = 0 to %[[K]] { // CHECK-NEXT: "foo"([[IV0]], [[IV1]]) // CHECK-NEXT: } diff --git a/mlir/test/Dialect/Affine/unroll.mlir b/mlir/test/Dialect/Affine/unroll.mlir --- a/mlir/test/Dialect/Affine/unroll.mlir +++ b/mlir/test/Dialect/Affine/unroll.mlir @@ -9,7 +9,7 @@ // UNROLL-FULL-DAG: [[$MAP3:#map[0-9]+]] = affine_map<(d0) -> (d0 + 4)> // UNROLL-FULL-DAG: [[$MAP4:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 1)> // UNROLL-FULL-DAG: [[$MAP5:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 3)> -// UNROLL-FULL-DAG: [[$MAP6:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 + s0 + 1)> +// UNROLL-FULL-DAG: [[$MAP6:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 + s0 + 1)> // SHORT-DAG: [[$MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)> @@ -18,10 +18,10 @@ // UNROLL-BY-4-DAG: [[$MAP2:#map[0-9]+]] = affine_map<(d0) -> (d0 + 3)> // UNROLL-BY-4-DAG: [[$MAP3:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 1)> // UNROLL-BY-4-DAG: [[$MAP4:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 3)> -// UNROLL-BY-4-DAG: [[$MAP5:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 + s0 + 1)> +// UNROLL-BY-4-DAG: [[$MAP5:#map[0-9]+]] = affine_map<(d0) [s0] -> (d0 + s0 + 1)> // UNROLL-BY-4-DAG: [[$MAP6:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 + d1)> // UNROLL-BY-4-DAG: [[$MAP11:#map[0-9]+]] = affine_map<(d0) -> (d0)> -// UNROLL-BY-4-DAG: [[$MAP_TRIP_COUNT_MULTIPLE_FOUR:#map[0-9]+]] = affine_map<()[s0, s1, s2] -> (s0 + ((-s0 + s1) floordiv 4) * 4, s0 + ((-s0 + s2) floordiv 4) * 4, s0 + ((-s0) floordiv 4) * 4 + 1024)> +// UNROLL-BY-4-DAG: [[$MAP_TRIP_COUNT_MULTIPLE_FOUR:#map[0-9]+]] = affine_map<() [s0, s1, s2] -> (s0 + ((-s0 + s1) floordiv 4) * 4, s0 + ((-s0 + s2) floordiv 4) * 4, s0 + ((-s0) floordiv 4) * 4 + 1024)> // UNROLL-FULL-LABEL: func @loop_nest_simplest() { func @loop_nest_simplest() { @@ -208,16 +208,16 @@ // UNROLL-FULL: affine.for %arg0 = 0 to 100 step 2 { affine.for %m = 0 to 100 step 2 { // UNROLL-FULL: %7 = affine.apply [[$MAP0]](%c0) - // UNROLL-FULL-NEXT: %8 = affine.apply [[$MAP6]](%c0)[%c99] + // UNROLL-FULL-NEXT: %8 = affine.apply [[$MAP6]](%c0) [%c99] // UNROLL-FULL-NEXT: %9 = affine.apply [[$MAP0]](%c0) // UNROLL-FULL-NEXT: %10 = affine.apply [[$MAP0]](%9) - // UNROLL-FULL-NEXT: %11 = affine.apply [[$MAP6]](%9)[%c99] + // UNROLL-FULL-NEXT: %11 = affine.apply [[$MAP6]](%9) [%c99] // UNROLL-FULL-NEXT: %12 = affine.apply [[$MAP1]](%c0) // UNROLL-FULL-NEXT: %13 = affine.apply [[$MAP0]](%12) - // UNROLL-FULL-NEXT: %14 = affine.apply [[$MAP6]](%12)[%c99] + // UNROLL-FULL-NEXT: %14 = affine.apply [[$MAP6]](%12) [%c99] // UNROLL-FULL-NEXT: %15 = affine.apply [[$MAP2]](%c0) // UNROLL-FULL-NEXT: %16 = affine.apply [[$MAP0]](%15) - // UNROLL-FULL-NEXT: %17 = affine.apply [[$MAP6]](%15)[%c99] + // UNROLL-FULL-NEXT: %17 = affine.apply [[$MAP6]](%15) [%c99] affine.for %n = 0 to 4 { %y = "affine.apply" (%n) { map = affine_map<(d0) -> (d0 + 1)> } : (index) -> (index) @@ -492,14 +492,14 @@ func @loop_nest_symbolic_bound(%N : index) { // UNROLL-BY-4: affine.for %arg1 = 0 to 100 { affine.for %i = 0 to 100 { - // UNROLL-BY-4: affine.for %arg2 = 0 to #map{{[0-9]+}}()[%arg0] step 4 { + // UNROLL-BY-4: affine.for %arg2 = 0 to #map{{[0-9]+}}() [%arg0] step 4 { // UNROLL-BY-4: %0 = "foo"() : () -> i32 // UNROLL-BY-4-NEXT: %1 = "foo"() : () -> i32 // UNROLL-BY-4-NEXT: %2 = "foo"() : () -> i32 // UNROLL-BY-4-NEXT: %3 = "foo"() : () -> i32 // UNROLL-BY-4-NEXT: } // A cleanup loop will be be generated here. - // UNROLL-BY-4-NEXT: affine.for %arg2 = #map{{[0-9]+}}()[%arg0] to %arg0 { + // UNROLL-BY-4-NEXT: affine.for %arg2 = #map{{[0-9]+}}() [%arg0] to %arg0 { // UNROLL-BY-4-NEXT: %0 = "foo"() : () -> i32 // UNROLL-BY-4-NEXT: } affine.for %j = 0 to %N { @@ -517,14 +517,14 @@ affine.for %j = 0 to %N step 3 { %x = "foo"() : () -> i32 } -// UNROLL-BY-4: affine.for %{{.*}} = 0 to #map{{[0-9]+}}()[%[[N]]] step 12 { +// UNROLL-BY-4: affine.for %{{.*}} = 0 to #map{{[0-9]+}}() [%[[N]]] step 12 { // UNROLL-BY-4: "foo"() // UNROLL-BY-4-NEXT: "foo"() // UNROLL-BY-4-NEXT: "foo"() // UNROLL-BY-4-NEXT: "foo"() // UNROLL-BY-4-NEXT: } // A cleanup loop will be be generated here. -// UNROLL-BY-4-NEXT: affine.for %{{.*}} = #map{{[0-9]+}}()[%[[N]]] to %[[N]] step 3 { +// UNROLL-BY-4-NEXT: affine.for %{{.*}} = #map{{[0-9]+}}() [%[[N]]] to %[[N]] step 3 { // UNROLL-BY-4-NEXT: "foo"() // UNROLL-BY-4-NEXT: } } @@ -533,18 +533,18 @@ // UNROLL-BY-4-LABEL: func @loop_nest_symbolic_and_min_upper_bound func @loop_nest_symbolic_and_min_upper_bound(%M : index, %N : index, %K : index) { - affine.for %i = %M to min affine_map<()[s0, s1] -> (s0, s1, 1024)>()[%N, %K] { + affine.for %i = %M to min affine_map<() [s0, s1] -> (s0, s1, 1024)>() [%N, %K] { "foo"() : () -> () } return } -// CHECK-NEXT: affine.for %arg0 = %arg0 to min [[$MAP_TRIP_COUNT_MULTIPLE_FOUR]]()[%arg0, %arg1, %arg2] step 4 { +// CHECK-NEXT: affine.for %arg0 = %arg0 to min [[$MAP_TRIP_COUNT_MULTIPLE_FOUR]]() [%arg0, %arg1, %arg2] step 4 { // CHECK-NEXT: "foo"() : () -> () // CHECK-NEXT: "foo"() : () -> () // CHECK-NEXT: "foo"() : () -> () // CHECK-NEXT: "foo"() : () -> () // CHECK-NEXT: } -// CHECK-NEXT: affine.for %arg1 = max [[$MAP_TRIP_COUNT_MULTIPLE_FOUR]]()[%arg0, %arg1, %arg2] to min #map28()[%arg1, %arg2] { +// CHECK-NEXT: affine.for %arg1 = max [[$MAP_TRIP_COUNT_MULTIPLE_FOUR]]() [%arg0, %arg1, %arg2] to min #map28() [%arg1, %arg2] { // CHECK-NEXT: "foo"() : () -> () // CHECK-NEXT: } // CHECK-NEXT: return @@ -567,7 +567,7 @@ // UNROLL-BY-4-LABEL: func @loop_nest_non_trivial_multiple_upper_bound_alt func @loop_nest_non_trivial_multiple_upper_bound_alt(%M : index, %N : index) { %K = affine.apply affine_map<(d0) -> (4*d0)> (%M) - affine.for %i = 0 to min affine_map<()[s0, s1] -> (4 * s0, s1, 1024)>()[%N, %K] { + affine.for %i = 0 to min affine_map<() [s0, s1] -> (4 * s0, s1, 1024)>() [%N, %K] { "foo"() : () -> () } // UNROLL-BY-4: affine.for %arg2 = 0 to min diff --git a/mlir/test/Dialect/Linalg/affine.mlir b/mlir/test/Dialect/Linalg/affine.mlir --- a/mlir/test/Dialect/Linalg/affine.mlir +++ b/mlir/test/Dialect/Linalg/affine.mlir @@ -3,7 +3,7 @@ // Test that we can lower all the way to LLVM without crashing, don't check results here. // RUN: mlir-opt %s -convert-linalg-to-affine-loops -convert-linalg-to-llvm -o=/dev/null 2>&1 -// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> +// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> // CHECK-DAG: #[[$stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)> diff --git a/mlir/test/Dialect/Linalg/fold-affine-min-scf.mlir b/mlir/test/Dialect/Linalg/fold-affine-min-scf.mlir --- a/mlir/test/Dialect/Linalg/fold-affine-min-scf.mlir +++ b/mlir/test/Dialect/Linalg/fold-affine-min-scf.mlir @@ -15,7 +15,7 @@ // CHECK-NEXT: %[[C2I64:.*]] = index_cast %[[C2:.*]] // CHECK-NEXT: store %[[C2I64]], %{{.*}}[] : memref scf.for %i = %c0 to %c4 step %c2 { - %1 = affine.min affine_map<(d0, d1)[] -> (2, d1 - d0)> (%i, %c4) + %1 = affine.min affine_map<(d0, d1) [] -> (2, d1 - d0)> (%i, %c4) %2 = index_cast %1: index to i64 store %2, %A[]: memref } @@ -25,7 +25,7 @@ // CHECK-NEXT: %[[C2I64:.*]] = index_cast %[[C2:.*]] // CHECK-NEXT: store %[[C2I64]], %{{.*}}[] : memref scf.for %i = %c1 to %c7 step %c2 { - %1 = affine.min affine_map<(d0)[s0] -> (s0 - d0, 2)> (%i)[%c7] + %1 = affine.min affine_map<(d0) [s0] -> (s0 - d0, 2)> (%i) [%c7] %2 = index_cast %1: index to i64 store %2, %A[]: memref } @@ -35,7 +35,7 @@ // CHECK: affine.min // CHECK: index_cast scf.for %i = %c1 to %c4 step %c2 { - %1 = affine.min affine_map<(d0)[s0] -> (2, s0 - d0)> (%i)[%c4] + %1 = affine.min affine_map<(d0) [s0] -> (2, s0 - d0)> (%i) [%c4] %2 = index_cast %1: index to i64 store %2, %A[]: memref } @@ -75,7 +75,7 @@ // CHECK: scf.for // CHECK: affine.min // CHECK: index_cast - %ub2 = affine.apply affine_map<(d0)[s0] -> (s0 * d0)> (%step)[%step] + %ub2 = affine.apply affine_map<(d0) [s0] -> (s0 * d0)> (%step) [%step] scf.for %i = %c0 to %ub2 step %step { %1 = affine.min affine_map<(d0, d1, d2) -> (d0, d2 - d1)> (%step, %i, %ub2) %2 = index_cast %1: index to i64 @@ -98,7 +98,7 @@ // CHECK-NEXT: %[[C2I64:.*]] = index_cast %[[C2:.*]] // CHECK-NEXT: store %[[C2I64]], %{{.*}}[] : memref scf.parallel (%i) = (%c0) to (%c4) step (%c2) { - %1 = affine.min affine_map<(d0, d1)[] -> (2, d1 - d0)> (%i, %c4) + %1 = affine.min affine_map<(d0, d1) [] -> (2, d1 - d0)> (%i, %c4) %2 = index_cast %1: index to i64 store %2, %A[]: memref } @@ -108,7 +108,7 @@ // CHECK-NEXT: %[[C2I64:.*]] = index_cast %[[C2:.*]] // CHECK-NEXT: store %[[C2I64]], %{{.*}}[] : memref scf.parallel (%i) = (%c1) to (%c7) step (%c2) { - %1 = affine.min affine_map<(d0)[s0] -> (2, s0 - d0)> (%i)[%c7] + %1 = affine.min affine_map<(d0) [s0] -> (2, s0 - d0)> (%i) [%c7] %2 = index_cast %1: index to i64 store %2, %A[]: memref } @@ -136,7 +136,7 @@ // CHECK: scf.parallel // CHECK: affine.min // CHECK: index_cast - %ub2 = affine.apply affine_map<(d0)[s0] -> (s0 * d0)> (%step)[%step] + %ub2 = affine.apply affine_map<(d0) [s0] -> (s0 * d0)> (%step) [%step] scf.parallel (%i) = (%c0) to (%ub2) step (%step) { %1 = affine.min affine_map<(d0, d1, d2) -> (d0, d2 - d1)> (%step, %i, %ub2) %2 = index_cast %1: index to i64 diff --git a/mlir/test/Dialect/Linalg/fusion-indexed-generic.mlir b/mlir/test/Dialect/Linalg/fusion-indexed-generic.mlir --- a/mlir/test/Dialect/Linalg/fusion-indexed-generic.mlir +++ b/mlir/test/Dialect/Linalg/fusion-indexed-generic.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s -test-linalg-greedy-fusion -split-input-file | FileCheck %s -#map = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +#map = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> #id_2d = affine_map<(d0, d1) -> (d0, d1)> #pointwise_2d_trait = { indexing_maps = [#id_2d, #id_2d, #id_2d], @@ -62,7 +62,7 @@ // ----- -#map = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +#map = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> #id_2d = affine_map<(d0, d1) -> (d0, d1)> #pointwise_2d_trait = { indexing_maps = [#id_2d, #id_2d, #id_2d], @@ -124,7 +124,7 @@ // ----- -#map = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +#map = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> #id_2d = affine_map<(d0, d1) -> (d0, d1)> #pointwise_2d_trait = { indexing_maps = [#id_2d, #id_2d, #id_2d], diff --git a/mlir/test/Dialect/Linalg/fusion-pattern.mlir b/mlir/test/Dialect/Linalg/fusion-pattern.mlir --- a/mlir/test/Dialect/Linalg/fusion-pattern.mlir +++ b/mlir/test/Dialect/Linalg/fusion-pattern.mlir @@ -12,10 +12,10 @@ } } -// CHECK-DAG: #[[MAP0:.+]] = affine_map<(d0)[s0] -> (32, -d0 + s0)> -// CHECK-DAG: #[[MAP1:.+]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECK-DAG: #[[MAP2:.+]] = affine_map<(d0)[s0] -> (64, -d0 + s0)> -// CHECK-DAG: #[[MAP3:.+]] = affine_map<(d0)[s0] -> (16, -d0 + s0)> +// CHECK-DAG: #[[MAP0:.+]] = affine_map<(d0) [s0] -> (32, -d0 + s0)> +// CHECK-DAG: #[[MAP1:.+]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[MAP2:.+]] = affine_map<(d0) [s0] -> (64, -d0 + s0)> +// CHECK-DAG: #[[MAP3:.+]] = affine_map<(d0) [s0] -> (16, -d0 + s0)> // CHECK: func @basic_fusion // CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]+]]: memref // CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]+]]: memref @@ -33,27 +33,27 @@ // CHECK: scf.parallel (%[[IV0:.+]], %[[IV1:.+]]) = // CHECK-SAME: to (%[[M]], %[[N]]) // CHECK-SAME: step (%[[C32]], %[[C64]]) { -// CHECK: %[[TILE_M:.+]] = affine.min #[[MAP0]](%[[IV0]])[%[[M]]] +// CHECK: %[[TILE_M:.+]] = affine.min #[[MAP0]](%[[IV0]]) [%[[M]]] // CHECK: %[[K:.+]] = dim %[[ARG0]], %[[C1]] // CHECK: %[[SV1:.+]] = subview %[[ARG0]][%[[IV0]], 0] // CHECK-SAME: [%[[TILE_M]], %[[K]]] // CHECK: %[[K_2:.+]] = dim %[[ARG1]], %[[C0]] -// CHECK: %[[TILE_N:.+]] = affine.min #[[MAP2]](%[[IV1]])[%[[N]]] +// CHECK: %[[TILE_N:.+]] = affine.min #[[MAP2]](%[[IV1]]) [%[[N]]] // CHECK: %[[SV2:.+]] = subview %[[ARG1]][0, %[[IV1]]] // CHECK-SAME: %[[K_2]], %[[TILE_N]] // CHECK: %[[M_2:.+]] = dim %[[ARG2]], %[[C0]] -// CHECK: %[[TILE_M_2:.+]] = affine.min #[[MAP0]](%[[IV0]])[%[[M_2]]] +// CHECK: %[[TILE_M_2:.+]] = affine.min #[[MAP0]](%[[IV0]]) [%[[M_2]]] // CHECK: %[[N_2:.+]] = dim %[[ARG2]], %[[C1]] -// CHECK: %[[TILE_N_2:.+]] = affine.min #[[MAP2]](%[[IV1]])[%[[N_2]]] +// CHECK: %[[TILE_N_2:.+]] = affine.min #[[MAP2]](%[[IV1]]) [%[[N_2]]] // CHECK: %[[SV3:.+]] = subview %[[ARG2]][%[[IV0]], %[[IV1]]] // CHECK-SAME: [%[[TILE_M_2]], %[[TILE_N_2]]] // CHECK: linalg.fill(%[[SV3]], %[[CST]]) // CHECK-SAME: __internal_linalg_transform__ = "after_basic_fusion_producer" // CHECK: scf.for %[[IV2:.+]] = %[[C0]] to %[[K]] step %[[C16]] { -// CHECK: %[[TILE_K:.+]] = affine.min #[[MAP3]](%[[IV2]])[%[[K]]] +// CHECK: %[[TILE_K:.+]] = affine.min #[[MAP3]](%[[IV2]]) [%[[K]]] // CHECK: %[[SV4:.+]] = subview %[[SV1]][0, %[[IV2]]] // CHECK-SAME: [%[[TILE_M]], %[[TILE_K]]] -// CHECK: %[[TILE_K_2:.+]] = affine.min #[[MAP3]](%[[IV2]])[%[[K_2]]] +// CHECK: %[[TILE_K_2:.+]] = affine.min #[[MAP3]](%[[IV2]]) [%[[K_2]]] // CHECK: %[[SV5:.+]] = subview %[[SV2]][%[[IV2]], 0] // CHECK-SAME: [%[[TILE_K_2]], %[[TILE_N]]] // CHECK: linalg.matmul @@ -80,10 +80,10 @@ return } } -// CHECK-DAG: #[[MAP0:.+]] = affine_map<(d0)[s0] -> (64, -d0 + s0)> -// CHECK-DAG: #[[MAP1:.+]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECK-DAG: #[[MAP2:.+]] = affine_map<(d0)[s0] -> (32, -d0 + s0)> -// CHECK-DAG: #[[MAP3:.+]] = affine_map<(d0)[s0] -> (16, -d0 + s0)> +// CHECK-DAG: #[[MAP0:.+]] = affine_map<(d0) [s0] -> (64, -d0 + s0)> +// CHECK-DAG: #[[MAP1:.+]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[MAP2:.+]] = affine_map<(d0) [s0] -> (32, -d0 + s0)> +// CHECK-DAG: #[[MAP3:.+]] = affine_map<(d0) [s0] -> (16, -d0 + s0)> // CHECK: func @rhs_fusion // CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]+]]: memref // CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]+]]: memref @@ -101,12 +101,12 @@ // CHECK: scf.parallel (%[[IV0:.+]]) = // CHECK-SAME: (%[[C0]]) to (%[[N]]) step (%[[C64]]) { // CHECK: %[[K:.+]] = dim %[[ARG2]], %[[C0]] -// CHECK: %[[TILE_N:.+]] = affine.min #[[MAP0]](%[[IV0]])[%[[N]]] +// CHECK: %[[TILE_N:.+]] = affine.min #[[MAP0]](%[[IV0]]) [%[[N]]] // CHECK: %[[SV1:.+]] = subview %[[ARG2]][0, %[[IV0]]] // CHECK-SAME: [%[[K]], %[[TILE_N]]] // CHECK: %[[M:.+]] = dim %[[ARG3]], %[[C0]] // CHECK: %[[N_2:.+]] = dim %[[ARG3]], %[[C1]] -// CHECK: %[[TILE_N_2:.+]] = affine.min #[[MAP0]](%[[IV0]])[%[[N_2]]] +// CHECK: %[[TILE_N_2:.+]] = affine.min #[[MAP0]](%[[IV0]]) [%[[N_2]]] // CHECK: %[[SV2:.+]] = subview %[[ARG3]][0, %[[IV0]]] // CHECK-SAME: [%[[M]], %[[TILE_N_2]]] // CHECK: %[[SV3:.+]] = subview %[[ARG1]][0, %[[IV0]]] @@ -119,14 +119,14 @@ // CHECK: scf.parallel (%[[IV1:.+]]) = // CHECK-SAME: (%[[C0]]) to (%[[M_2]]) step (%[[C32]]) { // CHECK-NEXT: scf.for %[[IV2:.+]] = %[[C0]] to %[[K_2]] step %[[C16]] { -// CHECK: %[[TILE_M:.+]] = affine.min #[[MAP2]](%[[IV1]])[%[[M_2]]] -// CHECK: %[[TILE_K:.+]] = affine.min #[[MAP3]](%[[IV2]])[%[[K_2]]] +// CHECK: %[[TILE_M:.+]] = affine.min #[[MAP2]](%[[IV1]]) [%[[M_2]]] +// CHECK: %[[TILE_K:.+]] = affine.min #[[MAP3]](%[[IV2]]) [%[[K_2]]] // CHECK: %[[SV4:.+]] = subview %[[ARG0]][%[[IV1]], %[[IV2]]] // CHECK-SAME: [%[[TILE_M]], %[[TILE_K]]] -// CHECK: %[[TILE_K_2:.+]] = affine.min #[[MAP3]](%[[IV2]])[%[[K]]] +// CHECK: %[[TILE_K_2:.+]] = affine.min #[[MAP3]](%[[IV2]]) [%[[K]]] // CHECK: %[[SV5:.+]] = subview %[[SV1]][%[[IV2]], 0] // CHECK-SAME: [%[[TILE_K_2]], %[[TILE_N]]] -// CHECK: %[[TILE_M_2:.+]] = affine.min #[[MAP2]](%[[IV1]])[%[[M]]] +// CHECK: %[[TILE_M_2:.+]] = affine.min #[[MAP2]](%[[IV1]]) [%[[M]]] // CHECK: %[[SV6:.+]] = subview %[[SV2]][%[[IV1]], 0] // CHECK-SAME: [%[[TILE_M_2]], %[[TILE_N_2]]] // CHECK: linalg.matmul @@ -155,10 +155,10 @@ return } } -// CHECK-DAG: #[[MAP0:.+]] = affine_map<(d0)[s0] -> (32, -d0 + s0)> -// CHECK-DAG: #[[MAP1:.+]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECK-DAG: #[[MAP2:.+]] = affine_map<(d0)[s0] -> (16, -d0 + s0)> -// CHECK-DAG: #[[MAP3:.+]] = affine_map<(d0)[s0] -> (64, -d0 + s0)> +// CHECK-DAG: #[[MAP0:.+]] = affine_map<(d0) [s0] -> (32, -d0 + s0)> +// CHECK-DAG: #[[MAP1:.+]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[MAP2:.+]] = affine_map<(d0) [s0] -> (16, -d0 + s0)> +// CHECK-DAG: #[[MAP3:.+]] = affine_map<(d0) [s0] -> (64, -d0 + s0)> // CHECK: func @two_operand_fusion // CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]+]]: memref // CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]+]]: memref @@ -177,12 +177,12 @@ // CHECK-DAG: %[[M:.+]] = dim %[[ARG1]], %[[C0]] // CHECK: scf.parallel (%[[IV0:.+]]) = // CHECK-SAME: (%[[C0]]) to (%[[M]]) step (%[[C32]]) { -// CHECK: %[[TILE_M:.+]] = affine.min #[[MAP0]](%[[IV0]])[%[[M]]] +// CHECK: %[[TILE_M:.+]] = affine.min #[[MAP0]](%[[IV0]]) [%[[M]]] // CHECK: %[[K:.+]] = dim %[[ARG1]], %[[C1]] // CHECK: %[[SV1:.+]] = subview %[[ARG1]][%[[IV0]], 0] // CHECK-SAME: [%[[TILE_M]], %[[K]]] // CHECK: %[[M_2:.+]] = dim %[[ARG3]], %[[C0]] -// CHECK: %[[TILE_M_2:.+]] = affine.min #[[MAP0]](%[[IV0]])[%[[M_2]]] +// CHECK: %[[TILE_M_2:.+]] = affine.min #[[MAP0]](%[[IV0]]) [%[[M_2]]] // CHECK: %[[N:.+]] = dim %[[ARG3]], %[[C1]] // CHECK: %[[SV2:.+]] = subview %[[ARG3]][%[[IV0]], 0] // CHECK-SAME: [%[[TILE_M_2]], %[[N]]] @@ -196,15 +196,15 @@ // CHECK: scf.parallel (%[[IV1:.+]]) = // CHECK-SAME: (%[[C0]]) to (%[[N_2]]) step (%[[C64]]) { // CHECK-NEXT: scf.for %[[IV2:.+]] = %[[C0]] to %[[K]] step %[[C16]] { -// CHECK: %[[TILE_K:.+]] = affine.min #[[MAP2]](%[[IV2]])[%[[K]]] +// CHECK: %[[TILE_K:.+]] = affine.min #[[MAP2]](%[[IV2]]) [%[[K]]] // CHECK: %[[SV4:.+]] = subview %[[SV1]][0, %[[IV2]]] // CHECK-SAME: [%[[TILE_M]], %[[TILE_K]]] // CHECK: %[[K_2:.+]] = dim %[[ARG2]], %[[C0]] -// CHECK: %[[TILE_K_2:.+]] = affine.min #[[MAP2]](%[[IV2]])[%[[K_2]]] -// CHECK: %[[TILE_N:.+]] = affine.min #[[MAP3]](%[[IV1]])[%[[N_2]]] +// CHECK: %[[TILE_K_2:.+]] = affine.min #[[MAP2]](%[[IV2]]) [%[[K_2]]] +// CHECK: %[[TILE_N:.+]] = affine.min #[[MAP3]](%[[IV1]]) [%[[N_2]]] // CHECK: %[[SV5:.+]] = subview %[[ARG2]][%[[IV2]], %[[IV1]]] // CHECK-SAME: [%[[TILE_K_2]], %[[TILE_N]]] -// CHECK: %[[TILE_N_2:.+]] = affine.min #[[MAP3]](%[[IV1]])[%[[N]]] +// CHECK: %[[TILE_N_2:.+]] = affine.min #[[MAP3]](%[[IV1]]) [%[[N]]] // CHECK: %[[SV6:.+]] = subview %[[SV2]][0, %[[IV1]]] // CHECK-SAME: [%[[TILE_M_2]], %[[TILE_N_2]]] // CHECK: linalg.matmul @@ -232,10 +232,10 @@ return } } -// CHECK-DAG: #[[MAP0:.+]] = affine_map<(d0)[s0] -> (32, -d0 + s0)> -// CHECK-DAG: #[[MAP1:.+]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECK-DAG: #[[MAP2:.+]] = affine_map<(d0)[s0] -> (16, -d0 + s0)> -// CHECK-DAG: #[[MAP3:.+]] = affine_map<(d0)[s0] -> (64, -d0 + s0)> +// CHECK-DAG: #[[MAP0:.+]] = affine_map<(d0) [s0] -> (32, -d0 + s0)> +// CHECK-DAG: #[[MAP1:.+]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[MAP2:.+]] = affine_map<(d0) [s0] -> (16, -d0 + s0)> +// CHECK-DAG: #[[MAP3:.+]] = affine_map<(d0) [s0] -> (64, -d0 + s0)> // CHECK: func @matmul_fusion // CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]+]]: memref // CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]+]]: memref @@ -252,12 +252,12 @@ // CHECK-DAG: %[[M:.+]] = dim %[[ARG2]], %[[C0]] // CHECK: scf.parallel (%[[IV0:.+]]) = // CHECK-SAME: (%[[C0]]) to (%[[M]]) step (%[[C32]]) { -// CHECK: %[[TILE_M:.+]] = affine.min #[[MAP0]](%[[IV0]])[%[[M]]] +// CHECK: %[[TILE_M:.+]] = affine.min #[[MAP0]](%[[IV0]]) [%[[M]]] // CHECK: %[[K2:.+]] = dim %[[ARG2]], %[[C1]] // CHECK: %[[SV1:.+]] = subview %[[ARG2]][%[[IV0]], 0] // CHECK-SAME: [%[[TILE_M]], %[[K2]]] // CHECK: %[[M_2:.+]] = dim %[[ARG4]], %[[C0]] -// CHECK: %[[TILE_M_2:.+]] = affine.min #[[MAP0]](%[[IV0]])[%[[M_2]]] +// CHECK: %[[TILE_M_2:.+]] = affine.min #[[MAP0]](%[[IV0]]) [%[[M_2]]] // CHECK: %[[N:.+]] = dim %[[ARG4]], %[[C1]] // CHECK: %[[SV2:.+]] = subview %[[ARG4]][%[[IV0]], 0] // CHECK-SAME: [%[[TILE_M_2]], %[[N]]] @@ -274,15 +274,15 @@ // CHECK: scf.parallel (%[[IV1:.+]]) = // CHECK-SAME: (%[[C0]]) to (%[[N_2]]) step (%[[C64]]) { // CHECK-NEXT: scf.for %[[IV2:.+]] = %[[C0]] to %[[K]] step %[[C16]] { -// CHECK: %[[TILE_K:.+]] = affine.min #[[MAP2]](%[[IV2]])[%[[K]]] +// CHECK: %[[TILE_K:.+]] = affine.min #[[MAP2]](%[[IV2]]) [%[[K]]] // CHECK: %[[SV6:.+]] = subview %[[SV1]][0, %[[IV2]]] // CHECK-SAME: [%[[TILE_M]], %[[TILE_K]]] // CHECK: %[[K_2:.+]] = dim %[[ARG3]], %[[C0]] -// CHECK: %[[TILE_K_2:.+]] = affine.min #[[MAP2]](%[[IV2]])[%[[K_2]]] -// CHECK: %[[TILE_N:.+]] = affine.min #[[MAP3]](%[[IV1]])[%[[N_2]]] +// CHECK: %[[TILE_K_2:.+]] = affine.min #[[MAP2]](%[[IV2]]) [%[[K_2]]] +// CHECK: %[[TILE_N:.+]] = affine.min #[[MAP3]](%[[IV1]]) [%[[N_2]]] // CHECK: %[[SV7:.+]] = subview %[[ARG3]][%[[IV2]], %[[IV1]]] // CHECK-SAME: [%[[TILE_K_2]], %[[TILE_N]]] -// CHECK: %[[TILE_N_2:.+]] = affine.min #[[MAP3]](%[[IV1]])[%[[N]]] +// CHECK: %[[TILE_N_2:.+]] = affine.min #[[MAP3]](%[[IV1]]) [%[[N]]] // CHECK: %[[SV8:.+]] = subview %[[SV2]][0, %[[IV1]]] // CHECK-SAME: [%[[TILE_M_2]], %[[TILE_N_2]]] // CHECK: linalg.matmul diff --git a/mlir/test/Dialect/Linalg/fusion.mlir b/mlir/test/Dialect/Linalg/fusion.mlir --- a/mlir/test/Dialect/Linalg/fusion.mlir +++ b/mlir/test/Dialect/Linalg/fusion.mlir @@ -47,7 +47,7 @@ // ----- -// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s0 + d1 * s1)> +// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s0 + d1 * s1)> func @f2(%A: memref, %B: memref, %C: memref, @@ -98,7 +98,7 @@ // ----- -// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s0 + d1 * s1)> +// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s0 + d1 * s1)> func @f3(%A: memref, %B: memref, @@ -152,7 +152,7 @@ // ----- -// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s0 + d1 * s1)> +// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s0 + d1 * s1)> func @f4(%A: memref, %B: memref, @@ -211,7 +211,7 @@ // ----- -// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s0 + d1 * s1)> +// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s0 + d1 * s1)> func @f5(%A: memref, %B: memref, %C: memref, @@ -594,7 +594,7 @@ #map0 = affine_map<(d0, d1) -> (d0)> #map1 = affine_map<(d0, d1) -> (d0, d1)> -#map2 = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +#map2 = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> func @fusion_of_three(%arg0: memref<100x10xf32>, %arg1: memref<100xf32>, @@ -662,8 +662,8 @@ // ----- #map0 = affine_map<(d0, d1, d2) -> (d0, d1 - d2)> -#map1 = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3, s4] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4)> -#map2 = affine_map<()[s0] -> (s0 + 3)> +#map1 = affine_map<(d0, d1, d2, d3) [s0, s1, s2, s3, s4] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4)> +#map2 = affine_map<() [s0] -> (s0 + 3)> func @fill_and_conv(%arg0: memref<1x4x5x1xf32>, %arg1: memref<2x3x1x1xf32>, %arg2: memref<1x4x5x1xf32>) { %cst = constant 0.000000e+00 : f32 @@ -688,7 +688,7 @@ scf.for %arg3 = %c0 to %6 step %c2 { scf.for %arg4 = %c0 to %10 step %c3 { %15 = affine.min #map0(%c2, %c1, %arg3) - %16 = affine.apply #map2()[%7] + %16 = affine.apply #map2() [%7] %17 = affine.min #map0(%16, %c4, %arg4) %18 = dim %arg0, %c2 : memref<1x4x5x1xf32> %19 = dim %arg0, %c3 : memref<1x4x5x1xf32> diff --git a/mlir/test/Dialect/Linalg/invalid.mlir b/mlir/test/Dialect/Linalg/invalid.mlir --- a/mlir/test/Dialect/Linalg/invalid.mlir +++ b/mlir/test/Dialect/Linalg/invalid.mlir @@ -8,18 +8,18 @@ // ----- -func @slice_number_of_indexings(%arg0: memref(off + M * i + j)>>) { +func @slice_number_of_indexings(%arg0: memref(off + M * i + j)>>) { // expected-error @+2 {{expected 2 indexings, got 1}} %c0 = constant 0: index - %0 = linalg.slice %arg0[%c0] : memref(off + M * i + j)>>, index, memref(off + M * i + j)>> + %0 = linalg.slice %arg0[%c0] : memref(off + M * i + j)>>, index, memref(off + M * i + j)>> } // ----- -func @slice_rank_vs_range_indices(%arg0: memref(off + M * i + j)>>) { +func @slice_rank_vs_range_indices(%arg0: memref(off + M * i + j)>>) { // expected-error @+2 {{op expected rank of the view(1) to be the number of ranges(0)}} %c0 = constant 0: index - %0 = linalg.slice %arg0[%c0, %c0] : memref(off + M * i + j)>>, index, index, memref(off + i)>> + %0 = linalg.slice %arg0[%c0, %c0] : memref(off + M * i + j)>>, index, index, memref(off + i)>> } // ----- @@ -33,9 +33,9 @@ // ----- -func @yield_parent(%arg0: memref(off + i)>>) { +func @yield_parent(%arg0: memref(off + i)>>) { // expected-error @+1 {{op expected parent op with LinalgOp interface}} - linalg.yield %arg0: memref(off + i)>> + linalg.yield %arg0: memref(off + i)>> } // ----- @@ -66,7 +66,7 @@ func @generic_symbol_in_map(%arg0: memref) { // expected-error @+1 {{expected the number of symbols in indexing_map #0 to match rank of operand `symbol_source`}} linalg.generic { - indexing_maps = [ affine_map<()[N] -> (0)> ], + indexing_maps = [ affine_map<() [N] -> (0)> ], iterator_types = ["parallel"]} outs(%arg0 : memref) { ^bb(%i : i32): @@ -79,7 +79,7 @@ func @generic_symbol_source_out_of_range(%arg0: memref) { // expected-error @+1 {{symbol_source index out of range}} linalg.generic { - indexing_maps = [ affine_map<()[N] -> (0)> ], + indexing_maps = [ affine_map<() [N] -> (0)> ], iterator_types = ["parallel"], symbol_source = 1} outs(%arg0 : memref) { @@ -103,12 +103,12 @@ // ----- -func @generic_one_d_view(%arg0: memref(off + i)>>) { - // expected-error @+1 {{op expected indexing_map #0 results to match view rank: 'memref (d0 + s0)>>'}} +func @generic_one_d_view(%arg0: memref(off + i)>>) { + // expected-error @+1 {{op expected indexing_map #0 results to match view rank: 'memref (d0 + s0)>>'}} linalg.generic { indexing_maps = [ affine_map<() -> (0, 0)> ], iterator_types = []} - outs(%arg0 : memref(off + i)>>) { + outs(%arg0 : memref(off + i)>>) { ^bb(%f : f32): linalg.yield %f: f32 } @@ -116,12 +116,12 @@ // ----- -func @generic_result_0_element_type(%arg0: memref(off + i)>>) { +func @generic_result_0_element_type(%arg0: memref(off + i)>>) { // expected-error @+7 {{'linalg.yield' op type of yield operand 1 ('i4') doesn't match the element type of the enclosing linalg.generic op ('f32')}} linalg.generic { indexing_maps = [ affine_map<(i) -> (i)> ], iterator_types = ["parallel"]} - outs(%arg0 : memref(off + i)>>) { + outs(%arg0 : memref(off + i)>>) { ^bb(%0: f32): %1 = constant 1: i4 linalg.yield %1: i4 @@ -130,7 +130,7 @@ // ----- -func @generic_singular_maps(%arg0: memref(off + i)>>, %arg1: memref(off + i)>>) { +func @generic_singular_maps(%arg0: memref(off + i)>>, %arg1: memref(off + i)>>) { // expected-error @+1 {{op expected the concatenation of maps in indexing_map to be invertible}} linalg.generic { indexing_maps = [ @@ -138,8 +138,8 @@ affine_map<(i, j) -> (i + j)> ], iterator_types = ["parallel","parallel"]} - ins(%arg0 : memref(off + i)>>) - outs(%arg1 : memref(off + i)>>) { + ins(%arg0 : memref(off + i)>>) + outs(%arg1 : memref(off + i)>>) { ^bb(%0: f32, %1: f32): linalg.yield %1: f32 } @@ -249,7 +249,7 @@ func @indexed_generic_arg_count(%arg0: memref) { // expected-error @+1 {{op expected number of block arguments to match number of operands + number of loops}} linalg.indexed_generic { - indexing_maps = [ affine_map<()[] -> ()> ], + indexing_maps = [ affine_map<() [] -> ()> ], iterator_types = []} outs(%arg0 : memref) { ^bb(%0: index, %1: f32): @@ -286,12 +286,12 @@ // ----- -func @generic_result_0_element_type(%arg0: memref(off + i)>>) { +func @generic_result_0_element_type(%arg0: memref(off + i)>>) { // expected-error @+7 {{type of yield operand 1 ('i1') doesn't match the element type of the enclosing linalg.generic op ('f32')}} linalg.generic { indexing_maps = [ affine_map<(i) -> (i)> ], iterator_types = ["parallel"]} - outs(%arg0 : memref(off + i)>>) { + outs(%arg0 : memref(off + i)>>) { ^bb(%i: f32): %0 = constant 0: i1 linalg.yield %0: i1 @@ -300,12 +300,12 @@ // ----- -func @generic_result_tensor_type(%arg0: memref(off + i)>>) { +func @generic_result_tensor_type(%arg0: memref(off + i)>>) { // expected-error @+1 {{op result #0 must be ranked tensor of any type values, but got 'f32'}} %0 = linalg.generic { indexing_maps = [ affine_map<(i) -> (i)> ], iterator_types = ["parallel"]} - ins(%arg0 : memref(off + i)>>) { + ins(%arg0 : memref(off + i)>>) { ^bb(%i: f32): linalg.yield %i: f32 } -> f32 @@ -384,9 +384,9 @@ // ----- func @reshape(%arg0: memref) { - // expected-error @+1 {{expected collapsed type to be 'memref', but got 'memref (d0 * s0 + d1)>>'}} + // expected-error @+1 {{expected collapsed type to be 'memref', but got 'memref (d0 * s0 + d1)>>'}} %0 = linalg.reshape %arg0 [affine_map<(i, j, k) -> (i, j)>, affine_map<(i, j, k) -> (k)>] : - memref into memref (d0 * s0 + d1)>> + memref into memref (d0 * s0 + d1)>> } // ----- diff --git a/mlir/test/Dialect/Linalg/loops.mlir b/mlir/test/Dialect/Linalg/loops.mlir --- a/mlir/test/Dialect/Linalg/loops.mlir +++ b/mlir/test/Dialect/Linalg/loops.mlir @@ -4,35 +4,35 @@ // Test that we can lower all the way to LLVM without crashing, don't check results here. // RUN: mlir-opt %s -convert-linalg-to-loops -convert-linalg-to-llvm -o=/dev/null 2>&1 -// CHECKLOOP-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> -// CHECKLOOP-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECKLOOP-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> -// CHECKLOOP-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> +// CHECKLOOP-DAG: #[[$strided1D:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> +// CHECKLOOP-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECKLOOP-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> +// CHECKLOOP-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3) [s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> // CHECKLOOP-DAG: #[[$clampMinMap:.*]] = affine_map<(d0) -> (d0, 0)> // CHECKLOOP-DAG: #[[$stride1Dilation1:.*]] = affine_map<(d0, d1) -> (d0 + d1)> // CHECKLOOP-DAG: #[[$stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)> // CHECKLOOP-DAG: #[[$stride2Dilation4:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1 * 4)> // CHECKLOOP-DAG: #[[$stride3Dilation5:.*]] = affine_map<(d0, d1) -> (d0 * 3 + d1 * 5)> -// CHECKLOOP-DAG: #[[$convLowerBound:.*]] = affine_map<()[s0] -> (s0 floordiv 2)> -// CHECKLOOP-DAG: #[[$convUpperBound:.*]] = affine_map<()[s0, s1] -> (s1 + s0 floordiv 2 - s0 + 1)> -// CHECKLOOP-DAG: #[[$convMap:.*]] = affine_map<(d0, d1)[s0] -> (d0 + d1 - s0 floordiv 2)> +// CHECKLOOP-DAG: #[[$convLowerBound:.*]] = affine_map<() [s0] -> (s0 floordiv 2)> +// CHECKLOOP-DAG: #[[$convUpperBound:.*]] = affine_map<() [s0, s1] -> (s1 + s0 floordiv 2 - s0 + 1)> +// CHECKLOOP-DAG: #[[$convMap:.*]] = affine_map<(d0, d1) [s0] -> (d0 + d1 - s0 floordiv 2)> // CHECKLOOP-DAG: #[[$stride1Dilation1Padding1:.*]] = affine_map<(d0, d1) -> (d0 + d1 - 1)> // CHECKLOOP-DAG: #[[$stride1Dilation1Padding2:.*]] = affine_map<(d0, d1) -> (d0 + d1 - 2)> -// CHECKPARALLEL-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> -// CHECKPARALLEL-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECKPARALLEL-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> -// CHECKPARALLEL-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> +// CHECKPARALLEL-DAG: #[[$strided1D:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> +// CHECKPARALLEL-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECKPARALLEL-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> +// CHECKPARALLEL-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3) [s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> // CHECKPARALLEL-DAG: #[[$clampMinMap:.*]] = affine_map<(d0) -> (d0, 0)> // CHECKPARALLEL-DAG: #[[$stride1Dilation1:.*]] = affine_map<(d0, d1) -> (d0 + d1)> // CHECKPARALLEL-DAG: #[[$stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)> // CHECKPARALLEL-DAG: #[[$stride2Dilation4:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1 * 4)> // CHECKPARALLEL-DAG: #[[$stride3Dilation5:.*]] = affine_map<(d0, d1) -> (d0 * 3 + d1 * 5)> -// CHECKPARALLEL-DAG: #[[$convLowerBound:.*]] = affine_map<()[s0] -> (s0 floordiv 2)> -// CHECKPARALLEL-DAG: #[[$convUpperBound:.*]] = affine_map<()[s0, s1] -> (s1 + s0 floordiv 2 - s0 + 1)> -// CHECKPARALLEL-DAG: #[[$convMap:.*]] = affine_map<(d0, d1)[s0] -> (d0 + d1 - s0 floordiv 2)> +// CHECKPARALLEL-DAG: #[[$convLowerBound:.*]] = affine_map<() [s0] -> (s0 floordiv 2)> +// CHECKPARALLEL-DAG: #[[$convUpperBound:.*]] = affine_map<() [s0, s1] -> (s1 + s0 floordiv 2 - s0 + 1)> +// CHECKPARALLEL-DAG: #[[$convMap:.*]] = affine_map<(d0, d1) [s0] -> (d0 + d1 - s0 floordiv 2)> // CHECKPARALLEL-DAG: #[[$stride1Dilation1Padding1:.*]] = affine_map<(d0, d1) -> (d0 + d1 - 1)> // CHECKPARALLEL-DAG: #[[$stride1Dilation1Padding2:.*]] = affine_map<(d0, d1) -> (d0 + d1 - 2)> @@ -1229,9 +1229,9 @@ // CHECKPARALLEL: store %[[res]], %[[mC]][%[[b]], %[[m]], %[[n]]] : memref #conv_1d_accesses = [ - affine_map<(m, n)[s0] -> (m + n - s0 floordiv 2)>, // in - affine_map<(m, n)[s0] -> (n)>, // filter - affine_map<(m, n)[s0] -> (m)> // out + affine_map<(m, n) [s0] -> (m + n - s0 floordiv 2)>, // in + affine_map<(m, n) [s0] -> (n)>, // filter + affine_map<(m, n) [s0] -> (m)> // out ] #conv_1d_trait = { @@ -1264,12 +1264,12 @@ // CHECKLOOP: %[[c0:.*]] = constant 0 : index // CHECKLOOP: %[[dim0:.*]] = dim %[[arg0]], %[[c0]] : memref // CHECKLOOP: %[[dim1:.*]] = dim %[[arg1]], %[[c0]] : memref -// CHECKLOOP: %[[lowerBound:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim1]]] -// CHECKLOOP: %[[upperBound:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim1]], %[[dim0]]] +// CHECKLOOP: %[[lowerBound:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim1]]] +// CHECKLOOP: %[[upperBound:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim1]], %[[dim0]]] // CHECKLOOP: scf.for %[[b:.*]] = %[[lowerBound]] to %[[upperBound]] step %{{.*}} { // CHECKLOOP: scf.for %[[m:.*]] = %{{.*}} to %[[dim1]] step %{{.*}} { // CHECKLOOP: %[[dim2:.*]] = dim %[[arg1]], %[[c0]] : memref -// CHECKLOOP: %[[aff:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim2]]] +// CHECKLOOP: %[[aff:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim2]]] // CHECKLOOP: %[[va:.*]] = load %[[arg0]][%[[aff]]] : memref // CHECKLOOP: %[[vb:.*]] = load %[[arg1]][%[[m]]] : memref // CHECKLOOP: %[[vc:.*]] = load %[[arg2]][%[[b]]] : memref @@ -1284,11 +1284,11 @@ // CHECKPARALLEL: %[[c0:.*]] = constant 0 : index // CHECKPARALLEL: %[[dim0:.*]] = dim %[[arg0]], %[[c0]] : memref // CHECKPARALLEL: %[[dim1:.*]] = dim %[[arg1]], %[[c0]] : memref -// CHECKPARALLEL: %[[lowerBound:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim1]]] -// CHECKPARALLEL: %[[upperBound:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim1]], %[[dim0]]] +// CHECKPARALLEL: %[[lowerBound:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim1]]] +// CHECKPARALLEL: %[[upperBound:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim1]], %[[dim0]]] // CHECKPARALLEL: scf.parallel (%[[b:.*]], %[[m:.*]]) = (%[[lowerBound]], %{{.*}}) to (%[[upperBound]], %[[dim1]]) step ({{.*}}) { // CHECKPARALLEL: %[[dim2:.*]] = dim %[[arg1]], %[[c0]] : memref -// CHECKPARALLEL: %[[aff:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim2]]] +// CHECKPARALLEL: %[[aff:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim2]]] // CHECKPARALLEL: %[[va:.*]] = load %[[arg0]][%[[aff]]] : memref // CHECKPARALLEL: %[[vb:.*]] = load %[[arg1]][%[[m]]] : memref // CHECKPARALLEL: %[[vc:.*]] = load %[[arg2]][%[[b]]] : memref @@ -1297,9 +1297,9 @@ // CHECKPARALLEL: store %[[res]], %[[arg2]][%[[b]]] : memref #conv_2d_accesses = [ - affine_map<(m, n, m1, n1)[s0, s1] -> (m + m1 - s0 floordiv 2, n + n1 - s1 floordiv 2)>, // in - affine_map<(m, n, m1, n1)[s0, s1] -> (m1, n1)>, // filter - affine_map<(m, n, m1, n1)[s0, s1] -> (m, n)> // out + affine_map<(m, n, m1, n1) [s0, s1] -> (m + m1 - s0 floordiv 2, n + n1 - s1 floordiv 2)>, // in + affine_map<(m, n, m1, n1) [s0, s1] -> (m1, n1)>, // filter + affine_map<(m, n, m1, n1) [s0, s1] -> (m, n)> // out ] #conv_2d_trait = { @@ -1335,18 +1335,18 @@ // CHECKLOOP: %[[dim1:.*]] = dim %[[arg0]], %[[c1]] : memref // CHECKLOOP: %[[dim2:.*]] = dim %[[arg1]], %[[c0]] : memref // CHECKLOOP: %[[dim3:.*]] = dim %[[arg1]], %[[c1]] : memref -// CHECKLOOP: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim2]]] -// CHECKLOOP: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim2]], %[[dim0]]] -// CHECKLOOP: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim3]]] -// CHECKLOOP: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim3]], %[[dim1]]] +// CHECKLOOP: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim2]]] +// CHECKLOOP: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim2]], %[[dim0]]] +// CHECKLOOP: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim3]]] +// CHECKLOOP: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim3]], %[[dim1]]] // CHECKLOOP: scf.for %[[i0:.*]] = %[[lowerBound1]] to %[[upperBound1]] step %{{.*}} { // CHECKLOOP: scf.for %[[i1:.*]] = %[[lowerBound2]] to %[[upperBound2]] step %{{.*}} { // CHECKLOOP: scf.for %[[i2:.*]] = %{{.*}} to %[[dim2]] step %{{.*}} { // CHECKLOOP: scf.for %[[i3:.*]] = %{{.*}} to %[[dim3]] step %{{.*}} { // CHECKLOOP: %[[dim4:.*]] = dim %[[arg1]], %[[c0]] : memref // CHECKLOOP: %[[dim5:.*]] = dim %[[arg1]], %[[c1]] : memref -// CHECKLOOP: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim4]]] -// CHECKLOOP: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim5]]] +// CHECKLOOP: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim4]]] +// CHECKLOOP: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim5]]] // CHECKLOOP: %[[va:.*]] = load %[[arg0]][%[[aff1]], %[[aff2]]] : memref // CHECKLOOP: %[[vb:.*]] = load %[[arg1]][%[[i2]], %[[i3]]] : memref // CHECKLOOP: %[[vc:.*]] = load %[[arg2]][%[[i0]], %[[i1]]] : memref @@ -1364,15 +1364,15 @@ // CHECKPARALLEL: %[[dim1:.*]] = dim %[[arg0]], %[[c1]] : memref // CHECKPARALLEL: %[[dim2:.*]] = dim %[[arg1]], %[[c0]] : memref // CHECKPARALLEL: %[[dim3:.*]] = dim %[[arg1]], %[[c1]] : memref -// CHECKPARALLEL: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim2]]] -// CHECKPARALLEL: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim2]], %[[dim0]]] -// CHECKPARALLEL: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim3]]] -// CHECKPARALLEL: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim3]], %[[dim1]]] +// CHECKPARALLEL: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim2]]] +// CHECKPARALLEL: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim2]], %[[dim0]]] +// CHECKPARALLEL: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim3]]] +// CHECKPARALLEL: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim3]], %[[dim1]]] // CHECKPARALLEL: scf.parallel (%[[i0:.*]], %[[i1:.*]], %[[i2:.*]], %[[i3:.*]]) = (%[[lowerBound1]], %[[lowerBound2]], %{{.*}}, %{{.*}}) to (%[[upperBound1]], %[[upperBound2]], %[[dim2]], %[[dim3]]) step ({{.*}}) { // CHECKPARALLEL: %[[dim4:.*]] = dim %[[arg1]], %[[c0]] : memref // CHECKPARALLEL: %[[dim5:.*]] = dim %[[arg1]], %[[c1]] : memref -// CHECKPARALLEL: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim4]]] -// CHECKPARALLEL: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim5]]] +// CHECKPARALLEL: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim4]]] +// CHECKPARALLEL: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim5]]] // CHECKPARALLEL: %[[va:.*]] = load %[[arg0]][%[[aff1]], %[[aff2]]] : memref // CHECKPARALLEL: %[[vb:.*]] = load %[[arg1]][%[[i2]], %[[i3]]] : memref // CHECKPARALLEL: %[[vc:.*]] = load %[[arg2]][%[[i0]], %[[i1]]] : memref @@ -1381,9 +1381,9 @@ // CHECKPARALLEL: store %[[res]], %[[arg2]][%[[i0]], %[[i1]]] : memref #conv_3d_accesses = [ - affine_map<(m, n, k, m1, n1, k1)[s0, s1, s2] -> (m + m1 - s0 floordiv 2, n + n1 - s1 floordiv 2, k + k1 - s2 floordiv 2)>, // in - affine_map<(m, n, k, m1, n1, k1)[s0, s1, s2] -> (m1, n1, k1)>, // filter - affine_map<(m, n, k, m1, n1, k1)[s0, s1, s2] -> (m, n, k)> // out + affine_map<(m, n, k, m1, n1, k1) [s0, s1, s2] -> (m + m1 - s0 floordiv 2, n + n1 - s1 floordiv 2, k + k1 - s2 floordiv 2)>, // in + affine_map<(m, n, k, m1, n1, k1) [s0, s1, s2] -> (m1, n1, k1)>, // filter + affine_map<(m, n, k, m1, n1, k1) [s0, s1, s2] -> (m, n, k)> // out ] #conv_3d_trait = { @@ -1422,12 +1422,12 @@ // CHECKLOOP: %[[dim3:.*]] = dim %[[arg1]], %[[c0]] : memref // CHECKLOOP: %[[dim4:.*]] = dim %[[arg1]], %[[c1]] : memref // CHECKLOOP: %[[dim5:.*]] = dim %[[arg1]], %[[c2]] : memref -// CHECKLOOP: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim3]]] -// CHECKLOOP: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim3]], %[[dim0]]] -// CHECKLOOP: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim4]]] -// CHECKLOOP: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim4]], %[[dim1]]] -// CHECKLOOP: %[[lowerBound3:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim5]]] -// CHECKLOOP: %[[upperBound3:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim5]], %[[dim2]]] +// CHECKLOOP: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim3]]] +// CHECKLOOP: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim3]], %[[dim0]]] +// CHECKLOOP: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim4]]] +// CHECKLOOP: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim4]], %[[dim1]]] +// CHECKLOOP: %[[lowerBound3:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim5]]] +// CHECKLOOP: %[[upperBound3:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim5]], %[[dim2]]] // CHECKLOOP: scf.for %[[i0:.*]] = %[[lowerBound1]] to %[[upperBound1]] step %{{.*}} { // CHECKLOOP: scf.for %[[i1:.*]] = %[[lowerBound2]] to %[[upperBound2]] step %{{.*}} { // CHECKLOOP: scf.for %[[i2:.*]] = %[[lowerBound3]] to %[[upperBound3]] step %{{.*}} { @@ -1437,9 +1437,9 @@ // CHECKLOOP: %[[dim6:.*]] = dim %[[arg1]], %[[c0]] : memref // CHECKLOOP: %[[dim7:.*]] = dim %[[arg1]], %[[c1]] : memref // CHECKLOOP: %[[dim8:.*]] = dim %[[arg1]], %[[c2]] : memref -// CHECKLOOP: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim6]]] -// CHECKLOOP: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim7]]] -// CHECKLOOP: %[[aff3:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim8]]] +// CHECKLOOP: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim6]]] +// CHECKLOOP: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim7]]] +// CHECKLOOP: %[[aff3:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim8]]] // CHECKLOOP: %[[va:.*]] = load %[[arg0]][%[[aff1]], %[[aff2]], %[[aff3]]] : memref // CHECKLOOP: %[[vb:.*]] = load %[[arg1]][%[[i3]], %[[i4]], %[[i5]]] : memref // CHECKLOOP: %[[vc:.*]] = load %[[arg2]][%[[i0]], %[[i1]], %[[i2]]] : memref @@ -1460,19 +1460,19 @@ // CHECKPARALLEL: %[[dim3:.*]] = dim %[[arg1]], %[[c0]] : memref // CHECKPARALLEL: %[[dim4:.*]] = dim %[[arg1]], %[[c1]] : memref // CHECKPARALLEL: %[[dim5:.*]] = dim %[[arg1]], %[[c2]] : memref -// CHECKPARALLEL: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim3]]] -// CHECKPARALLEL: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim3]], %[[dim0]]] -// CHECKPARALLEL: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim4]]] -// CHECKPARALLEL: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim4]], %[[dim1]]] -// CHECKPARALLEL: %[[lowerBound3:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim5]]] -// CHECKPARALLEL: %[[upperBound3:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim5]], %[[dim2]]] +// CHECKPARALLEL: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim3]]] +// CHECKPARALLEL: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim3]], %[[dim0]]] +// CHECKPARALLEL: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim4]]] +// CHECKPARALLEL: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim4]], %[[dim1]]] +// CHECKPARALLEL: %[[lowerBound3:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim5]]] +// CHECKPARALLEL: %[[upperBound3:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim5]], %[[dim2]]] // CHECKPARALLEL: scf.parallel (%[[i0:.*]], %[[i1:.*]], %[[i2:.*]], %[[i3:.*]], %[[i4:.*]], %[[i5:.*]]) = (%[[lowerBound1]], %[[lowerBound2]], %[[lowerBound3]], %{{.*}}, %{{.*}}, %{{.*}}) to (%[[upperBound1]], %[[upperBound2]], %[[upperBound3]], %[[dim3]], %[[dim4]], %[[dim5]]) step ({{.*}}) { // CHECKPARALLEL: %[[dim6:.*]] = dim %[[arg1]], %[[c0]] : memref // CHECKPARALLEL: %[[dim7:.*]] = dim %[[arg1]], %[[c1]] : memref // CHECKPARALLEL: %[[dim8:.*]] = dim %[[arg1]], %[[c2]] : memref -// CHECKPARALLEL: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim6]]] -// CHECKPARALLEL: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim7]]] -// CHECKPARALLEL: %[[aff3:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim8]]] +// CHECKPARALLEL: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim6]]] +// CHECKPARALLEL: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim7]]] +// CHECKPARALLEL: %[[aff3:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim8]]] // CHECKPARALLEL: %[[va:.*]] = load %[[arg0]][%[[aff1]], %[[aff2]], %[[aff3]]] : memref // CHECKPARALLEL: %[[vb:.*]] = load %[[arg1]][%[[i3]], %[[i4]], %[[i5]]] : memref // CHECKPARALLEL: %[[vc:.*]] = load %[[arg2]][%[[i0]], %[[i1]], %[[i2]]] : memref @@ -1481,9 +1481,9 @@ // CHECKPARALLEL: store %[[res]], %[[arg2]][%[[i0]], %[[i1]], %[[i2]]] : memref #conv_4d_accesses = [ - affine_map<(m, n, k, l, m1, n1, k1, l1)[s0, s1, s2, s3] -> (m + m1 - s0 floordiv 2, n + n1 - s1 floordiv 2, k + k1 - s2 floordiv 2, l + l1 - s3 floordiv 2)>, // in - affine_map<(m, n, k, l, m1, n1, k1, l1)[s0, s1, s2, s3] -> (m1, n1, k1, l1)>, // filter - affine_map<(m, n, k, l, m1, n1, k1, l1)[s0, s1, s2, s3] -> (m, n, k, l)> // out + affine_map<(m, n, k, l, m1, n1, k1, l1) [s0, s1, s2, s3] -> (m + m1 - s0 floordiv 2, n + n1 - s1 floordiv 2, k + k1 - s2 floordiv 2, l + l1 - s3 floordiv 2)>, // in + affine_map<(m, n, k, l, m1, n1, k1, l1) [s0, s1, s2, s3] -> (m1, n1, k1, l1)>, // filter + affine_map<(m, n, k, l, m1, n1, k1, l1) [s0, s1, s2, s3] -> (m, n, k, l)> // out ] #conv_4d_trait = { @@ -1525,14 +1525,14 @@ // CHECKLOOP: %[[dim5:.*]] = dim %[[arg1]], %[[c1]] : memref // CHECKLOOP: %[[dim6:.*]] = dim %[[arg1]], %[[c2]] : memref // CHECKLOOP: %[[dim7:.*]] = dim %[[arg1]], %[[c3]] : memref -// CHECKLOOP: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim4]]] -// CHECKLOOP: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim4]], %[[dim0]]] -// CHECKLOOP: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim5]]] -// CHECKLOOP: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim5]], %[[dim1]]] -// CHECKLOOP: %[[lowerBound3:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim6]]] -// CHECKLOOP: %[[upperBound3:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim6]], %[[dim2]]] -// CHECKLOOP: %[[lowerBound4:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim7]]] -// CHECKLOOP: %[[upperBound4:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim7]], %[[dim3]]] +// CHECKLOOP: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim4]]] +// CHECKLOOP: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim4]], %[[dim0]]] +// CHECKLOOP: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim5]]] +// CHECKLOOP: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim5]], %[[dim1]]] +// CHECKLOOP: %[[lowerBound3:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim6]]] +// CHECKLOOP: %[[upperBound3:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim6]], %[[dim2]]] +// CHECKLOOP: %[[lowerBound4:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim7]]] +// CHECKLOOP: %[[upperBound4:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim7]], %[[dim3]]] // CHECKLOOP: scf.for %[[i0:.*]] = %[[lowerBound1]] to %[[upperBound1]] step %{{.*}} { // CHECKLOOP: scf.for %[[i1:.*]] = %[[lowerBound2]] to %[[upperBound2]] step %{{.*}} { // CHECKLOOP: scf.for %[[i2:.*]] = %[[lowerBound3]] to %[[upperBound3]] step %{{.*}} { @@ -1545,10 +1545,10 @@ // CHECKLOOP: %[[dim9:.*]] = dim %[[arg1]], %[[c1]] : memref // CHECKLOOP: %[[dim10:.*]] = dim %[[arg1]], %[[c2]] : memref // CHECKLOOP: %[[dim11:.*]] = dim %[[arg1]], %[[c3]] : memref -// CHECKLOOP: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim8]]] -// CHECKLOOP: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim9]]] -// CHECKLOOP: %[[aff3:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim10]]] -// CHECKLOOP: %[[aff4:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim11]]] +// CHECKLOOP: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim8]]] +// CHECKLOOP: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim9]]] +// CHECKLOOP: %[[aff3:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim10]]] +// CHECKLOOP: %[[aff4:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim11]]] // CHECKLOOP: %[[va:.*]] = load %[[arg0]][%[[aff1]], %[[aff2]], %[[aff3]], %[[aff4]]] : memref // CHECKLOOP: %[[vb:.*]] = load %[[arg1]][%[[i4]], %[[i5]], %[[i6]], %[[i7]]] : memref // CHECKLOOP: %[[vc:.*]] = load %[[arg2]][%[[i0]], %[[i1]], %[[i2]], %[[i3]]] : memref @@ -1572,23 +1572,23 @@ // CHECKPARALLEL: %[[dim5:.*]] = dim %[[arg1]], %[[c1]] : memref // CHECKPARALLEL: %[[dim6:.*]] = dim %[[arg1]], %[[c2]] : memref // CHECKPARALLEL: %[[dim7:.*]] = dim %[[arg1]], %[[c3]] : memref -// CHECKPARALLEL: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim4]]] -// CHECKPARALLEL: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim4]], %[[dim0]]] -// CHECKPARALLEL: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim5]]] -// CHECKPARALLEL: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim5]], %[[dim1]]] -// CHECKPARALLEL: %[[lowerBound3:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim6]]] -// CHECKPARALLEL: %[[upperBound3:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim6]], %[[dim2]]] -// CHECKPARALLEL: %[[lowerBound4:.*]] = affine.apply #[[$convLowerBound]]()[%[[dim7]]] -// CHECKPARALLEL: %[[upperBound4:.*]] = affine.apply #[[$convUpperBound]]()[%[[dim7]], %[[dim3]]] +// CHECKPARALLEL: %[[lowerBound1:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim4]]] +// CHECKPARALLEL: %[[upperBound1:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim4]], %[[dim0]]] +// CHECKPARALLEL: %[[lowerBound2:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim5]]] +// CHECKPARALLEL: %[[upperBound2:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim5]], %[[dim1]]] +// CHECKPARALLEL: %[[lowerBound3:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim6]]] +// CHECKPARALLEL: %[[upperBound3:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim6]], %[[dim2]]] +// CHECKPARALLEL: %[[lowerBound4:.*]] = affine.apply #[[$convLowerBound]]() [%[[dim7]]] +// CHECKPARALLEL: %[[upperBound4:.*]] = affine.apply #[[$convUpperBound]]() [%[[dim7]], %[[dim3]]] // CHECKPARALLEL: scf.parallel (%[[i0:.*]], %[[i1:.*]], %[[i2:.*]], %[[i3:.*]], %[[i4:.*]], %[[i5:.*]], %[[i6:.*]], %[[i7:.*]]) = (%[[lowerBound1]], %[[lowerBound2]], %[[lowerBound3]], %[[lowerBound4]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) to (%[[upperBound1]], %[[upperBound2]], %[[upperBound3]], %[[upperBound4]], %[[dim4]], %[[dim5]], %[[dim6]], %[[dim7]]) step ({{.*}}) { // CHECKPARALLEL: %[[dim8:.*]] = dim %[[arg1]], %[[c0]] : memref // CHECKPARALLEL: %[[dim9:.*]] = dim %[[arg1]], %[[c1]] : memref // CHECKPARALLEL: %[[dim10:.*]] = dim %[[arg1]], %[[c2]] : memref // CHECKPARALLEL: %[[dim11:.*]] = dim %[[arg1]], %[[c3]] : memref -// CHECKPARALLEL: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim8]]] -// CHECKPARALLEL: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim9]]] -// CHECKPARALLEL: %[[aff3:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim10]]] -// CHECKPARALLEL: %[[aff4:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}})[%[[dim11]]] +// CHECKPARALLEL: %[[aff1:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim8]]] +// CHECKPARALLEL: %[[aff2:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim9]]] +// CHECKPARALLEL: %[[aff3:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim10]]] +// CHECKPARALLEL: %[[aff4:.*]] = affine.apply #[[$convMap]](%{{.*}}, %{{.*}}) [%[[dim11]]] // CHECKPARALLEL: %[[va:.*]] = load %[[arg0]][%[[aff1]], %[[aff2]], %[[aff3]], %[[aff4]]] : memref // CHECKPARALLEL: %[[vb:.*]] = load %[[arg1]][%[[i4]], %[[i5]], %[[i6]], %[[i7]]] : memref // CHECKPARALLEL: %[[vc:.*]] = load %[[arg2]][%[[i0]], %[[i1]], %[[i2]], %[[i3]]] : memref diff --git a/mlir/test/Dialect/Linalg/promote.mlir b/mlir/test/Dialect/Linalg/promote.mlir --- a/mlir/test/Dialect/Linalg/promote.mlir +++ b/mlir/test/Dialect/Linalg/promote.mlir @@ -6,8 +6,8 @@ #map2 = affine_map<(d0) -> (d0 + 4)> #map3 = affine_map<(d0) -> (d0 + 3)> -// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECK-DAG: #[[$strided2D_dynamic:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[$strided2D_dynamic:.*]] = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> func @matmul_f32(%A: memref, %M: index, %N: index, %K: index) { %c4 = constant 4 : index diff --git a/mlir/test/Dialect/Linalg/roundtrip.mlir b/mlir/test/Dialect/Linalg/roundtrip.mlir --- a/mlir/test/Dialect/Linalg/roundtrip.mlir +++ b/mlir/test/Dialect/Linalg/roundtrip.mlir @@ -15,7 +15,7 @@ // ----- -// CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> +// CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> func @views(%arg0: index, %arg1: index, %arg2: index, %arg3: index, %arg4: index) { %c0 = constant 0 : index @@ -76,8 +76,8 @@ // ----- -// CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> -// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> +// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> func @ops(%arg0: memref, %arg1: memref, @@ -110,7 +110,7 @@ // ----- -// CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> +// CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> func @fill_view(%arg0: memref, %arg1: f32) { linalg.fill(%arg0, %arg1) : memref, f32 @@ -122,11 +122,11 @@ // ----- -// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> -// CHECK-DAG: #[[$strided3DT:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 * s1 + s0 + d1 * s2 + d0)> +// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> +// CHECK-DAG: #[[$strided3DT:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d2 * s1 + s0 + d1 * s2 + d0)> func @transpose(%arg0: memref) { - %0 = transpose %arg0 (i, j, k) -> (k, j, i) : memref to memref (d2 * s1 + s0 + d1 * s2 + d0)>> + %0 = transpose %arg0 (i, j, k) -> (k, j, i) : memref to memref (d2 * s1 + s0 + d1 * s2 + d0)>> return } // CHECK-LABEL: func @transpose @@ -135,7 +135,7 @@ // ----- -// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> +// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> func @fill_view3(%arg0: memref, %arg1: f32) { linalg.fill(%arg0, %arg1) : memref, f32 @@ -147,7 +147,7 @@ // ----- -// CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> +// CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> func @copy_view(%arg0: memref, %arg1: memref) { @@ -161,7 +161,7 @@ // ----- -// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> +// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> // CHECK-DAG: #[[$map0:.*]] = affine_map<(d0, d1, d2) -> (d0, d2, d1)> // CHECK-DAG: #[[$map1:.*]] = affine_map<(d0, d1, d2) -> (d2, d1, d0)> @@ -182,7 +182,7 @@ // ----- -// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> +// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> func @conv_view3(%arg0: memref, %arg1: memref, @@ -200,7 +200,7 @@ // ----- -// CHECK-DAG: #[[$strided6D:.*]] = affine_map<(d0, d1, d2, d3, d4, d5)[s0, s1, s2, s3, s4, s5] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4 + d4 * s5 + d5)> +// CHECK-DAG: #[[$strided6D:.*]] = affine_map<(d0, d1, d2, d3, d4, d5) [s0, s1, s2, s3, s4, s5] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4 + d4 * s5 + d5)> func @conv_view6(%arg0: memref, %arg1: memref, @@ -284,8 +284,8 @@ // ----- -// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> +// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> #accesses = [ affine_map<(i, j, k) -> (j, i)>, @@ -462,8 +462,8 @@ // ----- -// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> +// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> #accesses = [ affine_map<(i, j, k) -> (j, i)>, @@ -603,10 +603,10 @@ // ----- -// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECK-DAG: #[[$strided2DOFF0:.*]] = affine_map<(d0, d1)[s0] -> (d0 * s0 + d1)> -// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> -// CHECK-DAG: #[[$strided3DOFF0:.*]] = affine_map<(d0, d1, d2)[s0, s1] -> (d0 * s0 + d1 * s1 + d2)> +// CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[$strided2DOFF0:.*]] = affine_map<(d0, d1) [s0] -> (d0 * s0 + d1)> +// CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> +// CHECK-DAG: #[[$strided3DOFF0:.*]] = affine_map<(d0, d1, d2) [s0, s1] -> (d0 * s0 + d1 * s1 + d2)> func @reshape_dynamic(%arg0: memref, %arg1: memref, diff --git a/mlir/test/Dialect/Linalg/standard.mlir b/mlir/test/Dialect/Linalg/standard.mlir --- a/mlir/test/Dialect/Linalg/standard.mlir +++ b/mlir/test/Dialect/Linalg/standard.mlir @@ -1,14 +1,14 @@ // RUN: mlir-opt %s -convert-linalg-to-std | FileCheck %s -// CHECK-DAG: #[[$map0:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> -// CHECK-DAG: #[[$map1:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> -// CHECK-DAG: #[[$map2:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d2 * s2 + d1)> +// CHECK-DAG: #[[$map0:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> +// CHECK-DAG: #[[$map1:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)> +// CHECK-DAG: #[[$map2:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d2 * s2 + d1)> // CHECK-DAG: #[[$map3:.*]] = affine_map<(d0, d1, d2) -> (d0, d2, d1)> -// CHECK-DAG: #[[$map4:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 * s1 + s0 + d1 * s2 + d0)> +// CHECK-DAG: #[[$map4:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d2 * s1 + s0 + d1 * s2 + d0)> // CHECK-DAG: #[[$map5:.*]] = affine_map<(d0, d1, d2) -> (d2, d1, d0)> -// CHECK-DAG: #[[$map6:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> -// CHECK-DAG: #[[$map7:.*]] = affine_map<()[s0] -> (s0)> -// CHECK-DAG: #[[$map8:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)> +// CHECK-DAG: #[[$map6:.*]] = affine_map<(d0) [s0, s1] -> (d0 * s1 + s0)> +// CHECK-DAG: #[[$map7:.*]] = affine_map<() [s0] -> (s0)> +// CHECK-DAG: #[[$map8:.*]] = affine_map<(d0, d1, d2) [s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)> func @dot(%arg0: memref, %arg1: memref, diff --git a/mlir/test/Dialect/Linalg/tile-and-distribute.mlir b/mlir/test/Dialect/Linalg/tile-and-distribute.mlir --- a/mlir/test/Dialect/Linalg/tile-and-distribute.mlir +++ b/mlir/test/Dialect/Linalg/tile-and-distribute.mlir @@ -7,7 +7,7 @@ outs(%c: memref) return } -// CHECK-DAG: #[[MAP0:.*]] = affine_map<()[s0] -> (s0 * 8)> +// CHECK-DAG: #[[MAP0:.*]] = affine_map<() [s0] -> (s0 * 8)> // CHECK: func @gemm1( // CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]*]]: memref // CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]*]]: memref @@ -15,12 +15,12 @@ // CHECK: %[[BIDY:.*]] = "gpu.block_id"() {dimension = "y"} // CHECK: %[[BIDX:.*]] = "gpu.block_id"() {dimension = "x"} // CHECK: scf.for %[[ARG3:.*]] = -// CHECK: %[[OFFSETY:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] +// CHECK: %[[OFFSETY:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] // CHECK: %[[SV1:.*]] = subview %[[ARG0]][%[[OFFSETY]], %[[ARG3]]] -// CHECK: %[[OFFSETX:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] +// CHECK: %[[OFFSETX:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] // CHECK: %[[SV2:.*]] = subview %[[ARG1]][%[[ARG3]], %[[OFFSETX]]] -// CHECK: %[[OFFSETY_2:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] -// CHECK: %[[OFFSETX:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] +// CHECK: %[[OFFSETY_2:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] +// CHECK: %[[OFFSETX:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] // CHECK: %[[SV3:.*]] = subview %[[ARG2]][%[[OFFSETY_2]], %[[OFFSETX]]] // CHECK: linalg.matmul ins(%[[SV1]], %[[SV2]]{{.*}} outs(%[[SV3]] @@ -33,26 +33,26 @@ outs(%c:memref) return } -// CHECK-DAG: #[[MAP0:.*]] = affine_map<()[s0] -> (s0 * 8)> +// CHECK-DAG: #[[MAP0:.*]] = affine_map<() [s0] -> (s0 * 8)> // CHECK: func @gemm2( // CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]*]]: memref // CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]*]]: memref // CHECK-SAME: %[[ARG2:[a-zA-Z0-9_]*]]: memref // CHECK-DAG: %[[BIDY:.*]] = "gpu.block_id"() {dimension = "y"} // CHECK-DAG: %[[BIDX:.*]] = "gpu.block_id"() {dimension = "x"} -// CHECK: %[[ITERY:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] -// CHECK: %[[ITERX:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] +// CHECK: %[[ITERY:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] +// CHECK: %[[ITERX:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] // CHECK: %[[INBOUNDSY:.*]] = cmpi "slt", %[[ITERY]], %{{.*}} // CHECK: %[[INBOUNDSX:.*]] = cmpi "slt", %[[ITERX]], %{{.*}} // CHECK: %[[INBOUNDS:.*]] = and %[[INBOUNDSY]], %[[INBOUNDSX]] // CHECK: scf.if %[[INBOUNDS]] // CHECK: scf.for %[[ARG3:.*]] = -// CHECK: %[[OFFSETY:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] +// CHECK: %[[OFFSETY:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] // CHECK: %[[SV1:.*]] = subview %[[ARG0]][%[[OFFSETY]], %[[ARG3]]] -// CHECK: %[[OFFSETX:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] +// CHECK: %[[OFFSETX:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] // CHECK: %[[SV2:.*]] = subview %[[ARG1]][%[[ARG3]], %[[OFFSETX]]] -// CHECK: %[[OFFSETY_2:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] -// CHECK: %[[OFFSETX_2:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] +// CHECK: %[[OFFSETY_2:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] +// CHECK: %[[OFFSETX_2:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] // CHECK: %[[SV3:.*]] = subview %[[ARG2]][%[[OFFSETY_2]], %[[OFFSETX_2]]] // CHECK: linalg.matmul ins(%[[SV1]], %[[SV2]]{{.*}} outs(%[[SV3]] @@ -65,7 +65,7 @@ outs(%c: memref) return } -// CHECK-DAG: #[[MAP0:.*]] = affine_map<()[s0] -> (s0 * 8)> +// CHECK-DAG: #[[MAP0:.*]] = affine_map<() [s0] -> (s0 * 8)> // CHECK: func @gemm3( // CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]*]]: memref // CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]*]]: memref @@ -74,10 +74,10 @@ // CHECK: %[[NBLOCKSY:.*]] = "gpu.grid_dim"() {dimension = "y"} // CHECK: %[[BIDX:.*]] = "gpu.block_id"() {dimension = "x"} // CHECK: %[[NBLOCKSX:.*]] = "gpu.grid_dim"() {dimension = "x"} -// CHECK: %[[LBY:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] -// CHECK: %[[STEPY:.*]] = affine.apply #[[MAP0]]()[%[[NBLOCKSY]]] -// CHECK: %[[LBX:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] -// CHECK: %[[STEPX:.*]] = affine.apply #[[MAP0]]()[%[[NBLOCKSX]]] +// CHECK: %[[LBY:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] +// CHECK: %[[STEPY:.*]] = affine.apply #[[MAP0]]() [%[[NBLOCKSY]]] +// CHECK: %[[LBX:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] +// CHECK: %[[STEPX:.*]] = affine.apply #[[MAP0]]() [%[[NBLOCKSX]]] // CHECK: scf.parallel (%[[ARG3:.*]], %[[ARG4:.*]]) = (%[[LBY]], %[[LBX]]) to (%{{.*}}, %{{.*}}) step (%[[STEPY]], %[[STEPX]]) // CHECK: scf.for %[[ARG5:.*]] = // CHECK: %[[SV1:.*]] = subview %[[ARG0]][%[[ARG3]], %[[ARG5]]] @@ -94,23 +94,23 @@ outs(%c: memref) return } -// CHECK-DAG: #[[MAP0:.*]] = affine_map<()[s0] -> (s0 * 8)> +// CHECK-DAG: #[[MAP0:.*]] = affine_map<() [s0] -> (s0 * 8)> // CHECK: func @gemm4( // CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]*]]: memref // CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]*]]: memref // CHECK-SAME: %[[ARG2:[a-zA-Z0-9_]*]]: memref // CHECK: %[[BIDY:.*]] = "gpu.block_id"() {dimension = "y"} // CHECK: %[[BIDX:.*]] = "gpu.block_id"() {dimension = "x"} -// CHECK: %[[LBX:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] +// CHECK: %[[LBX:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] // CHECK: %[[INBOUNDS:.*]] = cmpi "slt", %[[LBX]], %{{.*}} // CHECK: scf.if %[[INBOUNDS]] // CHECK: scf.for %[[ARG3:.*]] = -// CHECK: %[[OFFSETY:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] +// CHECK: %[[OFFSETY:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] // CHECK: %[[SV1:.*]] = subview %[[ARG0]][%[[OFFSETY]], %[[ARG3]]] -// CHECK: %[[OFFSETX:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] +// CHECK: %[[OFFSETX:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] // CHECK: %[[SV2:.*]] = subview %[[ARG1]][%[[ARG3]], %[[OFFSETX]]] -// CHECK: %[[OFFSETY_2:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] -// CHECK: %[[OFFSETX_2:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] +// CHECK: %[[OFFSETY_2:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] +// CHECK: %[[OFFSETX_2:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] // CHECK: %[[SV3:.*]] = subview %[[ARG2]][%[[OFFSETY_2]], %[[OFFSETX_2]]] // CHECK: linalg.matmul ins(%[[SV1]], %[[SV2]]{{.*}} outs(%[[SV3]] @@ -123,7 +123,7 @@ outs(%c: memref) return } -// CHECK-DAG: #[[MAP0:.*]] = affine_map<()[s0] -> (s0 * 8)> +// CHECK-DAG: #[[MAP0:.*]] = affine_map<() [s0] -> (s0 * 8)> // CHECK: func @gemm5( // CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]*]]: memref // CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]*]]: memref @@ -131,17 +131,17 @@ // CHECK: %[[BIDY:.*]] = "gpu.block_id"() {dimension = "y"} // CHECK: %[[BIDX:.*]] = "gpu.block_id"() {dimension = "x"} // CHECK: %[[NBLOCKSX:.*]] = "gpu.grid_dim"() {dimension = "x"} -// CHECK: %[[LBY:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] -// CHECK: %[[LBX:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] -// CHECK: %[[STEPX:.*]] = affine.apply #[[MAP0]]()[%[[NBLOCKSX]]] +// CHECK: %[[LBY:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] +// CHECK: %[[LBX:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] +// CHECK: %[[STEPX:.*]] = affine.apply #[[MAP0]]() [%[[NBLOCKSX]]] // CHECK: %[[INBOUNDS:.*]] = cmpi "slt", %[[LBY]], %{{.*}} // CHECK: scf.if %[[INBOUNDS]] // CHECK: scf.parallel (%[[ARG3.*]]) = (%[[LBX]]) to (%{{.*}}) step (%[[STEPX]]) // CHECK: scf.for %[[ARG4:.*]] = -// CHECK: %[[OFFSETY:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] +// CHECK: %[[OFFSETY:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] // CHECK: %[[SV1:.*]] = subview %[[ARG0]][%[[OFFSETY]], %[[ARG4]]] // CHECK: %[[SV2:.*]] = subview %[[ARG1]][%[[ARG4]], %[[ARG3]]] -// CHECK: %[[OFFSETY_2:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] +// CHECK: %[[OFFSETY_2:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] // CHECK: %[[SV3:.*]] = subview %[[ARG2]][%[[OFFSETY_2]], %[[ARG3]]] // CHECK: linalg.matmul ins(%[[SV1]], %[[SV2]]{{.*}} outs(%[[SV3]] @@ -154,7 +154,7 @@ outs(%c: memref) return } -// CHECK-DAG: #[[MAP0:.*]] = affine_map<()[s0] -> (s0 * 8)> +// CHECK-DAG: #[[MAP0:.*]] = affine_map<() [s0] -> (s0 * 8)> // CHECK: func @gemm6( // CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]*]]: memref // CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]*]]: memref @@ -162,13 +162,13 @@ // CHECK: %[[BIDY:.*]] = "gpu.block_id"() {dimension = "y"} // CHECK: %[[NBLOCKSY:.*]] = "gpu.grid_dim"() {dimension = "y"} // CHECK: %[[BIDX:.*]] = "gpu.block_id"() {dimension = "x"} -// CHECK: %[[LBY:.*]] = affine.apply #[[MAP0]]()[%[[BIDY]]] -// CHECK: %[[STEPY:.*]] = affine.apply #[[MAP0]]()[%[[NBLOCKSY]]] +// CHECK: %[[LBY:.*]] = affine.apply #[[MAP0]]() [%[[BIDY]]] +// CHECK: %[[STEPY:.*]] = affine.apply #[[MAP0]]() [%[[NBLOCKSY]]] // CHECK: scf.parallel (%[[ARG3.*]]) = (%[[LBY]]) to (%{{.*}}) step (%[[STEPY]]) // CHECK: scf.for %[[ARG4:.*]] = // CHECK: %[[SV1:.*]] = subview %[[ARG0]][%[[ARG3]], %[[ARG4]]] -// CHECK: %[[OFFSETX:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] +// CHECK: %[[OFFSETX:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] // CHECK: %[[SV2:.*]] = subview %[[ARG1]][%[[ARG4]], %[[OFFSETX]]] -// CHECK: %[[OFFSETX_2:.*]] = affine.apply #[[MAP0]]()[%[[BIDX]]] +// CHECK: %[[OFFSETX_2:.*]] = affine.apply #[[MAP0]]() [%[[BIDX]]] // CHECK: %[[SV3:.*]] = subview %[[ARG2]][%[[ARG3]], %[[OFFSETX_2]]] // CHECK: linalg.matmul ins(%[[SV1]], %[[SV2]]{{.*}} outs(%[[SV3]] diff --git a/mlir/test/Dialect/Linalg/tile-and-fuse-tensors.mlir b/mlir/test/Dialect/Linalg/tile-and-fuse-tensors.mlir --- a/mlir/test/Dialect/Linalg/tile-and-fuse-tensors.mlir +++ b/mlir/test/Dialect/Linalg/tile-and-fuse-tensors.mlir @@ -1,8 +1,8 @@ // RUN: mlir-opt %s -test-linalg-greedy-fusion -split-input-file | FileCheck %s -#map0 = affine_map<(d0)[s0] -> (2, -d0 + s0)> -#map1 = affine_map<(d0)[s0] -> (4, -d0 + s0)> -#map2 = affine_map<(d0)[s0] -> (3, -d0 + s0)> +#map0 = affine_map<(d0) [s0] -> (2, -d0 + s0)> +#map1 = affine_map<(d0) [s0] -> (4, -d0 + s0)> +#map2 = affine_map<(d0) [s0] -> (3, -d0 + s0)> #map3 = affine_map<(d0, d1) -> (2, d0 - d1)> #map4 = affine_map<(d0, d1) -> (3, d0 - d1)> diff --git a/mlir/test/Dialect/Linalg/tile-conv-padding.mlir b/mlir/test/Dialect/Linalg/tile-conv-padding.mlir --- a/mlir/test/Dialect/Linalg/tile-conv-padding.mlir +++ b/mlir/test/Dialect/Linalg/tile-conv-padding.mlir @@ -1,9 +1,9 @@ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,0,0,4" | FileCheck %s -check-prefix=TILE-23004 // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2" | FileCheck %s -check-prefix=TILE-20000 -// TILE-23004-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> -// TILE-20000-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> -// TILE-20000-DAG: #[[$minmap:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)> +// TILE-23004-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3) [s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> +// TILE-20000-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3) [s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> +// TILE-20000-DAG: #[[$minmap:.*]] = affine_map<(d0) [s0] -> (2, -d0 + s0)> func @conv_padding(%arg0: memref, %arg1: memref, %arg2: memref) { linalg.conv(%arg0, %arg1, %arg2) {dilations = [10, 20], padding = dense<[[1, 1], [0, 1]]> : tensor<2x2xi64>, strides = [30, 40]} : memref, memref, memref @@ -24,13 +24,13 @@ // TILE-20000: %[[B:.*]] = dim %[[ARG1]], %c0 // TILE-20000: scf.for %[[ivI:.*]] = %[[C0]] to %[[B]] step %[[C2]] { // TILE-20000: %[[DIM10:.*]] = dim %[[ARG1]], %c0 -// TILE-20000: %[[EXTENT:.*]] = affine.min #[[$minmap]](%[[ivI]])[%[[DIM10]]] +// TILE-20000: %[[EXTENT:.*]] = affine.min #[[$minmap]](%[[ivI]]) [%[[DIM10]]] // TILE-20000: %[[DIM11:.*]] = dim %[[ARG1]], %c1 // TILE-20000: %[[DIM12:.*]] = dim %[[ARG1]], %c2 // TILE-20000: %[[DIM13:.*]] = dim %[[ARG1]], %c3 // TILE-20000: %[[SUBVIEW1:.*]] = subview %[[ARG1]][%[[ivI]], 0, 0, 0] [%[[EXTENT]], %[[DIM11]], %[[DIM12]], %[[DIM13]]] // TILE-20000: %[[DIM20:.*]] = dim %[[ARG2]], %c0 -// TILE-20000: %[[EXTENT:.*]] = affine.min #[[$minmap]](%[[ivI]])[%[[DIM20]]] +// TILE-20000: %[[EXTENT:.*]] = affine.min #[[$minmap]](%[[ivI]]) [%[[DIM20]]] // TILE-20000: %[[DIM21:.*]] = dim %[[ARG2]], %c1 // TILE-20000: %[[DIM22:.*]] = dim %[[ARG2]], %c2 // TILE-20000: %[[DIM23:.*]] = dim %[[ARG2]], %c3 diff --git a/mlir/test/Dialect/Linalg/tile-conv.mlir b/mlir/test/Dialect/Linalg/tile-conv.mlir --- a/mlir/test/Dialect/Linalg/tile-conv.mlir +++ b/mlir/test/Dialect/Linalg/tile-conv.mlir @@ -1,9 +1,9 @@ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,0,0,0,4" | FileCheck %s -check-prefix=TILE-23004 // TILE-23004-DAG: #[[$D0x30pS0x10:.*]] = affine_map<(d0) -> (d0 * 30)> -// TILE-23004-DAG: #[[$S0x10p90D0x30pS1:.*]] = affine_map<(d0)[s0, s1] -> (s0 * 10 + 51, d0 * -30 + s1)> -// TILE-23004-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> -// TILE-23004-DAG: #[[$bound_map_4:.*]] = affine_map<(d0)[s0] -> (4, -d0 + s0)> +// TILE-23004-DAG: #[[$S0x10p90D0x30pS1:.*]] = affine_map<(d0) [s0, s1] -> (s0 * 10 + 51, d0 * -30 + s1)> +// TILE-23004-DAG: #[[$strided4D:.*]] = affine_map<(d0, d1, d2, d3) [s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)> +// TILE-23004-DAG: #[[$bound_map_4:.*]] = affine_map<(d0) [s0] -> (4, -d0 + s0)> func @conv(%arg0: memref, %arg1: memref, %arg2: memref) { linalg.conv(%arg0, %arg1, %arg2) {dilations = [10, 20], strides = [30, 40]} : memref, memref, memref @@ -27,16 +27,16 @@ // TILE-23004: %[[Z0_1:.*]] = dim %[[ARG0]], %c0 : memref // TILE-23004: %[[Z1:.*]] = dim %[[ARG0]], %c1 : memref // TILE-23004: %[[Z2:.*]] = dim %[[ARG0]], %c2 : memref -// TILE-23004: %[[szK:.*]] = affine.min #[[$bound_map_4]](%[[ivK]])[%[[Z2]]] +// TILE-23004: %[[szK:.*]] = affine.min #[[$bound_map_4]](%[[ivK]]) [%[[Z2]]] // TILE-23004: %[[K:.*]] = dim %[[ARG0]], %c3 : memref // TILE-23004: %[[FilterView:.*]] = subview %{{.*}}[0, 0, %[[ivK]], 0] [%[[Z0_1]], %[[Z1]], %[[szK]], %[[K]]] [1, 1, 1, 1] : memref to memref // // TILE-23004: %[[J1:.*]] = affine.apply #[[$D0x30pS0x10]](%[[ivJ]]) // TILE-23004: %[[PaddedInput0b:.*]] = dim %[[ARG1]], %c1 : memref -// TILE-23004: %[[I1pStep:.*]] = affine.min #[[$S0x10p90D0x30pS1]](%[[ivJ]])[%[[Z0]], %[[PaddedInput0b]]] +// TILE-23004: %[[I1pStep:.*]] = affine.min #[[$S0x10p90D0x30pS1]](%[[ivJ]]) [%[[Z0]], %[[PaddedInput0b]]] // TILE-23004: %[[SZ2:.*]] = dim %[[ARG1]], %c2 : memref // TILE-23004: %[[dim3:.*]] = dim %[[ARG1]], %c3 -// TILE-23004: %[[sz3:.*]] = affine.min #[[$bound_map_4]](%[[ivK]])[%[[dim3]]] +// TILE-23004: %[[sz3:.*]] = affine.min #[[$bound_map_4]](%[[ivK]]) [%[[dim3]]] // TILE-23004: %[[InputView:.*]] = subview %{{.*}}[%[[ivI]], %[[J1]], 0, %[[ivK]]] [%{{.*}}, %{{.*}}, %[[SZ2]], %[[sz3]]] [1, 1, 1, 1] : memref to memref // // TILE-23004: %[[X0:.*]] = dim %[[ARG2]], %c2 : memref diff --git a/mlir/test/Dialect/Linalg/tile-simple-conv.mlir b/mlir/test/Dialect/Linalg/tile-simple-conv.mlir --- a/mlir/test/Dialect/Linalg/tile-simple-conv.mlir +++ b/mlir/test/Dialect/Linalg/tile-simple-conv.mlir @@ -1,10 +1,10 @@ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,4" | FileCheck %s -// CHECK-DAG: #[[MAP0:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)> -// CHECK-DAG: #[[MAP1:.*]] = affine_map<(d0)[s0, s1] -> (s0 + 2, -d0 + s1)> -// CHECK-DAG: #[[MAP2:.*]] = affine_map<(d0)[s0, s1] -> (s0 + 3, -d0 + s1)> -// CHECK-DAG: #[[MAP4:.*]] = affine_map<(d0)[s0] -> (3, -d0 + s0)> -// CHECK-DAG: #[[MAP5:.*]] = affine_map<(d0)[s0] -> (4, -d0 + s0)> +// CHECK-DAG: #[[MAP0:.*]] = affine_map<(d0) [s0] -> (2, -d0 + s0)> +// CHECK-DAG: #[[MAP1:.*]] = affine_map<(d0) [s0, s1] -> (s0 + 2, -d0 + s1)> +// CHECK-DAG: #[[MAP2:.*]] = affine_map<(d0) [s0, s1] -> (s0 + 3, -d0 + s1)> +// CHECK-DAG: #[[MAP4:.*]] = affine_map<(d0) [s0] -> (3, -d0 + s0)> +// CHECK-DAG: #[[MAP5:.*]] = affine_map<(d0) [s0] -> (4, -d0 + s0)> func @conv(%arg0 : memref, %arg1 : memref, %arg2 : memref) { linalg.conv(%arg0, %arg1, %arg2) : memref, memref, memref @@ -29,20 +29,20 @@ // CHECK: scf.for %[[ARG4:.*]] = %[[C0]] to %[[T3]] step %[[C3]] // CHECK: scf.for %[[ARG5:.*]] = %[[C0]] to %[[T4]] step %[[C4]] // CHECK: %[[T5:.*]] = dim %[[ARG1]], %[[C0]] -// CHECK: %[[T6:.*]] = affine.min #[[MAP0]](%[[ARG3]])[%[[T5]]] +// CHECK: %[[T6:.*]] = affine.min #[[MAP0]](%[[ARG3]]) [%[[T5]]] // CHECK: %[[T7:.*]] = dim %[[ARG1]], %[[C1]] -// CHECK: %[[T8:.*]] = affine.min #[[MAP1]](%[[ARG4]])[%[[T0]], %[[T7]]] +// CHECK: %[[T8:.*]] = affine.min #[[MAP1]](%[[ARG4]]) [%[[T0]], %[[T7]]] // CHECK: %[[T9:.*]] = dim %[[ARG1]], %[[C2]] -// CHECK: %[[T10:.*]] = affine.min #[[MAP2]](%[[ARG5]])[%[[T1]], %[[T9]]] +// CHECK: %[[T10:.*]] = affine.min #[[MAP2]](%[[ARG5]]) [%[[T1]], %[[T9]]] // CHECK: %[[T11:.*]] = dim %[[ARG1]], %[[C3]] // CHECK: %[[SV1:.*]] = subview %[[ARG1]][%[[ARG3]], %[[ARG4]], %[[ARG5]], 0] // CHECK-SAME: [%[[T6]], %[[T8]], %[[T10]], %[[T11]]] // CHECK: %[[T13:.*]] = dim %[[ARG2]], %[[C0]] -// CHECK: %[[T14:.*]] = affine.min #[[MAP0]](%[[ARG3]])[%[[T13]]] +// CHECK: %[[T14:.*]] = affine.min #[[MAP0]](%[[ARG3]]) [%[[T13]]] // CHECK: %[[T15:.*]] = dim %[[ARG2]], %[[C1]] -// CHECK: %[[T16:.*]] = affine.min #[[MAP4]](%[[ARG4]])[%[[T15]]] +// CHECK: %[[T16:.*]] = affine.min #[[MAP4]](%[[ARG4]]) [%[[T15]]] // CHECK: %[[T17:.*]] = dim %[[ARG2]], %[[C2]] -// CHECK: %[[T18:.*]] = affine.min #[[MAP5]](%[[ARG5]])[%[[T17]]] +// CHECK: %[[T18:.*]] = affine.min #[[MAP5]](%[[ARG5]]) [%[[T17]]] // CHECK: %[[T19:.*]] = dim %[[ARG2]], %[[C3]] // CHECK: %[[SV2:.*]] = subview %[[ARG2]][%[[ARG3]], %[[ARG4]], %[[ARG5]], 0] // CHECK-SAME: [%[[T14]], %[[T16]], %[[T18]], %[[T19]]] diff --git a/mlir/test/Dialect/Linalg/tile.mlir b/mlir/test/Dialect/Linalg/tile.mlir --- a/mlir/test/Dialect/Linalg/tile.mlir +++ b/mlir/test/Dialect/Linalg/tile.mlir @@ -3,30 +3,30 @@ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=0,0,2" -mlir-disable-threading=true | FileCheck %s -check-prefix=TILE-002 // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,4" -mlir-disable-threading=true | FileCheck %s -check-prefix=TILE-234 -// TILE-2-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> -// TILE-02-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> -// TILE-002-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> -// TILE-234-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> - -// TILE-2-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// TILE-02-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// TILE-002-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// TILE-234-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> - -// TILE-2-DAG: #[[$bound_map:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)> -// TILE-02-DAG: #[[$bound_map:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)> -// TILE-002-DAG: #[[$bound_map:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)> -// TILE-234-DAG: #[[$bound_map_2:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)> -// TILE-234-DAG: #[[$bound_map_3:.*]] = affine_map<(d0)[s0] -> (3, -d0 + s0)> -// TILE-234-DAG: #[[$bound_map_4:.*]] = affine_map<(d0)[s0] -> (4, -d0 + s0)> +// TILE-2-DAG: #[[$strided1D:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> +// TILE-02-DAG: #[[$strided1D:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> +// TILE-002-DAG: #[[$strided1D:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> +// TILE-234-DAG: #[[$strided1D:.*]] = affine_map<(d0) [s0] -> (d0 + s0)> + +// TILE-2-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// TILE-02-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// TILE-002-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// TILE-234-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> + +// TILE-2-DAG: #[[$bound_map:.*]] = affine_map<(d0) [s0] -> (2, -d0 + s0)> +// TILE-02-DAG: #[[$bound_map:.*]] = affine_map<(d0) [s0] -> (2, -d0 + s0)> +// TILE-002-DAG: #[[$bound_map:.*]] = affine_map<(d0) [s0] -> (2, -d0 + s0)> +// TILE-234-DAG: #[[$bound_map_2:.*]] = affine_map<(d0) [s0] -> (2, -d0 + s0)> +// TILE-234-DAG: #[[$bound_map_3:.*]] = affine_map<(d0) [s0] -> (3, -d0 + s0)> +// TILE-234-DAG: #[[$bound_map_4:.*]] = affine_map<(d0) [s0] -> (4, -d0 + s0)> // TILE-2-DAG: #[[$bound_map_static:.*]] = affine_map<(d0) -> (2, -d0 + 10)> // TILE-02-DAG: #[[$bound_map_static:.*]] = affine_map<(d0) -> (2, -d0 + 12)> // TILE-002-DAG: #[[$bound_map_static:.*]] = affine_map<(d0) -> (2, -d0 + 16)> -// TILE-2-DAG: #[[$stride_99_1_layout_map:.*]] = affine_map<(d0, d1)[s0] -> (d0 * 99 + s0 + d1)> -// TILE-02-DAG: #[[$stride_99_1_layout_map:.*]] = affine_map<(d0, d1)[s0] -> (d0 * 99 + s0 + d1)> -// TILE-234-DAG: #[[$stride_99_1_layout_map:.*]] = affine_map<(d0, d1)[s0] -> (d0 * 99 + s0 + d1)> +// TILE-2-DAG: #[[$stride_99_1_layout_map:.*]] = affine_map<(d0, d1) [s0] -> (d0 * 99 + s0 + d1)> +// TILE-02-DAG: #[[$stride_99_1_layout_map:.*]] = affine_map<(d0, d1) [s0] -> (d0 * 99 + s0 + d1)> +// TILE-234-DAG: #[[$stride_99_1_layout_map:.*]] = affine_map<(d0, d1) [s0] -> (d0 * 99 + s0 + d1)> func @matmul(%arg0: memref, %arg1: memref, @@ -43,11 +43,11 @@ // TILE-2: %[[M:.*]] = dim %{{.*}}, %c0 : memref // TILE-2: scf.for %[[I:.*]] = %{{.*}}{{.*}} to %[[M]] step %{{.*}} { // TILE-2: %[[localM:.*]] = dim %{{.*}}, %c0 -// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[localM]]] +// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]]) [%[[localM]]] // TILE-2: %[[K:.*]] = dim %{{.*}}, %c1 : memref // TILE-2: %[[sAi:.*]] = subview %{{.*}}[%[[I]], 0] [%[[szM]], %[[K]]] [1, 1] : memref to memref // TILE-2: %[[localK:.*]] = dim %{{.*}}, %c0 -// TILE-2: %[[szK:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[localK]]] +// TILE-2: %[[szK:.*]] = affine.min #[[$bound_map]](%[[I]]) [%[[localK]]] // TILE-2: %[[N:.*]] = dim %{{.*}}, %c1 : memref // TILE-2: %[[sCi:.*]] = subview %{{.*}}[%[[I]], 0] [%[[szK]], %[[N]]] [1, 1] : memref to memref // TILE-2: linalg.matmul ins(%[[sAi]]{{.*}} outs(%[[sCi]] @@ -59,11 +59,11 @@ // TILE-02: scf.for %[[J:.*]] = %{{.*}} to %[[N]] step %{{.*}} { // TILE-02: %[[K:.*]] = dim %{{.*}}, %c0 : memref // TILE-02: %[[localN:.*]] = dim %{{.*}}, %c1 -// TILE-02: %[[szN:.*]] = affine.min #[[$bound_map]](%[[J]])[%[[localN]]] +// TILE-02: %[[szN:.*]] = affine.min #[[$bound_map]](%[[J]]) [%[[localN]]] // TILE-02: %[[sBj:.*]] = subview %{{.*}}[0, %[[J]]] [%[[K]], %[[szN]]] [1, 1] : memref to memref // TILE-02: %[[M:.*]] = dim %{{.*}}, %c0 : memref // TILE-02: %[[localK:.*]] = dim %{{.*}}, %c1 -// TILE-02: %[[szK:.*]] = affine.min #[[$bound_map]](%[[J]])[%[[localK]]] +// TILE-02: %[[szK:.*]] = affine.min #[[$bound_map]](%[[J]]) [%[[localK]]] // TILE-02: %[[sCj:.*]] = subview %{{.*}}[0, %[[J]]] [%[[M]], %[[szK]]] [1, 1] : memref to memref // TILE-02: linalg.matmul ins(%{{.*}}, %[[sBj]]{{.*}} outs(%[[sCj]] @@ -74,10 +74,10 @@ // TILE-002: scf.for %[[K:.*]] = %{{.*}}{{.*}} to %[[ubK]] step %{{.*}} { // TILE-002: %[[M:.*]] = dim %{{.*}}, %c0 : memref // TILE-002: %[[localK:.*]] = dim %{{.*}}, %c1 -// TILE-002: %[[szK:.*]] = affine.min #[[$bound_map]](%[[K]])[%[[localK]]] +// TILE-002: %[[szK:.*]] = affine.min #[[$bound_map]](%[[K]]) [%[[localK]]] // TILE-002: %[[sAj:.*]] = subview %{{.*}}[0, %[[K]]] [%[[M]], %[[szK]]] [1, 1] : memref to memref // TILE-002: %[[localK:.*]] = dim %{{.*}}, %c0 -// TILE-002: %[[szK:.*]] = affine.min #[[$bound_map]](%[[K]])[%[[localK]]] +// TILE-002: %[[szK:.*]] = affine.min #[[$bound_map]](%[[K]]) [%[[localK]]] // TILE-002: %[[N:.*]] = dim %{{.*}}, %c1 : memref // TILE-002: %[[sBj:.*]] = subview %{{.*}}[%[[K]], 0] [%[[szK]], %[[N]]] [1, 1] : memref to memref // TILE-002: linalg.matmul ins(%[[sAj]], %[[sBj]]{{.*}} outs(%{{.*}} @@ -94,19 +94,19 @@ // TILE-234: scf.for %[[J:.*]] = %{{.*}}{{.*}} to %[[ubN]] step %{{.*}} { // TILE-234: scf.for %[[K:.*]] = %{{.*}}{{.*}} to %[[ubK]] step %{{.*}} { // TILE-234: %[[localM:.*]] = dim %{{.*}}, %c0 -// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[localM]]] +// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]]) [%[[localM]]] // TILE-234: %[[localK:.*]] = dim %{{.*}}, %c1 -// TILE-234: %[[szK:.*]] = affine.min #[[$bound_map_4]](%[[K]])[%[[localK]]] +// TILE-234: %[[szK:.*]] = affine.min #[[$bound_map_4]](%[[K]]) [%[[localK]]] // TILE-234: %[[sAik:.*]] = subview %{{.*}}[%[[I]], %[[K]]] [%[[szM]], %[[szK]]] [1, 1] : memref to memref // TILE-234: %[[localK:.*]] = dim %{{.*}}, %c0 -// TILE-234: %[[szK:.*]] = affine.min #[[$bound_map_4]](%[[K]])[%[[localK]]] +// TILE-234: %[[szK:.*]] = affine.min #[[$bound_map_4]](%[[K]]) [%[[localK]]] // TILE-234: %[[localN:.*]] = dim %{{.*}}, %c1 -// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]])[%[[localN]]] +// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]]) [%[[localN]]] // TILE-234: %[[sBkj:.*]] = subview %{{.*}}[%[[K]], %[[J]]] [%[[szK]], %[[szN]]] [1, 1] : memref to memref // TILE-234: %[[localM:.*]] = dim %{{.*}}, %c0 -// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[localM]]] +// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]]) [%[[localM]]] // TILE-234: %[[localN:.*]] = dim %{{.*}}, %c1 -// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]])[%[[localN]]] +// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]]) [%[[localN]]] // TILE-234: %[[sCij:.*]] = subview %{{.*}}[%[[I]], %[[J]]] [%[[szM]], %[[szN]]] [1, 1] : memref to memref // // TILE-234: linalg.matmul ins(%[[sAik]], %[[sBkj]]{{.*}} outs(%[[sCij]] @@ -193,11 +193,11 @@ // TILE-2: %[[M:.*]] = dim %{{.*}}, %c0 : memref // TILE-2: scf.for %[[I:.*]] = %{{.*}}{{.*}} to %[[M]] step %{{.*}} { // TILE-2: %[[localM:.*]] = dim %[[ARG0]], %c0 -// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[localM]]] +// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]]) [%[[localM]]] // TILE-2: %[[N:.*]] = dim %{{.*}}, %c1 : memref // TILE-2: %[[sAi:.*]] = subview %{{.*}}[%[[I]], 0] [%[[szM]], %[[N]]] [1, 1] : memref to memref // TILE-2: %[[localN:.*]] = dim %{{.*}}, %c0 -// TILE-2: %[[szN:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[localN]]] +// TILE-2: %[[szN:.*]] = affine.min #[[$bound_map]](%[[I]]) [%[[localN]]] // TILE-2: %[[sCi:.*]] = subview %{{.*}}[%[[I]]] [%[[szN]]] [1] : memref to memref // TILE-2: linalg.matvec ins(%[[sAi]], %{{.*}} outs(%[[sCi]] @@ -211,10 +211,10 @@ // TILE-02: scf.for %[[J:.*]] = %{{.*}}{{.*}} to %[[K]] step %{{.*}} { // TILE-02: %[[M:.*]] = dim %{{.*}}, %c0 : memref // TILE-02: %[[localN:.*]] = dim %{{.*}}, %c1 -// TILE-02: %[[szN:.*]] = affine.min #[[$bound_map]](%[[J]])[%[[localN]]] +// TILE-02: %[[szN:.*]] = affine.min #[[$bound_map]](%[[J]]) [%[[localN]]] // TILE-02: %[[sAj:.*]] = subview %{{.*}}[0, %[[J]]] [%[[M]], %[[szN]]] [1, 1] : memref to memref // TILE-02: %[[localN:.*]] = dim %{{.*}}, %c0 -// TILE-02: %[[szN:.*]] = affine.min #[[$bound_map]](%[[J]])[%[[localN]]] +// TILE-02: %[[szN:.*]] = affine.min #[[$bound_map]](%[[J]]) [%[[localN]]] // TILE-02: %[[sBj:.*]] = subview %{{.*}}[%[[J]]] [%[[szN]]] [1] : memref to memref // TILE-02: linalg.matvec ins(%[[sAj]], %[[sBj]]{{.*}} outs(%{{.*}} @@ -236,15 +236,15 @@ // TILE-234: scf.for %[[I:.*]] = %{{.*}}{{.*}} to %[[M]] step %{{.*}} { // TILE-234: scf.for %[[J:.*]] = %{{.*}}{{.*}} to %[[K]] step %{{.*}} { // TILE-234: %[[localM:.*]] = dim %{{.*}}, %c0 -// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[localM]]] +// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]]) [%[[localM]]] // TILE-234: %[[localN:.*]] = dim %{{.*}}, %c1 -// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]])[%[[localN]]] +// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]]) [%[[localN]]] // TILE-234: %[[sAij:.*]] = subview %{{.*}}[%[[I]], %[[J]]] [%[[szM]], %[[szN]]] [1, 1] : memref to memref // TILE-234: %[[localN:.*]] = dim %{{.*}}, %c0 -// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]])[%[[localN]]] +// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]]) [%[[localN]]] // TILE-234: %[[sBj:.*]] = subview %{{.*}}[%[[J]]] [%[[szN]]] [1] : memref to memref // TILE-234: %[[localM:.*]] = dim %{{.*}}, %c0 -// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[localM]]] +// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]]) [%[[localM]]] // TILE-234: %[[sCi:.*]] = subview %{{.*}}[%[[I]]] [%[[szM]]] [1] : memref to memref // // TILE-234: linalg.matvec ins(%[[sAij]], %[[sBj]]{{.*}} outs(%[[sCi]] @@ -261,10 +261,10 @@ // TILE-2: %[[M:.*]] = dim %{{.*}}, %c0 : memref // TILE-2: scf.for %[[I:.*]] = %{{.*}}{{.*}} to %[[M]] step %{{.*}} { // TILE-2: %[[localM:.*]] = dim %{{.*}}, %c0 -// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[localM]]] +// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]]) [%[[localM]]] // TILE-2: %[[sAi:.*]] = subview %{{.*}}[%[[I]]] [%[[szM]]] [1] : memref to memref // TILE-2: %[[localM:.*]] = dim %{{.*}}, %c0 -// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[localM]]] +// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]]) [%[[localM]]] // TILE-2: %[[sBi:.*]] = subview %{{.*}}[%[[I]]] [%[[szM]]] [1] : memref to memref // TILE-2: linalg.dot ins(%[[sAi]], %[[sBi]]{{.*}} outs( @@ -280,10 +280,10 @@ // TILE-234: %[[ubK:.*]] = dim %{{.*}}, %c0 : memref // TILE-234: scf.for %[[I:.*]] = %{{.*}} to %[[ubK]] step %{{.*}} { // TILE-234: %[[localM:.*]] = dim %{{.*}}, %c0 -// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[localM]]] +// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]]) [%[[localM]]] // TILE-234: %[[sAi:.*]] = subview %{{.*}}[%[[I]]] [%[[szM]]] [1] : memref to memref // TILE-234: %[[localM:.*]] = dim %{{.*}}, %c0 -// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[localM]]] +// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]]) [%[[localM]]] // TILE-234: %[[sBi:.*]] = subview %{{.*}}[%[[I]]] [%[[szM]]] [1] : memref to memref // TILE-234: linalg.dot ins(%[[sAi]], %[[sBi]]{{.*}} outs( diff --git a/mlir/test/Dialect/Linalg/transform-patterns.mlir b/mlir/test/Dialect/Linalg/transform-patterns.mlir --- a/mlir/test/Dialect/Linalg/transform-patterns.mlir +++ b/mlir/test/Dialect/Linalg/transform-patterns.mlir @@ -1,10 +1,10 @@ // RUN: mlir-opt %s -test-linalg-transform-patterns=test-patterns | FileCheck %s -// CHECK-DAG: #[[$STRIDED_1D:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> +// CHECK-DAG: #[[$STRIDED_1D:.*]] = affine_map<(d0) [s0, s1] -> (d0 * s1 + s0)> // Map corresponding to a 2D memory access where the stride along the last dim is known to be 1. -// CHECK-DAG: #[[$STRIDED_2D_u_1:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[$STRIDED_2D_u_1:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> // Map corresponding to a 2D memory access where the stride along all dims are unknown. -// CHECK-DAG: #[[$STRIDED_2D:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +// CHECK-DAG: #[[$STRIDED_2D:.*]] = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> // CHECK-DAG: #[[$mk:.*]] = affine_map<(d0, d1, d2) -> (d0, d2)> // CHECK-DAG: #[[$kn:.*]] = affine_map<(d0, d1, d2) -> (d2, d1)> // CHECK-DAG: #[[$mn:.*]] = affine_map<(d0, d1, d2) -> (d0, d1)> diff --git a/mlir/test/Dialect/SCF/for-loop-specialization.mlir b/mlir/test/Dialect/SCF/for-loop-specialization.mlir --- a/mlir/test/Dialect/SCF/for-loop-specialization.mlir +++ b/mlir/test/Dialect/SCF/for-loop-specialization.mlir @@ -1,14 +1,14 @@ // RUN: mlir-opt %s -for-loop-specialization -split-input-file | FileCheck %s -#map0 = affine_map<()[s0, s1] -> (1024, s0 - s1)> -#map1 = affine_map<()[s0, s1] -> (64, s0 - s1)> +#map0 = affine_map<() [s0, s1] -> (1024, s0 - s1)> +#map1 = affine_map<() [s0, s1] -> (64, s0 - s1)> func @for(%outer: index, %A: memref, %B: memref, %C: memref, %result: memref) { %c0 = constant 0 : index %c1 = constant 1 : index %d0 = dim %A, %c0 : memref - %b0 = affine.min #map0()[%d0, %outer] + %b0 = affine.min #map0() [%d0, %outer] scf.for %i0 = %c0 to %b0 step %c1 { %B_elem = load %B[%i0] : memref %C_elem = load %C[%i0] : memref @@ -23,7 +23,7 @@ // CHECK: [[CST_0:%.*]] = constant 0 : index // CHECK: [[CST_1:%.*]] = constant 1 : index // CHECK: [[DIM_0:%.*]] = dim [[ARG1]], [[CST_0]] : memref -// CHECK: [[MIN:%.*]] = affine.min #map(){{\[}}[[DIM_0]], [[ARG0]]] +// CHECK: [[MIN:%.*]] = affine.min #map() {{\[}}[[DIM_0]], [[ARG0]]] // CHECK: [[CST_1024:%.*]] = constant 1024 : index // CHECK: [[PRED:%.*]] = cmpi "eq", [[MIN]], [[CST_1024]] : index // CHECK: scf.if [[PRED]] { diff --git a/mlir/test/Dialect/SCF/parallel-loop-specialization.mlir b/mlir/test/Dialect/SCF/parallel-loop-specialization.mlir --- a/mlir/test/Dialect/SCF/parallel-loop-specialization.mlir +++ b/mlir/test/Dialect/SCF/parallel-loop-specialization.mlir @@ -1,7 +1,7 @@ // RUN: mlir-opt %s -parallel-loop-specialization -split-input-file | FileCheck %s -#map0 = affine_map<()[s0, s1] -> (1024, s0 - s1)> -#map1 = affine_map<()[s0, s1] -> (64, s0 - s1)> +#map0 = affine_map<() [s0, s1] -> (1024, s0 - s1)> +#map1 = affine_map<() [s0, s1] -> (64, s0 - s1)> func @parallel_loop(%outer_i0: index, %outer_i1: index, %A: memref, %B: memref, %C: memref, %result: memref) { @@ -9,8 +9,8 @@ %c1 = constant 1 : index %d0 = dim %A, %c0 : memref %d1 = dim %A, %c1 : memref - %b0 = affine.min #map0()[%d0, %outer_i0] - %b1 = affine.min #map1()[%d1, %outer_i1] + %b0 = affine.min #map0() [%d0, %outer_i0] + %b1 = affine.min #map1() [%d1, %outer_i1] scf.parallel (%i0, %i1) = (%c0, %c0) to (%b0, %b1) step (%c1, %c1) { %B_elem = load %B[%i0, %i1] : memref %C_elem = load %C[%i0, %i1] : memref @@ -26,8 +26,8 @@ // CHECK: [[VAL_7:%.*]] = constant 1 : index // CHECK: [[VAL_8:%.*]] = dim [[VAL_2]], [[VAL_6]] : memref // CHECK: [[VAL_9:%.*]] = dim [[VAL_2]], [[VAL_7]] : memref -// CHECK: [[VAL_10:%.*]] = affine.min #map0(){{\[}}[[VAL_8]], [[VAL_0]]] -// CHECK: [[VAL_11:%.*]] = affine.min #map1(){{\[}}[[VAL_9]], [[VAL_1]]] +// CHECK: [[VAL_10:%.*]] = affine.min #map0() {{\[}}[[VAL_8]], [[VAL_0]]] +// CHECK: [[VAL_11:%.*]] = affine.min #map1() {{\[}}[[VAL_9]], [[VAL_1]]] // CHECK: [[VAL_12:%.*]] = constant 1024 : index // CHECK: [[VAL_13:%.*]] = cmpi "eq", [[VAL_10]], [[VAL_12]] : index // CHECK: [[VAL_14:%.*]] = constant 64 : index diff --git a/mlir/test/Dialect/Standard/invalid.mlir b/mlir/test/Dialect/Standard/invalid.mlir --- a/mlir/test/Dialect/Standard/invalid.mlir +++ b/mlir/test/Dialect/Standard/invalid.mlir @@ -82,23 +82,23 @@ // ----- -func @transpose_not_permutation(%v : memref(off + M * i + j)>>) { +func @transpose_not_permutation(%v : memref(off + M * i + j)>>) { // expected-error @+1 {{expected a permutation map}} - transpose %v (i, j) -> (i, i) : memref(off + M * i + j)>> to memref(off + M * i + j)>> + transpose %v (i, j) -> (i, i) : memref(off + M * i + j)>> to memref(off + M * i + j)>> } // ----- -func @transpose_bad_rank(%v : memref(off + M * i + j)>>) { +func @transpose_bad_rank(%v : memref(off + M * i + j)>>) { // expected-error @+1 {{expected a permutation map of same rank as the input}} - transpose %v (i) -> (i) : memref(off + M * i + j)>> to memref(off + M * i + j)>> + transpose %v (i) -> (i) : memref(off + M * i + j)>> to memref(off + M * i + j)>> } // ----- -func @transpose_wrong_type(%v : memref(off + M * i + j)>>) { - // expected-error @+1 {{output type 'memref (d0 * s1 + s0 + d1)>>' does not match transposed input type 'memref (d0 * s1 + s0 + d1)>>'}} - transpose %v (i, j) -> (j, i) : memref(off + M * i + j)>> to memref(off + M * i + j)>> +func @transpose_wrong_type(%v : memref(off + M * i + j)>>) { + // expected-error @+1 {{output type 'memref (d0 * s1 + s0 + d1)>>' does not match transposed input type 'memref (d0 * s1 + s0 + d1)>>'}} + transpose %v (i, j) -> (j, i) : memref(off + M * i + j)>> to memref(off + M * i + j)>> } // ----- diff --git a/mlir/test/Dialect/Vector/invalid.mlir b/mlir/test/Dialect/Vector/invalid.mlir --- a/mlir/test/Dialect/Vector/invalid.mlir +++ b/mlir/test/Dialect/Vector/invalid.mlir @@ -607,7 +607,7 @@ #contraction_accesses = [ affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>, - affine_map<(b0, f0, f1, c0, c1)[s0] -> (b0, s0, c0, f1)>, + affine_map<(b0, f0, f1, c0, c1) [s0] -> (b0, s0, c0, f1)>, affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)> ] #contraction_trait = { @@ -1191,9 +1191,9 @@ // ----- -func @type_cast_layout(%arg0: memref<4x3xf32, affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s0 + d1 * s1 + s2)>>) { +func @type_cast_layout(%arg0: memref<4x3xf32, affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s0 + d1 * s1 + s2)>>) { // expected-error@+1 {{expects operand to be a memref with no layout}} - %0 = vector.type_cast %arg0: memref<4x3xf32, affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s0 + d1 * s1 + s2)>> to memref> + %0 = vector.type_cast %arg0: memref<4x3xf32, affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s0 + d1 * s1 + s2)>> to memref> } // ----- diff --git a/mlir/test/Dialect/Vector/vector-distribution.mlir b/mlir/test/Dialect/Vector/vector-distribution.mlir --- a/mlir/test/Dialect/Vector/vector-distribution.mlir +++ b/mlir/test/Dialect/Vector/vector-distribution.mlir @@ -38,16 +38,16 @@ // ----- -// CHECK-DAG: #[[MAP0:map[0-9]+]] = affine_map<()[s0] -> (s0 * 2)> +// CHECK-DAG: #[[MAP0:map[0-9]+]] = affine_map<() [s0] -> (s0 * 2)> // CHECK: func @vector_add_cycle // CHECK-SAME: (%[[ID:.*]]: index -// CHECK: %[[ID1:.*]] = affine.apply #[[MAP0]]()[%[[ID]]] +// CHECK: %[[ID1:.*]] = affine.apply #[[MAP0]]() [%[[ID]]] // CHECK-NEXT: %[[EXA:.*]] = vector.transfer_read %{{.*}}[%[[ID1]]], %{{.*}} : memref<64xf32>, vector<2xf32> -// CHECK-NEXT: %[[ID2:.*]] = affine.apply #[[MAP0]]()[%[[ID]]] +// CHECK-NEXT: %[[ID2:.*]] = affine.apply #[[MAP0]]() [%[[ID]]] // CHECK-NEXT: %[[EXB:.*]] = vector.transfer_read %{{.*}}[%[[ID2]]], %{{.*}} : memref<64xf32>, vector<2xf32> // CHECK-NEXT: %[[ADD:.*]] = addf %[[EXA]], %[[EXB]] : vector<2xf32> -// CHECK-NEXT: %[[ID3:.*]] = affine.apply #[[MAP0]]()[%[[ID]]] +// CHECK-NEXT: %[[ID3:.*]] = affine.apply #[[MAP0]]() [%[[ID]]] // CHECK-NEXT: vector.transfer_write %[[ADD]], %{{.*}}[%[[ID3]]] : vector<2xf32>, memref<64xf32> // CHECK-NEXT: return func @vector_add_cycle(%id : index, %A: memref<64xf32>, %B: memref<64xf32>, %C: memref<64xf32>) { diff --git a/mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir b/mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir --- a/mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir +++ b/mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir @@ -1,14 +1,14 @@ // RUN: mlir-opt %s -test-vector-transfer-full-partial-split | FileCheck %s // RUN: mlir-opt %s -test-vector-transfer-full-partial-split=use-linalg-copy | FileCheck %s --check-prefix=LINALG -// CHECK-DAG: #[[$map_p4:.*]] = affine_map<()[s0] -> (s0 + 4)> -// CHECK-DAG: #[[$map_p8:.*]] = affine_map<()[s0] -> (s0 + 8)> -// CHECK-DAG: #[[$map_2d_stride_1:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[$map_p4:.*]] = affine_map<() [s0] -> (s0 + 4)> +// CHECK-DAG: #[[$map_p8:.*]] = affine_map<() [s0] -> (s0 + 8)> +// CHECK-DAG: #[[$map_2d_stride_1:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> -// LINALG-DAG: #[[$map_p4:.*]] = affine_map<()[s0] -> (s0 + 4)> -// LINALG-DAG: #[[$map_p8:.*]] = affine_map<()[s0] -> (s0 + 8)> -// LINALG-DAG: #[[$map_2d_stride_1:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// LINALG-DAG: #[[$map_2d_dynamic:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +// LINALG-DAG: #[[$map_p4:.*]] = affine_map<() [s0] -> (s0 + 4)> +// LINALG-DAG: #[[$map_p8:.*]] = affine_map<() [s0] -> (s0 + 8)> +// LINALG-DAG: #[[$map_2d_stride_1:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// LINALG-DAG: #[[$map_2d_dynamic:.*]] = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> // LINALG-DAG: #[[$bounds_map_4:.*]] = affine_map<(d0, d1, d2) -> (d0 - d1, 4)> // LINALG-DAG: #[[$bounds_map_8:.*]] = affine_map<(d0, d1, d2) -> (d0 - d1, 8)> @@ -31,11 +31,11 @@ // alloca for boundary full tile // CHECK: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32> // %i + 4 <= dim(%A, 0) - // CHECK: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]] + // CHECK: %[[idx0:.*]] = affine.apply #[[$map_p4]]() [%[[i]]] // CHECK: %[[d0:.*]] = dim %[[A]], %[[c0]] : memref // CHECK: %[[cmp0:.*]] = cmpi "sle", %[[idx0]], %[[d0]] : index // %j + 8 <= dim(%A, 1) - // CHECK: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]] + // CHECK: %[[idx1:.*]] = affine.apply #[[$map_p8]]() [%[[j]]] // CHECK: %[[cmp1:.*]] = cmpi "sle", %[[idx1]], %[[c8]] : index // are both conds true // CHECK: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1 @@ -65,11 +65,11 @@ // alloca for boundary full tile // LINALG: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32> // %i + 4 <= dim(%A, 0) - // LINALG: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]] + // LINALG: %[[idx0:.*]] = affine.apply #[[$map_p4]]() [%[[i]]] // LINALG: %[[d0:.*]] = dim %[[A]], %[[c0]] : memref // LINALG: %[[cmp0:.*]] = cmpi "sle", %[[idx0]], %[[d0]] : index // %j + 8 <= dim(%A, 1) - // LINALG: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]] + // LINALG: %[[idx1:.*]] = affine.apply #[[$map_p8]]() [%[[j]]] // LINALG: %[[cmp1:.*]] = cmpi "sle", %[[idx1]], %[[c8]] : index // are both conds true // LINALG: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1 @@ -120,10 +120,10 @@ // alloca for boundary full tile // CHECK: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32> // %i + 4 <= dim(%A, 0) - // CHECK: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]] + // CHECK: %[[idx0:.*]] = affine.apply #[[$map_p4]]() [%[[i]]] // CHECK: %[[cmp0:.*]] = cmpi "sle", %[[idx0]], %[[c7]] : index // %j + 8 <= dim(%A, 1) - // CHECK: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]] + // CHECK: %[[idx1:.*]] = affine.apply #[[$map_p8]]() [%[[j]]] // CHECK: %[[cmp1:.*]] = cmpi "sle", %[[idx1]], %[[c8]] : index // are both conds true // CHECK: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1 @@ -158,10 +158,10 @@ // alloca for boundary full tile // LINALG: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32> // %i + 4 <= dim(%A, 0) - // LINALG: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]] + // LINALG: %[[idx0:.*]] = affine.apply #[[$map_p4]]() [%[[i]]] // LINALG: %[[cmp0:.*]] = cmpi "sle", %[[idx0]], %[[c7]] : index // %j + 8 <= dim(%A, 1) - // LINALG: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]] + // LINALG: %[[idx1:.*]] = affine.apply #[[$map_p8]]() [%[[j]]] // LINALG: %[[cmp1:.*]] = cmpi "sle", %[[idx1]], %[[c8]] : index // are both conds true // LINALG: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1 diff --git a/mlir/test/EDSC/builder-api-test.cpp b/mlir/test/EDSC/builder-api-test.cpp --- a/mlir/test/EDSC/builder-api-test.cpp +++ b/mlir/test/EDSC/builder-api-test.cpp @@ -90,9 +90,9 @@ // clang-format off // CHECK-LABEL: func @builder_dynamic_for_func_args(%{{.*}}: index, %{{.*}}: index) { // CHECK: affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%{{.*}}) to affine_map<(d0) -> (d0)>(%{{.*}}) step 3 { - // CHECK: {{.*}} = affine.apply affine_map<()[s0] -> (s0 * 3)>()[%{{.*}}] - // CHECK: {{.*}} = affine.apply affine_map<()[s0, s1] -> (s1 + s0 * 3)>()[%{{.*}}, %{{.*}}] - // CHECK: {{.*}} = affine.apply affine_map<()[s0] -> (s0 + 3)>()[%{{.*}}] + // CHECK: {{.*}} = affine.apply affine_map<() [s0] -> (s0 * 3)>() [%{{.*}}] + // CHECK: {{.*}} = affine.apply affine_map<() [s0, s1] -> (s1 + s0 * 3)>() [%{{.*}}, %{{.*}}] + // CHECK: {{.*}} = affine.apply affine_map<() [s0] -> (s0 + 3)>() [%{{.*}}] // CHECK: affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%{{.*}}) to affine_map<(d0) -> (d0)>(%{{.*}}) step 2 { // CHECK: {{.*}} = affine.apply affine_map<(d0, d1) -> ((d0 + d1 * 3) floordiv 32)>(%{{.*}}, %{{.*}}) // CHECK: {{.*}} = affine.apply affine_map<(d0, d1) -> (((d0 + d1 * 3) floordiv 32) * 31)>(%{{.*}}, %{{.*}}) @@ -126,8 +126,8 @@ // clang-format off // CHECK-LABEL: func @builder_dynamic_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) { - // CHECK-DAG: [[r0:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 - s1)>()[%{{.*}}, %{{.*}}] - // CHECK-DAG: [[r1:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>()[%{{.*}}, %{{.*}}] + // CHECK-DAG: [[r0:%[0-9]+]] = affine.apply affine_map<() [s0, s1] -> (s0 - s1)>() [%{{.*}}, %{{.*}}] + // CHECK-DAG: [[r1:%[0-9]+]] = affine.apply affine_map<() [s0, s1] -> (s0 + s1)>() [%{{.*}}, %{{.*}}] // CHECK-NEXT: affine.for %{{.*}} = affine_map<(d0) -> (d0)>([[r0]]) to affine_map<(d0) -> (d0)>([[r1]]) step 2 { // clang-format on f.print(llvm::outs()); @@ -148,8 +148,8 @@ // clang-format off // CHECK-LABEL: func @builder_loop_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) { - // CHECK-DAG: [[r0:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 - s1)>()[%{{.*}}, %{{.*}}] - // CHECK-DAG: [[r1:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>()[%{{.*}}, %{{.*}}] + // CHECK-DAG: [[r0:%[0-9]+]] = affine.apply affine_map<() [s0, s1] -> (s0 - s1)>() [%{{.*}}, %{{.*}}] + // CHECK-DAG: [[r1:%[0-9]+]] = affine.apply affine_map<() [s0, s1] -> (s0 + s1)>() [%{{.*}}, %{{.*}}] // CHECK-NEXT: scf.for %{{.*}} = [[r0]] to [[r1]] step {{.*}} { // clang-format on f.print(llvm::outs()); @@ -766,10 +766,10 @@ // CHECK: affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%[[ZERO]]) to affine_map<(d0) -> (d0)>(%[[M]]) step 512 { // CHECK-NEXT: affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%[[ZERO]]) to affine_map<(d0) -> (d0)>(%[[N]]) step 1024 { // CHECK-NEXT: affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%[[ZERO]]) to affine_map<(d0) -> (d0)>(%[[P]]) { - // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0)[s0] -> (s0, d0 + 512)>(%{{.*}})[%[[M]]] step 16 { - // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0)[s0] -> (s0, d0 + 1024)>(%{{.*}})[%[[N]]] step 32 { - // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0, d1) -> (0, d0, d1)>(%{{.*}}, %{{.*}}) to min affine_map<(d0, d1)[s0] -> (s0, d0 + 1024, d1 + 32)>(%{{.*}}, %{{.*}})[%[[N]]] { - // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0, d1) -> (0, d0, d1)>(%{{.*}}, %{{.*}}) to min affine_map<(d0, d1)[s0] -> (s0, d0 + 512, d1 + 16)>(%{{.*}}, %{{.*}})[%[[M]]] { + // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0) [s0] -> (s0, d0 + 512)>(%{{.*}}) [%[[M]]] step 16 { + // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0) [s0] -> (s0, d0 + 1024)>(%{{.*}}) [%[[N]]] step 32 { + // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0, d1) -> (0, d0, d1)>(%{{.*}}, %{{.*}}) to min affine_map<(d0, d1) [s0] -> (s0, d0 + 1024, d1 + 32)>(%{{.*}}, %{{.*}}) [%[[N]]] { + // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0, d1) -> (0, d0, d1)>(%{{.*}}, %{{.*}}) to min affine_map<(d0, d1) [s0] -> (s0, d0 + 512, d1 + 16)>(%{{.*}}, %{{.*}}) [%[[M]]] { // CHECK-NEXT: {{.*}} = affine.load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref // CHECK-NEXT: {{.*}} = affine.load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref // CHECK-NEXT: {{.*}} = addf {{.*}}, {{.*}} : f32 @@ -780,8 +780,8 @@ // CHECK-NEXT: } // CHECK-NEXT: } // CHECK-NEXT: affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%[[ZERO]]) to affine_map<(d0) -> (d0)>(%[[P]]) { - // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0)[s0] -> (s0, d0 + 512)>(%{{.*}})[%[[M]]] { - // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0)[s0] -> (s0, d0 + 1024)>(%{{.*}})[%[[N]]] { + // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0) [s0] -> (s0, d0 + 512)>(%{{.*}}) [%[[M]]] { + // CHECK-NEXT: affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0) [s0] -> (s0, d0 + 1024)>(%{{.*}}) [%[[N]]] { // CHECK-NEXT: {{.*}} = affine.load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref // CHECK-NEXT: {{.*}} = affine.load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref // CHECK-NEXT: {{.*}}= addf {{.*}}, {{.*}} : f32 @@ -1230,8 +1230,8 @@ // CHECK-LABEL: func @builder_loop_for_yield(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) { // CHECK: [[init0:%.*]] = constant // CHECK: [[init1:%.*]] = constant - // CHECK-DAG: [[r0:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 - s1)>()[%{{.*}}, %{{.*}}] - // CHECK-DAG: [[r1:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>()[%{{.*}}, %{{.*}}] + // CHECK-DAG: [[r0:%[0-9]+]] = affine.apply affine_map<() [s0, s1] -> (s0 - s1)>() [%{{.*}}, %{{.*}}] + // CHECK-DAG: [[r1:%[0-9]+]] = affine.apply affine_map<() [s0, s1] -> (s0 + s1)>() [%{{.*}}, %{{.*}}] // CHECK-NEXT: [[res:%[0-9]+]]:2 = scf.for %{{.*}} = [[r0]] to [[r1]] step {{.*}} iter_args([[arg0:%.*]] = [[init0]], [[arg1:%.*]] = [[init1]]) -> (f32, f32) { // CHECK: [[sum:%[0-9]+]] = addf [[arg0]], [[arg1]] : f32 // CHECK: scf.yield [[arg1]], [[sum]] : f32, f32 diff --git a/mlir/test/IR/affine-map.mlir b/mlir/test/IR/affine-map.mlir --- a/mlir/test/IR/affine-map.mlir +++ b/mlir/test/IR/affine-map.mlir @@ -4,8 +4,8 @@ // CHECK-NOT: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0, d1)> #map0 = affine_map<(i, j) -> (i, j)> -// CHECK-NOT: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0, d1)> -#map1 = affine_map<(i, j)[s0] -> (i, j)> +// CHECK-NOT: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0, d1)> +#map1 = affine_map<(i, j) [s0] -> (i, j)> // CHECK: #map{{[0-9]+}} = affine_map<() -> (0)> // A map may have 0 inputs. @@ -39,44 +39,44 @@ // CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0 + 2, d1)> #map4 = affine_map<(i, j) -> (3+3-2*2+i, j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + s0, d1)> -#map5 = affine_map<(i, j)[s0] -> (i + s0, j)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 + s0, d1)> +#map5 = affine_map<(i, j) [s0] -> (i + s0, j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + s0, d1 + 5)> -#map6 = affine_map<(i, j)[s0] -> (i + s0, j + 5)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 + s0, d1 + 5)> +#map6 = affine_map<(i, j) [s0] -> (i + s0, j + 5)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + s0, d1)> -#map7 = affine_map<(i, j)[s0] -> (i + j + s0, j)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 + d1 + s0, d1)> +#map7 = affine_map<(i, j) [s0] -> (i + j + s0, j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + s0 + 5, d1)> -#map8 = affine_map<(i, j)[s0] -> (5 + i + j + s0, j)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 + d1 + s0 + 5, d1)> +#map8 = affine_map<(i, j) [s0] -> (5 + i + j + s0, j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + 5, d1)> -#map9 = affine_map<(i, j)[s0] -> ((i + j) + 5, j)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 + d1 + 5, d1)> +#map9 = affine_map<(i, j) [s0] -> ((i + j) + 5, j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + 5, d1)> -#map10 = affine_map<(i, j)[s0] -> (i + (j + 5), j)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 + d1 + 5, d1)> +#map10 = affine_map<(i, j) [s0] -> (i + (j + 5), j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 * 2, d1 * 3)> -#map11 = affine_map<(i, j)[s0] -> (2*i, 3*j)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 * 2, d1 * 3)> +#map11 = affine_map<(i, j) [s0] -> (2*i, 3*j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + (d1 + s0 * 3) * 5 + 12, d1)> -#map12 = affine_map<(i, j)[s0] -> (i + 2*6 + 5*(j+s0*3), j)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 + (d1 + s0 * 3) * 5 + 12, d1)> +#map12 = affine_map<(i, j) [s0] -> (i + 2*6 + 5*(j+s0*3), j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 * 5 + d1, d1)> -#map13 = affine_map<(i, j)[s0] -> (5*i + j, j)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 * 5 + d1, d1)> +#map13 = affine_map<(i, j) [s0] -> (5*i + j, j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1, d1)> -#map14 = affine_map<(i, j)[s0] -> ((i + j), (j))> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 + d1, d1)> +#map14 = affine_map<(i, j) [s0] -> ((i + j), (j))> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + 7, d1 + 3)> -#map15 = affine_map<(i, j)[s0] -> ((i + j + 2) + 5, (j)+3)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 + d1 + 7, d1 + 3)> +#map15 = affine_map<(i, j) [s0] -> ((i + j + 2) + 5, (j)+3)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0, 0)> -#map16 = affine_map<(i, j)[s1] -> (i, 0)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0, 0)> +#map16 = affine_map<(i, j) [s1] -> (i, 0)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0, d1 * s0)> -#map17 = affine_map<(i, j)[s0] -> (i, s0*j)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0, d1 * s0)> +#map17 = affine_map<(i, j) [s0] -> (i, s0*j)> // CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0, d0 * 3 + d1)> #map19 = affine_map<(i, j) -> (i, 3*i + j)> @@ -84,44 +84,44 @@ // CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0, d0 + d1 * 3)> #map20 = affine_map<(i, j) -> (i, i + 3*j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0, d0 * ((s0 * s0) * 9) + 3)> -#map18 = affine_map<(i, j)[N] -> (i, 2 + N*N*9*i + 1)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0, d0 * ((s0 * s0) * 9) + 3)> +#map18 = affine_map<(i, j) [N] -> (i, 2 + N*N*9*i + 1)> // CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (1, d0 + d1 * 3 + 5)> #map21 = affine_map<(i, j) -> (1, i + 3*j + 5)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (s0 * 5, d0 + d1 * 3 + d0 * 5)> -#map22 = affine_map<(i, j)[s0] -> (5*s0, i + 3*j + 5*i)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (s0 * 5, d0 + d1 * 3 + d0 * 5)> +#map22 = affine_map<(i, j) [s0] -> (5*s0, i + 3*j + 5*i)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0 * (s0 * s1), d1)> -#map23 = affine_map<(i, j)[s0, s1] -> (i*(s0*s1), j)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0, s1] -> (d0 * (s0 * s1), d1)> +#map23 = affine_map<(i, j) [s0, s1] -> (i*(s0*s1), j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d1 mod 5)> -#map24 = affine_map<(i, j)[s0, s1] -> (i, j mod 5)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0, s1] -> (d0, d1 mod 5)> +#map24 = affine_map<(i, j) [s0, s1] -> (i, j mod 5)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d1 floordiv 5)> -#map25 = affine_map<(i, j)[s0, s1] -> (i, j floordiv 5)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0, s1] -> (d0, d1 floordiv 5)> +#map25 = affine_map<(i, j) [s0, s1] -> (i, j floordiv 5)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d1 ceildiv 5)> -#map26 = affine_map<(i, j)[s0, s1] -> (i, j ceildiv 5)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0, s1] -> (d0, d1 ceildiv 5)> +#map26 = affine_map<(i, j) [s0, s1] -> (i, j ceildiv 5)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d0 - d1 - 5)> -#map29 = affine_map<(i, j)[s0, s1] -> (i, i - j - 5)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0, s1] -> (d0, d0 - d1 - 5)> +#map29 = affine_map<(i, j) [s0, s1] -> (i, i - j - 5)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d0 - d1 * s1 + 2)> -#map30 = affine_map<(i, j)[M, N] -> (i, i - N*j + 2)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0, s1] -> (d0, d0 - d1 * s1 + 2)> +#map30 = affine_map<(i, j) [M, N] -> (i, i - N*j + 2)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0 * -5, d1 * -3, -2, -(d0 + d1), -s0)> -#map32 = affine_map<(i, j)[s0, s1] -> (-5*i, -3*j, -2, -1*(i+j), -1*s0)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0, s1] -> (d0 * -5, d1 * -3, -2, -(d0 + d1), -s0)> +#map32 = affine_map<(i, j) [s0, s1] -> (-5*i, -3*j, -2, -1*(i+j), -1*s0)> // CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (-4, -d0)> #map33 = affine_map<(i, j) -> (-2+-5-(-3), -1*i)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d1 floordiv s0, d1 mod s0)> -#map34 = affine_map<(i, j)[s0, s1] -> (i, j floordiv s0, j mod s0)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0, s1] -> (d0, d1 floordiv s0, d1 mod s0)> +#map34 = affine_map<(i, j) [s0, s1] -> (i, j floordiv s0, j mod s0)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1, d2)[s0, s1, s2] -> ((d0 * s1) * s2 + d1 * s1 + d2)> -#map35 = affine_map<(i, j, k)[s0, s1, s2] -> (i*s1*s2 + j*s1 + k)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1, d2) [s0, s1, s2] -> ((d0 * s1) * s2 + d1 * s1 + d2)> +#map35 = affine_map<(i, j, k) [s0, s1, s2] -> (i*s1*s2 + j*s1 + k)> // Constant folding. // CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (8, 4, 1, 3, 2, 4)> @@ -132,17 +132,17 @@ // CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0 * 2 + 1, d1 + 2)> #map38 = affine_map<(i, j) -> (1 + i*2, 2 + j)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0 * s0, d0 + s0, d0 + 2, d1 * 2, s1 * 2, s0 + 2)> -#map39 = affine_map<(i, j)[M, N] -> (i*M, M + i, 2+i, j*2, N*2, 2 + M)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0, s1] -> (d0 * s0, d0 + s0, d0 + 2, d1 * 2, s1 * 2, s0 + 2)> +#map39 = affine_map<(i, j) [M, N] -> (i*M, M + i, 2+i, j*2, N*2, 2 + M)> -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> ((d0 * 5) floordiv 4, (d1 ceildiv 7) mod s0)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> ((d0 * 5) floordiv 4, (d1 ceildiv 7) mod s0)> #map43 = affine_map<(i, j) [s0] -> ( i * 5 floordiv 4, j ceildiv 7 mod s0)> // CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0 - d1 * 2, (d1 * 6) floordiv 4)> #map44 = affine_map<(i, j) -> (i - 2*j, j * 6 floordiv 4)> // Simplifications -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1, d2)[s0] -> (d0 + d1 + d2 + 1, d2 + d1, (d0 * s0) * 8)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1, d2) [s0] -> (d0 + d1 + d2 + 1, d2 + d1, (d0 * s0) * 8)> #map45 = affine_map<(i, j, k) [N] -> (1 + i + 3 + j - 3 + k, k + 5 + j - 5, 2*i*4*N)> // CHECK: #map{{[0-9]+}} = affine_map<(d0, d1, d2) -> (0, d1, d0 * 2, 0)> @@ -156,12 +156,12 @@ #map48 = affine_map<(i, j, k) -> (i * 64 floordiv 64, i * 512 floordiv 128, 4 * j mod 4, 4*j*4 mod 8)> // Simplifications for mod using known GCD's of the LHS expr. -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (0, 0, 0, 1)> -#map49 = affine_map<(i, j)[s0] -> ( (i * 4 + 8) mod 4, 32 * j * s0 * 8 mod 256, (4*i + (j * (s0 * 2))) mod 2, (4*i + 3) mod 2)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (0, 0, 0, 1)> +#map49 = affine_map<(i, j) [s0] -> ( (i * 4 + 8) mod 4, 32 * j * s0 * 8 mod 256, (4*i + (j * (s0 * 2))) mod 2, (4*i + 3) mod 2)> // Floordiv, ceildiv divide by one. -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 * 2 + 1, d1 + s0)> -#map50 = affine_map<(i, j)[s0] -> ( (i * 2 + 1) ceildiv 1, (j + s0) floordiv 1)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 * 2 + 1, d1 + s0)> +#map50 = affine_map<(i, j) [s0] -> ( (i * 2 + 1) ceildiv 1, (j + s0) floordiv 1)> // floordiv, ceildiv, and mod where LHS is negative. // CHECK: #map{{[0-9]+}} = affine_map<(d0) -> (-2, 1, -1)> @@ -174,8 +174,8 @@ // CHECK: #map{{[0-9]+}} = affine_map<(d0) -> (d0 - (d0 + 1))> #map53 = affine_map<(d0) -> (d0 - (d0 + 1))> -// CHECK: #map{{[0-9]+}} = affine_map<(d0)[s0] -> ((-s0) floordiv 4, d0 floordiv -1)> -#map54 = affine_map<(d0)[s0] -> (-s0 floordiv 4, d0 floordiv -1)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0) [s0] -> ((-s0) floordiv 4, d0 floordiv -1)> +#map54 = affine_map<(d0) [s0] -> (-s0 floordiv 4, d0 floordiv -1)> // CHECK: #map{{[0-9]+}} = affine_map<() -> ()> #map55 = affine_map<() -> ()> diff --git a/mlir/test/IR/core-ops.mlir b/mlir/test/IR/core-ops.mlir --- a/mlir/test/IR/core-ops.mlir +++ b/mlir/test/IR/core-ops.mlir @@ -6,22 +6,22 @@ // CHECK: #map0 = affine_map<(d0) -> (d0 + 1)> -// CHECK: #map1 = affine_map<()[s0] -> (s0 + 1)> +// CHECK: #map1 = affine_map<() [s0] -> (s0 + 1)> // CHECK-DAG: #[[$BASE_MAP0:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)> -// CHECK-DAG: #[[$BASE_MAP3:map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)> +// CHECK-DAG: #[[$BASE_MAP3:map[0-9]+]] = affine_map<(d0, d1, d2) [s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)> -// CHECK-DAG: #[[$BASE_MAP1:map[0-9]+]] = affine_map<(d0)[s0] -> (d0 + s0)> -// CHECK-DAG: #[[$SUBVIEW_MAP1:map[0-9]+]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> +// CHECK-DAG: #[[$BASE_MAP1:map[0-9]+]] = affine_map<(d0) [s0] -> (d0 + s0)> +// CHECK-DAG: #[[$SUBVIEW_MAP1:map[0-9]+]] = affine_map<(d0) [s0, s1] -> (d0 * s1 + s0)> // CHECK-DAG: #[[$BASE_MAP2:map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 22 + d1)> -// CHECK-DAG: #[[$SUBVIEW_MAP2:map[0-9]+]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +// CHECK-DAG: #[[$SUBVIEW_MAP2:map[0-9]+]] = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> // CHECK-DAG: #[[$SUBVIEW_MAP3:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2 + 8)> -// CHECK-DAG: #[[$SUBVIEW_MAP4:map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> -// CHECK-DAG: #[[$SUBVIEW_MAP5:map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 * 8 + s0 + d1 * 2)> +// CHECK-DAG: #[[$SUBVIEW_MAP4:map[0-9]+]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[$SUBVIEW_MAP5:map[0-9]+]] = affine_map<(d0, d1) [s0] -> (d0 * 8 + s0 + d1 * 2)> // CHECK-DAG: #[[$SUBVIEW_MAP6:map[0-9]+]] = affine_map<(d0, d1, d2, d3, d4) -> (d0 * 36 + d1 * 36 + d2 * 4 + d3 * 4 + d4)> -// CHECK-DAG: #[[$SUBVIEW_MAP7:map[0-9]+]] = affine_map<(d0, d1, d2, d3, d4, d5)[s0, s1, s2, s3, s4, s5, s6] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4 + d4 * s5 + d5 * s6)> -// CHECK-DAG: #[[$SUBVIEW_MAP8:map[0-9]+]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3, s4] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4)> +// CHECK-DAG: #[[$SUBVIEW_MAP7:map[0-9]+]] = affine_map<(d0, d1, d2, d3, d4, d5) [s0, s1, s2, s3, s4, s5, s6] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4 + d4 * s5 + d5 * s6)> +// CHECK-DAG: #[[$SUBVIEW_MAP8:map[0-9]+]] = affine_map<(d0, d1, d2, d3) [s0, s1, s2, s3, s4] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4)> // CHECK-LABEL: func @func_with_ops // CHECK-SAME: %[[ARG:.*]]: f32 @@ -605,8 +605,8 @@ %a = "affine.apply" (%i) { map = affine_map<(d0) -> (d0 + 1)> } : (index) -> (index) - // CHECK: affine.apply #map1()[%c0] - %b = affine.apply affine_map<()[x] -> (x+1)>()[%i] + // CHECK: affine.apply #map1() [%c0] + %b = affine.apply affine_map<() [x] -> (x+1)>() [%i] return } @@ -781,13 +781,13 @@ : memref<8x16x4xf32, offset:0, strides: [64, 4, 1]> to memref - %2 = alloc()[%arg2] : memref<64xf32, affine_map<(d0)[s0] -> (d0 + s0)>> + %2 = alloc()[%arg2] : memref<64xf32, affine_map<(d0) [s0] -> (d0 + s0)>> // CHECK: subview %2[%c1] [%arg0] [%c1] : // CHECK-SAME: memref<64xf32, #[[$BASE_MAP1]]> // CHECK-SAME: to memref %3 = subview %2[%c1][%arg0][%c1] - : memref<64xf32, affine_map<(d0)[s0] -> (d0 + s0)>> to - memref (d0 * s1 + s0)>> + : memref<64xf32, affine_map<(d0) [s0] -> (d0 + s0)>> to + memref (d0 * s1 + s0)>> %4 = alloc() : memref<64x22xf32, affine_map<(d0, d1) -> (d0 * 22 + d1)>> // CHECK: subview %4[%c0, %c1] [%arg0, %arg1] [%c1, %c0] : @@ -834,7 +834,7 @@ // CHECK-SAME: memref<1x9x1x4x1xf32, #[[$SUBVIEW_MAP6]]> to memref<1x9x4xf32, #[[$BASE_MAP3]]> %14 = subview %12[%arg1, %arg1, %arg1, %arg1, %arg1][1, 9, 1, 4, 1][%arg2, %arg2, %arg2, %arg2, %arg2] : memref<1x9x1x4x1xf32, offset: 0, strides: [36, 36, 4, 4, 1]> to memref<1x9x4xf32, offset: ?, strides: [?, ?, ?]> - %15 = alloc(%arg1, %arg2)[%c0, %c1, %arg1, %arg0, %arg0, %arg2, %arg2] : memref<1x?x5x1x?x1xf32, affine_map<(d0, d1, d2, d3, d4, d5)[s0, s1, s2, s3, s4, s5, s6] -> (s0 + s1 * d0 + s2 * d1 + s3 * d2 + s4 * d3 + s5 * d4 + s6 * d5)>> + %15 = alloc(%arg1, %arg2)[%c0, %c1, %arg1, %arg0, %arg0, %arg2, %arg2] : memref<1x?x5x1x?x1xf32, affine_map<(d0, d1, d2, d3, d4, d5) [s0, s1, s2, s3, s4, s5, s6] -> (s0 + s1 * d0 + s2 * d1 + s3 * d2 + s4 * d3 + s5 * d4 + s6 * d5)>> // CHECK: subview %15[0, 0, 0, 0, 0, 0] [1, %arg1, 5, 1, %arg2, 1] [1, 1, 1, 1, 1, 1] : // CHECK-SAME: memref<1x?x5x1x?x1xf32, #[[$SUBVIEW_MAP7]]> to memref %16 = subview %15[0, 0, 0, 0, 0, 0][1, %arg1, 5, 1, %arg2, 1][1, 1, 1, 1, 1, 1] : memref<1x?x5x1x?x1xf32, offset: ?, strides: [?, ?, ?, ?, ?, ?]> to memref diff --git a/mlir/test/IR/invalid-ops.mlir b/mlir/test/IR/invalid-ops.mlir --- a/mlir/test/IR/invalid-ops.mlir +++ b/mlir/test/IR/invalid-ops.mlir @@ -87,7 +87,8 @@ ^bb0: %0 = constant 7 : index // Test alloc with wrong number of dynamic dimensions. - %1 = alloc(%0)[%1] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1> // expected-error {{op 'std.alloc' dimension operand count does not equal memref dynamic dimension count}} + // expected-error@+1 {{dimension operand count does not equal memref dynamic dimension count}} + %1 = alloc(%0) [%0] : memref<2x4xf32, affine_map<(d0, d1) [s0] -> ((d0 + s0), d1)>, 1> return } @@ -97,7 +98,8 @@ ^bb0: %0 = constant 7 : index // Test alloc with wrong number of symbols - %1 = alloc(%0) : memref<2x?xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1> // expected-error {{operand count does not equal dimension plus symbol operand count}} + // expected-error@+1 {{symbol operand count does not equal memref symbol count}} + %1 = alloc(%0) : memref<2x?xf32, affine_map<(d0, d1) [s0] -> ((d0 + s0), d1)>, 1> return } @@ -941,7 +943,7 @@ // expected-error@+1 {{unsupported map for base memref type}} %1 = view %0[%arg2][%arg0, %arg1] : memref<2048xi8, affine_map<(d0) -> (d0 floordiv 8, d0 mod 8)>> to - memref (d0 * 4 + d1 + s0)>> + memref (d0 * 4 + d1 + s0)>> return } @@ -951,7 +953,7 @@ %0 = alloc() : memref<2048xi8> // expected-error@+1 {{unsupported map for result memref type}} %1 = view %0[%arg2][%arg0, %arg1] - : memref<2048xi8> to memref (d0, d1, s0)>> + : memref<2048xi8> to memref (d0, d1, s0)>> return } @@ -981,7 +983,7 @@ // expected-error@+1 {{different memory spaces}} %1 = subview %0[0, 0, 0][%arg2][1, 1, 1] : memref<8x16x4xf32, offset: 0, strides: [64, 4, 1], 2> to - memref<8x?x4xf32, affine_map<(d0, d1, d2)[s0] -> (d0 * s0 + d1 * 4 + d2)>> + memref<8x?x4xf32, affine_map<(d0, d1, d2) [s0] -> (d0 * s0 + d1 * 4 + d2)>> return } @@ -1011,7 +1013,7 @@ func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) { %0 = alloc() : memref<8x16x4xf32> - // expected-error@+1 {{expected result type to be 'memref (d0 * s1 + s0 + d1 * s2 + d2 * s3)>>' or a rank-reduced version. (mismatch of result strides)}} + // expected-error@+1 {{expected result type to be 'memref (d0 * s1 + s0 + d1 * s2 + d2 * s3)>>' or a rank-reduced version. (mismatch of result strides)}} %1 = subview %0[%arg0, %arg1, %arg2][%arg0, %arg1, %arg2][%arg0, %arg1, %arg2] : memref<8x16x4xf32> to memref @@ -1053,7 +1055,7 @@ // ----- func @invalid_rank_reducing_subview(%arg0 : memref, %arg1 : index, %arg2 : index) { - // expected-error@+1 {{expected result type to be 'memref (d0 * s1 + s0 + d1)>>' or a rank-reduced version. (mismatch of result strides)}} + // expected-error@+1 {{expected result type to be 'memref (d0 * s1 + s0 + d1)>>' or a rank-reduced version. (mismatch of result strides)}} %0 = subview %arg0[0, %arg1][%arg2, 1][1, 1] : memref to memref return } diff --git a/mlir/test/IR/invalid.mlir b/mlir/test/IR/invalid.mlir --- a/mlir/test/IR/invalid.mlir +++ b/mlir/test/IR/invalid.mlir @@ -257,7 +257,7 @@ func @invalid_if_conditional2() { affine.for %i = 1 to 10 { - affine.if affine_set<(i)[N] : (i >= )> // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}} + affine.if affine_set<(i) [N] : (i >= )> // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}} } } @@ -265,7 +265,7 @@ func @invalid_if_conditional3() { affine.for %i = 1 to 10 { - affine.if affine_set<(i)[N] : (i == 1)> // expected-error {{expected '0' after '=='}} + affine.if affine_set<(i) [N] : (i == 1)> // expected-error {{expected '0' after '=='}} } } @@ -273,7 +273,7 @@ func @invalid_if_conditional4() { affine.for %i = 1 to 10 { - affine.if affine_set<(i)[N] : (i >= 2)> // expected-error {{expected '0' after '>='}} + affine.if affine_set<(i) [N] : (i >= 2)> // expected-error {{expected '0' after '>='}} } } @@ -281,7 +281,7 @@ func @invalid_if_conditional5() { affine.for %i = 1 to 10 { - affine.if affine_set<(i)[N] : (i <= 0)> // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}} + affine.if affine_set<(i) [N] : (i <= 0)> // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}} } } @@ -523,7 +523,7 @@ // ----- -#map1 = affine_map<(i)[j] -> (i+j)> +#map1 = affine_map<(i) [j] -> (i+j)> func @bound_symbol_mismatch(%N : index) { affine.for %i = #map1(%N) to 100 { @@ -534,10 +534,10 @@ // ----- -#map1 = affine_map<(i)[j] -> (i+j)> +#map1 = affine_map<(i) [j] -> (i+j)> func @bound_dim_mismatch(%N : index) { - affine.for %i = #map1(%N, %N)[%N] to 100 { + affine.for %i = #map1(%N, %N) [%N] to 100 { // expected-error@-1 {{dim operand count and affine map dim count must match}} } return @@ -593,7 +593,7 @@ func @invalid_if_operands2(%N : index) { affine.for %i = 1 to 10 { - affine.if #set0()[%N] { + affine.if #set0() [%N] { // expected-error@-1 {{dim operand count and integer set dim count must match}} // ----- @@ -601,7 +601,7 @@ func @invalid_if_operands3(%N : index) { affine.for %i = 1 to 10 { - affine.if #set0(%i)[%i] { + affine.if #set0(%i) [%i] { // expected-error@-1 {{operand cannot be used as a symbol}} } } @@ -865,7 +865,7 @@ func @missing_for_max(%arg0: index, %arg1: index, %arg2: memref<100xf32>) { // expected-error @+1 {{lower loop bound affine map with multiple results requires 'max' prefix}} - affine.for %i0 = affine_map<()[s]->(0,s-1)>()[%arg0] to %arg1 { + affine.for %i0 = affine_map<() [s]->(0,s-1)>() [%arg0] to %arg1 { } return } @@ -874,7 +874,7 @@ func @missing_for_min(%arg0: index, %arg1: index, %arg2: memref<100xf32>) { // expected-error @+1 {{upper loop bound affine map with multiple results requires 'min' prefix}} - affine.for %i0 = %arg0 to affine_map<()[s]->(100,s+1)>()[%arg1] { + affine.for %i0 = %arg0 to affine_map<() [s]->(100,s+1)>() [%arg1] { } return } diff --git a/mlir/test/IR/memory-ops.mlir b/mlir/test/IR/memory-ops.mlir --- a/mlir/test/IR/memory-ops.mlir +++ b/mlir/test/IR/memory-ops.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt %s | FileCheck %s -// CHECK: #map = affine_map<(d0, d1)[s0] -> (d0 + s0, d1)> +// CHECK: #map = affine_map<(d0, d1) [s0] -> (d0 + s0, d1)> // CHECK-LABEL: func @alloc() { func @alloc() { @@ -17,12 +17,12 @@ %1 = alloc(%c0, %c1) : memref (d0, d1)>, 1> // Test alloc with no dynamic dimensions and one symbol. - // CHECK: %2 = alloc()[%c0] : memref<2x4xf32, #map, 1> - %2 = alloc()[%c0] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1> + // CHECK: %2 = alloc() [%c0] : memref<2x4xf32, #map, 1> + %2 = alloc() [%c0] : memref<2x4xf32, affine_map<(d0, d1) [s0] -> ((d0 + s0), d1)>, 1> // Test alloc with dynamic dimensions and one symbol. - // CHECK: %3 = alloc(%c1)[%c0] : memref<2x?xf32, #map, 1> - %3 = alloc(%c1)[%c0] : memref<2x?xf32, affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>, 1> + // CHECK: %3 = alloc(%c1) [%c0] : memref<2x?xf32, #map, 1> + %3 = alloc(%c1) [%c0] : memref<2x?xf32, affine_map<(d0, d1) [s0] -> (d0 + s0, d1)>, 1> // Alloc with no mappings. // b/116054838 Parser crash while parsing ill-formed AllocOp @@ -48,12 +48,12 @@ %1 = alloca(%c0, %c1) : memref (d0, d1)>, 1> // Test alloca with no dynamic dimensions and one symbol. - // CHECK: %2 = alloca()[%c0] : memref<2x4xf32, #map, 1> - %2 = alloca()[%c0] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1> + // CHECK: %2 = alloca() [%c0] : memref<2x4xf32, #map, 1> + %2 = alloca() [%c0] : memref<2x4xf32, affine_map<(d0, d1) [s0] -> ((d0 + s0), d1)>, 1> // Test alloca with dynamic dimensions and one symbol. - // CHECK: %3 = alloca(%c1)[%c0] : memref<2x?xf32, #map, 1> - %3 = alloca(%c1)[%c0] : memref<2x?xf32, affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>, 1> + // CHECK: %3 = alloca(%c1) [%c0] : memref<2x?xf32, #map, 1> + %3 = alloca(%c1) [%c0] : memref<2x?xf32, affine_map<(d0, d1) [s0] -> (d0 + s0, d1)>, 1> // Alloca with no mappings, but with alignment. // CHECK: %4 = alloca() {alignment = 64 : i64} : memref<2xi32> diff --git a/mlir/test/IR/parser.mlir b/mlir/test/IR/parser.mlir --- a/mlir/test/IR/parser.mlir +++ b/mlir/test/IR/parser.mlir @@ -1,7 +1,7 @@ // RUN: mlir-opt -allow-unregistered-dialect %s | FileCheck %s -// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1, d2, d3, d4)[s0] -> (d0, d1, d2, d4, d3)> -#map0 = affine_map<(d0, d1, d2, d3, d4)[s0] -> (d0, d1, d2, d4, d3)> +// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1, d2, d3, d4) [s0] -> (d0, d1, d2, d4, d3)> +#map0 = affine_map<(d0, d1, d2, d3, d4) [s0] -> (d0, d1, d2, d4, d3)> // CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0) -> (d0)> #map1 = affine_map<(d0) -> (d0)> @@ -15,20 +15,20 @@ // CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1, d2) -> (d2, d1, d0)> #map4 = affine_map<(d0, d1, d2) -> (d2, d1, d0)> -// CHECK-DAG: #map{{[0-9]+}} = affine_map<()[s0] -> (0, s0 - 1)> -#inline_map_minmax_loop1 = affine_map<()[s0] -> (0, s0 - 1)> +// CHECK-DAG: #map{{[0-9]+}} = affine_map<() [s0] -> (0, s0 - 1)> +#inline_map_minmax_loop1 = affine_map<() [s0] -> (0, s0 - 1)> -// CHECK-DAG: #map{{[0-9]+}} = affine_map<()[s0] -> (100, s0 + 1)> -#inline_map_minmax_loop2 = affine_map<()[s0] -> (100, s0 + 1)> +// CHECK-DAG: #map{{[0-9]+}} = affine_map<() [s0] -> (100, s0 + 1)> +#inline_map_minmax_loop2 = affine_map<() [s0] -> (100, s0 + 1)> -// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + s0)> -#bound_map1 = affine_map<(i, j)[s] -> (i + j + s)> +// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1) [s0] -> (d0 + d1 + s0)> +#bound_map1 = affine_map<(i, j) [s] -> (i + j + s)> // CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0 + d1)> #inline_map_loop_bounds2 = affine_map<(d0, d1) -> (d0 + d1)> -// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0)[s0] -> (d0 + s0, d0 - s0)> -#bound_map2 = affine_map<(i)[s] -> (i + s, i - s)> +// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0) [s0] -> (d0 + s0, d0 - s0)> +#bound_map2 = affine_map<(i) [s] -> (i + s, i - s)> // All maps appear in arbitrary order before all sets, in arbitrary order. // CHECK-NOT: Placeholder @@ -284,7 +284,7 @@ func @triang_loop(%arg0: index, %arg1: memref) { %c = constant 0 : i32 // CHECK: %{{.*}} = constant 0 : i32 affine.for %i0 = 1 to %arg0 { // CHECK: affine.for %{{.*}} = 1 to %{{.*}} { - affine.for %i1 = affine_map<(d0)[]->(d0)>(%i0)[] to %arg0 { // CHECK: affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to %{{.*}} { + affine.for %i1 = affine_map<(d0) []->(d0)>(%i0) [] to %arg0 { // CHECK: affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to %{{.*}} { store %c, %arg1[%i0, %i1] : memref // CHECK: store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] } // CHECK: } } // CHECK: } @@ -293,8 +293,8 @@ // CHECK: func @minmax_loop(%{{.*}}: index, %{{.*}}: index, %{{.*}}: memref<100xf32>) { func @minmax_loop(%arg0: index, %arg1: index, %arg2: memref<100xf32>) { - // CHECK: affine.for %{{.*}} = max #map{{.*}}()[%{{.*}}] to min #map{{.*}}()[%{{.*}}] { - affine.for %i0 = max affine_map<()[s]->(0,s-1)>()[%arg0] to min affine_map<()[s]->(100,s+1)>()[%arg1] { + // CHECK: affine.for %{{.*}} = max #map{{.*}}() [%{{.*}}] to min #map{{.*}}() [%{{.*}}] { + affine.for %i0 = max affine_map<() [s]->(0,s-1)>() [%arg0] to min affine_map<() [s]->(100,s+1)>() [%arg1] { // CHECK: "foo"(%{{.*}}, %{{.*}}) : (memref<100xf32>, index) -> () "foo"(%arg2, %i0) : (memref<100xf32>, index) -> () } // CHECK: } @@ -308,21 +308,21 @@ // CHECK: affine.for %{{.*}} = %{{.*}} to %{{.*}} affine.for %i = %s to %N { // CHECK: affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to 0 - affine.for %j = affine_map<(d0)[]->(d0)>(%i)[] to 0 step 1 { - // CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}] - %w1 = affine.apply affine_map<(d0, d1)[s0] -> (d0+d1)> (%i, %j) [%s] - // CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}] - %w2 = affine.apply affine_map<(d0, d1)[s0] -> (s0+1)> (%i, %j) [%s] - // CHECK: affine.for %{{.*}} = #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}] to #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}] { - affine.for %k = #bound_map1 (%w1, %i)[%N] to affine_map<(i, j)[s] -> (i + j + s)> (%w2, %j)[%s] { + affine.for %j = affine_map<(d0) []->(d0)>(%i) [] to 0 step 1 { + // CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}}) [%{{.*}}] + %w1 = affine.apply affine_map<(d0, d1) [s0] -> (d0+d1)> (%i, %j) [%s] + // CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}}) [%{{.*}}] + %w2 = affine.apply affine_map<(d0, d1) [s0] -> (s0+1)> (%i, %j) [%s] + // CHECK: affine.for %{{.*}} = #map{{.*}}(%{{.*}}, %{{.*}}) [%{{.*}}] to #map{{.*}}(%{{.*}}, %{{.*}}) [%{{.*}}] { + affine.for %k = #bound_map1 (%w1, %i) [%N] to affine_map<(i, j) [s] -> (i + j + s)> (%w2, %j) [%s] { // CHECK: "foo"(%{{.*}}, %{{.*}}, %{{.*}}) : (index, index, index) -> () "foo"(%i, %j, %k) : (index, index, index)->() // CHECK: %{{.*}} = constant 30 : index %c = constant 30 : index // CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}}) %u = affine.apply affine_map<(d0, d1)->(d0+d1)> (%N, %c) - // CHECK: affine.for %{{.*}} = max #map{{.*}}(%{{.*}})[%{{.*}}] to min #map{{.*}}(%{{.*}})[%{{.*}}] { - affine.for %l = max #bound_map2(%i)[%u] to min #bound_map2(%k)[%c] { + // CHECK: affine.for %{{.*}} = max #map{{.*}}(%{{.*}}) [%{{.*}}] to min #map{{.*}}(%{{.*}}) [%{{.*}}] { + affine.for %l = max #bound_map2(%i) [%u] to min #bound_map2(%k) [%c] { // CHECK: "bar"(%{{.*}}) : (index) -> () "bar"(%l) : (index) -> () } // CHECK: } @@ -336,17 +336,17 @@ func @ifinst(%N: index) { %c = constant 200 : index // CHECK %{{.*}} = constant 200 affine.for %i = 1 to 10 { // CHECK affine.for %{{.*}} = 1 to 10 { - affine.if #set0(%i)[%N, %c] { // CHECK affine.if #set0(%{{.*}})[%{{.*}}, %{{.*}}] { + affine.if #set0(%i) [%N, %c] { // CHECK affine.if #set0(%{{.*}}) [%{{.*}}, %{{.*}}] { %x = constant 1 : i32 // CHECK: %{{.*}} = constant 1 : i32 %y = "add"(%x, %i) : (i32, index) -> i32 // CHECK: %{{.*}} = "add"(%{{.*}}, %{{.*}}) : (i32, index) -> i32 %z = "mul"(%y, %y) : (i32, i32) -> i32 // CHECK: %{{.*}} = "mul"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32 } else { // CHECK } else { - affine.if affine_set<(i)[N] : (i - 2 >= 0, 4 - i >= 0)>(%i)[%N] { // CHECK affine.if (#set1(%{{.*}})[%{{.*}}]) { + affine.if affine_set<(i) [N] : (i - 2 >= 0, 4 - i >= 0)>(%i) [%N] { // CHECK affine.if (#set1(%{{.*}}) [%{{.*}}]) { // CHECK: %{{.*}} = constant 1 : index %u = constant 1 : index - // CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}] - %w = affine.apply affine_map<(d0,d1)[s0] -> (d0+d1+s0)> (%i, %i) [%u] + // CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}}) [%{{.*}}] + %w = affine.apply affine_map<(d0,d1) [s0] -> (d0+d1+s0)> (%i, %i) [%u] } else { // CHECK } else { %v = constant 3 : i32 // %c3_i32 = constant 3 : i32 } @@ -359,7 +359,7 @@ func @simple_ifinst(%N: index) { %c = constant 200 : index // CHECK %{{.*}} = constant 200 affine.for %i = 1 to 10 { // CHECK affine.for %{{.*}} = 1 to 10 { - affine.if #set0(%i)[%N, %c] { // CHECK affine.if #set0(%{{.*}})[%{{.*}}, %{{.*}}] { + affine.if #set0(%i) [%N, %c] { // CHECK affine.if #set0(%{{.*}}) [%{{.*}}, %{{.*}}] { %x = constant 1 : i32 // CHECK: %{{.*}} = constant 1 : i32 %y = "add"(%x, %i) : (i32, index) -> i32 // CHECK: %{{.*}} = "add"(%{{.*}}, %{{.*}}) : (i32, index) -> i32 @@ -590,25 +590,25 @@ } // CHECK-label func @funcsimplemap -#map_simple0 = affine_map<()[] -> (10)> -#map_simple1 = affine_map<()[s0] -> (s0)> -#map_non_simple0 = affine_map<(d0)[] -> (d0)> -#map_non_simple1 = affine_map<(d0)[s0] -> (d0 + s0)> -#map_non_simple2 = affine_map<()[s0, s1] -> (s0 + s1)> -#map_non_simple3 = affine_map<()[s0] -> (s0 + 3)> +#map_simple0 = affine_map<() [] -> (10)> +#map_simple1 = affine_map<() [s0] -> (s0)> +#map_non_simple0 = affine_map<(d0) [] -> (d0)> +#map_non_simple1 = affine_map<(d0) [s0] -> (d0 + s0)> +#map_non_simple2 = affine_map<() [s0, s1] -> (s0 + s1)> +#map_non_simple3 = affine_map<() [s0] -> (s0 + 3)> func @funcsimplemap(%arg0: index, %arg1: index) -> () { - affine.for %i0 = 0 to #map_simple0()[] { + affine.for %i0 = 0 to #map_simple0() [] { // CHECK: affine.for %{{.*}} = 0 to 10 { - affine.for %i1 = 0 to #map_simple1()[%arg1] { + affine.for %i1 = 0 to #map_simple1() [%arg1] { // CHECK: affine.for %{{.*}} = 0 to %{{.*}} { - affine.for %i2 = 0 to #map_non_simple0(%i0)[] { + affine.for %i2 = 0 to #map_non_simple0(%i0) [] { // CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}(%{{.*}}) { - affine.for %i3 = 0 to #map_non_simple1(%i0)[%arg1] { - // CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}(%{{.*}})[%{{.*}}] { - affine.for %i4 = 0 to #map_non_simple2()[%arg1, %arg0] { - // CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}()[%{{.*}}, %{{.*}}] { - affine.for %i5 = 0 to #map_non_simple3()[%arg0] { - // CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}()[%{{.*}}] { + affine.for %i3 = 0 to #map_non_simple1(%i0) [%arg1] { + // CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}(%{{.*}}) [%{{.*}}] { + affine.for %i4 = 0 to #map_non_simple2() [%arg1, %arg0] { + // CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}() [%{{.*}}, %{{.*}}] { + affine.for %i5 = 0 to #map_non_simple3() [%arg0] { + // CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}() [%{{.*}}] { %c42_i32 = constant 42 : i32 } } @@ -847,7 +847,7 @@ func @verbose_if(%N: index) { %c = constant 200 : index - // CHECK: affine.if #set{{.*}}(%{{.*}})[%{{.*}}, %{{.*}}] { + // CHECK: affine.if #set{{.*}}(%{{.*}}) [%{{.*}}, %{{.*}}] { "affine.if"(%c, %N, %c) ({ // CHECK-NEXT: "add" %y = "add"(%c, %N) : (index, index) -> index diff --git a/mlir/test/Transforms/canonicalize.mlir b/mlir/test/Transforms/canonicalize.mlir --- a/mlir/test/Transforms/canonicalize.mlir +++ b/mlir/test/Transforms/canonicalize.mlir @@ -452,9 +452,9 @@ return %c, %d : memref, memref } -#map1 = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> -#map2 = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s2 + d1 * s1 + d2 + s0)> -#map3 = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> +#map1 = affine_map<(d0, d1) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> +#map2 = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s2 + d1 * s1 + d2 + s0)> +#map3 = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> // CHECK-LABEL: func @dim_op_fold( // CHECK-SAME: %[[ARG0:[a-z0-9]*]]: index @@ -718,14 +718,14 @@ // ----- // CHECK-DAG: #[[$BASE_MAP0:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)> -// CHECK-DAG: #[[$SUBVIEW_MAP0:map[0-9]+]] = affine_map<(d0, d1, d2)[s0] -> (d0 * 64 + s0 + d1 * 4 + d2)> +// CHECK-DAG: #[[$SUBVIEW_MAP0:map[0-9]+]] = affine_map<(d0, d1, d2) [s0] -> (d0 * 64 + s0 + d1 * 4 + d2)> // CHECK-DAG: #[[$SUBVIEW_MAP1:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2 + 79)> // CHECK-DAG: #[[$SUBVIEW_MAP2:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 128 + d1 * 28 + d2 * 11)> -// CHECK-DAG: #[[$SUBVIEW_MAP3:map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)> -// CHECK-DAG: #[[$SUBVIEW_MAP4:map[0-9]+]] = affine_map<(d0, d1, d2)[s0] -> (d0 * 128 + s0 + d1 * 28 + d2 * 11)> -// CHECK-DAG: #[[$SUBVIEW_MAP5:map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s0 + d1 * s1 + d2 * s2 + 79)> -// CHECK-DAG: #[[$SUBVIEW_MAP6:map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2 * 2)> -// CHECK-DAG: #[[$SUBVIEW_MAP7:map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 * 4 + s0 + d1)> +// CHECK-DAG: #[[$SUBVIEW_MAP3:map[0-9]+]] = affine_map<(d0, d1, d2) [s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)> +// CHECK-DAG: #[[$SUBVIEW_MAP4:map[0-9]+]] = affine_map<(d0, d1, d2) [s0] -> (d0 * 128 + s0 + d1 * 28 + d2 * 11)> +// CHECK-DAG: #[[$SUBVIEW_MAP5:map[0-9]+]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s0 + d1 * s1 + d2 * s2 + 79)> +// CHECK-DAG: #[[$SUBVIEW_MAP6:map[0-9]+]] = affine_map<(d0, d1, d2) [s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2 * 2)> +// CHECK-DAG: #[[$SUBVIEW_MAP7:map[0-9]+]] = affine_map<(d0, d1) [s0] -> (d0 * 4 + s0 + d1)> // CHECK-DAG: #[[$SUBVIEW_MAP8:map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1 + 12)> @@ -1024,7 +1024,7 @@ // ----- // CHECK-DAG: #[[$map0:.*]] = affine_map<(d0, d1) -> (d0 * 16 + d1)> -// CHECK-DAG: #[[$map1:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> +// CHECK-DAG: #[[$map1:.*]] = affine_map<(d0, d1) [s0, s1] -> (d0 * s1 + s0 + d1)> // CHECK-LABEL: func @memref_cast_folding_subview_static( func @memref_cast_folding_subview_static(%V: memref<16x16xf32>, %a: index, %b: index) diff --git a/mlir/test/Transforms/constant-fold.mlir b/mlir/test/Transforms/constant-fold.mlir --- a/mlir/test/Transforms/constant-fold.mlir +++ b/mlir/test/Transforms/constant-fold.mlir @@ -259,9 +259,9 @@ // CHECK:[[C1159:%.+]] = constant 1159 : index // CHECK:[[C1152:%.+]] = constant 1152 : index - %x0 = affine.apply affine_map<(d0, d1)[S0] -> ( (d0 + 128 * S0) floordiv 128 + d1 mod 128)> + %x0 = affine.apply affine_map<(d0, d1) [S0] -> ( (d0 + 128 * S0) floordiv 128 + d1 mod 128)> (%c177, %c211)[%N] - %x1 = affine.apply affine_map<(d0, d1)[S0] -> (128 * (S0 ceildiv 128))> + %x1 = affine.apply affine_map<(d0, d1) [S0] -> (128 * (S0 ceildiv 128))> (%c177, %c211)[%N] // CHECK:[[C42:%.+]] = constant 42 : index diff --git a/mlir/test/Transforms/memref-bound-check.mlir b/mlir/test/Transforms/memref-bound-check.mlir --- a/mlir/test/Transforms/memref-bound-check.mlir +++ b/mlir/test/Transforms/memref-bound-check.mlir @@ -128,7 +128,7 @@ func @test_semi_affine_bailout(%N : index) { %B = alloc() : memref<10 x i32> affine.for %i = 0 to 10 { - %idx = affine.apply affine_map<(d0)[s0] -> (d0 * s0)>(%i)[%N] + %idx = affine.apply affine_map<(d0) [s0] -> (d0 * s0)>(%i) [%N] %y = affine.load %B[%idx] : memref<10 x i32> // expected-error@-1 {{getMemRefRegion: compose affine map failed}} } diff --git a/mlir/test/Transforms/memref-dependence-check.mlir b/mlir/test/Transforms/memref-dependence-check.mlir --- a/mlir/test/Transforms/memref-dependence-check.mlir +++ b/mlir/test/Transforms/memref-dependence-check.mlir @@ -1045,7 +1045,7 @@ %cf7 = constant 7.0 : f32 affine.for %i0 = 0 to 101 { - affine.if #set1(%i0)[%N] { + affine.if #set1(%i0) [%N] { %1 = affine.load %0[%i0] : memref<101xf32> // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}} // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}} diff --git a/mlir/test/Transforms/normalize-memrefs.mlir b/mlir/test/Transforms/normalize-memrefs.mlir --- a/mlir/test/Transforms/normalize-memrefs.mlir +++ b/mlir/test/Transforms/normalize-memrefs.mlir @@ -115,11 +115,11 @@ // CHECK-LABEL: func @symbolic_operands func @symbolic_operands(%s : index) { // CHECK: alloc() : memref<100xf32> - %A = alloc()[%s] : memref<10x10xf32, affine_map<(d0,d1)[s0] -> (10*d0 + d1)>> + %A = alloc()[%s] : memref<10x10xf32, affine_map<(d0,d1) [s0] -> (10*d0 + d1)>> affine.for %i = 0 to 10 { affine.for %j = 0 to 10 { // CHECK: affine.load %{{.*}}[%{{.*}} * 10 + %{{.*}}] : memref<100xf32> - %1 = affine.load %A[%i, %j] : memref<10x10xf32, affine_map<(d0,d1)[s0] -> (10*d0 + d1)>> + %1 = affine.load %A[%i, %j] : memref<10x10xf32, affine_map<(d0,d1) [s0] -> (10*d0 + d1)>> "prevent.dce"(%1) : (f32) -> () } } @@ -129,11 +129,11 @@ // Semi-affine maps, normalization not implemented yet. // CHECK-LABEL: func @semi_affine_layout_map func @semi_affine_layout_map(%s0: index, %s1: index) { - %A = alloc()[%s0, %s1] : memref<256x1024xf32, affine_map<(d0, d1)[s0, s1] -> (d0*s0 + d1*s1)>> + %A = alloc()[%s0, %s1] : memref<256x1024xf32, affine_map<(d0, d1) [s0, s1] -> (d0*s0 + d1*s1)>> affine.for %i = 0 to 256 { affine.for %j = 0 to 1024 { // CHECK: memref<256x1024xf32, #map{{[0-9]+}}> - affine.load %A[%i, %j] : memref<256x1024xf32, affine_map<(d0, d1)[s0, s1] -> (d0*s0 + d1*s1)>> + affine.load %A[%i, %j] : memref<256x1024xf32, affine_map<(d0, d1) [s0, s1] -> (d0*s0 + d1*s1)>> } } return